Come confrontare il numero di versione del software usando js? (solo numero)

Ecco il numero di versione del software:

"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"

Come posso confrontare questo ?? Supponiamo che l'ordine corretto sia:

"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"

L'idea è semplice ...: leggi la prima cifra, poi la seconda, dopo la terza .... Ma non riesco a convertire il numero di versione in numero float .... Puoi anche vedere il numero di versione come Questo:

"1.0.0.0", "1.0.1.0", "2.0.0.0", "2.0.0.1", "2.0.1.0"

e questo è più chiaro per vedere qual è l'idea alla base ... Ma come convertirlo in un programma per computer ?? Qualcuno ha qualche idea su come ordinare questo? Grazie.

L'idea di base per fare questo confronto sarebbe quella di usare Array.splitper ottenere array di parti dalle stringhe di input e quindi confrontare coppie di parti dai due array; se le parti non sono uguali, sappiamo quale versione è più piccola.

Ci sono alcuni dettagli importanti da tenere a mente:

1. Come devono essere confrontate le parti di ciascuna coppia? La domanda vuole fare un confronto numerico, ma cosa succede se abbiamo stringhe di versione che non sono composte da sole cifre (ad es. "1.0a")?
2. Cosa dovrebbe succedere se una stringa di versione ha più parti dell'altra? Molto probabilmente "1.0" dovrebbe essere considerato inferiore a "1.0.1", ma che dire di "1.0.0"?

Ecco il codice per un'implementazione che puoi usare direttamente (in sintesi con la documentazione ):

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

Questa versione confronta le parti in modo naturale , non accetta suffissi di carattere e considera "1.7" inferiore a "1.7.0". La modalità di confronto può essere cambiata in lessico e le stringhe di versione più brevi possono essere automaticamente riempite di zero usando il terzo argomento opzionale.

C'è un JSFiddle che esegue "unit test" qui ; è una versione leggermente ampliata del lavoro di ripper234 (grazie).

Nota importante: questo codice utilizza Array.mape Array.every, il che significa che non verrà eseguito nelle versioni di IE precedenti alla 9. Se è necessario supportarle, è necessario fornire polyfill per i metodi mancanti.

semver

Il parser della versione semantica utilizzato da npm.

$ npm installa 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, '*')

Linking versione semantica :
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"));

Questa funzione di confronto molto piccola, ma molto veloce, prende numeri di versione di qualsiasi lunghezza e qualsiasi dimensione numerica per segmento .

Valori di ritorno:
- un numero < 0se a <b
- un numero > 0se a> b
-0 se a = b

Quindi puoi usarlo come funzione di confronto per Array.sort ();

EDIT: versione corretta di bug che rimuoveva gli zeri finali per riconoscere "1" e "1.0.0" come uguali

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

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

Impossibile trovare una funzione che fa quello che volevo qui. Quindi ho scritto il mio. Questo è il mio contributo Spero che qualcuno lo trovi utile.

Professionisti:

• Gestisce stringhe di versione di lunghezza arbitraria. '1' o '1.1.1.1.1'.

• Ogni valore predefinito è 0 se non specificato. Solo perché una stringa è più lunga non significa che sia una versione più grande. ('1' dovrebbe essere uguale a '1.0' e '1.0.0.0'.)

• Confronta i numeri non le stringhe. ('3' <'21' dovrebbe essere vero. Non falso.)

• Non perdere tempo con confronti inutili nel ciclo. (Confronto per ==)

• Puoi scegliere il tuo comparatore.

Contro:

• Non gestisce le lettere nella stringa della versione. (Non so come avrebbe funzionato?)

Il mio codice, simile alla risposta accettata da Jon :

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

Esempi :

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

Funzione semplice e breve:

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
}

test:

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

Scusami se questa idea è già stata visitata in un link che non ho visto.

Ho avuto un certo successo con la conversione delle parti in una somma ponderata in questo modo:

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

Il che ha reso i confronti molto facili (confrontando un doppio). I nostri campi versione non sono mai più di 4 cifre.

7.10.2.184  -> 7010002184.0
7.11.0.1385 -> 7011001385.0

Spero che questo aiuti qualcuno, poiché i condizionali multipli sembrano un po 'eccessivi.

