如何使用js比较软件版本号?(仅数字)

2020/10/22 21:03 · javascript ·  · 0评论

这是软件版本号:

"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"

而且更清楚地看到背后的想法是什么...但是,如何将其转换为计算机程序?有人对如何排序有任何想法吗?谢谢。

进行比较的基本思想是使用Array.split从输入字符串中获取零件的数组,然后比较两个数组中的零件对。如果零件不相等,我们知道哪个版本较小。

需要牢记一些重要的细节:

  1. 每对中的部分应该如何比较?这个问题想进行数字比较,但是如果我们有不是仅由数字组成的版本字符串(例如“ 1.0a”)怎么办?
  2. 如果一个版本字符串比其他版本字符串包含更多部分,应该怎么办?最有可能将“ 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.mapArray.every,这意味着它将无法在9之前的IE版本中运行。如果需要支持这些代码,则必须为缺少的方法提供polyfills。

塞姆弗

npm使用的语义版本解析器。

$ npm安装semver

var semver = require('semver');

semver.diff('3.4.5', '4.3.7') //'major'
semver.diff('3.4.5', '3.3.7') //'minor'
semver.gte('3.4.8', '3.4.7') //true
semver.ltr('3.4.8', '3.4.7') //false

semver.valid('1.2.3') // '1.2.3'
semver.valid('a.b.c') // null
semver.clean(' =v1.2.3 ') // '1.2.3'
semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
semver.gt('1.2.3', '9.8.7') // false
semver.lt('1.2.3', '9.8.7') // true

var versions = [ '1.2.3', '3.4.5', '1.0.2' ]
var max = versions.sort(semver.rcompare)[0]
var min = versions.sort(semver.compare)[0]
var max = semver.maxSatisfying(versions, '*')

语义版本控制链接https :
//www.npmjs.com/package/semver#prerelease-identifiers

// Return 1 if a > b
// Return -1 if a < b
// Return 0 if a == b
function compare(a, b) {
    if (a === b) {
       return 0;
    }

    var a_components = a.split(".");
    var b_components = b.split(".");

    var len = Math.min(a_components.length, b_components.length);

    // loop while the components are equal
    for (var i = 0; i < len; i++) {
        // A bigger than B
        if (parseInt(a_components[i]) > parseInt(b_components[i])) {
            return 1;
        }

        // B bigger than A
        if (parseInt(a_components[i]) < parseInt(b_components[i])) {
            return -1;
        }
    }

    // If one's a prefix of the other, the longer one is greater.
    if (a_components.length > b_components.length) {
        return 1;
    }

    if (a_components.length < b_components.length) {
        return -1;
    }

    // Otherwise they are the same.
    return 0;
}

console.log(compare("1", "2"));
console.log(compare("2", "1"));

console.log(compare("1.0", "1.0"));
console.log(compare("2.0", "1.0"));
console.log(compare("1.0", "2.0"));
console.log(compare("1.0.1", "1.0"));

这个非常小而又非常快的比较功能是每段采用任意长度任意数字大小的版本号

返回值:

-
< 0如果a <b

为数字-
> 0如果a> b为数字

-
0如果a = b

因此,您可以将其用作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"]

取自http://java.com/js/deployJava.js

    // return true if 'installed' (considered as a JRE version string) is
    // greater than or equal to 'required' (again, a JRE version string).
    compareVersions: function (installed, required) {

        var a = installed.split('.');
        var b = required.split('.');

        for (var i = 0; i < a.length; ++i) {
            a[i] = Number(a[i]);
        }
        for (var i = 0; i < b.length; ++i) {
            b[i] = Number(b[i]);
        }
        if (a.length == 2) {
            a[2] = 0;
        }

        if (a[0] > b[0]) return true;
        if (a[0] < b[0]) return false;

        if (a[1] > b[1]) return true;
        if (a[1] < b[1]) return false;

        if (a[2] > b[2]) return true;
        if (a[2] < b[2]) return false;

        return true;
    }

