如何比较任意版本号？

Question

有人有在 JavaScript 中比较两个版本号的代码吗？我只想要简单的版本比较（例如 "1.0" 与 "1.5.6"），并且它应该适用于数字或字符串。它可以忽略尾随的 beta 标识符，例如 "1.5.6b4"，但可以期望字符串格式良好。该函数应像普通 cmp 函数一样返回一个有符号整数。

function cmpVersion(a, b)
  return less than one if a < b
  return 0 if a == b
  return greater than one if a > b

我有一个答案，但会选择一个比我自己的更好或更优雅的解决方案。

（我用它来比较 jQuery.browser.version 数字，但答案将更广泛适用）

Answer 1

如果您不关心 .5.6，请使用 parseInt

var majorV = parseInt("1.5.6",10)

既然你说你关心小版本：

function cmpVersion(v1, v2) {
    if(v1===v2) return 0;
    var a1 = v1.toString().split(".");
    var a2 = v2.toString().split(".");
    for( var i = 0; i < a1.length && i < a2.length; i++ ) {
        var diff = parseInt(a1[i],10) - parseInt(a2[i],10);
        if( diff>0 ) {
            return 1;
        }
        else if( diff<0 ) {
            return -1;
        }
    }
    diff = a1.length - a2.length;
    return (diff>0) ? 1 : (diff<0) ? -1 : 0;
}

console.log( cmpVersion( "1.0", "1.56") );
console.log( cmpVersion( "1.56", "1.56") );
console.log( cmpVersion( "1.65", "1.5.6") );
console.log( cmpVersion( "1.0", "1.5.6b3") );

Answer 2

如果版本大于或等于最小版本，则此函数返回 true。当版本为字符串时，假定 1.0 大于 1。当它们是数字时，就表示它们是相同的。如果您想让两种类型返回相同的值，那么您需要将数字转换为字符串，这也很容易。或者您可以修改字符串条件来检查较长的版本号是否全部尾随零，例如 1.1 与 1.1.0.0.0.0。第二个全是尾随零

 function doesMyVersionMeetMinimum(myVersion, minimumVersion) {

    if(typeof myVersion === 'number' && typeof minimumVersion === 'number') {
      return(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 false;
        }
       else if(Number(v1[i]) < Number(v2[i])) {
            return true;
        }           

    }

    return (v1.length >= v2.length);
}

Answer 3

function cmpVersion(a, b) {
    var i, cmp, len;
    a = (a + '').split('.');
    b = (b + '').split('.');
    len = Math.max(a.length, b.length);
    for( i = 0; i < len; i++ ) {
        if( a[i] === undefined ) {
            a[i] = '0';
        }
        if( b[i] === undefined ) {
            b[i] = '0';
        }
        cmp = parseInt(a[i], 10) - parseInt(b[i], 10);
        if( cmp !== 0 ) {
            return (cmp < 0 ? -1 : 1);
        }
    }
    return 0;
}

function gteVersion(a, b) {
    return cmpVersion(a, b) >= 0;
}
function ltVersion(a, b) {
    return cmpVersion(a, b) < 0;
}

该函数处理：

• 数字或字符串作为输入
• 尾随零（例如 cmpVersion("1.0", 1) 返回 0）
• 忽略尾随 alpha、<代码>b、pre4等

Answer 4

如果您想完全正确，请查看 PEP386 上的讨论，尤其是标题“新版本控制算法”。

否则看起来你的答案很好。

Answer 5

npm 使用很好的语法来比较版本，您可以在这里获取相同的模块： https://github.com/ isaacs/node-semver

支持以下范围样式：

• 1.2.3 特定版本。当没有其他事可以做的时候。请注意，构建元数据仍然被忽略，因此 1.2.3+build2012 将满足此范围。
• >1.2.3 大于特定版本。
• <1.2.3 小于特定版本。如果版本范围上没有预发布标签，则也不会允许预发布版本，即使这些版本在技术上“小于”。
• >=1.2.3 大于或等于。请注意，预发布版本不等于其“正常”版本，因此 1.2.3-beta 不会满足此范围，但 2.3.0-beta 可以。
• <=1.2.3 小于或等于。在这种情况下，允许预发布版本，因此 1.2.3-beta 就可以满足。
• 1.2.3 - 2.3.4 := >=1.2.3 <=2.3.4
• ~1.2.3 := >=1.2.3-0 <1.3.0-0 “相当接近 1.2.3”。使用波形符运算符时，也支持预发布版本，但下一个有效数字的预发布将无法令人满意，因此 1.3.0-beta 将不满足 ~1.2.3代码>.
• ^1.2.3 := >=1.2.3-0 <2.0.0-0 “与 1.2.3 兼容”。使用脱字符号运算符时，指定版本（包括预发行版）中的任何内容都将受到支持，直到但不包括下一个主要版本（或其预发行版）。 1.5.1 将满足 ^1.2.3，而 1.2.2 和 2.0.0-beta 则不会。
• ^0.1.3 := >=0.1.3-0 <0.2.0-0 “与 0.1.3 兼容”。 0.xx 版本很特殊：第一个非零组件表示潜在的重大更改，这意味着插入符号运算符与从指定版本开始具有相同第一个非零组件的任何版本相匹配。
• ^0.0.2 := =0.0.2 "只有 0.0.2 版本才被认为是兼容的"
• ~1.2 := > ;=1.2.0-0 <1.3.0-0 "以 1.2 开头的任何版本"
• ^1.2 := >=1.2.0-0 <2.0.0-0 “与 1.2 兼容的任何版本”
• 1.2.x := >=1.2.0 -0 <1.3.0-0 "以 1.2 开头的任何版本"
• ~1 := >=1.0.0-0 <2.0.0-0 "以 1 开头的任何版本"
• ^1 := >=1.0.0-0 <2.0.0-0 "与 1 兼容的任何版本"
• 1.x := >=1.0.0-0 <2.0.0-0 "以 1 开头的任何版本"

