以下是软件版本号:
"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"
我怎么比较呢?
假设正确的顺序是:
"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"
想法很简单… 读第一个数字，然后，第二个，第三个… 但是我不能将版本号转换为浮点数… 你也可以像这样看到版本号:
"1.0.0.0", "1.0.1.0", "2.0.0.0", "2.0.0.1", "2.0.1.0"
这样可以更清楚地看到背后的想法。 但是，我怎样才能把它转换成计算机程序呢?
当前回答
最简单的方法是使用localeCompare:
a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' })
这将返回:
0:版本字符串相等 1: a版本大于b版本 -1:版本b大于版本a
其他回答
2020年(大多数时候)正确的JavaScript答案
Nina Scholz在2020年3月和Sid Vishnoi在2020年4月都给出了现代的答案:
var versions = ["2.0.1", "2.0", "1.0", "1.0.1", "2.0.0.1"];
versions.sort((a, b) =>
a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' })
);
console.log(versions);
localCompare已经存在一段时间了
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator
但是1.0a和1.0.1呢
localCompare不能解决这个问题，仍然返回1.0.1,1.0a
迈克尔·迪尔(Michael Deal)在他的(略长且复杂的)解决方案中已经在2013年解决了这个问题
他将数字转换为另一种进位，以便更好地排序
他的回答让我思考……
666 -不要用数字思考- 999
排序是基于ASCII值的字母数字排序，所以让我们(ab)使用ASCII作为“基”
我的解决方案是将1.0.2.1到b.a.c.b转换为bacb，然后排序
这解决了1.1 vs. 1.0.0.0.1: bb vs. baaab
立即用baa和bab符号解决了1.0a和1.0.1排序问题
转换是通过:
const str = s => s.match(/(\d+)|[a-z]/g)
.map(c => c == ~~c ? String.fromCharCode(97 + c) : c);
=计算ASCII值0…999数字，否则连字母
1.0 > > >(“0”,“1”” " ] >>> [ " b”、“”、“”)
为了便于比较，没有必要使用.join("")将其连接到一个字符串。
Oneliner
const sortVersions=(x,v=s=>s.match(/(\d+)|[a-z]/g)
.map(c=>c==~~c?String.fromCharCode(97+c):c))
=>x.sort((a,b)=>v(b)<v(a)?1:-1)
测试代码片段:
function log(label,val){ document.body.append(label,String(val).replace(/,/g," - "),document.createElement("BR")); } let v = ["1.90.1", "1.9.1", "1.89", "1.090", "1.2", "1.0a", "1.0.1", "1.10", "1.0.0a"]; log('not sorted input :',v); v.sort((a, b) => a.localeCompare(b,undefined,{numeric:true,sensitivity:'base' })); log(' locale Compare :', v); // 1.0a AFTER 1.0.1 const str = s => s.match(/(\d+)|[a-z]/g) .map(c => c == ~~c ? String.fromCharCode(97 + c) : c); const versionCompare = (a, b) => { a = str(a); b = str(b); return b < a ? 1 : a == b ? 0 : -1; } v.sort(versionCompare); log('versionCompare:', v);
注意1.090是如何在两个结果中排序的。
我的代码不会解决一个答案中提到的001.012.001符号，但是localeCompare正确地解决了这部分挑战。
你可以结合这两种方法:
当涉及字母时，使用.localCompare或versionCompare进行排序
最终的JavaScript解决方案
const sortVersions = ( x, V = s => s.match(/[a-z]|\d+/g)。Map (c => c==~~c ?String.fromCharCode(97 + c): c) => x.sort((a, b) => (a + b).match(/[a-z]/) ？ V (b) < V (a) ?1: -1 : a.localeCompare(b, 0， {numeric: true})) 让v =[" 1.90.1”、“1.090”、“1.0”、“1.0.1”,“1.0.0a”,“1.0.0b”、“1.0.0.1”); console.log (sortVersions (v));
我们的想法是比较两个版本，并知道哪个是最大的。我们删除“。”，并将向量的每个位置与其他位置进行比较。
// Return 1 if a > b
// Return -1 if a < b
// Return 0 if a == b
function compareVersions(a_components, b_components) {
if (a_components === b_components) {
return 0;
}
var partsNumberA = a_components.split(".");
var partsNumberB = b_components.split(".");
for (var i = 0; i < partsNumberA.length; i++) {
var valueA = parseInt(partsNumberA[i]);
var valueB = parseInt(partsNumberB[i]);
// A bigger than B
if (valueA > valueB || isNaN(valueB)) {
return 1;
}
// B bigger than A
if (valueA < valueB) {
return -1;
}
}
}
例如，如果我们想检查当前jQuery版本是否小于1.8，如果version是"1.10.1"，parseFloat($.ui.version) < 1.8)将会给出错误的结果，因为parseFloat("1.10.1")返回1.1。 字符串比较也会出错，因为"1.8" < "1.10"的结果为false。
所以我们需要一个这样的测试
if(versionCompare($.ui.version, "1.8") < 0){
alert("please update jQuery");
}
下面的函数可以正确地处理这个问题:
/** Compare two dotted version strings (like '10.2.3').
* @returns {Integer} 0: v1 == v2, -1: v1 < v2, 1: v1 > v2
*/
function versionCompare(v1, v2) {
var v1parts = ("" + v1).split("."),
v2parts = ("" + v2).split("."),
minLength = Math.min(v1parts.length, v2parts.length),
p1, p2, i;
// Compare tuple pair-by-pair.
for(i = 0; i < minLength; i++) {
// Convert to integer if possible, because "8" > "10".
p1 = parseInt(v1parts[i], 10);
p2 = parseInt(v2parts[i], 10);
if (isNaN(p1)){ p1 = v1parts[i]; }
if (isNaN(p2)){ p2 = v2parts[i]; }
if (p1 == p2) {
continue;
}else if (p1 > p2) {
return 1;
}else if (p1 < p2) {
return -1;
}
// one operand is NaN
return NaN;
}
// The longer tuple is always considered 'greater'
if (v1parts.length === v2parts.length) {
return 0;
}
return (v1parts.length < v2parts.length) ? -1 : 1;
}
下面是一些例子:
// compare dotted version strings
console.assert(versionCompare("1.8", "1.8.1") < 0);
console.assert(versionCompare("1.8.3", "1.8.1") > 0);
console.assert(versionCompare("1.8", "1.10") < 0);
console.assert(versionCompare("1.10.1", "1.10.1") === 0);
// Longer is considered 'greater'
console.assert(versionCompare("1.10.1.0", "1.10.1") > 0);
console.assert(versionCompare("1.10.1", "1.10.1.0") < 0);
// Strings pairs are accepted
console.assert(versionCompare("1.x", "1.x") === 0);
// Mixed int/string pairs return NaN
console.assert(isNaN(versionCompare("1.8", "1.x")));
//works with plain numbers
console.assert(versionCompare("4", 3) > 0);
看到这里的现场示例和测试套件: http://jsfiddle.net/mar10/8KjvP/
你可以遍历每个以句点分隔的字符并将其转换为int类型:
var parts = versionString.split('.');
for (var i = 0; i < parts.length; i++) {
var value = parseInt(parts[i]);
// do stuffs here.. perhaps build a numeric version variable?
}
我认为这是一个值得分享的实现，因为它简短，简单，但功能强大。请注意，它只使用数字比较。通常它会检查version2是否比version1晚，如果是，则返回true。假设您有version1: 1.1.1和version2: 1.1.2。它遍历两个版本的每个部分，将它们的部分相加如下:对于版本1(1 + 0.1)然后(1.1 + 0.01)，对于版本2(1 + 0.1)然后(1.1 + 0.02)。
function compareVersions(version1, version2) {
version1 = version1.split('.');
version2 = version2.split('.');
var maxSubVersionLength = String(Math.max.apply(undefined, version1.concat(version2))).length;
var reduce = function(prev, current, index) {
return parseFloat(prev) + parseFloat('0.' + Array(index + (maxSubVersionLength - String(current).length)).join('0') + current);
};
return version1.reduce(reduce) < version2.reduce(reduce);
}
如果你想从版本列表中找到最新的版本，那么这可能是有用的:
function findLatestVersion(versions) {
if (!(versions instanceof Array)) {
versions = Array.prototype.slice.apply(arguments, [0]);
}
versions = versions.map(function(version) { return version.split('.'); });
var maxSubVersionLength = String(Math.max.apply(undefined, Array.prototype.concat.apply([], versions))).length;
var reduce = function(prev, current, index) {
return parseFloat(prev) + parseFloat('0.' + Array(index + (maxSubVersionLength - String(current).length)).join('0') + current);
};
var sums = [];
for (var i = 0; i < versions.length; i++) {
sums.push(parseFloat(versions[i].reduce(reduce)));
}
return versions[sums.indexOf(Math.max.apply(undefined, sums))].join('.');
}
console.log(findLatestVersion('0.1000000.1', '2.0.0.10', '1.6.10', '1.4.3', '2', '2.0.0.1')); // 2.0.0.10
console.log(findLatestVersion(['0.1000000.1', '2.0.0.10', '1.6.10', '1.4.3', '2', '2.0.0.1'])); // 2.0.0.10
