• Как сравнить номер версии программного обеспечения с помощью JS? (только число)

    Вот это номер версии программного обеспечения:

    "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,0 а")?
    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.map и Array.every это означает , что она не будет работать в версиях, т. е. раньше, чем 9. Если вам нужно поддерживать тех, вы должны будете предоставить полифиллы для недостающих методов.

    // 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")); 

    Взято из 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;     } 

    Не смог найти функцию, делая то, что я хотел здесь. Поэтому я написал свой собственный. Это мой вклад. Надеюсь кто-то найдет его полезным.

    Плюсы:

    • Версия обрабатывает строки произвольной длины. '1' или '1.1.1.1.1'.

    • По умолчанию каждое значение на 0, Если не указано. Просто потому, что строка длиннее, не значит, что это более сложная версия. ('1' должно быть таким же, как '1.0' и '1.0.0.0'.)

    • Сравните числа а не строки. ('3'<'21' должно быть правдой. Не ложные.)

    • Не тратьте время на бесполезные сравнивает в цикле. (Сравнение по ==)

    • Вы можете выбрать свой собственный компаратор.

    Минусы:

    • Он не обрабатывает письма в строке версии. (Я не знаю, как это сработает?)

    Мой код, похожий на принятый ответ от Джона:

    function compareVersions(v1, comparator, v2) {     "use strict";     comparator = 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 

    Здесь может быть другое решение (простой, но эффективный):

    var versions = ["2.0", "1.0", "1.0.1", "2.0.0.1", "2.0.1"];    versions.sort(function(a, b) {      a = a.split('.');      b = b.split('.');      while (a.length && b.length) {          if (a[0] != b[0]) {              return a[0] - b[0];          }          a.shift();          b.shift();              }      return a.length - b.length;  });    document.write(versions.join("<br />"));

    Вот мое решение этой проблемы. Очень маленький, но очень быстро функции сравнения номера версии. Он снимает номера версии любой длины и любого размера числа каждого сегмента.

    Он будет возвращать число, меньшее 0, Если a < b, то число больше нуля, если b > а, и нулю, если А = Б. Так что вы можете также использовать его в качестве функции сравнения для массива.сортировать();

    function cmpVersions (a, b) {     var i, l, d;      a = a.split('.');     b = b.split('.');     l = Math.min(a.length, b.length);      for (i=0; i<l; i++) {         d = parseInt(a[i], 10) - parseInt(b[i], 10);         if (d !== 0) {             return d;         }     }      return a.length - b.length; } 

    Проверить функцию version_compare() от php.js проект. Он похож на PHP version_compare().

    Вы можете просто использовать его как это:

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

    В 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, parseFloat($.ui.version) < 1.8 ) дал бы неверный результат, если версия "1.10.1", так как 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/

    Вы можете цикл через каждый период-с разделителями символ и преобразовать его в int:

    var parts = versionString.split('.');  for (var i = 0; i < parts.length; i++) {   var value = parseInt(parts[i]);   // do stuffs here.. perhaps build a numeric version variable? } 

    Вот интересный способ, чтобы сделать это ОО:

        function versionString(str) {     var parts = str.split('.');     this.product = parts.length > 0 ? parts[0] * 1 : 0;     this.major = parts.length > 1 ? parts[1] * 1 : 0;     this.minor = parts.length > 2 ? parts[2] * 1 : 0;     this.build = parts.length > 3 ? parts[3] * 1 : 0;      this.compareTo = function(vStr){         vStr = this._isVersionString(vStr) ? vStr : new versionString(vStr);         return this.compare(this, vStr);     };      this.toString = function(){         return this.product + "." + this.major + "." + this.minor + "." + this.build;     }      this.compare = function (str1, str2) {         var vs1 = this._isVersionString(str1) ? str1 : new versionString(str1);         var vs2 = this._isVersionString(str2) ? str2 : new versionString(str2);          if (this._compareNumbers(vs1.product, vs2.product) == 0) {             if (this._compareNumbers(vs1.major, vs2.major) == 0) {                 if (this._compareNumbers(vs1.minor, vs2.minor) == 0) {                     return this._compareNumbers(vs1.build, vs2.build);                 } else {                     return this._compareNumbers(vs1.minor, vs2.minor);                 }             } else {                 return this._compareNumbers(vs1.major, vs2.major);             }         } else {             return this._compareNumbers(vs1.product, vs2.product);         }     };      this._isVersionString = function (str) {         return str !== undefined && str.build !== undefined;     };      this._compareNumbers = function (n1, n2) {         if (n1 > n2) {             return 1;         } else if (n1 < n2) {             return -1;         } else {             return 0;         }     }; } 

    И некоторые тесты:

    var v1 = new versionString("1.0"); var v2 = new versionString("1.0.1"); var v3 = new versionString("2.0"); var v4 = new versionString("2.0.0.1"); var v5 = new versionString("2.0.1");   alert(v1.compareTo("1.4.2")); alert(v3.compareTo(v1)); alert(v5.compareTo(v4)); alert(v4.compareTo(v5)); alert(v5.compareTo(v5)); 

    Это действительно зависит от логики вашей системы контроля версий. Что означает каждое число представляют, и как она используется.

    Каждое subversion-это нумерация для обозначения стадии развития? 0 Альфа-1 бета-2 для релиз-кандидат 3 для (окончательного) освобождения

    Это версия сборки? Вы подаете инкрементные обновления?

    Как только вы знаете, как система контроля версий работает, создавая алгоритм становится легко.

    Если Вы не позволяете числа больше 9 в каждой подрывной деятельности, устраняя все десятичные числа, но первый позволит вам делать прямые сравнения.

    Если Вы не сделаете этого числа больше 9 в любой стиль, есть несколько способов, чтобы сравнить их. Наиболее простой способ разделить строку на числа и сравнение каждого столбца.

    Но, не зная, как система управления версиями работ, осуществление процесса, как те, что выше, может вам Гарри, когда версия 1.0.2 а освобождается.

    не мог преобразовать их в цифры, а потом вроде через Размер? Добавить 0, чтобы те цифры, которые являются < 4 в длину

    играл в консоли:

    $(["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  ) }); 

    чем больше версия, тем больше число. Редактировать: вероятно, нуждается в корректировке, чтобы учесть увеличенный вариант серии

    Это ловкий трюк. Если вы имеете дело с числовыми значениями, между определенный диапазон значений можно присвоить значение для каждого уровня объекта версии. Например "largestValue" имеет значение 0xFF здесь, что создает очень "ИС", то посмотрите на свой версиями.

    Это также обрабатывает буквенно-цифровой версий (т. е. 1,2 а < 1.2 б)

    // 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); 

    Мне нравится версия от @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); 

    Поэтому каждый суб-число, кроме первого, будут сравниваться как поплавок, так 09 и 1 станет 0.09 и 0.1 соответственно и по сравнению с правильно таким образом. 2054 и 3 станет 0.2054 и 0.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; } 

    П. С. это медленнее, но также можно подумать о повторном использовании той же сравнивая функции операционной тот факт, что строка на самом деле такие персонажи:

     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;      }  } 

    Я сделал это на основе идеи конс, и оптимизировали ее для 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 

    Вот реализация на 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 

    Я написал узла модуль для сортировки версий, вы можете найти его здесь: версия-сортировка

    Особенности:

    • не предел произведения последовательностей 1.0.1.5.53.54654.114.1.154.45'
    • нет предела длина последовательности: '1.1546515465451654654654654138754431574364321353734 работ
    • можно сортировать объекты по версии (см. readme)
    • стадии (как Альфа -, бета -, и RC1, RC2 в)

    Не стесняйтесь, чтобы открыть вопрос, если вам нужны другие функции.

    Это не совсем решение для вопрос был задан, но он очень похож.

    Такого рода функция предназначена для семантической версии, он обрабатывает решен версии, так он не работает с шаблонами, как x или *.

    Он работает с версий где это регулярное выражение соответствует: /\d+\.\d+\.\d+.*$/. Это очень похоже на это ответить кроме того, что она также работает с версиями как 1.2.3-dev. В сравнении с другими ответ: я удалил некоторые чеки, которые мне не нужны, но мое решение может быть объединена с другой.

    semVerSort = function(v1, v2) {   var v1Array = v1.split('.');   var v2Array = v2.split('.');   for (var i=0; i<v1Array.length; ++i) {     var a = v1Array[i];     var b = v2Array[i];     var aInt = parseInt(a, 10);     var bInt = parseInt(b, 10);     if (aInt === bInt) {       var aLex = a.substr((""+aInt).length);       var bLex = b.substr((""+bInt).length);       if (aLex === '' && bLex !== '') return 1;       if (aLex !== '' && bLex === '') return -1;       if (aLex !== '' && bLex !== '') return aLex > bLex ? 1 : -1;       continue;     } else if (aInt > bInt) {       return 1;     } else {       return -1;     }   }   return 0; } 

    Объединенные решения является то, что:

    function versionCompare(v1, v2, options) {     var zeroExtend = options && options.zeroExtend,         v1parts = v1.split('.'),         v2parts = v2.split('.');      if (zeroExtend) {         while (v1parts.length < v2parts.length) v1parts.push("0");         while (v2parts.length < v1parts.length) v2parts.push("0");     }      for (var i = 0; i < v1parts.length; ++i) {         if (v2parts.length == i) {             return 1;         }         var v1Int = parseInt(v1parts[i], 10);         var v2Int = parseInt(v2parts[i], 10);         if (v1Int == v2Int) {             var v1Lex = v1parts[i].substr((""+v1Int).length);             var v2Lex = v2parts[i].substr((""+v2Int).length);             if (aLex === '' && bLex !== '') return 1;             if (aLex !== '' && bLex === '') return -1;             if (aLex !== '' && bLex !== '') return aLex > bLex ? 1 : -1;             continue;         }         else if (v1Int > v2Int) {             return 1;         }         else {             return -1;         }     }      if (v1parts.length != v2parts.length) {         return -1;     }      return 0; } 

    У меня была та же проблема сравнения версии, но версии могут содержать ничего (т. е.: сепараторы, которые были не точки, расширения, как и 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-вертолет.1" < "1.0.0", как определено семантические versionning 2.0.0

    function versionCompare(version1, version2){                 var a = version1.split('.');                 var b = version2.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]);                 }                 var length=a.length;                  for(j=0; j<length; j++){                     if(typeof b[j]=='undefined')b[j]=0;                     if (a[j] > b[j]) return true;                     else if(a[j] < b[j])return false;                     if(j==length-1 && a[j] >= b[j])return true;                 }                               return false;             }, 

    semver

    Семантический парсер версии нпм.

    $ нпм установить semver

    вар semver = требуют('semver');

    semver.дифф('3.4.5', '4.3.7') основные//''
    semver.дифф('3.4.5', '3.3.7') незначительные//''
    semver.ГТД('3.4.8', '3.4.7') //правда
    semver.л('3.4.8', '3.4.7') //ложные

    semver.допустимые('1.2.3') // '1.2.3'
    semver.действительный('а.б.с') // нуль
    semver.чистый(' =В1.2.3 ') // '1.2.3'
    semver.удовлетворяет('1.2.3', '1.х|| >=2.5.0 || 5.0.0 - 7.2.3') // правда
    semver.ГТ('1.2.3', '9.8.7') // ложные
    semver.ЛТ('1.2.3', '9.8.7') // правда

    версии вар= [ '1.2.3', '3.4.5', '1.0.2' ]
    вар Макс = версии.сортировка(semver.rcompare)[0]
    вар мин = версии.сортировка(semver.сравнение)[0]
    вар Макс = semver.maxSatisfying(версии, '*')
    Семантическое Версионирование Ссылке :
    https://www.npmjs.com/package/semver#prerelease-identifiers