简单和简短的功能:

function isNewerVersion (oldVer, newVer) {
  const oldParts = oldVer.split('.')
  const newParts = newVer.split('.')
  for (var i = 0; i < newParts.length; i++) {
    const a = parseInt(newParts[i]) || 0
    const b = parseInt(oldParts[i]) || 0
    if (a > b) return true
    if (a < b) return false
  }
  return false
}

测试:

isNewerVersion('1.0', '2.0') // true
isNewerVersion('1.0', '1.0.1') // true
isNewerVersion('1.0.1', '1.0.10') // true
isNewerVersion('1.0.1', '1.0.1') // false
isNewerVersion('2.0', '1.0') // false
isNewerVersion('2', '1.0') // false
isNewerVersion('2.0.0.0.0.1', '2.1') // true
isNewerVersion('2.0.0.0.0.1', '2.0') // false

在这里找不到我想要的功能。所以我写了我自己的。这是我的贡献。我希望有人觉得它有用。

优点:

  • 处理任意长度的版本字符串。'1'或'1.1.1.1.1'。

  • 如果未指定,则将每个值默认为0。仅仅因为字符串更长并不意味着它是一个更大的版本。(“ 1”应与“ 1.0”和“ 1.0.0.0”相同。)

  • 比较数字而不是字符串。(“ 3” <“ 21”应为true。不能为false。)

  • 不要在循环中浪费时间进行无用的比较。(与==相比)

  • 您可以选择自己的比较器。

缺点:

  • 它不处理版本字符串中的字母。(我不知道那怎么办?)

我的代码,类似于乔恩接受的答案

function compareVersions(v1, comparator, v2) {
    "use strict";
    var comparator = comparator == '=' ? '==' : comparator;
    if(['==','===','<','<=','>','>=','!=','!=='].indexOf(comparator) == -1) {
        throw new Error('Invalid comparator. ' + comparator);
    }
    var v1parts = v1.split('.'), v2parts = v2.split('.');
    var maxLen = Math.max(v1parts.length, v2parts.length);
    var part1, part2;
    var cmp = 0;
    for(var i = 0; i < maxLen && !cmp; i++) {
        part1 = parseInt(v1parts[i], 10) || 0;
        part2 = parseInt(v2parts[i], 10) || 0;
        if(part1 < part2)
            cmp = 1;
        if(part1 > part2)
            cmp = -1;
    }
    return eval('0' + comparator + cmp);
}

例子

compareVersions('1.2.0', '==', '1.2'); // true
compareVersions('00001', '==', '1.0.0'); // true
compareVersions('1.2.0', '<=', '1.2'); // true
compareVersions('2.2.0', '<=', '1.2'); // false

这是另一个简短版本,适用于任意数量的子版本,填充零甚至带字母的数字(1.0.0b3)

function compareVer(a, b)
{
    function fix(t)
    {
        return ("" + t)
                //treat non-numerical characters as lower version
                //replacing them with a negative number based on charcode of first character
                .replace(/[^0-9\.]+/g, function(c){return "." + (c.replace(/^[\W_]+/, "").toLowerCase().charCodeAt(0) - 65536) + "."})
                //remove trailing "." and "0"
                .replace(/^\.|0*\.$/g, "")
                //remove trailing "0" if followed by non-numerical characters (1.0.0b);
                .replace(/(\.0)*(\.-[0-9]+)(\.[0-9]+)?$/g, function(a,b,c,d){return c + (d ?  d : "")})
                .split('.');
    }
    a = fix(a);
    b = fix(b);
    for (var i = 0, c = Math.max(a.length, b.length); i < c; i++)
    {
        //convert to integer the most efficient way
        a[i] = ~~a[i];
        b[i] = ~~b[i];
        if (a[i] > b[i])
            return 1;
        else if (a[i] < b[i])
            return -1;
    }
    return 0;
}

函数返回:

0a = b

1a > b

-1a < b

