从Javascript中的字符串获取版本号？

我有一个3位数的版本号作为字符串

var version = "1.2.3";

并想将其与另一个版本进行比较。要查看版本是否比其他版本更新

var otherVersion = "1.2.4";

---

你会怎么做

使用其中一个比较运算符

“1.2.3”>“1.2.4”//false

“1.2.3”<“1.2.4”//true

伪：

• 在

• 按顺序比较零件：主要->次要->版本（如果两个版本都有零件）
• 如果oV[n]>v[n]：oV是最大的
• 其他：比较下一个子部分

---

（请参阅@arhorns以了解优雅的实现）

如果确实每个部分只有一位数字，为什么不直接使用比较法呢

>>> var version = "1.2.3"; var otherVersion = "1.2.4"; version < otherVersion
true

---

例如，您可能希望使用以下实现（）：

函数较新（a、b）{
var partsA=a.split（'.'）；
var partsB=b.split（'.'）；
var numParts=partsA.length>partsB.length？partsA.length:partsB.length；
var i；
对于（i=0；i（parseInt（partsA[i]，10）| | 0））；
}
}
返回false；
}
log（isNewer（'1.2.3'，'1.2.4'）；//真的
log（isNewer（'1.2.3'，'1.2.0'）；//假的
log（isNewer（'1.2.3'，'1.2.3.1'）；//真的
log（isNewer（'1.2.3'，'1.2.2.9'）；//假的
console.log（isNewer（'1.2.3'，'1.2.10'）；//真的

请注意，必须使用

parseInt（）

，否则最后一个测试将返回

false

：

“10”>“3”

返回

false
可能是这样（快速）

函数较新（s0、s1）{
变量v0=s0.拆分（'.'），v1=s1.拆分（'.'）；
变量len0=v0.length，len1=v1.length；
var temp0，temp1，idx=0；
while（idxidx）{
temp1=parseInt（v1[idx]，10）；
如果（temp1>temp0）{return true；}
}
idx+=1；
}
if（parseInt（v0[idx-1]，10）>parseInt（v1[idx-1]，10））{return false；}
返回len1>len0；
}
var version=“1.2.3”；
var otherVersion=“1.2.4”；
log（'newer:'+（isNewer（version，otherVersion））；

它负责不同数量的部件，但只适用于点之间的数字。
大多数提交的版本的问题是，它们无法处理任何数量的版本部件（例如1.4.2..1.2等）和/或它们要求版本部件为单个数字，这实际上并不常见

改进的compareVersions（）函数

如果v1大于v2，此函数将返回1；如果v2大于v2，则返回1
如果版本相同，则为0（也便于自定义排序）

我没有对输入进行任何错误检查

function compareVersions (v1, v2)
{
    v1 = v1.split('.');
    v2 = v2.split('.');
    var longestLength = (v1.length > v2.length) ? v1.length : v2.length;
    for (var i = 0; i < longestLength; i++) {
        if (v1[i] != v2[i]) {
            return (v1 > v2) ? 1 : -1
        }
    }
    return 0; 
 }

函数比较（v1、v2）
{
v1=v1.拆分（'.'）；
v2=v2.拆分（'.'）；
var longestLength=（v1.length>v2.length）？v1.length:v2.length；
对于（变量i=0；iv2）？1:-1
}
}
返回0；
}
由于我很无聊，这里有一种类似于我们的十进制系统（十、百、千等）的方法，它使用regex回调而不是循环：

function compareVersion(a, b) {
    var expr = /\d+/g, places = Math.max(a.split(expr).length, b.split(expr).length);
    function convert(s) {
        var place = Math.pow(100, places), total = 0;
        s.replace(expr,
            function (n) {
                total += n * place;
                place /= 100;
            }
        );
        return total;
    };

    if (convert(a) > convert(b)) {
        return a;
    }

    return b;
}

它返回更大的版本，例如：

compareVersion('1.4', '1.3.99.32.60.4'); // => 1.4

请注意，对于
0.9beta
或
1.0rc1
之类的问题，这些解决方案都不会故意返回正确的结果。然而，它在PHP中的处理非常直观：这有一个JS端口：（我不认为这是非常好或有效的，只是有点“完整”）。
函数是正确的版本（已使用，必需）{
var used=parseFloat（“0.”+used.replace（/\./gi，”）；
var required=parseFloat（“0.”+required.replace（/\./gi，”）；
返回（已使用<必需）？假：真；
}

我用它来比较jQuery函数，它似乎工作得很好，还比较了例如1.4与1.4.1或1.4.1与1.4.11。
我找不到一个返回1、0或-1并同时处理尾随的.0和两位数部分的答案。这应该支持所有部分都是数字的情况（参见底部的测试）

