js를 사용하여 소프트웨어 버전 번호를 비교하는 방법은 무엇입니까? (숫자 만)


164

소프트웨어 버전 번호는 다음과 같습니다.

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

그리고 이것은 뒤에있는 아이디어가 무엇인지 더 분명합니다 ... 그러나 그것을 컴퓨터 프로그램으로 변환하는 방법 ?? 이것을 분류하는 방법에 대한 아이디어가 있습니까? 감사합니다.


5
이것은 좋은 fizzbuzz 형 인터뷰 질문 일 것입니다.
Steve Claridge

2
이것이 모든 소프트웨어 버전 번호가 2001403과 같은 정수 여야하는 이유입니다. "2.0.14.3"과 같은 친숙한 방식으로 표시하려면 프리젠 테이션시 버전 번호를 형식화하십시오.
jarmod

2
여기서 일반적인 문제는 시맨틱 버전 비교이며 사소하지 않습니다 ( semver.org의 # 11 참조 ). 다행히도 npm시맨틱 버전 관리를 위한 공식 라이브러리가 있습니다.
Dan Dascalescu

1
발견 간단한 스크립트 semvers를 비교
수직 동기화

답변:


133

이 비교를위한 기본 아이디어 Array.split는 입력 문자열에서 부품 배열을 가져온 다음 두 배열에서 부품 쌍을 비교하는 데 사용 하는 것입니다 . 부품이 동일하지 않은 경우 어떤 버전이 더 작은 지 알고 있습니다.

명심해야 할 몇 가지 중요한 세부 사항이 있습니다.

  1. 각 쌍의 부품을 어떻게 비교해야합니까? 질문은 숫자로 비교하려고하지만 숫자만으로 구성되지 않은 버전 문자열 (예 : "1.0a")이있는 경우 어떻게해야합니까?
  2. 한 버전 문자열에 다른 버전 문자열이 더 많은 경우 어떻게됩니까? "1.0"은 "1.0.1"보다 작아야하지만 "1.0.0"은 어떻습니까?

직접 사용할 수있는 구현 코드는 다음과 같습니다 ( documents with documentation ).

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"보다 작은 것으로 간주합니다. 비교 모드는 사전 식으로 변경 될 수 있으며 더 짧은 버전의 문자열은 선택적 세 번째 인수를 사용하여 자동으로 0으로 채워질 수 있습니다.

여기에 "단위 테스트"를 실행하는 JSFiddle이 있습니다 . ripper234 작품의 약간 확장 된 버전입니다 (감사합니다).

중요 사항 : 이 코드를 사용 Array.map하고 Array.every당신이 누락 된 방법에 대한 polyfills을 제공해야합니다 사람들을 지원해야하는 경우가 9보다 이전의 IE 버전에서 실행되지 않음을 의미합니다.


16
다음은 몇 가지 단위 테스트를 통해 개선 된 버전입니다. jsfiddle.net/ripper234/Xv9WL/28
ripper234

5
모두 안녕, 나는이 요점을 테스트와 모든 것을 가진 gitrepo로 굴려서 npm과 bower에 올려 놓았으므로 프로젝트에 더 쉽게 포함시킬 수 있습니다. github.com/gabe0x02/version_compare
Gabriel Littman 1

2
@GabrielLittman : 이봐, 시간 내 줘서 고마워! 그러나 SO의 모든 코드는 기본적 으로 CC-BY-SA 로 라이센스가 부여됩니다 . 즉, GPL 라이센스 패키지를 가질 수 없습니다. 변호사가 여기있는 사람이 아니라는 것을 알고 있지만, 고치면 좋을 것입니다.
Jon

2
@GabrielLittman : GPL은 기존 GPL 코드와 접촉하는 모든 코드를 GPL 라이센스로 강제한다는 점에서 실제로 매우 제한적입니다. 어쨌든, 나중에 참조 할 수 있도록 : 훌륭하고 널리 사용되는 "원하는대로 문자열을 첨부하지 마십시오"라이센스는 MIT 입니다.
Jon

3
@GabrielLittman : 이미 semver 비교를 수행 하는 노련한 개발자작성한 기존 라이브러리가 있습니다.
Dan Dascalescu

82

셈버

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


8
예. 이것은 정답입니다-비교 버전은 사소하지 않으며 (semver.org의 # 11 참조 ) 작업을 수행하는 프로덕션 레벨 라이브러리가 있습니다.
Dan Dascalescu

7
기술적으로 node.js와 javascript가 다르기 때문에 정답이 아닙니다. 나는 원래 질문이 브라우저를 위해 더 많이 타겟팅되었다고 가정했다. 그러나 구글이 나를 여기로 데려왔고 운 좋게 나는 노드를 사용하고 있습니다 :)
Lee Gary

2
NodeJS는 서버 측 솔루션 만이 아닙니다. 전자 프레임 워크는 데스크탑 애플리케이션을위한 nodeJS를 포함합니다. 이것은 실제로 내가 찾던 대답입니다.
Anthony Raymond

2
그것은 npm 패키지이므로 모든 JS 환경에서 사용할 수 있습니다! 이것이 정답입니다
neiker

4
@artuska 아니라 단순히 같은 다른 패키지에 갈 semver-비교 ) : 233B (! 적은 0.5kB보다) gzip으로 압축 -
카노

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