1.0         = 1.0.0.0.0.0
1.0         < 1.0.1
1.0b1       < 1.0
1.0b        = 1.0b
1.1         > 1.0.1b
1.1alpha    < 1.1beta
1.1rc1      > 1.1beta
1.1rc1      < 1.1rc2
1.1.0a1     < 1.1a2
1.1.0a10    > 1.1.0a1
1.1.0alpha  = 1.1a
1.1.0alpha2 < 1.1b1
1.0001      > 1.00000.1.0.0.0.01

https://jsfiddle.net/vanowm/p7uvtbor/

如果您没有在链接中访问过此想法,请原谅我。

我已经成功地将零件转换成加权总和,如下所示:

partSum = this.major * Math.Pow(10,9);
partSum += this.minor * Math.Pow(10, 6);
partSum += this.revision * Math.Pow(10, 3);
partSum += this.build * Math.Pow(10, 0);

这使得比较非常容易(比较双精度)。我们的版本字段不得超过4位。

7.10.2.184  -> 7010002184.0
7.11.0.1385 -> 7011001385.0

我希望这对某人有帮助,因为多种条件似乎有些过分了。

2017年答案:

v1 = '20.0.12'; 
v2 = '3.123.12';

compareVersions(v1,v2) 
// return positive: v1 > v2, zero:v1 == v2, negative: v1 < v2 
function compareVersions(v1, v2) {
        v1= v1.split('.')
        v2= v2.split('.')
        var len = Math.max(v1.length,v2.length)
        /*default is true*/
        for( let i=0; i < len; i++)
            v1 = Number(v1[i] || 0);
            v2 = Number(v2[i] || 0);
            if (v1 !== v2) return v1 - v2 ;
            i++;
        }
        return 0;
    }

现代浏览器的最简单代码:

 function compareVersion2(ver1, ver2) {
      ver1 = ver1.split('.').map( s => s.padStart(10) ).join('.');
      ver2 = ver2.split('.').map( s => s.padStart(10) ).join('.');
      return ver1 <= ver2;
 }

这里的想法是比较数字,但以字符串形式。为了使比较有效,两个字符串的长度必须相同。所以:

"123" > "99"成为"123" > "099"

填充所述短号码“修复”的比较

在这里,我用零填充每个部分的长度为10。然后使用简单的字符串比较作为答案

范例:

var ver1 = '0.2.10', ver2=`0.10.2`
//become 
ver1 = '0000000000.0000000002.0000000010'
ver2 = '0000000000.0000000010.0000000002'
// then it easy to see that
ver1 <= ver2 // true

检查version_compare()php.js项目中的功能它类似于PHP的 version_compare()

您可以像这样简单地使用它:

version_compare('2.0', '2.0.0.1', '<'); 
// returns true

我的答案比这里的大多数答案都少

/**
 * Compare two semver versions. Returns true if version A is greater than
 * version B
 * @param {string} versionA
 * @param {string} versionB
 * @returns {boolean}
 */
export const semverGreaterThan = function(versionA, versionB){
  var versionsA = versionA.split(/\./g),
    versionsB = versionB.split(/\./g)
  while (versionsA.length || versionsB.length) {
    var a = Number(versionsA.shift()), b = Number(versionsB.shift())
    if (a == b)
      continue
    return (a > b || isNaN(b))
  }
  return false
}

尽管这个问题已经有了很多答案,但是每个人都在推广自己的后院解决方案,而与此同时,我们拥有经过(战斗)测试的库的整个生态系统。

NPMGitHub,X上进行快速搜索将为我们提供一些可爱的库,而我想遍历一下:

semver-compare是一个伟大的轻量级(〜230B)lib如果你想通过版本号来排序这是特别有用,因为图书馆的曝光方法返回-101适当。

lib的核心:

module.exports = function cmp (a, b) {
    var pa = a.split('.');
    var pb = b.split('.');
    for (var i = 0; i < 3; i++) {
        var na = Number(pa[i]);
        var nb = Number(pb[i]);
        if (na > nb) return 1;
        if (nb > na) return -1;
        if (!isNaN(na) && isNaN(nb)) return 1;
        if (isNaN(na) && !isNaN(nb)) return -1;
    }
    return 0;
};

compare-semver 的大小相当大(〜4.4kB压缩),但可以进行一些不错的独特比较,例如查找一堆版本的最小值/最大值,或者查找所提供的版本是否唯一或比其他版本中的其他版本少版本。

compare-versions是另一个较小的库(〜630B已压缩),并很好地遵循了规范,这意味着您可以将带有alpha / beta标志甚至通配符的版本进行比较(如次要/补丁版本:1.0.x1.0.*

要点是:如果您可以通过选择的包管理器找到不错的(经过单元测试的)版本,则不一定总是需要从StackOverflow复制粘贴代码

你可以使用String#localeCompareoptions

灵敏度

字符串中的哪些差异应导致非零结果值。可能的值为:

  • "base":只有基本字母不同的字符串才能比较为不相等。例如:a ≠ ba = áa = A
  • "accent":仅将基本字母或重音和其他音标不同的字符串比较为不相等。例如:a ≠ ba ≠ áa = A
  • "case":仅将基本字母或大小写不同的字符串比较为不相等。例如:a ≠ ba = áa ≠ A
  • "variant":基本字母,重音和其他变音符号或大小写不同的字符串比较不相等。还可以考虑其他差异。例如:a ≠ ba ≠ áa ≠ A

用法“ sort”的默认值为“ variant”;它取决于使用情况“搜索”的语言环境。

数字

是否应使用数字排序规则,例如“ 1” <“ 2” <“ 10”。可能的值为truefalse; 默认值为false可以通过options属性或Unicode扩展键设置此选项。如果两者都提供,则该options属性优先。不需要实现来支持此属性。

var versions = ["2.0.1", "2.0", "1.0", "1.0.1", "2.0.0.1"];

versions.sort((a, b) => a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' }));

console.log(versions);

我遇到了类似的问题,并且已经为它创建了解决方案。随时尝试一下。

它返回0equal1如果版本greater-1如果是less

function compareVersion(currentVersion, minVersion) {
  let current = currentVersion.replace(/\./g," .").split(' ').map(x=>parseFloat(x,10))
  let min = minVersion.replace(/\./g," .").split(' ').map(x=>parseFloat(x,10))

  for(let i = 0; i < Math.max(current.length, min.length); i++) {
    if((current[i] || 0) < (min[i] || 0)) {
      return -1
    } else if ((current[i] || 0) > (min[i] || 0)) {
      return 1
    }
  }
  return 0
}


console.log(compareVersion("81.0.1212.121","80.4.1121.121"));
console.log(compareVersion("81.0.1212.121","80.4.9921.121"));
console.log(compareVersion("80.0.1212.121","80.4.9921.121"));
console.log(compareVersion("4.4.0","4.4.1"));
console.log(compareVersion("5.24","5.2"));
console.log(compareVersion("4.1","4.1.2"));
console.log(compareVersion("4.1.2","4.1"));
console.log(compareVersion("4.4.4.4","4.4.4.4.4"));
console.log(compareVersion("4.4.4.4.4.4","4.4.4.4.4"));
console.log(compareVersion("0","1"));
console.log(compareVersion("1","1"));
console.log(compareVersion("1","1.0.00000.0000"));
console.log(compareVersion("","1"));
console.log(compareVersion("10.0.1","10.1"));

这个想法是两个版本的比较,并且知道哪个是最大的版本。我们删除“。” 然后我们比较向量的每个位置

// Return 1  if a > b
// Return -1 if a < b
// Return 0  if a == b

function compareVersions(a_components, b_components) {

   if (a_components === b_components) {
       return 0;
   }

   var partsNumberA = a_components.split(".");
   var partsNumberB = b_components.split(".");

   for (var i = 0; i < partsNumberA.length; i++) {

      var valueA = parseInt(partsNumberA[i]);
      var valueB = parseInt(partsNumberB[i]);

      // A bigger than B
      if (valueA > valueB || isNaN(valueB)) {
         return 1;
      }

      // B bigger than A
      if (valueA < valueB) {
         return -1;
      }
   }
}
// Returns true if v1 is bigger than v2, and false if otherwise.
function isNewerThan(v1, v2) {
      v1=v1.split('.');
      v2=v2.split('.');
      for(var i = 0; i<Math.max(v1.length,v2.length); i++){
        if(v1[i] == undefined) return false; // If there is no digit, v2 is automatically bigger
        if(v2[i] == undefined) return true; // if there is no digit, v1 is automatically bigger
        if(v1[i] > v2[i]) return true;
        if(v1[i] < v2[i]) return false;
      }
      return false; // Returns false if they are equal
    }

现在我们可以使用Intl.CollatorAPI创建数字比较器。浏览器支持相当不错,但是在撰写本文时,Node.js不支持浏览器

const semverCompare = new Intl.Collator("en", { numeric: true }).compare;

const versions = ['1.0.1', '1.10.2', '1.1.1', '1.10.1', '1.5.10', '2.10.0', '2.0.1'];

console.log(versions.sort(semverCompare))

const example2 = ["1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"];
console.log(example2.sort(semverCompare))

replace()函数仅替换字符串中的第一个匹配项。因此,让更换.,随后删除所有.,使,.再次解析它漂浮。

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

例如,如果我们要检查当前jQuery版本是否小于1.8,则版本为“ 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/

这是一个巧妙的把戏。如果要处理数字值,请在特定范围的值之间,为版本对象的每个级别分配一个值。例如,此处的“ largestValue”设置为0xFF,这会为您的版本创建非常“ IP”的外观。

这也可以处理字母数字版本控制(即1.2a <1.2b)

// The version compare function
function compareVersion(data0, data1, levels) {
    function getVersionHash(version) {
        var value = 0;
        version = version.split(".").map(function (a) {
            var n = parseInt(a);
            var letter = a.replace(n, "");
            if (letter) {
                return n + letter[0].charCodeAt() / 0xFF;
            } else {
                return n;
            }
        });
        for (var i = 0; i < version.length; ++i) {
            if (levels === i) break;
            value += version[i] / 0xFF * Math.pow(0xFF, levels - i + 1);
        }
        return value;
    };
    var v1 = getVersionHash(data0);
    var v2 = getVersionHash(data1);
    return v1 === v2 ? -1 : v1 > v2 ? 0 : 1;
};
// Returns 0 or 1, correlating to input A and input B
// Direct match returns -1
var version = compareVersion("1.254.253", "1.254.253a", 3);

这是一个适用于Array.sort的coffeescript实现,灵感来自此处的其他答案:

# Returns > 0 if v1 > v2 and < 0 if v1 < v2 and 0 if v1 == v2
compareVersions = (v1, v2) ->
  v1Parts = v1.split('.')
  v2Parts = v2.split('.')
  minLength = Math.min(v1Parts.length, v2Parts.length)
  if minLength > 0
    for idx in [0..minLength - 1]
      diff = Number(v1Parts[idx]) - Number(v2Parts[idx])
      return diff unless diff is 0
  return v1Parts.length - v2Parts.length

我编写了一个用于对版本进行排序的节点模块,您可以在这里找到它:version-sort

特点

  • 无序列限制'1.0.1.5.53.54654.114.1.154.45'有效
  • 序列长度无限制:“ 1.1546515465451654654654654138754431574364364321353734”作品
  • 可以按版本对对象进行排序(请参阅自述文件)
  • 阶段(例如alpha,beta,rc1,rc2)

如果您需要其他功能,请不要犹豫。

这适用于以句点分隔的任何长度的数字版本。仅当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);
}

