จะเปรียบเทียบหมายเลขรุ่นซอฟต์แวร์โดยใช้ 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.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.mapและArray.everyซึ่งหมายความว่าจะไม่ทำงานในเวอร์ชัน IE ที่เก่ากว่า 9 หากคุณต้องการสนับสนุนผู้ใช้เหล่านั้นคุณจะต้องจัดทำโพลีฟิลสำหรับวิธีการที่หายไป

semver

parser รุ่น semantic ที่ใช้โดย 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 ();

แก้ไข:รุ่น Bugfixed ปอกศูนย์ต่อท้ายเพื่อรับรู้ "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;
    }

ไม่พบฟังก์ชันที่ทำสิ่งที่ฉันต้องการที่นี่ ดังนั้นฉันจึงเขียนของตัวเอง นี่คือผลงานของฉัน ฉันหวังว่าบางคนจะพบว่ามีประโยชน์

ข้อดี:

• จัดการสตริงรุ่นที่มีความยาวโดยพลการ '1' หรือ '1.1.1.1.1'

• เริ่มต้นแต่ละค่าเป็น 0 หากไม่ได้ระบุ เพียงเพราะสายยาวไม่ได้หมายความว่ามันเป็นรุ่นที่ใหญ่กว่า ('1' ควรเหมือนกับ '1.0' และ '1.0.0.0')

• เปรียบเทียบตัวเลขไม่ใช่สตริง ('3' <'21' ควรเป็นจริงไม่ใช่เท็จ)

• ไม่ต้องเสียเวลากับการเปรียบเทียบที่ไร้ประโยชน์ในลูป (เปรียบเทียบเพื่อ ==)

• คุณสามารถเลือกเครื่องมือเปรียบเทียบของคุณเอง

จุดด้อย:

• มันไม่ได้จัดการกับตัวอักษรในสตริงรุ่น (ฉันไม่รู้ว่ามันจะทำงานยังไง)

รหัสของฉันคล้ายกับคำตอบที่ยอมรับโดย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);
}

ตัวอย่าง :

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

ฟังก์ชั่นที่ง่ายและสั้น:

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

ยกโทษให้ฉันถ้าความคิดนี้ได้รับการเข้าชมในลิงค์ที่ฉันไม่ได้เห็น

ฉันประสบความสำเร็จด้วยการเปลี่ยนชิ้นส่วนเป็นผลรวมถ่วงน้ำหนักดังนี้:

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

ฉันหวังว่าสิ่งนี้จะช่วยใครบางคนเนื่องจากเงื่อนไขหลายอย่างดูเหมือนจะเกินความจริงเล็กน้อย

นี่คืออีกเวอร์ชั่นสั้นที่ใช้งานได้กับเวอร์ชันย่อยใด ๆ เลขศูนย์และเบาะเลขคู่ด้วยตัวอักษร (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;
}

เอาท์พุท:

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/

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 มันจะคล้ายกับของ version_compare()PHP

คุณสามารถใช้มันได้ดังนี้:

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

คำตอบ verbose ของฉันน้อยกว่าคำตอบส่วนใหญ่ที่นี่

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

แม้ว่าคำถามนี้มีแล้ว คำตอบจำนวนมาก แต่คำถามแต่ละข้อก็ส่งเสริมวิธีการแก้ปัญหาหลังบ้านของพวกเขาเองในขณะที่เรามีระบบนิเวศทั้งหมดของห้องสมุดทดสอบ (การต่อสู้) สำหรับเรื่องนี้

การค้นหาอย่างรวดเร็วเกี่ยวกับNPM , GitHub , X จะทำให้เรามี libs ที่น่ารักและฉันต้องการเรียกใช้บางส่วน:

semver-compareเป็น lib ที่มีน้ำหนักเบามาก (~ 230B) ซึ่งมีประโยชน์อย่างยิ่งหากคุณต้องการเรียงลำดับตามหมายเลขเวอร์ชันเมื่อเมธอดที่เปิดเผยของไลบรารีกลับ-1มา0หรือ1เหมาะสม

แกนกลางของ 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 gzipped) แต่อนุญาตให้มีการเปรียบเทียบที่ไม่เหมือนใครบางอย่างเช่นหา min / max ของ stack ของรุ่นหรือเพื่อดูว่ารุ่นที่ให้มานั้นมีความพิเศษหรือน้อยกว่าอย่างอื่นในคอลเลกชันของ รุ่น

compare-versionsเป็นอีกหนึ่ง lib ขนาดเล็ก (~ 630B gzipped) และทำตามข้อกำหนดอย่างดีซึ่งหมายความว่าคุณสามารถเปรียบเทียบรุ่นที่มีการตั้งค่าสถานะ alpha / beta และแม้กระทั่ง wildcards (เช่นสำหรับรุ่นรอง / patch: 1.0.xหรือ1.0.*)

ประเด็นคือ: ไม่จำเป็นต้องคัดลอกโค้ดจาก StackOverflow เสมอไปหากคุณสามารถหารุ่นทดสอบ (หน่วย -) ที่เหมาะสมผ่านผู้จัดการแพ็คเกจที่คุณเลือก