나는 라인을 생각합니다 : var len = Math.min(a_components.length, b_components.length);버전 2.0.1.1과 2.0.1이 동일하게 취급됩니까?
Jon Egerton

1
아뇨. 루프를 돌봐주세요! 한 문자열이 다른 문자열의 접두사 인 경우 (즉, 루프가 끝에 도달하면) 더 긴 문자열이 더 높은 것으로 간주됩니다.
Joe

어쩌면 당신은 코멘트에 영어에 대한 내 걸림돌을 미루었을 수도 있습니다 ...
Joe

@ 조 나는 조금 오래된 대답이지만 함수를 사용하고 있었다. 7.0이 더 길기 때문에 테스트 a = '7'b = '7.0'반환 -1. 그것에 대한 제안이 있습니까? ( console.log(compare("7", "7.0")); //returns -1)
RaphaelDDL

나는 그것이 정의되지 않은 행동이라는 제목 아래에 있다고 생각합니다. 이 버전 번호가 있으면 요구 사항에 맞게 논리를 수정할 수 있습니다.
Joe

48

이 매우 작지만 매우 빠른 비교 기능은 세그먼트마다 길이숫자 크기 의 버전 번호를 사용합니다 .

리턴 값 :
- 다수 < 0은 <B의 경우
- 숫자 > 0경우> B
- 0A = B가되는 경우

따라서이를 Array.sort ()의 비교 함수 로 사용할 수 있습니다 .

편집 : "1"과 "1.0.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"]


'0.0'및 '0.0.0'으로 실패했습니다. 바이올린 참조 : jsfiddle.net/emragins/9e9pweqg
엠 라긴

1
@ emragins 언제해야합니까?
Skylar Ittner

1
@ emragins : 어디에서 실패했는지 알 수 없습니다. 이는 출력 ["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"] 코드 출력 여기서 ["0.0", "0.0.0", "0.4.1", "0.5", "1", "1.0.0", "1.1", "1.2.15", "1.25.4", "2", "2.5.0", "2.5.10", "2.5.10.4159", "10.5"] 0.0 0.0.0 보낸 완벽 동일 인 것으로 간주 동일 는 반대로 "0.0.0"또는 그 이전 인 '0.0'의 여부 무관 의미한다.
LeJared

나는 이것이 일반적인 지점이라는 데 동의합니다. 버전과 비슷한 방식으로 노드를 계층화 하는 github.com/jonmiles/bootstrap-treeview 와 함께 이것을 사용하고 있으며 실제로는 단지 부모 / 자식 노드와 인덱스입니다. 전의. 부모 : 0.0, 자식 : 0.0.0, 0.0.1. 내가 관심을 갖는
emragins

1
여기에 대한 답변을 참조하십시오 stackoverflow.com/questions/6611824/why-do-we-ne-need-to-use-radix . 오래된 브라우저는 지정되지 않은 경우 radix 매개 변수를 추측하는 데 사용됩니다. "1.09.12"의 중간 부분과 같은 숫자 문자열에서 선행 0은 기수 = 8로 구문 분석되어 예상 숫자 9 대신 숫자 0이되었습니다.
LeJared

14

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

단순하지만 세 가지 버전 필드로 제한됩니다.
Dan Dascalescu

11

내가 원하는 것을하는 함수를 찾을 수 없습니다. 그래서 나는 내 자신을 썼습니다. 이것이 나의 공헌입니다. 누군가가 유용하다고 생각합니다.

장점 :

  • 임의 길이의 버전 문자열을 처리합니다. '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

이 버전은 내 의견으로는 승인 된 답변보다 낫습니다!
user3807877

1
이 기능은 비교기 파라미터가 점검되지 않은 사용자 입력과 함께 사용되는 경우 코드 주입이 발생하기 쉽습니다! 예 : compareVersions ( '1.2', '== 0; alert ( "cotcha");', '1.2');
르자 레드

