以下是软件版本号:
"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"
这样可以更清楚地看到背后的想法。 但是，我怎样才能把它转换成计算机程序呢?
当前回答
例如，如果我们想检查当前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/
其他回答
我找到了最简单的方法来比较它们，但我不确定这是否是你想要的。
当我在控制台中运行下面的代码时，它是有意义的，并且使用sort()方法，我可以获得版本字符串的排序数组。它是根据字母顺序排列的。
"1.0" < "1.0.1" //true
var arr = ["1.0.1", "1.0", "3.2.0", "1.3"]
arr.sort(); //["1.0", "1.0.1", "1.3", "3.2.0"]
这个非常小，但非常快的比较函数接受每个段的任何长度和任何数字大小的版本号。
返回值: -如果a < b，则数字< 0 -如果是> b，则为> 0 如果a = b - 0
所以你可以使用它作为array。sort()的比较函数;
编辑:修正了版本剥离尾随零识别“1”和“1.0.0”相等的错误
function cmpVersions (a, b) { var i, diff; var regExStrip0 = /(\.0+)+$/; var segmentsA = a.replace(regExStrip0, '').split('.'); var segmentsB = b.replace(regExStrip0, '').split('.'); var l = Math.min(segmentsA.length, segmentsB.length); for (i = 0; i < l; i++) { diff = parseInt(segmentsA[i], 10) - parseInt(segmentsB[i], 10); if (diff) { return diff; } } return segmentsA.length - segmentsB.length; } // TEST console.log( ['2.5.10.4159', '1.0.0', '0.5', '0.4.1', '1', '1.1', '0.0.0', '2.5.0', '2', '0.0', '2.5.10', '10.5', '1.25.4', '1.2.15'].sort(cmpVersions)); // Result: // ["0.0.0", "0.0", "0.4.1", "0.5", "1.0.0", "1", "1.1", "1.2.15", "1.25.4", "2", "2.5.0", "2.5.10", "2.5.10.4159", "10.5"]
你可以遍历每个以句点分隔的字符并将其转换为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?
}
replace()函数只替换字符串中的第一个出现项。我们来替换。与,。然后全部删除。然后做，to。再次将其解析为float。
for(i=0; i<versions.length; i++) {
v = versions[i].replace('.', ',');
v = v.replace(/\./g, '');
versions[i] = parseFloat(v.replace(',', '.'));
}
最后，排序:
versions.sort();
function compare(versionA: string | undefined, versionB: string | undefined, operator: string = '>') {
if (versionA === undefined || versionB === undefined) {
return false
}
const listA = versionA.split('.')
const listB = versionB.split('.')
let a = []
let b = []
for (let i = 0; i < listA.length; i++) {
a.push(parseInt(listA[i].replace(/\D/g, ''), 10))
b.push(parseInt(listB[i].replace(/\D/g, ''), 10))
}
for (let i = 0; i < listA.length; i++) {
switch (operator) {
case '>':
case '>=':
if (a[i] === b[i]) {
continue
}
if (a[i] > b[i]) {
return true
}
if (a[i] < b[i]) {
return false
}
break
case '<':
case '<=':
if (a[i] === b[i]) {
continue
}
if (a[i] > b[i]) {
return false
}
if (a[i] < b[i]) {
return true
}
break
case '=':
if (a[i] > b[i]) {
return false
}
if (a[i] < b[i]) {
return false
}
break
}
}
switch (operator) {
case '>':
return false
case '<':
return false
case '=':
case '>=':
case '<=':
return true
}
}