ฉันพบปัญหาที่คล้ายกันและฉันได้สร้างวิธีแก้ไขปัญหาแล้ว รู้สึกอิสระที่จะลอง

ก็จะส่งกลับ0สำหรับequal, 1ถ้ารุ่นที่มี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
    }

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/

นี่คือการใช้ coffeescript ที่เหมาะสำหรับใช้กับ Array.sort ซึ่งได้แรงบันดาลใจจากคำตอบอื่น ๆ ที่นี่:

# 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.1546515465451654654654654654138754431574364321353734'
• สามารถเรียงลำดับวัตถุตามรุ่น (ดู README)
• สเตจ (เช่นอัลฟ่า, เบต้า, rc1, rc2)

อย่าลังเลที่จะเปิดปัญหาหากคุณต้องการคุณสมบัติอื่น

สิ่งนี้ใช้ได้กับรุ่นที่เป็นตัวเลขของความยาวใด ๆ คั่นด้วยจุด มันจะคืนค่าเป็นจริงก็ต่อเมื่อ myVersion คือ> = MinimumVersion ทำให้การสันนิษฐานว่ารุ่น 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);
}

ฉันค้นหาวิธีที่ง่ายที่สุดในการเปรียบเทียบพวกเขาไม่แน่ใจว่าเป็นสิ่งที่คุณต้องการหรือไม่ เมื่อฉันเรียกใช้โค้ดด้านล่างในคอนโซลมันสมเหตุสมผลและใช้ sort () วิธีฉันจะได้รับเรียงแถวของสตริงรุ่น มันขึ้นอยู่กับลำดับตัวอักษร

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

คุณสามารถใช้String#localeCompareกับoptions

ความไว

ความแตกต่างในสตริงควรนำไปสู่ค่าผลลัพธ์ที่ไม่ใช่ศูนย์ ค่าที่เป็นไปได้คือ:

• "base": เฉพาะสตริงที่แตกต่างในตัวอักษรฐานเปรียบเทียบไม่เท่ากัน ตัวอย่าง: a ≠ b, a = á,a = A ,
• "accent": เฉพาะสตริงที่แตกต่างในตัวอักษรฐานหรือสำเนียงและเครื่องหมายกำกับอื่น ๆ เปรียบเทียบว่าไม่เท่ากัน a ≠ bตัวอย่าง: a ≠ á, a = A,
• "case": เฉพาะสตริงที่แตกต่างกันในตัวอักษรฐานหรือตัวพิมพ์เปรียบเทียบเป็นไม่เท่ากัน a ≠ bตัวอย่าง: a = á, a ≠ A,
• "variant": สตริงที่แตกต่างกันในตัวอักษรฐานสำเนียงและเครื่องหมายกำกับอื่น ๆ หรือกรณีเปรียบเทียบไม่เท่ากัน ความแตกต่างอื่น ๆ อาจถูกนำมาพิจารณาด้วย a ≠ bตัวอย่าง: a ≠ á, a ≠ A,

ค่าเริ่มต้นคือ "ตัวแปร" สำหรับการใช้งาน "เรียงลำดับ"; มันขึ้นอยู่กับสถานที่สำหรับการใช้งาน "ค้นหา"

เป็นตัวเลข

ไม่ว่าจะเป็นการเรียงลำดับตัวเลขควรใช้เช่น "1" <"2" <"10" ค่าที่เป็นไปได้คือtrueและfalse; falseเริ่มต้นคือ ตัวเลือกนี้สามารถตั้งค่าผ่านคุณสมบัติตัวเลือกหรือผ่านคีย์ส่วนขยาย 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);

คุณไม่สามารถแปลงเป็นตัวเลขแล้วเรียงลำดับตามขนาดได้หรือไม่ ผนวก 0's กับตัวเลขที่มีความยาว <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  )
});

รุ่นที่ใหญ่กว่าจำนวนที่มากกว่า แก้ไข: อาจต้องปรับเป็นบัญชีสำหรับซีรี่ส์รุ่นที่ใหญ่กว่า

นี่เป็นกลลวงที่เรียบร้อย หากคุณกำลังจัดการกับค่าตัวเลขระหว่างช่วงของค่าเฉพาะคุณสามารถกำหนดค่าให้กับแต่ละระดับของวัตถุเวอร์ชัน ตัวอย่างเช่น "hugeValue" ถูกตั้งค่าเป็น 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);

ฉันชอบรุ่นจาก@ 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;
}

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" มันล้มเหลวในการจัดการ "1.0.0-rc.1" <"1.0.0" ตามที่ระบุโดย Semantic versionning 2.0.0

การประมวลผลรุ่นก่อนหน้าการจัดเรียงล่วงหน้าหมายความว่าการแยกวิเคราะห์จะไม่ถูกเรียกหลาย ๆ ครั้งโดยไม่จำเป็น การใช้ Array # map คล้ายกับข้อเสนอของ Michael Deal นี่เป็นประเภทที่ฉันใช้เพื่อค้นหาเซเวอร์มาตรฐานส่วนที่ 3 ใหม่ล่าสุด:

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"