@LeJared True. 내가 작성했을 때 우리는 사용자가 제출 한 코드와 함께 사용하지 않았습니다. 아마 사기로 제기했을 것입니다. 그 가능성을 없애기 위해 코드를 업데이트했습니다. 그러나 webpack과 다른 node.js 번 들러가 널리 보급되면 위의 Mohammed Akdim 의 대답은 semver를 사용하여 거의 항상이 질문에 대한 정답 이라고 제안합니다 .
Viktor

10

간단하고 짧은 기능 :

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

다음과 같이 단순화 할 수 있습니다. const a = ~~ newParts [i]; 실제로 이것은 문자열을 정수로 변환하는 가장 효율적인 방법입니다. 변수가 정의되지 않았거나 숫자가 아닌 문자를 포함하면 0을 반환합니다.
vanowm

5

이 아이디어가 이미 보지 못한 링크로 방문한 경우 용서하십시오.

다음과 같이 부품을 가중 합계로 변환하는 데 성공했습니다.

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

여러 조건이 약간 과도하게 보이므로 이것이 누군가에게 도움이되기를 바랍니다.


2
마이너> 999 (주와 겹치게 됨)
Afanasii Kurakin

5

다음은 임의의 수의 하위 버전, 채워진 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

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


5

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"
"수정에게"비교를 짧은 수를 패딩

여기에 각 부분을 0에서 길이 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

compareVersion2정확히 무슨 일이 일어 났는지 기능을 설명 하시겠습니까?
Usman Wali

좋아, 그럼 당신은 더 나은 호환성 substringpadStart위해 대신 사용할 수 있습니다, 즉 var zeros = "0000000000"; '0.2.32'.split('.').map( s => zeros.substring(0, zeros.length-s.length) + s ).join('.') 당신에게 줄 것이다 0000000000.0000000002.0000000032:)
Usman Wali


4

여기의 대부분의 답변보다 덜 장황한 답변

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

1
모듈로 만들고 node.js에 넣어야합니다. 그때까지는 귀속 코드를 훔칩니다. 감사합니다.
r3wt

3

이 질문은 이미 많이 있지만 답변이 있지만 각 질문은 자체적으로 뒤뜰에서 만든 솔루션을 홍보하는 반면, 우리는 이에 대한 (전쟁으로 테스트 된) 라이브러리의 전체 생태계가 있습니다.

NPM , GitHub , X 에 대한 빠른 검색 은 우리에게 멋진 라이브러리를 제공하며 일부를 실행하고 싶습니다.

semver-compare당신이 버전 번호를 기준으로 정렬하려면 라이브러리의 노출 된 메소드가 리턴으로, 특히 유용 좋은 경량 (~ 230B) lib 디렉토리 -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), 버전 스택의 최소 / 최대를 찾거나 제공된 버전이 컬렉션의 다른 것보다 고유하거나 작은 지 확인하는 것과 같은 멋진 고유 비교가 가능합니다. 버전.

compare-versions(~ 630B는 gzip으로 압축 된) 또 다른 작은 lib 디렉토리 당신이 (작은 / 패치 버전 같은 경우에도 와일드 카드 알파 / 베타 플래그 버전을 비교 할 수 있습니다 의미 정중하게 사양을 다음과 1.0.x1.0.* ).

요점 : 선택한 패키지 관리자를 통해 괜찮은 (단위) 테스트 된 버전을 찾을 수 있다면 항상 StackOverflow에서 코드를 복사하여 붙여 넣을 필요는 없습니다 .


3

나는 비슷한 문제에 직면했으며 이미 해결책을 만들었습니다. 시도해보십시오.

그것은 반환 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"));


2

아이디어는 두 가지 버전을 비교하고 가장 큰 버전을 알고 있습니다. "."을 삭제합니다 벡터의 각 위치를 다른 위치와 비교합니다.

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

내가 원하는 것을 정확하게 대답합니다.
빈스

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

1
SO에 오신 것을 환영합니다. 이 질문에는 이미 좋은 답변이 많이 있습니다. 새로운 것을 추가하지 않는 한 새로운 답변을 추가하지 마십시오.
ext

1

replace()함수는 문자열에서 첫 번째 항목 만 바꿉니다. 그래서, 교체 할 수 있습니다 .,. 그런 다음 모두를 삭제 .하고 ,to를 .다시 만들고 파싱하도록 구문 분석하십시오.

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

마지막으로 정렬하십시오.

versions.sort();

1

블로그 게시물을 확인하십시오 . 이 기능은 숫자 버전 번호에서 작동합니다.

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