/*
*如果v1较新，则返回1；如果v2较新，则返回1；如果两者相等，则返回0。
*将忽略版本末尾的.0s。
*
*如果某个版本的计算结果为false，则该版本将被视为0。
*
*示例：
*比较（“2.0”、“2”）输出0，
*比较（“2.0.1”、“2”）输出1，
*比较（“0.2”、“0.12.1”）输出-1，
*
*/
函数比较（版本1、版本2）{
var version1=version1？version1.split（'.'）：['0']，
version2=version2？version2.split（'.'）：['0']，
最长=数学最大值（version1.length，version2.length）；
对于（变量i=0；iv2Part）？1:-1；
}
返回0；
}
}
返回0；
}
console.log（比较（“1”、“1”）==0）；
日志（比较（“1.1”、“1”）==1）；
日志（比较（“1.1.1”、“1”）==1）；
有限公司
function isNewer(s0, s1) {
    var v0 = s0.split('.'), v1 = s1.split('.');
    var len0 = v0.length, len1=v1.length;
    var temp0, temp1, idx = 0;
    while (idx<len0) {
        temp0 = parseInt(v0[idx], 10);
        if (len1>idx) {
            temp1 = parseInt(v1[idx], 10);
            if (temp1>temp0) {return true;}
        }
        idx += 1;
    }
    if (parseInt(v0[idx-1], 10)>parseInt(v1[idx-1], 10)) {return false;}
    return len1 > len0;
}
var version = "1.2.3";
var otherVersion = "1.2.4";

console.log('newer:'+(isNewer(version, otherVersion)));

function compareVersions (v1, v2)
{
    v1 = v1.split('.');
    v2 = v2.split('.');
    var longestLength = (v1.length > v2.length) ? v1.length : v2.length;
    for (var i = 0; i < longestLength; i++) {
        if (v1[i] != v2[i]) {
            return (v1 > v2) ? 1 : -1
        }
    }
    return 0; 
 }

function compareVersion(a, b) {
    var expr = /\d+/g, places = Math.max(a.split(expr).length, b.split(expr).length);
    function convert(s) {
        var place = Math.pow(100, places), total = 0;
        s.replace(expr,
            function (n) {
                total += n * place;
                place /= 100;
            }
        );
        return total;
    };

    if (convert(a) > convert(b)) {
        return a;
    }

    return b;
}

compareVersion('1.4', '1.3.99.32.60.4'); // => 1.4

function isCorrectVersion(used,required){
    var used = parseFloat("0."+used.replace(/\./gi,""));
    var required = parseFloat("0."+required.replace(/\./gi,""));

    return (used < required) ? false : true;
}

/*
 * Returns 1 if v1 is newer, -1 if v2 is newer and 0 if they are equal.
 * .0s at the end of the version will be ignored.
 *
 * If a version evaluates to false it will be treated as 0.
 *
 * Examples:
 * compareVersions ("2.0", "2") outputs 0,
 * compareVersions ("2.0.1", "2") outputs 1,
 * compareVersions ("0.2", "0.12.1") outputs -1,
 *
 */
function compareVersions (version1, version2) {
  var version1 = version1 ? version1.split('.') : ['0'],
      version2 = version2 ? version2.split('.') : ['0'],
      longest = Math.max(version1.length, version2.length);

  for (var i = 0; i < longest; i++) {
    /*
     * Convert to ints so that we can compare two digit parts
     * properly. (Otherwise would "2" be greater than "12").
     *
     * This returns NaN if the value is undefined, so we check for
     * NaN later.
     */
    var v1Part = parseInt(version1[i]),
        v2Part = parseInt(version2[i]);

    if (v1Part != v2Part) {

      // version2 is longer
      if (isNaN(v1Part)) {
        /*
         * Go through the rest of the parts of version 2. If it is only zeros,
         * consider the versions equal, otherwise consider version 2 as newer.
         */
        for (var j = i; j < longest; j++) {
          if (parseInt(version2[j]) != 0) return -1;
        }

      // version1 is longer
      } else if (isNaN(v2Part)) {
        for (var j = i; j < longest; j++) {
          if (parseInt(version1[j]) != 0) return 1;
        }

      // versions are equally long
      } else {
        return (v1Part > v2Part) ? 1 : -1;
      }
      return 0;
    }
  }
  return 0;
}

console.log(compareVersions("1", "1") === 0);
console.log(compareVersions("1.1", "1") === 1);
console.log(compareVersions("1.1.1", "1") === 1);
console.log(compareVersions("1", "1.1.1") === -1);
console.log(compareVersions("0.3", "0.3.0.0.1") === -1);
console.log(compareVersions("0.3", "0.3.0") === 0);
console.log(compareVersions("0.3.0.0.1", "0.3") === 1);
console.log(compareVersions("0.3.0", "0.3") === 0);
console.log(compareVersions("0.12", "0.2") === 1);
console.log(compareVersions("0.2", "0.12") === -1);
console.log(compareVersions("0.12.0", "0.2") === 1);
console.log(compareVersions("0.02.0", "0.2") === 0);
console.log(compareVersions("0.01.0", "0.2") === -1);