blocks|key|827244|text|您可以遍历每个以句点分隔的字符，并将其转换为int：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827245|var+parts+=+versionString.split('.');

for+(var+i+=+0;+i+<+parts.length;+i%2B%2B)+{
++var+value+=+parseInt(parts[i]);
++//+do+stuffs+here..+perhaps+build+a+numeric+version+variable?
}|code-block|syntax|javascript|827246|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can loop through every period-delimited character and convert it to an int: 

<pre><code>var parts = versionString.split('.');

for (var i = 0; i &lt; parts.length; i++) {
 var value = parseInt(parts[i]);
 // do stuffs here.. perhaps build a numeric version variable?
}
</code></pre>

blocks|key|612407|text|摘自http://java.com/js/deployJava.js|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|612408|++++//+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;+%2B%2Bi)+{
++++++++++++a[i]+=+Number(a[i]);
++++++++}
++++++++for+(var+i+=+0;+i+<+b.length;+%2B%2Bi)+{
++++++++++++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;
++++}|code-block|syntax|javascript|612409|entityMap|0|LINK|mutability|MUTABLE|url|http://java.com/js/deployJava.js^0|2|W|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Taken from <a href="http://java.com/js/deployJava.js">http://java.com/js/deployJava.js</a>:

<pre><code> // 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 &lt; a.length; ++i) {
 a[i] = Number(a[i]);
 }
 for (var i = 0; i &lt; b.length; ++i) {
 b[i] = Number(b[i]);
 }
 if (a.length == 2) {
 a[2] = 0;
 }

 if (a[0] &gt; b[0]) return true;
 if (a[0] &lt; b[0]) return false;

 if (a[1] &gt; b[1]) return true;
 if (a[1] &lt; b[1]) return false;

 if (a[2] &gt; b[2]) return true;
 if (a[2] &lt; b[2]) return false;

 return true;
 }
</code></pre>

blocks|key|612416|text|//+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%2B%2B)+{
++++++++//+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"));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|612417|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>// Return 1 if a &gt; b
// Return -1 if a &lt; 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 &lt; len; i++) {
 // A bigger than B
 if (parseInt(a_components[i]) &gt; parseInt(b_components[i])) {
 return 1;
 }

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

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

 if (a_components.length &lt; 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"));
</code></pre>

blocks|key|827346|text|replace()函数只替换字符串中的第一个匹配项。因此，让我们用,替换.。然后删除所有.，并再次将,转换为.，并将其解析为float。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|827347|for(i=0;+i<versions.length;+i%2B%2B)+{
++++v+=+versions[i].replace('.',+',');
++++v+=+v.replace(/\./g,+'');
++++versions[i]+=+parseFloat(v.replace(',',+'.'));
}|code-block|syntax|javascript|827348|最后，对其进行排序：|827349|versions.sort();|827350|entityMap^0|0|9|X|1|10|1|18|1|1E|1|1I|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|P|$]]

The <code>replace()</code> function only replaces the first occurence in the string. So, lets replace the <code>.</code> with <code>,</code>. Afterwards delete all <code>.</code> and make the <code>,</code> to <code>.</code> again and parse it to float.

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

finally, sort it:

<pre><code>versions.sort();
</code></pre>

blocks|key|827823|text|检查函数version_compare()+from+the+php.js+project。它类似于PHP's version_compare()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|827824|你可以像这样简单地使用它：|827825|version_compare('2.0',+'2.0.0.1',+'<');+
//+returns+true|code-block|syntax|javascript|827826|entityMap|0|LINK|mutability|MUTABLE|url|http://phpjs.org/functions/version_compare|1|http://php.net/manual/de/function.version-compare.php^0|4|H|1K|H|4|15|0|1E|N|1|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]|$9|14|A|15|1|16]]|E|$]]|$1|F|3|G|5|6|7|17|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

Check the function <a href="http://phpjs.org/functions/version_compare" rel="nofollow"><code>version_compare()</code> from the php.js project</a>. It's is similar to <a href="http://php.net/manual/de/function.version-compare.php" rel="nofollow">PHP's&nbsp;<code>version_compare()</code></a>.

You can simply use it like this:

<pre><code>version_compare('2.0', '2.0.0.1', '&lt;'); 
// returns true
</code></pre>

blocks|key|827959|text|难道你不能把它们转换成数字，然后按大小排序吗？将0附加到长度小于4的数字的1上|type|unstyled|depth|inlineStyleRanges|entityRanges|data|827960|在控制台中播放：|827961|$(["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%2B="0"+;+
++++num.push(++%2Bn++)
});|code-block|syntax|javascript|827962|版本越大，数字越大。编辑:可能需要调整以适应更大的版本系列|827963|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

couldnt you convert them into numbers and then sort after size? Append 0's to the ones to the numbers that are &lt; 4 in length

played around in console: 

<pre><code>$(["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 &lt; 4) n+="0" ; 
 num.push( +n )
});
</code></pre>

bigger the version, the bigger number. 
Edit: probably needs adjusting to account for bigger version series

blocks|key|612736|text|下面是一种有趣的面向对象的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|612737|++++function+versionString(str)+{
++++var+parts+=+str.split('.');
++++this.product+=+parts.length+>+0+?+parts[0]+*+1+:+0;
++++this.major+=+parts.length+>+1+?+parts[1]+*+1+:+0;
++++this.minor+=+parts.length+>+2+?+parts[2]+*+1+:+0;
++++this.build+=+parts.length+>+3+?+parts[3]+*+1+:+0;

++++this.compareTo+=+function(vStr){
++++++++vStr+=+this._isVersionString(vStr)+?+vStr+:+new+versionString(vStr);
++++++++return+this.compare(this,+vStr);
++++};

++++this.toString+=+function(){
++++++++return+this.product+%2B+"."+%2B+this.major+%2B+"."+%2B+this.minor+%2B+"."+%2B+this.build;
++++}

++++this.compare+=+function+(str1,+str2)+{
++++++++var+vs1+=+this._isVersionString(str1)+?+str1+:+new+versionString(str1);
++++++++var+vs2+=+this._isVersionString(str2)+?+str2+:+new+versionString(str2);

++++++++if+(this._compareNumbers(vs1.product,+vs2.product)+==+0)+{
++++++++++++if+(this._compareNumbers(vs1.major,+vs2.major)+==+0)+{
++++++++++++++++if+(this._compareNumbers(vs1.minor,+vs2.minor)+==+0)+{
++++++++++++++++++++return+this._compareNumbers(vs1.build,+vs2.build);
++++++++++++++++}+else+{
++++++++++++++++++++return+this._compareNumbers(vs1.minor,+vs2.minor);
++++++++++++++++}
++++++++++++}+else+{
++++++++++++++++return+this._compareNumbers(vs1.major,+vs2.major);
++++++++++++}
++++++++}+else+{
++++++++++++return+this._compareNumbers(vs1.product,+vs2.product);
++++++++}
++++};

++++this._isVersionString+=+function+(str)+{
++++++++return+str+!==+undefined+&&+str.build+!==+undefined;
++++};

++++this._compareNumbers+=+function+(n1,+n2)+{
++++++++if+(n1+>+n2)+{
++++++++++++return+1;
++++++++}+else+if+(n1+<+n2)+{
++++++++++++return+-1;
++++++++}+else+{
++++++++++++return+0;
++++++++}
++++};
}|code-block|syntax|javascript|612738|还有一些测试：|612739|var+v1+=+new+versionString("1.0");
var+v2+=+new+versionString("1.0.1");
var+v3+=+new+versionString("2.0");
var+v4+=+new+versionString("2.0.0.1");
var+v5+=+new+versionString("2.0.1");


alert(v1.compareTo("1.4.2"));
alert(v3.compareTo(v1));
alert(v5.compareTo(v4));
alert(v4.compareTo(v5));
alert(v5.compareTo(v5));|612740|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's a fun way to do it OO:

<pre><code> function versionString(str) {
 var parts = str.split('.');
 this.product = parts.length &gt; 0 ? parts[0] * 1 : 0;
 this.major = parts.length &gt; 1 ? parts[1] * 1 : 0;
 this.minor = parts.length &gt; 2 ? parts[2] * 1 : 0;
 this.build = parts.length &gt; 3 ? parts[3] * 1 : 0;

 this.compareTo = function(vStr){
 vStr = this._isVersionString(vStr) ? vStr : new versionString(vStr);
 return this.compare(this, vStr);
 };

 this.toString = function(){
 return this.product + "." + this.major + "." + this.minor + "." + this.build;
 }

 this.compare = function (str1, str2) {
 var vs1 = this._isVersionString(str1) ? str1 : new versionString(str1);
 var vs2 = this._isVersionString(str2) ? str2 : new versionString(str2);

 if (this._compareNumbers(vs1.product, vs2.product) == 0) {
 if (this._compareNumbers(vs1.major, vs2.major) == 0) {
 if (this._compareNumbers(vs1.minor, vs2.minor) == 0) {
 return this._compareNumbers(vs1.build, vs2.build);
 } else {
 return this._compareNumbers(vs1.minor, vs2.minor);
 }
 } else {
 return this._compareNumbers(vs1.major, vs2.major);
 }
 } else {
 return this._compareNumbers(vs1.product, vs2.product);
 }
 };

 this._isVersionString = function (str) {
 return str !== undefined &amp;&amp; str.build !== undefined;
 };

 this._compareNumbers = function (n1, n2) {
 if (n1 &gt; n2) {
 return 1;
 } else if (n1 &lt; n2) {
 return -1;
 } else {
 return 0;
 }
 };
}
</code></pre>

And some tests:

<pre><code>var v1 = new versionString("1.0");
var v2 = new versionString("1.0.1");
var v3 = new versionString("2.0");
var v4 = new versionString("2.0.0.1");
var v5 = new versionString("2.0.1");


alert(v1.compareTo("1.4.2"));
alert(v3.compareTo(v1));
alert(v5.compareTo(v4));
alert(v4.compareTo(v5));
alert(v5.compareTo(v5));
</code></pre>

blocks|key|612852|text|这真的取决于versioning+system背后的逻辑。每个数字代表什么，以及如何使用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|612853|是否每个subversion都是一个表示开发阶段的数字?0代表alpha+1代表beta+2代表发布候选3代表(最终)发布|612854|它是一个构建版本吗？您是否正在应用增量更新？|612855|一旦您了解了版本控制系统是如何工作的，创建算法就变得很容易。|612856|如果您不允许在每个subversion中使用大于9的数字，那么删除除第一个小数之外的所有小数将允许您进行直接比较。|612857|如果您确实允许在任何subversions中使用大于9的数字，有几种方法可以比较它们。最明显的方法是按小数拆分字符串，然后比较每一列。|612858|但是，在不知道版本控制系统如何工作的情况下，当版本1.0.2a发布时，实现上面的过程可以得到harry。|612859|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Versioning^0|6|H|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|12|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|13|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|14|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|15|8|@]|9|@]|C|$]]|$1|N|3|O|5|6|7|16|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|Q|$R|$5|S|T|U|C|$V|W]]]]