(大多数时候)2020年正确的JavaScript答案

无论尼娜肖尔茨2020年3月和 希德Vishnoi在2020年4月后现代的答案:

var versions = ["2.0.1", "2.0", "1.0", "1.0.1", "2.0.0.1"];

versions.sort((a, b) => 
   a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' })
);

console.log(versions);

localCompare已经存在一段时间了

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collat​​or/Collat​​or

但是关于1.0a1.0.1呢?

localCompare不能解决问题,仍然会返回 1.0.1 , 1.0a

Michael Deal在他的(冗长而复杂)的解决方案中已经在2013年破解了该问题

他将Numbers转换为另一个Base,以便可以更好地对其进行排序

他的回答让我开始想...

666-不要以数字思考-999

排序是基于ASCII值的字母数字,因此让我们(ab)使用ASCII作为“基础”

我的解决方案是将1.0.2.1转换bacb转换bacb,然后进行排序

这解决了1.11.0.0.0.1有:BBbaaab

并立即用符号解决了1.0a1.0.1排序问题:baabab

转换是通过以下方式完成的:

    const str = s => s.match(/(\d+)|[a-z]/g)
                      .map(c => c == ~~c ? String.fromCharCode(97 + c) : c);

=计算0 ... 999个数字的ASCII值,否则为concat字母