1

예를 들어 현재 jQuery 버전이 1.8보다 작은 지 확인하려는 경우 parseFloat ( "1.10.1")이 반환하므로 버전이 "1.10.1"인 경우 잘못된 결과를 parseFloat($.ui.version) < 1.8 )제공 합니다 . 문자열 비교도 잘못 됩니다.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/


arghh, ripper234가 몇 달 전 코멘트에 fiddle URL을 게시했음을 알았습니다. 어쨌든, 나는 내 대답을 여기에 유지합니다 ...
mar10

이 경우에도 (대부분의 변형으로) 실패합니다. versionCompare ( '1.09', '1.1')은 versionCompare ( '1.702', '1.8')와 같은 방식으로 "1"을 반환합니다.
shaman.sir

이 코드는 "1.09"> "1.1"및 "1.702"> "1.8"을 평가합니다. 동의하지 않는 경우 : 자신의 의견을 뒷받침하는 자료를 지적 할 수 있습니까?
mar10

엄격한 규칙이나 무언가가 없다는 것을 알고 있기 때문에 그것은 당신의 원칙에 달려 있습니다. 리소스와 관련하여 "증가 시퀀스"의 "소프트웨어 버전 관리"에 대한 Wikipedia 기사에 따르면 1.81은 1.8의 부 버전 일 수 있으므로 1.8은 1.80으로 표시되어야합니다. 시맨틱 버전 관리 문서 semver.org/spec/v2.0.0.html 은 또한 1.9.0- > 1.10.0- > 1.11.0이므로 1.9.0은 이와 같이 1.90.0으로 취급됩니다. 따라서이 논리에 따라 1.702 버전은 1.8 이전 버전이며 1.800으로 처리되었습니다.
shaman.sir

1
일부 규칙은 1.8 <1.81 <1.9를 처리합니다. 그러나 semver에서는 1.81 대신 1.8.1을 사용합니다. Semver (내가 이해하는 것처럼)는 부품을 증가 시키면 항상 '나중에'버전을 생성한다고 가정하여 1.8 <1.8.1 <1.9 <1.10 <1.81 <1.90 <1.100입니다. 이 숫자도 두 자리로 제한되어 있다는 표시가 없습니다. 그래서 내 코드는 semver와 완벽하게 호환됩니다.
mar10

1

다음은 다른 답변에서 영감을 얻은 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

이것은 LeJared의 답변에서 영감을 얻었습니다 .
Dan Dascalescu

이것은 제대로 작동하지 않습니다. 여기에 결과가 있습니다. 결과 [ '1.1.1', '2.1.1', '3.3.1.0', '3.1.1.0']
ertan2002

1

버전 정렬을위한 노드 모듈을 작성했습니다. 여기서 찾을 수 있습니다 : version-sort

특징 :

  • 시퀀스 제한 없음 '1.0.1.5.53.54654.114.1.154.45'작동
  • 시퀀스 길이 제한 없음 : '1.1546515465451654654654654138754431574364321353734'작동
  • 버전별로 객체를 정렬 할 수 있습니다 (README 참조)
  • 단계 (알파, 베타, rc1, rc2 등)

다른 기능이 필요한 경우 언제든지 주저하지 마십시오.


1

마침표로 구분 된 모든 길이의 숫자 버전에서 작동합니다. myVersion이> = minimumVersion 인 경우에만 true를 리턴하며, 버전 1이 1.0 미만, 버전 1.1이 1.1.0 미만인 것으로 가정합니다. 숫자 허용 (문자열로 변환) 및 16 진수 허용 또는 분리 문자를 동적으로 작성 (분리 문자 매개 변수를 추가 한 후 "."을 매개 변수로 대체)과 같은 추가 조건을 추가하는 것은 매우 단순해야합니다.

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

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

3
두 자리 버전 번호 (예 : 1.10.0)에는 적합하지 않습니다.
Leukipp

1

String#localeCompare함께 사용할 수 있습니다options

감광도

문자열의 어떤 차이로 인해 0이 아닌 결과 값이 발생합니까? 가능한 값은 다음과 같습니다.

  • "base": 기본 문자가 다른 문자열 만 다른 것으로 비교합니다. 예 : a ≠ b, a = á, a = A.
  • "accent": 기본 문자 나 액센트 및 기타 분음 부호가 다른 문자열 만 동일하지 않습니다. 예 : a ≠ b, a ≠ á, a = A.
  • "case": 기본 문자 나 대소 문자가 다른 문자열 만 다른 것으로 비교합니다. 예 : a ≠ b, a = á, a ≠ A.
  • "variant": 기본 문자, 악센트 및 기타 발음 구별 부호가 다르거 나 대소 문자가 다른 문자열은 동일하지 않습니다. 다른 차이점들도 고려 될 수있다. 예 : a ≠ b, a ≠ á, a ≠ A.