It really depends on the logic behind your <a href="http://en.wikipedia.org/wiki/Versioning" rel="nofollow">versioning system</a>. What does each number represent, and how it is used. 

Is each subversion is a numeration for designating development stage?
0 for alpha
1 for beta
2 for release candidate
3 for (final) release

Is it a build version? Are you applying incremental updates?

Once you know how the versioning system works, creating the algorithm becomes easy.

If you don't allow numbers greater than 9 in each subversion, eliminating all the decimals but the first will allow you to do a straight comparison.

If you do allow numbers greater than 9 in any of subversions, there are several ways to compare them. The most obvious is to split the string by the decimals and compare each column. 

But without knowing how the versioning system works, implementing a process like the ones above can get harry when version 1.0.2a is released.

blocks|key|828173|text|看看这个blog+post。此函数适用于数字版本号。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|828174|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%2B%2B)+{
++++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|code-block|syntax|javascript|828175|entityMap|0|LINK|mutability|MUTABLE|url|http://paintincode.blogspot.com/2012/05/javascript-function-to-compare-versions.html^0|4|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Check out this <a href="http://paintincode.blogspot.com/2012/05/javascript-function-to-compare-versions.html" rel="nofollow">blog post</a>. This function works for numeric version numbers. 

<pre><code>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 &lt; nLen; i++) {
 var nP1 = (i &lt; parts1.length) ? parseInt(parts1[i], 10) : 0
 , nP2 = (i &lt; parts2.length) ? parseInt(parts2[i], 10) : 0;

 if (isNaN(nP1)) { nP1 = 0; }
 if (isNaN(nP2)) { nP2 = 0; }

 if (nP1 != nP2) {
 nRes = (nP1 &gt; 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
</code></pre>

blocks|key|612947|text|这是一个巧妙的技巧。如果要处理特定范围内数值之间的数值，则可以为version对象的每个级别分配一个值。例如，这里将"largestValue“设置为0xFF，这为您的版本控制创建了一种非常"IP”的外观。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|612948|这也处理字母数字版本控制(即1.2a+<+1.2b)|612949|//+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+%2B+letter[0].charCodeAt()+/+0xFF;
++++++++++++}+else+{
++++++++++++++++return+n;
++++++++++++}
++++++++});
++++++++for+(var+i+=+0;+i+<+version.length;+%2B%2Bi)+{
++++++++++++if+(levels+===+i)+break;
++++++++++++value+%2B=+version[i]+/+0xFF+*+Math.pow(0xFF,+levels+-+i+%2B+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);|code-block|syntax|javascript|612950|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This is a neat trick. If you are dealing with numeric values, between a specific range of values, you can assign a value to each level of the version object. For instance "largestValue" is set to 0xFF here, which creates a very "IP" sort of look to your versioning. 

This also handles alpha-numeric versioning (i.e. 1.2a &lt; 1.2b)

<pre><code>// 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 &lt; 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 &gt; 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);
</code></pre>

blocks|key|828269|text|我喜欢来自@mar10的the+version，尽管从我的角度来看，有可能会被误用(如果版本与Semantic+Versioning文档兼容，似乎就不是这样，但如果使用了一些“内部版本号”，情况可能就会这样)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|828270|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|code-block|syntax|javascript|828271|这里的问题是，在某些情况下，版本号的子号是用尾随零来写的(至少我最近在使用不同的软件时看到了这一点)，这类似于数字的有理部分，所以：|828272|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|828273|但是，第一个(或第一个和第二个)版本子编号始终被视为它实际上等于的整数值。|828274|如果您使用这种版本控制，则只需更改示例中的几行：|828275|//+replace+this:
p1+=+parseInt(v1parts[i],+10);
p2+=+parseInt(v2parts[i],+10);
//+with+this:
p1+=+i/*+>+0+*/+?+parseFloat('0.'+%2B+v1parts[i],+10)+:+parseInt(v1parts[i],+10);
p2+=+i/*+>+0+*/+?+parseFloat('0.'+%2B+v2parts[i],+10)+:+parseInt(v2parts[i],+10);|828276|因此，除了第一个子数之外的每个子数都将作为浮点数进行比较，因此09和1将相应地变成0.09和0.1，并以这种方式进行适当的比较。2054和3将成为0.2054和0.3。|style|CODE|828277|那么完整的版本是(致谢给@mar10)：|828278|/**+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+=+(""+%2B+v1).split("."),
++++++++v2parts+=+(""+%2B+v2).split("."),
++++++++minLength+=+Math.min(v1parts.length,+v2parts.length),
++++++++p1,+p2,+i;
++++//+Compare+tuple+pair-by-pair.+
++++for(i+=+0;+i+<+minLength;+i%2B%2B)+{
++++++++//+Convert+to+integer+if+possible,+because+"8"+>+"10".
++++++++p1+=+i/*+>+0+*/+?+parseFloat('0.'+%2B+v1parts[i],+10)+:+parseInt(v1parts[i],+10);;
++++++++p2+=+i/*+>+0+*/+?+parseFloat('0.'+%2B+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;
}|828279|附注。它速度较慢，但也可以考虑重新使用相同的比较函数来操作字符串实际上是字符数组的事实：|828280|+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;
+++++}
+}|828281|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/19166/mar10|1|https://stackoverflow.com/a/14540169/167262|2|http://semver.org/spec/v2.0.0.html|3^0|5|6|0|C|B|1|1B|J|2|0|0|0|0|0|0|0|V|2|Y|1|15|4|1A|3|1S|4|1X|1|21|6|28|3|0|C|6|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@$A|1I|B|1J|1|1K]|$A|1L|B|1M|1|1N]|$A|1O|B|1P|1|1Q]]|C|$]]|$1|D|3|E|5|F|7|1R|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1S|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1T|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1U|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|1V|8|@]|9|@]|C|$]]|$1|Q|3|R|5|F|7|1W|8|@]|9|@]|C|$G|H]]|$1|S|3|T|5|6|7|1X|8|@$A|1Y|B|1Z|U|V]|$A|20|B|21|U|V]|$A|22|B|23|U|V]|$A|24|B|25|U|V]|$A|26|B|27|U|V]|$A|28|B|29|U|V]|$A|2A|B|2B|U|V]|$A|2C|B|2D|U|V]]|9|@]|C|$]]|$1|W|3|X|5|6|7|2E|8|@]|9|@$A|2F|B|2G|1|2H]]|C|$]]|$1|Y|3|Z|5|F|7|2I|8|@]|9|@]|C|$G|H]]|$1|10|3|11|5|6|7|2J|8|@]|9|@]|C|$]]|$1|12|3|13|5|F|7|2K|8|@]|9|@]|C|$G|H]]|$1|14|3|-4|5|6|7|2L|8|@]|9|@]|C|$]]]|15|$16|$5|17|18|19|C|$1A|1B]]|1C|$5|17|18|19|C|$1A|1D]]|1E|$5|17|18|19|C|$1A|1F]]|1G|$5|17|18|19|C|$1A|1B]]]]

I like <a href="https://stackoverflow.com/a/14540169/167262">the version</a> from <a href="https://stackoverflow.com/users/19166/mar10">@mar10</a>, though from my point of view, there is a chance of misusage (seems it is not the case if versions are compatible with <a href="http://semver.org/spec/v2.0.0.html" rel="nofollow noreferrer">Semantic Versioning</a> document, but may be the case if some "build number" is used):

<pre><code>versionCompare( '1.09', '1.1'); // returns 1, which is wrong: 1.09 &lt; 1.1
versionCompare('1.702', '1.8'); // returns 1, which is wrong: 1.702 &lt; 1.8
</code></pre>

The problem here is that sub-numbers of version number are, in some cases, written with trailing zeroes cut out (at least as I recently see it while using different software), which is similar to rational part of a number, so:

<pre><code>5.17.2054 &gt; 5.17.2
5.17.2 == 5.17.20 == 5.17.200 == ... 
5.17.2054 &gt; 5.17.20
5.17.2054 &gt; 5.17.200
5.17.2054 &gt; 5.17.2000
5.17.2054 &gt; 5.17.20000
5.17.2054 &lt; 5.17.20001
5.17.2054 &lt; 5.17.3
5.17.2054 &lt; 5.17.30
</code></pre>

The first (or both first and second) version sub-number, however, is always treated as an integer value it actually equals to. 

If you use this kind of versioning, you may change just a few lines in the example:

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

So every sub-number except the first one will be compared as a float, so <code>09</code> and <code>1</code> will become <code>0.09</code> and <code>0.1</code> accordingly and compared properly this way. <code>2054</code> and <code>3</code> will become <code>0.2054</code> and <code>0.3</code>.

The complete version then, is (credits to <a href="https://stackoverflow.com/users/19166/mar10">@mar10</a>):

