以下是软件版本号:
"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"
这样可以更清楚地看到背后的想法。 但是，我怎样才能把它转换成计算机程序呢?
当前回答
我想为解决这个问题的轻量级库做广告:语义版本
可以同时使用面向对象(OO)和面向函数。它可以作为npm-package和现成的包文件使用。
其他回答
我已经创建了这个解决方案，我希望你觉得它有用:
https://runkit.com/ecancino/5f3c6c59593d23001485992e
const quantify = max => (n, i) => n * (+max.slice(0, max.length - i))
const add = (a, b) => a + b
const calc = s => s.
split('.').
map(quantify('1000000')).
reduce(add, 0)
const sortVersions = unsortedVersions => unsortedVersions
.map(version => ({ version, order: calc(version) }))
.sort((a, b) => a.order - b.order)
.reverse()
.map(o => o.version)
这是另一种递归算法。
这段代码只使用了Array。shift和递归，这意味着它可以在Internet Explorer 6+中运行。如果你有任何疑问，你可以访问我的GitHub页面。
(function(root, factory) {
if (typeof exports === 'object') {
return module.exports = factory();
} else if (typeof define === 'function' && define.amd) {
return define(factory);
} else {
return root.compareVer = factory();
}
})(this, function() {
'use strict';
var _compareVer;
_compareVer = function(newVer, oldVer) {
var VER_RE, compareNum, isTrue, maxLen, newArr, newLen, newMatch, oldArr, oldLen, oldMatch, zerofill;
VER_RE = /(\d+\.){1,9}\d+/;
if (arguments.length !== 2) {
return -100;
}
if (typeof newVer !== 'string') {
return -2;
}
if (typeof oldVer !== 'string') {
return -3;
}
newMatch = newVer.match(VER_RE);
if (!newMatch || newMatch[0] !== newVer) {
return -4;
}
oldMatch = oldVer.match(VER_RE);
if (!oldMatch || oldMatch[0] !== oldVer) {
return -5;
}
newVer = newVer.replace(/^0/, '');
oldVer = oldVer.replace(/^0/, '');
if (newVer === oldVer) {
return 0;
} else {
newArr = newVer.split('.');
oldArr = oldVer.split('.');
newLen = newArr.length;
oldLen = oldArr.length;
maxLen = Math.max(newLen, oldLen);
zerofill = function() {
newArr.length < maxLen && newArr.push('0');
oldArr.length < maxLen && oldArr.push('0');
return newArr.length !== oldArr.length && zerofill();
};
newLen !== oldLen && zerofill();
if (newArr.toString() === oldArr.toString()) {
if (newLen > oldLen) {
return 1;
} else {
return -1;
}
} else {
isTrue = -1;
compareNum = function() {
var _new, _old;
_new = ~~newArr.shift();
_old = ~~oldArr.shift();
_new > _old && (isTrue = 1);
return _new === _old && newArr.length > 0 && compareNum();
};
compareNum();
return isTrue;
}
}
};
return _compareVer;
});
好吧，我希望这段代码能帮助到一些人。
下面是测试。
console.log(compareVer("0.0.2","0.0.1"));//1
console.log(compareVer("0.0.10","0.0.1")); //1
console.log(compareVer("0.0.10","0.0.2")); //1
console.log(compareVer("0.9.0","0.9")); //1
console.log(compareVer("0.10.0","0.9.0")); //1
console.log(compareVer("1.7", "1.07")); //1
console.log(compareVer("1.0.07", "1.0.007")); //1
console.log(compareVer("0.3","0.3")); //0
console.log(compareVer("0.0.3","0.0.3")); //0
console.log(compareVer("0.0.3.0","0.0.3.0")); //0
console.log(compareVer("00.3","0.3")); //0
console.log(compareVer("00.3","00.3")); //0
console.log(compareVer("01.0.3","1.0.3")); //0
console.log(compareVer("1.0.3","01.0.3")); //0
console.log(compareVer("0.2.0","1.0.0")); //-1
console.log(compareVer('0.0.2.2.0',"0.0.2.3")); //-1
console.log(compareVer('0.0.2.0',"0.0.2")); //-1
console.log(compareVer('0.0.2',"0.0.2.0")); //-1
console.log(compareVer("1.07", "1.7")); //-1
console.log(compareVer("1.0.007", "1.0.07")); //-1
console.log(compareVer()); //-100
console.log(compareVer("0.0.2")); //-100
console.log(compareVer("0.0.2","0.0.2","0.0.2")); //-100
console.log(compareVer(1212,"0.0.2")); //-2
console.log(compareVer("0.0.2",1212)); //-3
console.log(compareVer('1.abc.2',"1.0.2")); //-4
console.log(compareVer('1.0.2',"1.abc.2")); //-5
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 compVersions(strV1, strV2) {
var nRes = 0
, parts1 = strV1.split('.')
, parts2 = strV2.split('.')
, nLen = Math.max(parts1.length, parts2.length);
for (var i = 0; i < nLen; i++) {
var nP1 = (i < parts1.length) ? parseInt(parts1[i], 10) : 0
, nP2 = (i < parts2.length) ? parseInt(parts2[i], 10) : 0;
if (isNaN(nP1)) { nP1 = 0; }
if (isNaN(nP2)) { nP2 = 0; }
if (nP1 != nP2) {
nRes = (nP1 > nP2) ? 1 : -1;
break;
}
}
return nRes;
};
compVersions('10', '10.0'); // 0
compVersions('10.1', '10.01.0'); // 0
compVersions('10.0.1', '10.0'); // 1
compVersions('10.0.1', '10.1'); // -1
进行这种比较的基本思想是使用Array。拆分以从输入字符串中获得部件数组，然后比较两个数组中的部件对;如果部分不相等，我们就知道哪个版本更小。
这里有一些重要的细节需要记住:
每对零件应该如何比较?这个问题想要从数字上进行比较，但是如果我们有不只是由数字组成的版本字符串(例如。“1.0”)? 如果一个版本字符串的部分比另一个多，会发生什么?很可能“1.0”应该被认为小于“1.0.1”，但是“1.0.0”呢?
下面是你可以直接使用的实现代码(要点和文档):
function versionCompare(v1, v2, options) {
var lexicographical = options && options.lexicographical,
zeroExtend = options && options.zeroExtend,
v1parts = v1.split('.'),
v2parts = v2.split('.');
function isValidPart(x) {
return (lexicographical ? /^\d+[A-Za-z]*$/ : /^\d+$/).test(x);
}
if (!v1parts.every(isValidPart) || !v2parts.every(isValidPart)) {
return NaN;
}
if (zeroExtend) {
while (v1parts.length < v2parts.length) v1parts.push("0");
while (v2parts.length < v1parts.length) v2parts.push("0");
}
if (!lexicographical) {
v1parts = v1parts.map(Number);
v2parts = v2parts.map(Number);
}
for (var i = 0; i < v1parts.length; ++i) {
if (v2parts.length == i) {
return 1;
}
if (v1parts[i] == v2parts[i]) {
continue;
}
else if (v1parts[i] > v2parts[i]) {
return 1;
}
else {
return -1;
}
}
if (v1parts.length != v2parts.length) {
return -1;
}
return 0;
}
这个版本自然地比较各个部分，不接受字符后缀，并认为“1.7”比“1.7.0”小。比较模式可以更改为字典式，短版本字符串可以使用可选的第三个参数自动填充零。
这里有一个运行“单元测试”的JSFiddle;这是一个稍微扩展的版本的ripper234的工作(谢谢)。
重要提示:此代码使用Array。map和Array。这意味着它将不会在9之前的IE版本中运行。如果你需要支持这些方法，你就必须为缺失的方法提供填充。
