以下是软件版本号:
"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"
这样可以更清楚地看到背后的想法。 但是，我怎样才能把它转换成计算机程序呢?
当前回答
这适用于由句点分隔的任何长度的数字版本。只有当myVersion为>= minimumVersion时，它才返回true，假设版本1小于1.0，版本1.1小于1.1.0，以此类推。添加额外的条件应该相当简单，比如接受数字(只需转换为字符串)和十六进制，或者使分隔符动态(只需添加一个分隔符参数，然后将“。”替换为参数)
function versionCompare(myVersion, minimumVersion) {
var v1 = myVersion.split("."), v2 = minimumVersion.split("."), minLength;
minLength= Math.min(v1.length, v2.length);
for(i=0; i<minLength; i++) {
if(Number(v1[i]) > Number(v2[i])) {
return true;
}
if(Number(v1[i]) < Number(v2[i])) {
return false;
}
}
return (v1.length >= v2.length);
}
下面是一些测试:
console.log(versionCompare("4.4.0","4.4.1"));
console.log(versionCompare("5.24","5.2"));
console.log(versionCompare("4.1","4.1.2"));
console.log(versionCompare("4.1.2","4.1"));
console.log(versionCompare("4.4.4.4","4.4.4.4.4"));
console.log(versionCompare("4.4.4.4.4.4","4.4.4.4.4"));
console.log(versionCompare("0","1"));
console.log(versionCompare("1","1"));
console.log(versionCompare("","1"));
console.log(versionCompare("10.0.1","10.1"));
这里有一个递归版本
function versionCompare(myVersion, minimumVersion) {
return recursiveCompare(myVersion.split("."),minimumVersion.split("."),Math.min(myVersion.length, minimumVersion.length),0);
}
function recursiveCompare(v1, v2,minLength, index) {
if(Number(v1[index]) < Number(v2[index])) {
return false;
}
if(Number(v1[i]) < Number(v2[i])) {
return true;
}
if(index === minLength) {
return (v1.length >= v2.length);
}
return recursiveCompare(v1,v2,minLength,index+1);
}
其他回答
我写了一个排序版本的节点模块，你可以在这里找到它:version-sort
特点:
序列“1.0.1.5.53.54654.114.1.154.45”不受限制 不限制序列长度:'1.1546515465451654654654654138754431574364321353734'工作 可以根据版本对对象进行排序(参见README) 阶段(如alpha, beta, rc1, rc2)
如果您需要其他功能，请不要犹豫，打开一个问题。
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
}
}
我认为这是一个值得分享的实现，因为它简短，简单，但功能强大。请注意，它只使用数字比较。通常它会检查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
下面是一个版本，它对版本字符串进行排序，而不分配任何子字符串或数组。由于它分配的对象更少，GC要做的工作也就更少。
有一对分配(允许重用getVersionPart方法)，但是如果您对性能非常敏感，您可以扩展它以完全避免分配。
const compareVersionStrings : (a: string, b: string) => number = (a, b) =>
{
var ia = {s:a,i:0}, ib = {s:b,i:0};
while (true)
{
var na = getVersionPart(ia), nb = getVersionPart(ib);
if (na === null && nb === null)
return 0;
if (na === null)
return -1;
if (nb === null)
return 1;
if (na > nb)
return 1;
if (na < nb)
return -1;
}
};
const zeroCharCode = '0'.charCodeAt(0);
const getVersionPart = (a : {s:string, i:number}) =>
{
if (a.i >= a.s.length)
return null;
var n = 0;
while (a.i < a.s.length)
{
if (a.s[a.i] === '.')
{
a.i++;
break;
}
n *= 10;
n += a.s.charCodeAt(a.i) - zeroCharCode;
a.i++;
}
return n;
}
我也遇到了版本比较的问题，但是版本可能包含任何内容(例如:不是点的分隔符，像rc1, rc2…)
我使用了这个方法，它基本上将版本字符串分为数字和非数字，并尝试根据类型进行比较。
function versionCompare(a,b) {
av = a.match(/([0-9]+|[^0-9]+)/g)
bv = b.match(/([0-9]+|[^0-9]+)/g)
for (;;) {
ia = av.shift();
ib = bv.shift();
if ( (typeof ia === 'undefined') && (typeof ib === 'undefined') ) { return 0; }
if (typeof ia === 'undefined') { ia = '' }
if (typeof ib === 'undefined') { ib = '' }
ian = parseInt(ia);
ibn = parseInt(ib);
if ( isNaN(ian) || isNaN(ibn) ) {
// non-numeric comparison
if (ia < ib) { return -1;}
if (ia > ib) { return 1;}
} else {
if (ian < ibn) { return -1;}
if (ian > ibn) { return 1;}
}
}
}
对于某些情况，这里有一些假设，例如:"1.01" === "1.1"，或"1.8" < "1.71"。它无法管理“1.0.0-rc”。1" < "1.0.0"，由语义版本2.0.0指定