<pre><code>/** Compare two dotted version strings (like '10.2.3').
 * @returns {Integer} 0: v1 == v2, -1: v1 &lt; v2, 1: v1 &gt; 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 &lt; minLength; i++) {
 // Convert to integer if possible, because "8" &gt; "10".
 p1 = i/* &gt; 0 */ ? parseFloat('0.' + v1parts[i], 10) : parseInt(v1parts[i], 10);;
 p2 = i/* &gt; 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 &gt; p2) {
 return 1;
 }else if (p1 &lt; 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 &lt; v2parts.length) ? -1 : 1;
}
</code></pre>

P.S. It is slower, but also possible to think on re-using the same comparing function operating the fact that the string is actually the array of characters:

<pre><code> 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 &lt; 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 -&gt; max_length) {
 var res = cmp_ver(arr1[i], arr2[i]);
 if (res !== 0) return res;
 }
 }
</code></pre>

blocks|key|828315|text|我基于Kons的想法制作了它，并针对Java版本"1.7.0_45“进行了优化。它只是一个将版本字符串转换为浮点型的函数。这是函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|828316|function+parseVersionFloat(versionString)+{
++++var+versionArray+=+(""+%2B+versionString)
++++++++++++.replace("_",+".")
++++++++++++.replace(/[%5E0-9.]/g,+"")
++++++++++++.split("."),
++++++++sum+=+0;
++++for+(var+i+=+0;+i+<+versionArray.length;+%2B%2Bi)+{
++++++++sum+%2B=+Number(versionArray[i])+/+Math.pow(10,+i+*+3);
++++}
++++console.log(versionString+%2B+"+->+"+%2B+sum);
++++return+sum;
}|code-block|syntax|javascript|828317|字符串"1.7.0_45“被转换为1.0070000450000001，这对于正常的比较来说已经足够了。这里解释的错误：How+to+deal+with+floating+point+number+precision+in+JavaScript?。如果任何零件需要3位以上的位数，您可以更改分频器Math.pow(10,+i+*+3);。|offset|length|style|CODE|828318|输出将如下所示：|828319|1.7.0_45+++++++++>+1.007000045
ver+1.7.build_45+>+1.007000045
1.234.567.890++++>+1.23456789|828320|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1458633/elegant-workaround-for-javascript-floating-point-number-problem^0|0|0|44|K|1O|1R|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@$I|13|J|14|1|15]]|A|$]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

I made this based on Kons idea, and optimized it for Java version "1.7.0_45". It's just a function meant to convert a version string to a float. This is the function:

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

String "1.7.0_45" is converted to 1.0070000450000001 and this is good enough for a normal comparison. Error explained here: <a href="https://stackoverflow.com/questions/1458633/elegant-workaround-for-javascript-floating-point-number-problem">How to deal with floating point number precision in JavaScript?</a>. If need more then 3 digits on any part you can change the divider <code>Math.pow(10, i * 3);</code>.

Output will look like this:

<pre><code>1.7.0_45 &gt; 1.007000045
ver 1.7.build_45 &gt; 1.007000045
1.234.567.890 &gt; 1.23456789
</code></pre>

blocks|key|613156|text|这里有一个受其他答案启发的适合与Array.sort一起使用的coffeescript实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|613157|#+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|code-block|syntax|javascript|613158|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a coffeescript implementation suitable for use with Array.sort inspired by other answers here:

<pre><code># Returns &gt; 0 if v1 &gt; v2 and &lt; 0 if v1 &lt; v2 and 0 if v1 == v2
compareVersions = (v1, v2) -&gt;
 v1Parts = v1.split('.')
 v2Parts = v2.split('.')
 minLength = Math.min(v1Parts.length, v2Parts.length)
 if minLength &gt; 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
</code></pre>

blocks|key|613206|text|我遇到了同样的版本比较问题，但版本可能包含任何内容(例如:不是点的分隔符，像rc1，rc2这样的扩展名...)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|613207|我使用了这个方法，它基本上将版本字符串分为数字和非数字，并尝试相应地与类型进行比较。|613208|function+versionCompare(a,b)+{
++av+=+a.match(/([0-9]%2B%7C[%5E0-9]%2B)/g)
++bv+=+b.match(/([0-9]%2B%7C[%5E0-9]%2B)/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)+%7C%7C+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;}
++++}
++}
}|code-block|syntax|javascript|613209|对于某些情况，这里有一些假设，例如："1.01“===+"1.1"，或"1.8”<+"1.71“。无法管理语义版本2.0.0规定的1.0.0-rc.1<1.0.0|613210|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I had the same problem of version comparison, but with versions possibly containing anything (ie: separators that were not dots, extensions like rc1, rc2...).

I used this, which basically split the version strings into numbers and non-numbers, and tries to compare accordingly to the type.

<pre><code>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') &amp;&amp; (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 &lt; ib) { return -1;}
 if (ia &gt; ib) { return 1;}
 } else {
 if (ian &lt; ibn) { return -1;}
 if (ian &gt; ibn) { return 1;}
 }
 }
}
</code></pre>

There are some assumptions here for some cases, for example : "1.01" === "1.1", or "1.8" &lt; "1.71". It fails to manage "1.0.0-rc.1" &lt; "1.0.0", as specified by Semantic versionning 2.0.0

blocks|key|613236|text|function+versionCompare(version1,+version2){
++++++++++++++++var+a+=+version1.split('.');
++++++++++++++++var+b+=+version2.split('.');
++++++++++++++++for+(var+i+=+0;+i+<+a.length;+%2B%2Bi)+{
++++++++++++++++++++a[i]+=+Number(a[i]);
++++++++++++++++}
++++++++++++++++for+(var+i+=+0;+i+<+b.length;+%2B%2Bi)+{
++++++++++++++++++++b[i]+=+Number(b[i]);
++++++++++++++++}
++++++++++++++++var+length=a.length;

++++++++++++++++for(j=0;+j<length;+j%2B%2B){
++++++++++++++++++++if(typeof+b[j]=='undefined')b[j]=0;
++++++++++++++++++++if+(a[j]+>+b[j])+return+true;
++++++++++++++++++++else+if(a[j]+<+b[j])return+false;
++++++++++++++++++++if(j==length-1+&&+a[j]+>=+b[j])return+true;
++++++++++++++++}+++++++++++++

++++++++++++++++return+false;
++++++++++++},|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|613237|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function versionCompare(version1, version2){
 var a = version1.split('.');
 var b = version2.split('.');
 for (var i = 0; i &lt; a.length; ++i) {
 a[i] = Number(a[i]);
 }
 for (var i = 0; i &lt; b.length; ++i) {
 b[i] = Number(b[i]);
 }
 var length=a.length;

 for(j=0; j&lt;length; j++){
 if(typeof b[j]=='undefined')b[j]=0;
 if (a[j] &gt; b[j]) return true;
 else if(a[j] &lt; b[j])return false;
 if(j==length-1 &amp;&amp; a[j] &gt;= b[j])return true;
 } 

 return false;
 },
</code></pre>

blocks|key|613283|text|在排序之前对版本进行预处理意味着不会不必要地多次调用parseInt。使用类似于Michael+Deal的建议的Array#map，下面是我用来查找标准三部分半的最新版本的排序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|613284|​|613285|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"|code-block|syntax|javascript|613286|613287|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

Preprocessing the versions prior to the sort means parseInt isn't called multiple times unnecessarily.
Using Array#map similar to Michael Deal's suggestion, here's a sort I use to find the newest version of a standard 3 part semver:

<div class="snippet" data-lang="js" data-hide="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>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] &lt; b[0]) return 1;
 else if (a[0] &gt; b[0]) return -1;
 else if (a[1] &lt; b[1]) return 1;
 else if (a[1] &gt; b[1]) return -1;
 else if (a[2] &lt; b[2]) return 1;
 else if (a[2] &gt; b[2]) return -1;
 return 0;
});

var newest = versions[0].join(".");
console.log(newest); // "1.1.0"</code></pre>
</div>
</div>

blocks|key|613370|text|另一个我认为值得分享的实现，因为它简短，简单，但功能强大。请注意，它只使用数字比较。通常，它检查version2是否晚于version1，如果是，则返回true。假设您有version1:+1.1.1和version2:+1.1.2。它遍历了两个版本的每个部分，添加它们的部分如下：(1+%2B+0.1)然后(1.1+%2B+0.01)用于version1和(1+%2B+0.1)然后(1.1+%2B+0.02)用于version2。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|613371|function+compareVersions(version1,+version2)+{

++++version1+=+version1.split('.');
++++version2+=+version2.split('.');

++++var+maxSubVersionLength+=+String(Math.max.apply(undefined,+version1.concat(version2))).length;

++++var+reduce+=+function(prev,+current,+index)+{

++++++++return+parseFloat(prev)+%2B+parseFloat('0.'+%2B+Array(index+%2B+(maxSubVersionLength+-+String(current).length)).join('0')+%2B+current);
++++};

++++return+version1.reduce(reduce)+<+version2.reduce(reduce);
}|code-block|syntax|javascript|613372|如果你想从版本列表中找到最新的版本，这可能会很有用：|613373|function+findLatestVersion(versions)+{

++++if+(!(versions+instanceof+Array))+{
++++++++versions+=+Array.prototype.slice.apply(arguments,+[0]);
++++}

++++versions+=+versions.map(function(version)+{+return+version.split('.');+});

++++var+maxSubVersionLength+=+String(Math.max.apply(undefined,+Array.prototype.concat.apply([],+versions))).length;

++++var+reduce+=+function(prev,+current,+index)+{

++++++++return+parseFloat(prev)+%2B+parseFloat('0.'+%2B+Array(index+%2B+(maxSubVersionLength+-+String(current).length)).join('0')+%2B+current);
++++};

++++var+sums+=+[];

++++for+(var+i+=+0;+i+<+versions.length;+i%2B%2B)+{
++++++++sums.push(parseFloat(versions[i].reduce(reduce)));
++++}

++++return+versions[sums.indexOf(Math.max.apply(undefined,+sums))].join('.');
}

console.log(findLatestVersion('0.1000000.1',+'2.0.0.10',+'1.6.10',+'1.4.3',+'2',+'2.0.0.1'));+//+2.0.0.10
console.log(findLatestVersion(['0.1000000.1',+'2.0.0.10',+'1.6.10',+'1.4.3',+'2',+'2.0.0.1']));+//+2.0.0.10|613374|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

One more implementation I believe worth sharing as it's short, simple and yet powerful. Please note that it uses digit comparison only. Generally it checks if version2 is later than version1 and returns true if it's the case. Suppose you have version1: 1.1.1 and version2: 1.1.2. It goes through each part of the two versions adding their parts as follows: (1 + 0.1) then (1.1 + 0.01) for version1 and (1 + 0.1) then (1.1 + 0.02) for version2.

<pre><code>function compareVersions(version1, version2) {

 version1 = version1.split('.');
 version2 = version2.split('.');

 var maxSubVersionLength = String(Math.max.apply(undefined, version1.concat(version2))).length;

 var reduce = function(prev, current, index) {

 return parseFloat(prev) + parseFloat('0.' + Array(index + (maxSubVersionLength - String(current).length)).join('0') + current);
 };

 return version1.reduce(reduce) &lt; version2.reduce(reduce);
}
</code></pre>

If you want to find the latest version out of list of versions then this might be useful:

<pre><code>function findLatestVersion(versions) {

 if (!(versions instanceof Array)) {
 versions = Array.prototype.slice.apply(arguments, [0]);
 }

 versions = versions.map(function(version) { return version.split('.'); });

 var maxSubVersionLength = String(Math.max.apply(undefined, Array.prototype.concat.apply([], versions))).length;

 var reduce = function(prev, current, index) {

 return parseFloat(prev) + parseFloat('0.' + Array(index + (maxSubVersionLength - String(current).length)).join('0') + current);
 };

 var sums = [];

 for (var i = 0; i &lt; versions.length; i++) {
 sums.push(parseFloat(versions[i].reduce(reduce)));
 }

 return versions[sums.indexOf(Math.max.apply(undefined, sums))].join('.');
}

console.log(findLatestVersion('0.1000000.1', '2.0.0.10', '1.6.10', '1.4.3', '2', '2.0.0.1')); // 2.0.0.10
console.log(findLatestVersion(['0.1000000.1', '2.0.0.10', '1.6.10', '1.4.3', '2', '2.0.0.1'])); // 2.0.0.10
</code></pre>

blocks|key|613432|text|如果这个想法已经在一个我没有见过的链接中被访问过，请原谅。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|613433|我已经成功地将各部分转换为加权和，如下所示：|613434|partSum+=+this.major+*+Math.Pow(10,9);
partSum+%2B=+this.minor+*+Math.Pow(10,+6);
partSum+%2B=+this.revision+*+Math.Pow(10,+3);
partSum+%2B=+this.build+*+Math.Pow(10,+0);|code-block|syntax|javascript|613435|这使得比较变得非常容易(比较double)。我们的版本字段从不超过4位。|613436|7.10.2.184++->+7010002184.0
7.11.0.1385+->+7011001385.0|613437|我希望这对某些人有帮助，因为多个条件句看起来有点过头了。|613438|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Forgive me if this idea already been visited in a link I have not seen.

I have had some success with conversion of the parts into a weighted sum like so:

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

Which made comparisons very easy (comparing a double).
Our version fields are never more than 4 digits.

<pre><code>7.10.2.184 -&gt; 7010002184.0
7.11.0.1385 -&gt; 7011001385.0
</code></pre>

I hope this helps someone, as the multiple conditionals seem a bit overkill.

blocks|key|613523|text|这适用于由句点分隔的任意长度的数字版本。仅当myVersion为>=+minimumVersion时才返回true，并假设版本1小于1.0，版本1.1小于1.1.0，依此类推。添加额外的条件应该相当简单，比如接受数字(只需转换为字符串)和十六进制，或使分隔符为动态的(只需添加一个分隔符参数，然后替换“。使用参数)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|613524|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%2B%2B)+{
++++++++if(Number(v1[i])+>+Number(v2[i]))+{
++++++++++++return+true;
++++++++}
++++++++if(Number(v1[i])+<+Number(v2[i]))+{
++++++++++++return+false;
++++++++}+++++++++++
++++}

++++return+(v1.length+>=+v2.length);
}|code-block|syntax|javascript|613525|以下是一些测试：|613526|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"));|613527|或者，这里是一个递归版本|613528|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%2B1);
}|613529|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This works for numeric versions of any length separated by a period. It returns true only if myVersion is >= minimumVersion, making the assumption that version 1 is less than 1.0, version 1.1 is less than 1.1.0 and so on. It should be fairly simple to add extra conditions such as accepting numbers (just convert to a string) and hexadecimal or making the delimiter dynamic (just add a delimiter parameter then replace the "." with the param)

<pre><code>function versionCompare(myVersion, minimumVersion) {

 var v1 = myVersion.split("."), v2 = minimumVersion.split("."), minLength; 

 minLength= Math.min(v1.length, v2.length);

 for(i=0; i&lt;minLength; i++) {
 if(Number(v1[i]) &gt; Number(v2[i])) {
 return true;
 }
 if(Number(v1[i]) &lt; Number(v2[i])) {
 return false;
 } 
 }

 return (v1.length &gt;= v2.length);
}
</code></pre>

Here are some tests:

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

Alternatively here is a recursive version

<pre><code>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]) &lt; Number(v2[index])) {
 return false;
 }
 if(Number(v1[i]) &lt; Number(v2[i])) {
 return true;
 }
 if(index === minLength) {
 return (v1.length &gt;= v2.length);
 }
 return recursiveCompare(v1,v2,minLength,index+1);
}
</code></pre>

blocks|key|828792|text|这是用递归算法实现的另一种方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|828793|这段代码只使用了Array.shift和递归，这意味着它可以在IE+6%2B中运行。如果您有任何疑问，可以访问my+GitHub|offset|length|828794|(function(root,+factory)+{
++if+(typeof+exports+===+'object')+{
++++return+module.exports+=+factory();
++}+else+if+(typeof+define+===+'function'+&&+define.amd)+{
++++return+define(factory);
++}+else+{
++++return+root.compareVer+=+factory();
++}
})(this,+function()+{
++'use+strict';
++var+_compareVer;
++_compareVer+=+function(newVer,+oldVer)+{
++++var+VER_RE,+compareNum,+isTrue,+maxLen,+newArr,+newLen,+newMatch,+oldArr,+oldLen,+oldMatch,+zerofill;
++++VER_RE+=+/(\d%2B\.){1,9}\d%2B/;
++++if+(arguments.length+!==+2)+{
++++++return+-100;
++++}
++++if+(typeof+newVer+!==+'string')+{
++++++return+-2;
++++}
++++if+(typeof+oldVer+!==+'string')+{
++++++return+-3;
++++}
++++newMatch+=+newVer.match(VER_RE);
++++if+(!newMatch+%7C%7C+newMatch[0]+!==+newVer)+{
++++++return+-4;
++++}
++++oldMatch+=+oldVer.match(VER_RE);
++++if+(!oldMatch+%7C%7C+oldMatch[0]+!==+oldVer)+{
++++++return+-5;
++++}
++++newVer+=+newVer.replace(/%5E0/,+'');
++++oldVer+=+oldVer.replace(/%5E0/,+'');
++++if+(newVer+===+oldVer)+{
++++++return+0;
++++}+else+{
++++++newArr+=+newVer.split('.');
++++++oldArr+=+oldVer.split('.');
++++++newLen+=+newArr.length;
++++++oldLen+=+oldArr.length;
++++++maxLen+=+Math.max(newLen,+oldLen);
++++++zerofill+=+function()+{
++++++++newArr.length+<+maxLen+&&+newArr.push('0');
++++++++oldArr.length+<+maxLen+&&+oldArr.push('0');
++++++++return+newArr.length+!==+oldArr.length+&&+zerofill();
++++++};
++++++newLen+!==+oldLen+&&+zerofill();
++++++if+(newArr.toString()+===+oldArr.toString())+{
++++++++if+(newLen+>+oldLen)+{
++++++++++return+1;
++++++++}+else+{
++++++++++return+-1;
++++++++}
++++++}+else+{
++++++++isTrue+=+-1;
++++++++compareNum+=+function()+{
++++++++++var+_new,+_old;
++++++++++_new+=+~~newArr.shift();
++++++++++_old+=+~~oldArr.shift();
++++++++++_new+>+_old+&&+(isTrue+=+1);
++++++++++return+_new+===+_old+&&+newArr.length+>+0+&&+compareNum();
++++++++};
++++++++compareNum();
++++++++return+isTrue;
++++++}
++++}
++};
++return+_compareVer;
});|code-block|syntax|javascript|828795|我希望这些代码能帮到什么人。|828796|下面是测试结果。|828797|console.log(compareVer("0.0.2","0.0.1"));//1
console.log(compareVer("0.0.10","0.0.1"));+//1
console.log(compareVer("0.0.10","0.0.2"));+//1
console.log(compareVer("0.9.0","0.9"));+//1
console.log(compareVer("0.10.0","0.9.0"));+//1
console.log(compareVer("1.7",+"1.07"));+//1
console.log(compareVer("1.0.07",+"1.0.007"));+//1

console.log(compareVer("0.3","0.3"));+//0
console.log(compareVer("0.0.3","0.0.3"));+//0
console.log(compareVer("0.0.3.0","0.0.3.0"));+//0
console.log(compareVer("00.3","0.3"));+//0
console.log(compareVer("00.3","00.3"));+//0
console.log(compareVer("01.0.3","1.0.3"));+//0
console.log(compareVer("1.0.3","01.0.3"));+//0

console.log(compareVer("0.2.0","1.0.0"));+//-1
console.log(compareVer('0.0.2.2.0',"0.0.2.3"));+//-1
console.log(compareVer('0.0.2.0',"0.0.2"));+//-1
console.log(compareVer('0.0.2',"0.0.2.0"));+//-1
console.log(compareVer("1.07",+"1.7"));+//-1
console.log(compareVer("1.0.007",+"1.0.07"));+//-1

console.log(compareVer());+//-100
console.log(compareVer("0.0.2"));+//-100
console.log(compareVer("0.0.2","0.0.2","0.0.2"));+//-100
console.log(compareVer(1212,"0.0.2"));+//-2
console.log(compareVer("0.0.2",1212));+//-3
console.log(compareVer('1.abc.2',"1.0.2"));+//-4
console.log(compareVer('1.0.2',"1.abc.2"));+//-5|828798|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/lmtdit/compare-ver^0|0|1H|9|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]]|A|$]]|$1|F|3|G|5|H|7|13|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|H|7|16|8|@]|9|@]|A|$I|J]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

Here's another way to do it with recursive algorithm.

This code just uses Array.shift and recursive, which means that it can run in IE 6+. If you have any doubts, you can visit <a href="https://github.com/lmtdit/compare-ver" rel="nofollow">my GitHub</a>

<pre><code>(function(root, factory) {
 if (typeof exports === 'object') {
 return module.exports = factory();
 } else if (typeof define === 'function' &amp;&amp; define.amd) {
 return define(factory);
 } else {
 return root.compareVer = factory();
 }
})(this, function() {
 'use strict';
 var _compareVer;
 _compareVer = function(newVer, oldVer) {
 var VER_RE, compareNum, isTrue, maxLen, newArr, newLen, newMatch, oldArr, oldLen, oldMatch, zerofill;
 VER_RE = /(\d+\.){1,9}\d+/;
 if (arguments.length !== 2) {
 return -100;
 }
 if (typeof newVer !== 'string') {
 return -2;
 }
 if (typeof oldVer !== 'string') {
 return -3;
 }
 newMatch = newVer.match(VER_RE);
 if (!newMatch || newMatch[0] !== newVer) {
 return -4;
 }
 oldMatch = oldVer.match(VER_RE);
 if (!oldMatch || oldMatch[0] !== oldVer) {
 return -5;
 }
 newVer = newVer.replace(/^0/, '');
 oldVer = oldVer.replace(/^0/, '');
 if (newVer === oldVer) {
 return 0;
 } else {
 newArr = newVer.split('.');
 oldArr = oldVer.split('.');
 newLen = newArr.length;
 oldLen = oldArr.length;
 maxLen = Math.max(newLen, oldLen);
 zerofill = function() {
 newArr.length &lt; maxLen &amp;&amp; newArr.push('0');
 oldArr.length &lt; maxLen &amp;&amp; oldArr.push('0');
 return newArr.length !== oldArr.length &amp;&amp; zerofill();
 };
 newLen !== oldLen &amp;&amp; zerofill();
 if (newArr.toString() === oldArr.toString()) {
 if (newLen &gt; oldLen) {
 return 1;
 } else {
 return -1;
 }
 } else {
 isTrue = -1;
 compareNum = function() {
 var _new, _old;
 _new = ~~newArr.shift();
 _old = ~~oldArr.shift();
 _new &gt; _old &amp;&amp; (isTrue = 1);
 return _new === _old &amp;&amp; newArr.length &gt; 0 &amp;&amp; compareNum();
 };
 compareNum();
 return isTrue;
 }
 }
 };
 return _compareVer;
});
</code></pre>

Well, I hope this codes help someone. 

Here's the testing.

<pre><code>console.log(compareVer("0.0.2","0.0.1"));//1
console.log(compareVer("0.0.10","0.0.1")); //1
console.log(compareVer("0.0.10","0.0.2")); //1
console.log(compareVer("0.9.0","0.9")); //1
console.log(compareVer("0.10.0","0.9.0")); //1
console.log(compareVer("1.7", "1.07")); //1
console.log(compareVer("1.0.07", "1.0.007")); //1

console.log(compareVer("0.3","0.3")); //0
console.log(compareVer("0.0.3","0.0.3")); //0
console.log(compareVer("0.0.3.0","0.0.3.0")); //0
console.log(compareVer("00.3","0.3")); //0
console.log(compareVer("00.3","00.3")); //0
console.log(compareVer("01.0.3","1.0.3")); //0
console.log(compareVer("1.0.3","01.0.3")); //0

console.log(compareVer("0.2.0","1.0.0")); //-1
console.log(compareVer('0.0.2.2.0',"0.0.2.3")); //-1
console.log(compareVer('0.0.2.0',"0.0.2")); //-1
console.log(compareVer('0.0.2',"0.0.2.0")); //-1
console.log(compareVer("1.07", "1.7")); //-1
console.log(compareVer("1.0.007", "1.0.07")); //-1

console.log(compareVer()); //-100
console.log(compareVer("0.0.2")); //-100
console.log(compareVer("0.0.2","0.0.2","0.0.2")); //-100
console.log(compareVer(1212,"0.0.2")); //-2
console.log(compareVer("0.0.2",1212)); //-3
console.log(compareVer('1.abc.2',"1.0.2")); //-4
console.log(compareVer('1.0.2',"1.abc.2")); //-5
</code></pre>

blocks|key|828879|text|这个想法是比较两个版本，并知道哪个是最大的。我们删除".“我们将向量的每个位置与另一个进行比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|828880|//+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%2B%2B)+{

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

++++++//+A+bigger+than+B
++++++if+(valueA+>+valueB+%7C%7C+isNaN(valueB))+{
+++++++++return+1;
++++++}

++++++//+B+bigger+than+A
++++++if+(valueA+<+valueB)+{
+++++++++return+-1;
++++++}
+++}
}|code-block|syntax|javascript|828881|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The idea is comparate two versions and know which is the biggest. We delete "." and we compare each position of the vector with the other.

<pre><code>// Return 1 if a &gt; b
// Return -1 if a &lt; 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 &lt; partsNumberA.length; i++) {

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

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

 // B bigger than A
 if (valueA &lt; valueB) {
 return -1;
 }
 }
}
</code></pre>

blocks|key|613717|text|我找到了一个最简单的方法来比较它们，不确定这是否是你想要的。当我在控制台中运行下面的代码时，它是有意义的，并且使用sort()方法，我可以获得经过排序的版本字符串数组。它是按字母顺序排列的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|613718|"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"]|code-block|syntax|javascript|613719|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I find a simplest way to compare them, don't sure if it's what you want.
when I run below code in console, it make sense, and using sort() method, I could get the sorted array of versions string. it's based on the alphabetical order.

<pre><code>"1.0" &lt; "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"]
</code></pre>

blocks|key|613793|text|这里有一个版本，它对版本字符串进行排序，而不分配任何子字符串或数组。因为它分配的对象更少，所以GC要做的工作也更少。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|613794|有一对分配(允许重用getVersionPart方法)，但如果您对性能非常敏感，则可以扩展它以完全避免分配。|offset|length|style|CODE|613795|const+compareVersionStrings+:+(a:+string,+b:+string)+=>+number+=+(a,+b)+=>
{
++++var+ia+=+{s:a,i:0},+ib+=+{s:b,i:0};
++++while+(true)
++++{
++++++++var+na+=+getVersionPart(ia),+nb+=+getVersionPart(ib);

++++++++if+(na+===+null+&&+nb+===+null)
++++++++++++return+0;
++++++++if+(na+===+null)
++++++++++++return+-1;
++++++++if+(nb+===+null)
++++++++++++return+1;
++++++++if+(na+>+nb)
++++++++++++return+1;
++++++++if+(na+<+nb)
++++++++++++return+-1;
++++}
};

const+zeroCharCode+=+'0'.charCodeAt(0);

const+getVersionPart+=+(a+:+{s:string,+i:number})+=>
{
++++if+(a.i+>=+a.s.length)
++++++++return+null;

++++var+n+=+0;
++++while+(a.i+<+a.s.length)
++++{
++++++++if+(a.s[a.i]+===+'.')
++++++++{
++++++++++++a.i%2B%2B;
++++++++++++break;
++++++++}

++++++++n+*=+10;
++++++++n+%2B=+a.s.charCodeAt(a.i)+-+zeroCharCode;
++++++++a.i%2B%2B;
++++}
++++return+n;
}|code-block|syntax|javascript|613796|entityMap^0|0|A|E|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here's a version that orders version strings without allocating any sub-strings or arrays. Being that it allocates fewer objects, there's less work for the GC to do.

There is one pair of allocations (to allow reuse of the <code>getVersionPart</code> method), but you could expand that to avoid allocations altogether if you were very performance sensitive.

<pre class="lang-js prettyprint-override"><code>const compareVersionStrings : (a: string, b: string) =&gt; number = (a, b) =&gt;
{
 var ia = {s:a,i:0}, ib = {s:b,i:0};
 while (true)
 {
 var na = getVersionPart(ia), nb = getVersionPart(ib);

 if (na === null &amp;&amp; nb === null)
 return 0;
 if (na === null)
 return -1;
 if (nb === null)
 return 1;
 if (na &gt; nb)
 return 1;
 if (na &lt; nb)
 return -1;
 }
};

const zeroCharCode = '0'.charCodeAt(0);

const getVersionPart = (a : {s:string, i:number}) =&gt;
{
 if (a.i &gt;= a.s.length)
 return null;

 var n = 0;
 while (a.i &lt; a.s.length)
 {
 if (a.s[a.i] === '.')
 {
 a.i++;
 break;
 }

 n *= 10;
 n += a.s.charCodeAt(a.i) - zeroCharCode;
 a.i++;
 }
 return n;
}
</code></pre>

blocks|key|613809|text|//+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%2B%2B){
++++++++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
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|613810|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>// 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&lt;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] &gt; v2[i]) return true;
 if(v1[i] &lt; v2[i]) return false;
 }
 return false; // Returns false if they are equal
 }
</code></pre>

blocks|key|613880|text|简单而简短的功能：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|613881|function+isNewerVersion+(oldVer,+newVer)+{
++const+oldParts+=+oldVer.split('.')
++const+newParts+=+newVer.split('.')
++for+(var+i+=+0;+i+<+newParts.length;+i%2B%2B)+{
++++const+a+=+~~newParts[i]+//+parse+int
++++const+b+=+~~oldParts[i]+//+parse+int
++++if+(a+>+b)+return+true
++++if+(a+<+b)+return+false
++}
++return+false
}|code-block|syntax|javascript|613882|测试：|613883|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|613884|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Simple and short function:
<pre><code>function isNewerVersion (oldVer, newVer) {
 const oldParts = oldVer.split('.')
 const newParts = newVer.split('.')
 for (var i = 0; i &lt; newParts.length; i++) {
 const a = ~~newParts[i] // parse int
 const b = ~~oldParts[i] // parse int
 if (a &gt; b) return true
 if (a &lt; b) return false
 }
 return false
}
</code></pre>
Tests:
<pre><code>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
</code></pre>

blocks|key|613960|text|这是我的解决方案。它已经接受了leetcode。我在今天的面试中遇到了这个问题。但是我当时没有解决这个问题。我又想了一遍。添加零以使两个数组的长度相等。然后进行比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|613961|​|613962|var+compareVersion+=+function(version1,+version2)+{
++++let+arr1+=+version1.split('.').map(Number);
++++let+arr2+=+version2.split('.').map(Number);
++++let+diff+=+0;
++++if+(arr1.length+>+arr2.length){
++++++++diff+=+arr1.length+-+arr2.length;
++++++++while+(diff+>+0){
++++++++++++arr2.push(0);
++++++++++++diff--;
++++++++}+
++++}
++++else+if+(arr1.length+<+arr2.length){
++++++++diff+=+arr2.length+-+arr1.length;
++++++++while+(diff+>+0){
++++++++++++arr1.push(0);
++++++++++++diff--;
++++++++}
++++}
+++
++++let+i+=+0;
++++while+(i+<+arr1.length){
++++++++if+(arr1[i]+>+arr2[i]){
+++++++++++return+1;
+++++++}+else+if+(arr1[i]+<+arr2[i]){
+++++++++++return+-1;
+++++++}
++++++++i%2B%2B;
++++}
++++return+0;
++++
};|code-block|syntax|javascript|613963|613964|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

this is my solution. it has accepted on leetcode. I met the problem in my interview today. But i did not solve it at that time.
I thought about it again. Adding zeros to make the two arrays' length equal. Then comparison. 

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var compareVersion = function(version1, version2) {
 let arr1 = version1.split('.').map(Number);
 let arr2 = version2.split('.').map(Number);
 let diff = 0;
 if (arr1.length &gt; arr2.length){
 diff = arr1.length - arr2.length;
 while (diff &gt; 0){
 arr2.push(0);
 diff--;
 } 
 }
 else if (arr1.length &lt; arr2.length){
 diff = arr2.length - arr1.length;
 while (diff &gt; 0){
 arr1.push(0);
 diff--;
 }
 }
 
 let i = 0;
 while (i &lt; arr1.length){
 if (arr1[i] &gt; arr2[i]){
 return 1;
 } else if (arr1[i] &lt; arr2[i]){
 return -1;
 }
 i++;
 }
 return 0;
 
};</code></pre>
</div>
</div>

blocks|key|829327|text|我的回答比这里的大多数答案都要简单|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829328|/**
+*+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+%7C%7C+versionsB.length)+{
++++var+a+=+Number(versionsA.shift()),+b+=+Number(versionsB.shift())
++++if+(a+==+b)
++++++continue
++++return+(a+>+b+%7C%7C+isNaN(b))
++}
++return+false
}|code-block|syntax|javascript|829329|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My less verbose answer than most of the answers here

<pre><code>/**
 * 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 &gt; b || isNaN(b))
 }
 return false
}
</code></pre>

blocks|key|614058|text|如果版本相同，函数将返回-1；如果第一个版本是最新版本，则返回0；如果第二个版本是最新版本，则返回1。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|614059|let+v1+=+'12.0.1.0'
let+v2+=+'12.0.1'

let+temp1+=+v1.split('.');
let+temp2+=+v2.split('.');

console.log(compareVersion(temp1,+temp2))


function+compareVersion(version1,+version2)+{
++++let+flag+=+false;
++++var+compareResult;
++++let+maxLength+=+Math.max(version1.length,+version2.length);+
++++let+minLength+=+Math.min(version1.length,+version2.length);

++++for+(let+i+=+0;+i+<+maxLength;+%2B%2Bi+)+{
++++++++let+result+=+version1[i]+-+version2[i];
++++++++if+(result+>+0)+{
++++++++++++flag+=+true;
++++++++++++compareResult+=+0;
++++++++++++break;
++++++++}
++++++++else+if+(result+<+0)+{
++++++++++++flag+=+true;
++++++++++++compareResult+=+1;
++++++++++++break;
++++++++}

++++++++if+(i+===+minLength)+{
++++++++++++if+(version1.length+>+version1.length)+{
++++++++++++++++compareResult+=+version1[version1.length-1]+>+0+?+'0'+:+'-1'
++++++++++++}++else++{
++++++++++++++++compareResult+=+version1[version2.length-1]+>+0+?+'1'+:+'-1'
++++++++++++}
++++++++++++break;
++++++++}
++++}
++++if+(flag+===+false)+{
++++++++compareResult+=+-1;
++++}
++++return+compareResult;
}|code-block|syntax|javascript|614060|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The function will return -1 if the version are equal, 0 if the first version is the latest and 1 to indicate the second version is the latest. 

<pre><code>let v1 = '12.0.1.0'
let v2 = '12.0.1'

let temp1 = v1.split('.');
let temp2 = v2.split('.');

console.log(compareVersion(temp1, temp2))


function compareVersion(version1, version2) {
 let flag = false;
 var compareResult;
 let maxLength = Math.max(version1.length, version2.length); 
 let minLength = Math.min(version1.length, version2.length);

 for (let i = 0; i &lt; maxLength; ++i ) {
 let result = version1[i] - version2[i];
 if (result &gt; 0) {
 flag = true;
 compareResult = 0;
 break;
 }
 else if (result &lt; 0) {
 flag = true;
 compareResult = 1;
 break;
 }

 if (i === minLength) {
 if (version1.length &gt; version1.length) {
 compareResult = version1[version1.length-1] &gt; 0 ? '0' : '-1'
 } else {
 compareResult = version1[version2.length-1] &gt; 0 ? '1' : '-1'
 }
 break;
 }
 }
 if (flag === false) {
 compareResult = -1;
 }
 return compareResult;
}
</code></pre>

blocks|key|829589|text|我不喜欢其中的任何一个解决方案，所以我根据我的编码偏好重写了它。请注意，最后四个检查结果与接受的答案略有不同。这对我很有效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829590|function+v_check(version_a,+version_b)+{
++++//+compares+version_a+as+it+relates+to+version_b
++++//+a+=+b+=>+"same"
++++//+a+>+b+=>+"larger"
++++//+a+<+b+=>+"smaller"
++++//+NaN+++=>+"invalid"

++++const+arr_a+=+version_a.split('.');
++++const+arr_b+=+version_b.split('.');

++++let+result+=+"same";+//+initialize+to+same+//+loop+tries+to+disprove

++++//+loop+through+a+and+check+each+number+against+the+same+position+in+b
++++for+(let+i+=+0;+i+<+arr_a.length;+i%2B%2B)+{
++++++++let+a+=+arr_a[i];
++++++++let+b+=+arr_b[i];

++++++++//+same+up+to+this+point+so+if+a+is+not+there,+a+is+smaller
++++++++if+(typeof+a+===+'undefined')+{
++++++++++++result+=+"smaller";
++++++++++++break;

++++++++//+same+up+to+this+point+so+if+b+is+not+there,+a+is+larger
++++++++}+else+if+(typeof+b+===+'undefined')+{
++++++++++++result+=+"larger";
++++++++++++break;

++++++++//+otherwise,+compare+the+two+numbers
++++++++}+else+{

++++++++++++//+non-positive+numbers+are+invalid
++++++++++++if+(a+>=+0+&&+b+>=+0)+{

++++++++++++++++if+(a+<+b)+{
++++++++++++++++++++result+=+"smaller";
++++++++++++++++++++break;
++++++++++++++++}
++++++++++++++++else+if+(a+>+b)+{
++++++++++++++++++++result+=+"larger";
++++++++++++++++++++break;
++++++++++++++++}

++++++++++++}+else+{
++++++++++++++++result+=+"invalid";
++++++++++++++++break;
++++++++++++}
++++++++}
++++}

++++//+account+for+the+case+where+the+loop+ended+but+there+was+still+a+position+in+b+to+evaluate
++++if+(result+==+"same"+&&+arr_b.length+>+arr_a.length)+result+=+"smaller";

++++return+result;
}


console.log(v_check("1.7.1",+"1.7.10"));++//+smaller
console.log(v_check("1.6.1",+"1.7.10"));++//+smaller
console.log(v_check("1.6.20",+"1.7.10"));+//+smaller
console.log(v_check("1.7.1",+"1.7.10"));++//+smaller
console.log(v_check("1.7",+"1.7.0"));+++++//+smaller
console.log(v_check("1.7",+"1.8.0"));+++++//+smaller

console.log(v_check("1.7.10",+"1.7.1"));++//+larger
console.log(v_check("1.7.10",+"1.6.1"));++//+larger
console.log(v_check("1.7.10",+"1.6.20"));+//+larger
console.log(v_check("1.7.0",+"1.7"));+++++//+larger
console.log(v_check("1.8.0",+"1.7"));+++++//+larger

console.log(v_check("1.7.10",+"1.7.10"));+//+same
console.log(v_check("1.7",+"1.7"));+++++++//+same

console.log(v_check("1.7",+"1..7"));+//+larger
console.log(v_check("1.7",+"Bad"));++//+invalid
console.log(v_check("1..7",+"1.7"));+//+smaller
console.log(v_check("Bad",+"1.7"));++//+invalid|code-block|syntax|javascript|829591|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I didn't love any of the solutions so I rewrote it for my coding preferences. Notice the last four checks come out slightly different than the accepted answer. Works for me.

<pre><code>function v_check(version_a, version_b) {
 // compares version_a as it relates to version_b
 // a = b =&gt; "same"
 // a &gt; b =&gt; "larger"
 // a &lt; b =&gt; "smaller"
 // NaN =&gt; "invalid"

 const arr_a = version_a.split('.');
 const arr_b = version_b.split('.');

 let result = "same"; // initialize to same // loop tries to disprove

 // loop through a and check each number against the same position in b
 for (let i = 0; i &lt; arr_a.length; i++) {
 let a = arr_a[i];
 let b = arr_b[i];

 // same up to this point so if a is not there, a is smaller
 if (typeof a === 'undefined') {
 result = "smaller";
 break;

 // same up to this point so if b is not there, a is larger
 } else if (typeof b === 'undefined') {
 result = "larger";
 break;

 // otherwise, compare the two numbers
 } else {

 // non-positive numbers are invalid
 if (a &gt;= 0 &amp;&amp; b &gt;= 0) {

 if (a &lt; b) {
 result = "smaller";
 break;
 }
 else if (a &gt; b) {
 result = "larger";
 break;
 }

 } else {
 result = "invalid";
 break;
 }
 }
 }

 // account for the case where the loop ended but there was still a position in b to evaluate
 if (result == "same" &amp;&amp; arr_b.length &gt; arr_a.length) result = "smaller";

 return result;
}


console.log(v_check("1.7.1", "1.7.10")); // smaller
console.log(v_check("1.6.1", "1.7.10")); // smaller
console.log(v_check("1.6.20", "1.7.10")); // smaller
console.log(v_check("1.7.1", "1.7.10")); // smaller
console.log(v_check("1.7", "1.7.0")); // smaller
console.log(v_check("1.7", "1.8.0")); // smaller

console.log(v_check("1.7.10", "1.7.1")); // larger
console.log(v_check("1.7.10", "1.6.1")); // larger
console.log(v_check("1.7.10", "1.6.20")); // larger
console.log(v_check("1.7.0", "1.7")); // larger
console.log(v_check("1.8.0", "1.7")); // larger

console.log(v_check("1.7.10", "1.7.10")); // same
console.log(v_check("1.7", "1.7")); // same

console.log(v_check("1.7", "1..7")); // larger
console.log(v_check("1.7", "Bad")); // invalid
console.log(v_check("1..7", "1.7")); // smaller
console.log(v_check("Bad", "1.7")); // invalid
</code></pre>

blocks|key|829741|text|我不得不比较我的扩展的版本，但在这里没有找到有效的解决方案，当比较1.89+>+1.9或1.24.1+==+1.240.1时，几乎所有建议的选项都会中断|type|unstyled|depth|inlineStyleRanges|entityRanges|data|829742|在这里，我从这样一个事实开始:只有在最后一个记录1.1+==+1.10和1.10.1+>+1.1.1中，零才会下降|829743|compare_version+=+(new_version,+old_version)+=>+{
++++new_version+=+new_version.split('.');
++++old_version+=+old_version.split('.');
++++for(let+i+=+0,+m+=+Math.max(new_version.length,+old_version.length);+i<m;+i%2B%2B){
++++++++//compare+text
++++++++let+new_part+=+(i<m-1?'':'.')+%2B+(new_version[i]+%7C%7C+0)
++++++++,+++old_part+=+(i<m-1?'':'.')+%2B+(old_version[i]+%7C%7C+0);
++++++++//compare+number+(I+don’t+know+what+better)
++++++//let+new_part+=+%2B((i<m-1?0:'.')+%2B+new_version[i])+%7C%7C+0
++++++//,+++old_part+=+%2B((i<m-1?0:'.')+%2B+old_version[i])+%7C%7C+0;
++++++++//console.log(new_part,+old_part);
++++++++if(old_part+>+new_part)return+0;++++//change+to+-1+for+sort+the+array
++++++++if(new_part+>+old_part)return+1
++++}
++++return+0
};
compare_version('1.0.240.1','1.0.240.1');+++//0+
compare_version('1.0.24.1','1.0.240.1');++++//0
compare_version('1.0.240.89','1.0.240.9');++//0
compare_version('1.0.24.1','1.0.24');+++++++//1|code-block|syntax|javascript|829744|我不是专家，但我构建了简单的代码来比较两个版本，将第一个返回值更改为-1以对版本数组进行排序|829745|['1.0.240',+'1.0.24',+'1.0.240.9',+'1.0.240.89'].sort(compare_version)
//results+["1.0.24",+"1.0.240",+"1.0.240.89",+"1.0.240.9"]|829746|和用于比较完整字符串的简短版本|829747|c=e=>e.split('.').map((e,i,a)=>e[i<a.length-1?'padStart':'padEnd'](5)).join('');

//results+"++++1++++0++2409++++"+>+"++++1++++0++24089+++"

c('1.0.240.9')>c('1.0.240.89')++++++++++++++//true|829748|如果您有意见或改进，请毫不犹豫地提出建议。|829749|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I had to compare the version of my extension, but did not find here working solution, almost all the proposed options break when comparing 1.89 > 1.9 or 1.24.1 == 1.240.1

here I started from the fact that zeros go down only in the last record 1.1 == 1.10 and 1.10.1 > 1.1.1

<pre><code>compare_version = (new_version, old_version) =&gt; {
 new_version = new_version.split('.');
 old_version = old_version.split('.');
 for(let i = 0, m = Math.max(new_version.length, old_version.length); i&lt;m; i++){
 //compare text
 let new_part = (i&lt;m-1?'':'.') + (new_version[i] || 0)
 , old_part = (i&lt;m-1?'':'.') + (old_version[i] || 0);
 //compare number (I don’t know what better)
 //let new_part = +((i&lt;m-1?0:'.') + new_version[i]) || 0
 //, old_part = +((i&lt;m-1?0:'.') + old_version[i]) || 0;
 //console.log(new_part, old_part);
 if(old_part &gt; new_part)return 0; //change to -1 for sort the array
 if(new_part &gt; old_part)return 1
 }
 return 0
};
compare_version('1.0.240.1','1.0.240.1'); //0 
compare_version('1.0.24.1','1.0.240.1'); //0
compare_version('1.0.240.89','1.0.240.9'); //0
compare_version('1.0.24.1','1.0.24'); //1
</code></pre>

I'm not a big specialist, but I built simple code to compare 2 versions, change the first return to -1 to sort the array of versions

<pre><code>['1.0.240', '1.0.24', '1.0.240.9', '1.0.240.89'].sort(compare_version)
//results ["1.0.24", "1.0.240", "1.0.240.89", "1.0.240.9"]
</code></pre>

and short version for compare full string

<pre><code>c=e=&gt;e.split('.').map((e,i,a)=&gt;e[i&lt;a.length-1?'padStart':'padEnd'](5)).join('');

//results " 1 0 2409 " &gt; " 1 0 24089 "

c('1.0.240.9')&gt;c('1.0.240.89') //true
</code></pre>

If you have comments or improvements, do not hesitate to suggest

blocks|key|614500|text|我遇到了类似的问题，我已经为它创建了一个解决方案。你可以试一试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|614501|对于equal，它返回0；如果版本是greater，则返回1；如果版本是less，则返回-1|offset|length|style|CODE|614502|​|614503|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%2B%2B)+{
++++if((current[i]+%7C%7C+0)+<+(min[i]+%7C%7C+0))+{
++++++return+-1
++++}+else+if+((current[i]+%7C%7C+0)+>+(min[i]+%7C%7C+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"));|code-block|syntax|javascript|614504|614505|entityMap^0|0|2|5|B|1|I|7|T|1|10|4|18|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]|$D|V|E|W|F|G]|$D|X|E|Y|F|G]|$D|Z|E|10|F|G]|$D|11|E|12|F|G]|$D|13|E|14|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|15|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|16|8|@]|9|@]|A|$M|N]]|$1|O|3|I|5|6|7|17|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|Q|$]]

I faced the similar issue, and I had already created a solution for it. Feel free to give it a try.
It returns <code>0</code> for <code>equal</code>, <code>1</code> if the version is <code>greater</code> and <code>-1</code> if it is <code>less</code>
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function compareVersion(currentVersion, minVersion) {
 let current = currentVersion.replace(/\./g," .").split(' ').map(x=&gt;parseFloat(x,10))
 let min = minVersion.replace(/\./g," .").split(' ').map(x=&gt;parseFloat(x,10))

 for(let i = 0; i &lt; Math.max(current.length, min.length); i++) {
 if((current[i] || 0) &lt; (min[i] || 0)) {
 return -1
 } else if ((current[i] || 0) &gt; (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"));</code></pre>
</div>
</div>

blocks|key|614629|text|我已经创建了这个解决方案，我希望你会发现它很有用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|614630|https://runkit.com/ecancino/5f3c6c59593d23001485992e|offset|length|614631|const+quantify+=+max+=>+(n,+i)+=>+n+*+(%2Bmax.slice(0,+max.length+-+i))

const+add+=+(a,+b)+=>+a+%2B+b

const+calc+=+s+=>+s.
++++split('.').
++++map(quantify('1000000')).
++++reduce(add,+0)

const+sortVersions+=+unsortedVersions+=>+unsortedVersions
++++.map(version+=>+({+version,+order:+calc(version)+}))
++++.sort((a,+b)+=>+a.order+-+b.order)
++++.reverse()
++++.map(o+=>+o.version)|code-block|syntax|javascript|614632|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1G|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|H|7|W|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|C]]]]

I have created this solution, I hope you find it useful:
<a href="https://runkit.com/ecancino/5f3c6c59593d23001485992e" rel="nofollow noreferrer">https://runkit.com/ecancino/5f3c6c59593d23001485992e</a>
<pre class="lang-js prettyprint-override"><code>
const quantify = max =&gt; (n, i) =&gt; n * (+max.slice(0, max.length - i))

const add = (a, b) =&gt; a + b

const calc = s =&gt; s.
 split('.').
 map(quantify('1000000')).
 reduce(add, 0)

const sortVersions = unsortedVersions =&gt; unsortedVersions
 .map(version =&gt; ({ version, order: calc(version) }))
 .sort((a, b) =&gt; a.order - b.order)
 .reverse()
 .map(o =&gt; o.version)
</code></pre>

blocks|key|614712|text|以下是我的解决方案，适用于任何版本的任何深度。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|614713|自动处理number%2Bdot问题。如果不是，则函数存在，控制台日志将给出undefined，而不是true、false或true。|614714|自动处理尾随零问题。|614715|自动中继存在于任何可能的地方。|614716|在旧浏览器上自动向后兼容。|614717|​|614718|function+checkVersion+(vv,vvv){
if(!(/%5E[0-9.]*$/.test(vv)+&&+/%5E[0-9.]*$/.test(vvv)))+return;
va+=+vv.toString().split('.');
vb+=+vvv.toString().split('.');
length+=+Math.max(va.length,+vb.length);
for+(i+=+0;+i+<+length;+i%2B%2B)+{

if+((va[i]%7C%7C+0)+<+(vb[i]%7C%7C+0)++)+{return+false;+}+
++}
++return+true;}
++
++console.log(checkVersion('20.0.0.1'+,+'20.0.0.2'));
++console.log(checkVersion(20.0+,+'20.0.0.2'));
++console.log(checkVersion('20.0.0.0.0'+,+20));
++console.log(checkVersion('20.0.0.0.1'+,+20));
++console.log(checkVersion('20.0.0-0.1'+,+20));|code-block|syntax|javascript|614719|614720|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|Z|8|@]|9|@]|A|$O|P]]|$1|Q|3|K|5|6|7|10|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|S|$]]

Here is my solution works for any level of depth for either version.
Auto deal with number+dot issue. If not so function exists and console log would give undefined instead of truthy false or true.
Auto deal with trailing zero issue.
Auto relay exists where ever possible.
Auto backward compatible on old browsers.
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function checkVersion (vv,vvv){
if(!(/^[0-9.]*$/.test(vv) &amp;&amp; /^[0-9.]*$/.test(vvv))) return;
va = vv.toString().split('.');
vb = vvv.toString().split('.');
length = Math.max(va.length, vb.length);
for (i = 0; i &lt; length; i++) {

if ((va[i]|| 0) &lt; (vb[i]|| 0) ) {return false; } 
 }
 return true;}
 
 console.log(checkVersion('20.0.0.1' , '20.0.0.2'));
 console.log(checkVersion(20.0 , '20.0.0.2'));
 console.log(checkVersion('20.0.0.0.0' , 20));
 console.log(checkVersion('20.0.0.0.1' , 20));
 console.log(checkVersion('20.0.0-0.1' , 20));</code></pre>
</div>
</div>

blocks|key|830026|text|非常简单的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|830027|function+compareVer(previousVersion,+currentVersion)+{
++const+[prevMajor,+prevMinor+=+0,+prevPatch+=+0]+=+previousVersion
++++.split(".")
++++.map(Number);
++const+[curMajor,+curMinor+=+0,+curPatch+=+0]+=+currentVersion
++++.split(".")
++++.map(Number);

++if+(curMajor+>+prevMajor)+{
++++return+"major";
++}
++if+(curMinor+>+prevMinor)+{
++++return+"minor";
++}
++if+(curPatch+>+prevPatch)+{
++++return+"patch";
++}
++return+"same+or+downgrade+version";
}|code-block|syntax|javascript|830028|输出：|830029|compareVer("3.1",+"3.1.1")+//+patch
compareVer("3.1.1",+"3.2")+//+minor
compareVer("1.1.1",+"2.1.1")+//+major
compareVer("1.1.1",+"1.2.1")+//+minor
compareVer("1.1.1",+"1.1.2")+//+patch
compareVer("1.1.1",+"0.1.1")+//+same+or+downgrade+version|830030|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Dead simple way:
<pre class="lang-js prettyprint-override"><code>function compareVer(previousVersion, currentVersion) {
 const [prevMajor, prevMinor = 0, prevPatch = 0] = previousVersion
 .split(&quot;.&quot;)
 .map(Number);
 const [curMajor, curMinor = 0, curPatch = 0] = currentVersion
 .split(&quot;.&quot;)
 .map(Number);

 if (curMajor &gt; prevMajor) {
 return &quot;major&quot;;
 }
 if (curMinor &gt; prevMinor) {
 return &quot;minor&quot;;
 }
 if (curPatch &gt; prevPatch) {
 return &quot;patch&quot;;
 }
 return &quot;same or downgrade version&quot;;
}
</code></pre>
Output:
<pre><code>compareVer(&quot;3.1&quot;, &quot;3.1.1&quot;) // patch
compareVer(&quot;3.1.1&quot;, &quot;3.2&quot;) // minor
compareVer(&quot;1.1.1&quot;, &quot;2.1.1&quot;) // major
compareVer(&quot;1.1.1&quot;, &quot;1.2.1&quot;) // minor
compareVer(&quot;1.1.1&quot;, &quot;1.1.2&quot;) // patch
compareVer(&quot;1.1.1&quot;, &quot;0.1.1&quot;) // same or downgrade version

</code></pre>

blocks|key|614823|text|我也可以登广告招聘我为解决这个问题而开发的轻量级库吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|614824|https://github.com/pearnaly/semantic-version|offset|length|614825|你可以面向对象和面向函数来使用它。它以npm包和现成的捆绑包文件的形式提供。|614826|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|18|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

May I also advertise for the lightweight library I made to solve this problem?
<a href="https://github.com/pearnaly/semantic-version" rel="nofollow noreferrer">https://github.com/pearnaly/semantic-version</a>
You can use it both Object-Oriented and function-oriented. It is available as npm-package and ready-to-use bundle files.

blocks|key|830135|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|830136|const+compareAppVersions+=+(firstVersion,+secondVersion)+=>+{
++const+firstVersionArray+=+firstVersion.split(".").map(Number);
++const+secondVersionArray+=+secondVersion.split(".").map(Number);
++const+loopLength+=+Math.max(
++++firstVersionArray.length,
++++secondVersionArray.length
++);
++for+(let+i+=+0;+i+<+loopLength;+%2B%2Bi)+{
++++const+a+=+firstVersionArray[i]+%7C%7C+0;
++++const+b+=+secondVersionArray[i]+%7C%7C+0;
++++if+(a+!==+b)+{
++++++return+a+>+b+?+1+:+-1;
++++}
++}
++return+0;
};|code-block|syntax|javascript|830137|830138|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-html lang-html prettyprint-override"><code>const compareAppVersions = (firstVersion, secondVersion) =&gt; {
 const firstVersionArray = firstVersion.split(".").map(Number);
 const secondVersionArray = secondVersion.split(".").map(Number);
 const loopLength = Math.max(
 firstVersionArray.length,
 secondVersionArray.length
 );
 for (let i = 0; i &lt; loopLength; ++i) {
 const a = firstVersionArray[i] || 0;
 const b = secondVersionArray[i] || 0;
 if (a !== b) {
 return a &gt; b ? 1 : -1;
 }
 }
 return 0;
};</code></pre>
</div>
</div>

blocks|key|614898|text|几行代码，如果你不想使用字母或符号，这是很好的。如果你控制了版本化方案，并且它不是第三方提供的东西，那么这是可行的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|614899|​|614900|//+we+presume+all+versions+are+of+this+format+"1.4"+or+"1.10.2.3",+without+letters
//+returns:+1+(bigger),+0+(same),+-1+(smaller)
function+versionCompare+(v1,+v2)+{
++const+v1Parts+=+v1.split('.')
++const+v2Parts+=+v2.split('.')
++const+length+=+Math.max(v1Parts.length,+v2Parts.length)
++for+(let+i+=+0;+i+<+length;+i%2B%2B)+{
++++const+value+=+(parseInt(v1Parts[i])+%7C%7C+0)+-+(parseInt(v2Parts[i])+%7C%7C+0)
++++if+(value+<+0)+return+-1
++++if+(value+>+0)+return+1
++}
++return+0
}

console.log(versionCompare('1.2.0',+'1.2.4')+===+-1)
console.log(versionCompare('1.2',+'1.2.0')+===+0)
console.log(versionCompare('1.2',+'1')+===+1)
console.log(versionCompare('1.2.10',+'1.2.1')+===+1)
console.log(versionCompare('1.2.134230',+'1.2.2')+===+1)
console.log(versionCompare('1.2.134230',+'1.3.0.1.2.3.1')+===+-1)|code-block|syntax|javascript|614901|614902|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

Few lines of code and good if you don't want to allow letters or symbols. This works if you control the versioning scheme and it's not something a 3rd party provides.
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>// we presume all versions are of this format "1.4" or "1.10.2.3", without letters
// returns: 1 (bigger), 0 (same), -1 (smaller)
function versionCompare (v1, v2) {
 const v1Parts = v1.split('.')
 const v2Parts = v2.split('.')
 const length = Math.max(v1Parts.length, v2Parts.length)
 for (let i = 0; i &lt; length; i++) {
 const value = (parseInt(v1Parts[i]) || 0) - (parseInt(v2Parts[i]) || 0)
 if (value &lt; 0) return -1
 if (value &gt; 0) return 1
 }
 return 0
}

console.log(versionCompare('1.2.0', '1.2.4') === -1)
console.log(versionCompare('1.2', '1.2.0') === 0)
console.log(versionCompare('1.2', '1') === 1)
console.log(versionCompare('1.2.10', '1.2.1') === 1)
console.log(versionCompare('1.2.134230', '1.2.2') === 1)
console.log(versionCompare('1.2.134230', '1.3.0.1.2.3.1') === -1)</code></pre>
</div>
</div>

blocks|key|830200|text|function+compare(versionA:+string+%7C+undefined,+versionB:+string+%7C+undefined,+operator:+string+=+'>')+{
++++if+(versionA+===+undefined+%7C%7C+versionB+===+undefined)+{
++++++++return+false
++++}
++++const+listA+=+versionA.split('.')
++++const+listB+=+versionB.split('.')
++++let+a+=+[]
++++let+b+=+[]
++++for+(let+i+=+0;+i+<+listA.length;+i%2B%2B)+{
++++++++a.push(parseInt(listA[i].replace(/\D/g,+''),+10))
++++++++b.push(parseInt(listB[i].replace(/\D/g,+''),+10))
++++}

++++for+(let+i+=+0;+i+<+listA.length;+i%2B%2B)+{
++++++++switch+(operator)+{
++++++++++++case+'>':
++++++++++++case+'>=':
++++++++++++++++if+(a[i]+===+b[i])+{
++++++++++++++++++++continue
++++++++++++++++}
++++++++++++++++if+(a[i]+>+b[i])+{
++++++++++++++++++++return+true
++++++++++++++++}
++++++++++++++++if+(a[i]+<+b[i])+{
++++++++++++++++++++return+false
++++++++++++++++}
++++++++++++++++break
++++++++++++case+'<':
++++++++++++case+'<=':
++++++++++++++++if+(a[i]+===+b[i])+{
++++++++++++++++++++continue
++++++++++++++++}
++++++++++++++++if+(a[i]+>+b[i])+{
++++++++++++++++++++return+false
++++++++++++++++}
++++++++++++++++if+(a[i]+<+b[i])+{
++++++++++++++++++++return+true
++++++++++++++++}
++++++++++++++++break
++++++++++++case+'=':
+++++++++++++++if+(a[i]+>+b[i])+{
+++++++++++++++++++return+false
+++++++++++++++}
+++++++++++++++if+(a[i]+<+b[i])+{
+++++++++++++++++++return+false
+++++++++++++++}
+++++++++++++++break
++++++++}
++++}
++++switch+(operator)+{
++++++++case+'>':
++++++++++++return+false
++++++++case+'<':
++++++++++++return+false
++++++++case+'=':
++++++++case+'>=':
++++++++case+'<=':
++++++++++++return+true
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|830201|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function compare(versionA: string | undefined, versionB: string | undefined, operator: string = '&gt;') {
 if (versionA === undefined || versionB === undefined) {
 return false
 }
 const listA = versionA.split('.')
 const listB = versionB.split('.')
 let a = []
 let b = []
 for (let i = 0; i &lt; listA.length; i++) {
 a.push(parseInt(listA[i].replace(/\D/g, ''), 10))
 b.push(parseInt(listB[i].replace(/\D/g, ''), 10))
 }

 for (let i = 0; i &lt; listA.length; i++) {
 switch (operator) {
 case '&gt;':
 case '&gt;=':
 if (a[i] === b[i]) {
 continue
 }
 if (a[i] &gt; b[i]) {
 return true
 }
 if (a[i] &lt; b[i]) {
 return false
 }
 break
 case '&lt;':
 case '&lt;=':
 if (a[i] === b[i]) {
 continue
 }
 if (a[i] &gt; b[i]) {
 return false
 }
 if (a[i] &lt; b[i]) {
 return true
 }
 break
 case '=':
 if (a[i] &gt; b[i]) {
 return false
 }
 if (a[i] &lt; b[i]) {
 return false
 }
 break
 }
 }
 switch (operator) {
 case '&gt;':
 return false
 case '&lt;':
 return false
 case '=':
 case '&gt;=':
 case '&lt;=':
 return true
 }
}
</code></pre>

blocks|key|830231|text|您可以使用Javascript+localeCompare方法|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|830232|a.localeCompare(b,+undefined,+{+numeric:+true+})|830233|下面是一个示例：|830234|"1.1".localeCompare("2.1.1",+undefined,+{+numeric:+true+})+=>+-1|830235|"1.0.0".localeCompare("1.0",+undefined,+{+numeric:+true+})+=>+1|830236|"1.0.0".localeCompare("1.0.0",+undefined,+{+numeric:+true+})+=>+%250|830237|entityMap^0|G|D|0|0|1C|0|0|0|1M|0|0|1M|0|0|1O|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|Q|$]]

you can use Javascript <code>localeCompare</code> method
<code>a.localeCompare(b, undefined, { numeric: true })</code>
here is an example:
<code>&quot;1.1&quot;.localeCompare(&quot;2.1.1&quot;, undefined, { numeric: true })</code> =&gt; -1
<code>&quot;1.0.0&quot;.localeCompare(&quot;1.0&quot;, undefined, { numeric: true })</code> =&gt; 1
<code>&quot;1.0.0&quot;.localeCompare(&quot;1.0.0&quot;, undefined, { numeric: true })</code> =&gt; 0

Here is the software version number:

<pre><code>"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"
</code></pre>

How can I compare this??
Assume the correct order is:

<pre><code>"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"
</code></pre>

The idea is simple...:
Read the first digit, than, the second, after that the third....
But I can't convert the version number to float number....
You also can see the version number like this:

<pre><code>"1.0.0.0", "1.0.1.0", "2.0.0.0", "2.0.0.1", "2.0.1.0"
</code></pre>

and this is more clear to see what is the idea behind...
But, how to convert it into a computer program??
Do any one have any idea on how to sorting this? Thank you.

How to compare software version number using js? (only number)

版本控制系统

Java

以下是软件版本号："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"想法很简单……：读第一个数字，然后读第二个数字，然后读第三个数字。但是我无法将版本号转换为浮点数.....

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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