1.0a>>> [ "1" , "0" , "a" ]>>>[ "b" , "a" , "a" ]

为了比较起见,不需要将其连接到一个字符串 .join("")

Oneliner

const sortVersions=(x,v=s=>s.match(/(\d+)|[a-z]/g)
                            .map(c=>c==~~c?String.fromCharCode(97+c):c))
                    =>x.sort((a,b)=>v(b)<v(a)?1:-1)

测试代码段:

function log(label,val){
  document.body.append(label,String(val).replace(/,/g," - "),document.createElement("BR"));
}

let v = ["1.90.1", "1.9.1", "1.89", "1.090", "1.2", "1.0a", "1.0.1", "1.10", "1.0.0a"];
log('not sorted input :',v);

v.sort((a, b) => a.localeCompare(b,undefined,{numeric:true,sensitivity:'base'   }));
log(' locale Compare :', v); // 1.0a AFTER 1.0.1

const str = s => s.match(/(\d+)|[a-z]/g)
                  .map(c => c == ~~c ? String.fromCharCode(97 + c) : c);
const versionCompare = (a, b) => {
  a = str(a);
  b = str(b);
  return b < a ? 1 : a == b ? 0 : -1;
}

v.sort(versionCompare);
log('versionCompare:', v);

请注意如何在两个结果中对1.090进行排序。

我的代码将不会解决001.012.001在一个答复中提到的符号,但localeCompare得到的挑战权的那部分。

您可以结合使用两种方法:

  • 涉及字母时.localCompareOR排序versionCompare

最终的JavaScript解决方案

const sortVersions = (
  x,
  v = s => s.match(/[a-z]|\d+/g).map(c => c==~~c ? String.fromCharCode(97 + c) : c)
) => x.sort((a, b) => (a + b).match(/[a-z]/) 
                             ? v(b) < v(a) ? 1 : -1 
                             : a.localeCompare(b, 0, {numeric: true}))

let v=["1.90.1","1.090","1.0a","1.0.1","1.0.0a","1.0.0b","1.0.0.1"];
console.log(sortVersions(v));

您不能将它们转换成数字然后按大小排序吗?在长度小于4的数字后面加上0

在控制台中玩:

$(["1.0.0.0", "1.0.1.0", "2.0.0.0", "2.0.0.1", "2.0.1", "3.0"]).each(function(i,e) {
    var n =   e.replace(/\./g,"");
    while(n.length < 4) n+="0" ; 
    num.push(  +n  )
});

版本越大,数字越大。编辑:可能需要调整以考虑更大版本的系列

我喜欢的版本@ mar10,不过从我的角度来看,存在误用的机会(看来,这是不是这样的,如果版本都兼容的语义版本的文件,但如果使用一些“集结号”可能是这种情况):