"sort"사용법의 기본값은 "variant"입니다. 사용 "검색"에 따라 로케일이 다릅니다.

숫자

"1"< "2"< "10"과 같은 숫자 조합을 사용해야하는지 여부 가능한 값은 truefalse; 기본값은 false입니다. 이 옵션은 옵션 속성 또는 유니 코드 확장 키를 통해 설정할 수 있습니다. 둘 다 제공되면 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);


실제로 어떻게 작동합니까? undefined위의 언어 는 무엇입니까 ? 내가 다른 글을 읽는 동안 어떻게 게시합니까?;)
mplungjan

undefined로케일 부분이며 여기서 사용되지 않습니다.
니나 숄츠

0

숫자로 변환 한 다음 크기별로 정렬 할 수 없습니까? 길이가 <4 인 숫자에 0을 추가하십시오.

콘솔에서 놀았습니다 :

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

버전이 클수록 숫자가 커집니다. 편집 : 아마도 더 큰 버전 시리즈를 고려하여 조정해야 할 것입니다.


P는 4 대신에 가장 큰 버전의 숫자를 얻은 다음 0보다 작은 숫자를 채 웁니다.
Contra

0

이것은 깔끔한 트릭입니다. 특정 범위의 값 사이에서 숫자 값을 처리하는 경우 버전 개체의 각 수준에 값을 할당 할 수 있습니다. 예를 들어 여기서 "largestValue"는 0xFF로 설정되어 버전 관리와 매우 유사한 "IP"모양을 만듭니다.

또한 영숫자 버전 관리도 처리합니다 (예 : 1.2a <1.2b)

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

0

@ 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

여기서 문제는 버전 번호의 하위 번호가 경우에 따라 후행 0으로 잘라 낸 것입니다 (적어도 다른 소프트웨어를 사용하는 동안 최근에 본 것처럼). 수의 합리적인 부분과 비슷합니다.

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

첫 번째 제외한 모든 하위 번호를 float로서 비교할 수 있도록, 그래서 091될 것입니다 0.090.1그에 따라 적절하게이 방법을 비교 하였다. 2054그리고 3될 것입니다 0.20540.3 .

완전한 버전은 다음과 같습니다 ( @ mar10의 신용 ) :

/** Compare two dotted version strings (like '10.2.3').
 * @returns {Integer} 0: v1 == v2, -1: v1 < v2, 1: v1 > v2
 */
function versionCompare(v1, v2) {
    var v1parts = ("" + v1).split("."),
        v2parts = ("" + v2).split("."),
        minLength = Math.min(v1parts.length, v2parts.length),
        p1, p2, i;
    // Compare tuple pair-by-pair. 
    for(i = 0; i < minLength; i++) {
        // Convert to integer if possible, because "8" > "10".
        p1 = i/* > 0 */ ? parseFloat('0.' + v1parts[i], 10) : parseInt(v1parts[i], 10);;
        p2 = i/* > 0 */ ? parseFloat('0.' + v2parts[i], 10) : parseInt(v2parts[i], 10);
        if (isNaN(p1)){ p1 = v1parts[i]; } 
        if (isNaN(p2)){ p2 = v2parts[i]; } 
        if (p1 == p2) {
            continue;
        }else if (p1 > p2) {
            return 1;
        }else if (p1 < p2) {
            return -1;
        }
        // one operand is NaN
        return NaN;
    }
    // The longer tuple is always considered 'greater'
    if (v1parts.length === v2parts.length) {
        return 0;
    }
    return (v1parts.length < v2parts.length) ? -1 : 1;
}

추신 : 속도는 느리지 만 문자열이 실제로 문자 배열이라는 사실을 작동시키는 동일한 비교 함수를 재사용하는 것이 가능합니다.

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

0

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

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"과 같은 가정이 있습니다. 시맨틱 버전 관리 2.0.0에 지정된대로 "1.0.0-rc.1"< "1.0.0"을 관리하지 못합니다.


0

정렬 전에 버전을 전처리한다는 것은 parseInt가 불필요하게 여러 번 호출되지 않음을 의미합니다. Michael Deal의 제안과 유사한 Array # map을 사용하여 표준 3 파트 semver의 최신 버전을 찾는 데 사용하는 정렬은 다음과 같습니다.

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"

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.