Ecco un'altra versione breve che funziona con qualsiasi numero di sotto-versioni, zeri imbottiti e numeri pari con lettere (1.0.0b3)

function compareVer(a, b)
{
    //treat non-numerical characters as lower version
    //replacing them with a negative number based on charcode of each character
    function fix(s)
    {
        return "." + (s.toLowerCase().charCodeAt(0) - 2147483647) + ".";
    }
    a = ("" + a).replace(/[^0-9\.]/g, fix).split('.');
    b = ("" + b).replace(/[^0-9\.]/g, fix).split('.');
    var c = Math.max(a.length, b.length);
    for (var i = 0; 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;
}

Produzione:

0 : a = b

1 : a> b

-1 : a <b

1.0.0.0.0.0 = 1.0
1.0         < 1.0.1
1.0b1       < 1.0
1.0a        < 1.0b
1.1         > 1.0.1b
1.1alpha    < 1.1beta
1.1rc1      > 1.1beta
1.0001      > 1.00000.1.0.0.0.01

/*use strict*/

function compareVer(a, b)
{
    //treat non-numerical characters as lover version
    //replacing them with a negative number based on charcode of each character
    function fix(s)
    {
        return "." + (s.toLowerCase().charCodeAt(0) - 2147483647) + ".";
    }
    a = ("" + a).replace(/[^0-9\.]/g, fix).split('.');
    b = ("" + b).replace(/[^0-9\.]/g, fix).split('.');
    var c = Math.max(a.length, b.length);
    for (var i = 0; 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;
}

var type = {
  "-1": " < ",
   "0": " = ",
   "1": " > "
};
var list = [
  ["1.0.0.0.0.0", "1.0"],
  ["1.0",         "1.0.1"],
  ["1.0b1",       "1.0"],
  ["1.0a",        "1.0b"],
  ["1.1",         "1.0.1b"],
  ["1.1alpha",    "1.1beta"],
  ["1.1rc1",      "1.1beta"],
  ["1.0001",      "1.00000.1.0.0.0.01"]
];

for(var i = 0; i < list.length; i++)
{
  console.log(list[i][0] + type[compareVer(list[i][0], list[i][1])] + list[i][1]);
}

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

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

Codice più semplice per i browser moderni:

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

L'idea qui è di confrontare i numeri ma sotto forma di stringa. per far funzionare il confronto, le due stringhe devono avere la stessa lunghezza. così:

"123" > "99" diventare "123" > "099"
riempimento del breve numero "aggiusta" il confronto

Qui riempio ogni parte con zeri a lunghezze di 10. Quindi uso semplicemente il confronto di stringhe per la risposta

Esempio :

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

Controllare il funzionamento version_compare()del progetto php.js . È simile a PHP version_compare() .

Puoi semplicemente usarlo in questo modo:

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

La mia risposta meno dettagliata della maggior parte delle risposte qui

/**
 * 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
}

Sebbene questa domanda abbia già molto risposte, ognuna promuove la propria soluzione prodotta nel cortile di casa, mentre per questo abbiamo un intero ecosistema di librerie (battaglie) testate.

Una rapida ricerca su NPM , GitHub , X ci fornirà alcune fantastiche librerie e vorrei esaminarne alcune:

semver-compareè un grande peso leggero (~ 230B) lib che è particolarmente utile se si desidera ordinare i numeri di versione, come metodo restituisce a vista della biblioteca -1, 0o 1in modo appropriato.

Il nucleo della 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 è piuttosto pesante (~ 4.4kB gzip), ma consente alcuni raffinati confronti unici come trovare il minimo / massimo di uno stack di versioni o scoprire se la versione fornita è unica o meno di qualsiasi altra cosa in una raccolta di versioni.

compare-versionsè un'altra piccola lib (~ 630B gzip) e segue bene le specifiche, il che significa che puoi confrontare le versioni con i flag alpha / beta e anche i caratteri jolly (come per le versioni minori / patch: 1.0.xo 1.0.*)

Il punto è: non è sempre necessario copiare e incollare il codice da StackOverflow, se riesci a trovare versioni decenti, (unit-) testate tramite il tuo gestore pacchetti preferito.

Ho affrontato il problema simile e avevo già creato una soluzione per questo. Sentiti libero di provarlo.

Restituisce 0per equal, 1se la versione è greatere -1se lo è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"));

L'idea è di confrontare due versioni e sapere qual è la più grande. Eliminiamo "." e confrontiamo ogni posizione del vettore con l'altra.

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

La replace()funzione sostituisce solo la prima occorrenza nella stringa. Quindi, sostituiamo il .con ,. Successivamente elimina tutto .e fai ,di .nuovo il to e analizzalo in float.

for(i=0; i<versions.length; i++) {
    v = versions[i].replace('.', ',');
    v = v.replace(/\./g, '');
    versions[i] = parseFloat(v.replace(',', '.'));
}

infine, ordinalo:

versions.sort();

Dai un'occhiata a questo post sul blog . Questa funzione funziona con numeri di versione numerici.

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

Se, ad esempio, vogliamo verificare se l'attuale versione di jQuery è inferiore a 1.8, si parseFloat($.ui.version) < 1.8 )otterrebbe un risultato errato se la versione è "1.10.1", poiché restituisce parseFloat ("1.10.1") 1.1. Anche un confronto tra stringhe potrebbe andare storto, poiché "1.8" < "1.10"valuta false.

Quindi abbiamo bisogno di un test come questo

if(versionCompare($.ui.version, "1.8") < 0){
    alert("please update jQuery");
}

La seguente funzione gestisce questo correttamente:

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

Ecco alcuni esempi:

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

Vedi qui per un esempio live e una suite di test: http://jsfiddle.net/mar10/8KjvP/

Ecco un'implementazione di coffeescript adatta per l'uso con Array.sort ispirata ad altre risposte qui:

# 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

Ho scritto un modulo nodo per ordinare le versioni, lo puoi trovare qui: version-sort

Caratteristiche :

• nessun limite di sequenze "1.0.1.5.53.54654.114.1.154.45" funziona
• nessun limite di lunghezza della sequenza: "1.1546515465451654654654654138754431574364321353734" funziona
• può ordinare gli oggetti per versione (vedi README)
• fasi (come alfa, beta, rc1, rc2)

Non esitare ad aprire un problema se hai bisogno di un'altra funzione.

Funziona con versioni numeriche di qualsiasi lunghezza separate da un punto. Restituisce vero solo se myVersion è> = minimumVersion, supponendo che la versione 1 sia inferiore a 1.0, la versione 1.1 sia inferiore a 1.1.0 e così via. Dovrebbe essere abbastanza semplice aggiungere condizioni extra come accettare numeri (basta convertirli in una stringa) ed esadecimali o rendere dinamico il delimitatore (basta aggiungere un parametro delimitatore quindi sostituire il "." Con il parametro)

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

Ecco alcuni test:

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

In alternativa, ecco una versione ricorsiva

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

Trovo il modo più semplice per confrontarli, non sono sicuro che sia quello che vuoi. quando corro sotto il codice nella console, ha senso e usando il metodo sort (), potrei ottenere l'array ordinato delle stringhe delle versioni. si basa sull'ordine alfabetico.

"1.0" < "1.0.1" //true
var arr = ["1.0.1", "1.0", "3.2.0", "1.3"]
arr.sort();     //["1.0", "1.0.1", "1.3", "3.2.0"]

Puoi usarlo String#localeCompareconoptions

sensibilità

Quali differenze nelle stringhe dovrebbero portare a valori di risultato diversi da zero. I valori possibili sono:

• "base": Solo le stringhe che differiscono nelle lettere di base si equivalgono. Esempi: a ≠ b, a = á, a = A.
• "accent": Solo le stringhe che differiscono per lettere o accenti di base e altri segni diacritici possono essere paragonate alla disparità. Esempi: a ≠ b, a ≠ á, a = A.
• "case": Solo le stringhe che si differenziano per lettere di base o maiuscole si equivalgono. Esempi: a ≠ b, a = á, a ≠ A.
• "variant": Stringhe che differiscono per lettere di base, accenti e altri segni diacritici o che il caso si confronta come disuguale. Altre differenze possono anche essere prese in considerazione. Esempi: a ≠ b, a ≠ á, a ≠ A.

L'impostazione predefinita è "variante" per l'utilizzo "ordina"; dipende dalle impostazioni locali per l'uso "cerca".

numerico

Se utilizzare le regole di confronto numeriche, in modo che "1" <"2" <"10". I valori possibili sono truee false; il valore predefinito è false. Questa opzione può essere impostata tramite una proprietà options o tramite una chiave di estensione Unicode; se vengono forniti entrambi, la optionsproprietà ha la precedenza. Le implementazioni non sono necessarie per supportare questa proprietà.

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

non potresti convertirli in numeri e poi ordinare in base alle dimensioni? Aggiungi 0 a quelli ai numeri che sono <4 di lunghezza

giocato in console:

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

più grande è la versione, il numero più grande. Modifica: probabilmente deve essere modificato per tenere conto delle serie di versioni più grandi

Questo è un trucco pulito. Se hai a che fare con valori numerici, tra un intervallo specifico di valori, puoi assegnare un valore a ciascun livello dell'oggetto versione. Ad esempio "largeValue" è impostato su 0xFF qui, il che crea un aspetto molto "IP" per il tuo controllo delle versioni.

Questo gestisce anche il versioning alfanumerico (cioè 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);

Mi piace la versione di @ mar10 , anche se dal mio punto di vista c'è una possibilità di uso improprio (sembra che non sia il caso se le versioni sono compatibili con il documento Semantic Versioning , ma potrebbe essere il caso se si utilizza un "numero di build" ):

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

Il problema qui è che i sotto-numeri del numero di versione sono, in alcuni casi, scritti con zero finali (almeno come lo vedo di recente mentre uso software diverso), che è simile alla parte razionale di un numero, quindi:

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

Il sotto-numero della prima (o della prima e della seconda) versione, tuttavia, viene sempre trattato come un valore intero a cui effettivamente corrisponde.

Se si utilizza questo tipo di controllo delle versioni, è possibile modificare solo alcune righe nell'esempio:

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

Quindi ogni sotto-numero tranne il primo verrà confrontato come float, così 09e 1diventerà 0.09e di 0.1conseguenza e confrontato correttamente in questo modo. 2054e 3diventerà 0.2054e 0.3.

La versione completa quindi è (credits to @ 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 È più lento, ma è anche possibile pensare a riutilizzare la stessa funzione di confronto operando il fatto che la stringa è in realtà l'array di caratteri:

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

L'ho realizzato sulla base dell'idea di Kons e l'ho ottimizzato per la versione Java "1.7.0_45". È solo una funzione pensata per convertire una stringa di versione in un float. Questa è la funzione:

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

La stringa "1.7.0_45" viene convertita in 1.0070000450000001 e questo è abbastanza buono per un confronto normale. Errore spiegato qui: come gestire la precisione del numero in virgola mobile in JavaScript? . Se sono necessarie più di 3 cifre su qualsiasi parte, è possibile modificare il divisoreMath.pow(10, i * 3); .

L'output sarà simile al seguente:

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

Ho avuto lo stesso problema del confronto delle versioni, ma con versioni che probabilmente contenevano qualcosa (es .: separatori che non erano punti, estensioni come rc1, rc2 ...).

Ho usato questo, che fondamentalmente ha diviso le stringhe di versione in numeri e non numeri, e cerca di confrontare di conseguenza con il tipo.

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

Ci sono alcune ipotesi qui per alcuni casi, ad esempio: "1.01" === "1.1" o "1.8" <"1.71". Non riesce a gestire "1.0.0-rc.1" <"1.0.0", come specificato da Semantic versionning 2.0.0

La preelaborazione delle versioni precedenti all'ordinamento significa che parseInt non viene chiamato più volte inutilmente. Utilizzando la mappa Array # simile al suggerimento di Michael Deal, ecco un tipo che uso per trovare la versione più recente di un semver standard in 3 parti:

var semvers = ["0.1.0", "1.0.0", "1.1.0", "1.0.5"];

var versions = semvers.map(function(semver) {
    return semver.split(".").map(function(part) {
        return parseInt(part);
    });
});

versions.sort(function(a, b) {
    if (a[0] < b[0]) return 1;
    else if (a[0] > b[0]) return -1;
    else if (a[1] < b[1]) return 1;
    else if (a[1] > b[1]) return -1;
    else if (a[2] < b[2]) return 1;
    else if (a[2] > b[2]) return -1;
    return 0;
});

var newest = versions[0].join(".");
console.log(newest); // "1.1.0"