范围可以用空格（暗示“和”）或
||（暗示“或”）。

Answer 6

我制作了以下函数，它支持尾随字母、前导零……（参见下面的示例）：

function cmpVersions(a, b) {

    var partsA = a.split('.');
    var partsB = b.split('.');
    var nbParts = Math.max(partsA.length, partsB.length);

    for (var i = 0; i < nbParts; ++i) {
        if (partsA[i] === undefined) {
            partsA[i] = '0';
        }
        if (partsB[i] === undefined) {
            partsB[i] = '0';
        }

        // edit: added this part
        // - fixes the important case "1.2 / 1.10"
        // - but breaks the not-so-important case "1.02 / 1.1"
        var intA = parseInt(partsA[i], 10);
        var intB = parseInt(partsB[i], 10);
        if (!isNaN(intA) && !isNaN(intB)) {
            if (intA > intB) {
                return 1;
            } else if (intA < intB) {
                return -1;
            }
        }

        var compare = partsA[i].localeCompare(partsB[i]);
        if (compare !== 0) {
            return compare;
        }
    }

    return 0;
}

所以，有几个例子：

// trailing letters
cmpVersion('1.0a', '1.0b'); // -1

// leading zeroes
cmpVersion('1.01', '1.1'); // -1

// "zero" parts
cmpVersion('1', '1.0'); // 0

如果您不需要支持前导零，这里有一个更简单的替代方案：

function cmpVersions(a, b) {

    function padParts(version) {
        return version
            .split('.')
            .map(function (part) {
                return '00000000'.substr(0, 8 - part.length) + part;
            })
            .join('.');
    }

    a = padParts(a);
    b = padParts(b);

    return a.localeCompare(b);
}

快速更新：后来我注意到第一个函数将“1.2”排序在“1.10”之前，这是明显错误的。此外，“重要的前导零”是棘手且不明确的（无论是解释还是实现），语义版本控制明确避免它们。因此，我认为第二个功能应该始终是首选。

更新2：但是第二个函数将“1.2a”排序在“1.1”之前...我认为没有“一应俱全”的函数...根据以下内容选择“更合适”的函数您的用例，或者更好的是，如果可以的话，按日期排序。

更新3：修改了第一个函数以正确处理重要情况“1.2 / 1.10”。作为副作用，它打破了不那么重要的情况“1.02 / 1.1”，显然它现在是唯一的警告（也许它可以被修复，但我不确定它是否值得）。因此，我现在推荐固定的第一个函数。

Answer 7

function compareVersion(a, b) {
    return compareVersionRecursive(a.split("."), b.split("."));
}

function compareVersionRecursive(a, b) {
    if (a.length == 0) {
        a = [0];
    }
    if (b.length == 0) {
        b = [0];
    }
    if (a[0] != b[0] || (a.length == 1 && b.length == 1)) {
        return a[0] - b[0];
    }
    return compareVersionRecursive(a.slice(1), b.slice(1));
}

Answer 8

我已经将我的内容重构为尽可能简洁。它不检查尾随零，但适用于任何长度的内部版本号（例如，major、major.minor、major.minor.build）。

var cmpVersion = function(a, b) {
  let arrA = Array.from(a.split('.'), i => +i);
  let arrB = Array.from(b.split('.'), i => +i);

  for (let i = 0; i < (arrA.length >= arrB.length ? arrA.length : arrB.length); i++) {
    if (arrA[i] && !arrB[i] || arrA[i] > arrB[i]) return 'less than one';
    else if (!arrA[i] && arrB[i] || arrA[i] < arrB[i]) return 'greater than one';
  }
  return 0;
}

基本上，首先我从每个版本字符串中创建了一个新数组，以便我可以单独比较每个数字。然后在 for 循环中，我选择最长版本字符串的长度（如果它们长度相等，则选择第一个版本字符串的长度）。

if 语句检查 a 中是否有数字但 b 中没有，或者对于相应的占位符，a 的数字是否大于 b 的数字，在这种情况下，它将返回“小于一”。

同样，else 语句检查 b 中是否有数字但 a 中没有，或者 b 的数字是否大于相应位值的 a 的数字，在这种情况下，它将返回“大于一” 。

最后一个 return 0 语句是一个包罗万象的语句，如果版本字符串相等，我们的函数就会到达它。