versionCompare( '1.09', '1.1');  // returns 1, which is wrong:  1.09 < 1.1
versionCompare('1.702', '1.8');  // returns 1, which is wrong: 1.702 < 1.8

这里的问题是,在某些情况下,版本号的子编号写有尾随零(至少就像我最近在使用其他软件时看到的那样),这类似于数字的有理数,因此:

5.17.2054 > 5.17.2
5.17.2 == 5.17.20 == 5.17.200 == ... 
5.17.2054 > 5.17.20
5.17.2054 > 5.17.200
5.17.2054 > 5.17.2000
5.17.2054 > 5.17.20000
5.17.2054 < 5.17.20001
5.17.2054 < 5.17.3
5.17.2054 < 5.17.30

但是,第一个(或第一个和第二个)版本子编号始终被视为实际上等于的整数值。

如果使用这种版本控制,则可以在示例中仅更改几行:

// replace this:
p1 = parseInt(v1parts[i], 10);
p2 = parseInt(v2parts[i], 10);
// with this:
p1 = i/* > 0 */ ? parseFloat('0.' + v1parts[i], 10) : parseInt(v1parts[i], 10);
p2 = i/* > 0 */ ? parseFloat('0.' + v2parts[i], 10) : parseInt(v2parts[i], 10);

因此,除第一个数字外的每个子数字都将以浮点数进行比较,因此 091它将变成0.090.1因此以这种方式正确进行比较。2054并且3会变得0.20540.3

完整的版本是(贷方为@ mar10):

/** 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 = i/* > 0 */ ? parseFloat('0.' + v1parts[i], 10) : parseInt(v1parts[i], 10);;
        p2 = i/* > 0 */ ? parseFloat('0.' + v2parts[i], 10) : 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;
}

PS这比较慢,但也可以考虑重新使用相同的比较函数,该操作实际上是字符串实际上是字符数组:

 function cmp_ver(arr1, arr2) {
     // fill the tail of the array with smaller length with zeroes, to make both array have the same length
     while (min_arr.length < max_arr.length) {
         min_arr[min_arr.lentgh] = '0';
     }
     // compare every element in arr1 with corresponding element from arr2, 
     // but pass them into the same function, so string '2054' will act as
     // ['2','0','5','4'] and string '19', in this case, will become ['1', '9', '0', '0']
     for (i: 0 -> max_length) {
         var res = cmp_ver(arr1[i], arr2[i]);
         if (res !== 0) return res;
     }
 }

我是根据Kons的想法制作的,并针对Java版本“ 1.7.0_45”进行了优化。它只是一个将版本字符串转换为浮点数的函数。这是功能:

function parseVersionFloat(versionString) {
    var versionArray = ("" + versionString)
            .replace("_", ".")
            .replace(/[^0-9.]/g, "")
            .split("."),
        sum = 0;
    for (var i = 0; i < versionArray.length; ++i) {
        sum += Number(versionArray[i]) / Math.pow(10, i * 3);
    }
    console.log(versionString + " -> " + sum);
    return sum;
}

字符串“ 1.7.0_45”被转换为1.0070000450000001,这足以进行常规比较。错误的解释在这里:如何处理JavaScript中的浮点数精度?如果任何部分需要3位以上的数字,则可以更改分频器Math.pow(10, i * 3);

输出将如下所示:

1.7.0_45         > 1.007000045
ver 1.7.build_45 > 1.007000045
1.234.567.890    > 1.23456789

我遇到了版本比较的相同问题,但是版本可能包含任何内容(即:不是点的分隔符,诸如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”。如语义版本控制2.0.0所指定,它无法管理“ 1.0.0-rc.1” <“ 1.0.0”

本文地址:http://javascript.askforanswer.com/ruheshiyongjsbijiaoruanjianbanbenhaojinshuzi.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇: 链接?
下一篇:

评论已关闭!