以下是软件版本号:
"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"
我怎么比较呢?
假设正确的顺序是:
"1.0", "1.0.1", "2.0", "2.0.0.1", "2.0.1"
想法很简单… 读第一个数字，然后，第二个，第三个… 但是我不能将版本号转换为浮点数… 你也可以像这样看到版本号:
"1.0.0.0", "1.0.1.0", "2.0.0.0", "2.0.0.1", "2.0.1.0"
这样可以更清楚地看到背后的想法。 但是，我怎样才能把它转换成计算机程序呢?
当前回答
function compare(versionA: string | undefined, versionB: string | undefined, operator: string = '>') {
if (versionA === undefined || versionB === undefined) {
return false
}
const listA = versionA.split('.')
const listB = versionB.split('.')
let a = []
let b = []
for (let i = 0; i < 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 < listA.length; i++) {
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
}
}
其他回答
看看这篇博客文章。此函数适用于数字版本号。
function compVersions(strV1, strV2) {
var nRes = 0
, parts1 = strV1.split('.')
, parts2 = strV2.split('.')
, nLen = Math.max(parts1.length, parts2.length);
for (var i = 0; i < nLen; i++) {
var nP1 = (i < parts1.length) ? parseInt(parts1[i], 10) : 0
, nP2 = (i < parts2.length) ? parseInt(parts2[i], 10) : 0;
if (isNaN(nP1)) { nP1 = 0; }
if (isNaN(nP2)) { nP2 = 0; }
if (nP1 != nP2) {
nRes = (nP1 > nP2) ? 1 : -1;
break;
}
}
return nRes;
};
compVersions('10', '10.0'); // 0
compVersions('10.1', '10.01.0'); // 0
compVersions('10.0.1', '10.0'); // 1
compVersions('10.0.1', '10.1'); // -1
function compare(versionA: string | undefined, versionB: string | undefined, operator: string = '>') {
if (versionA === undefined || versionB === undefined) {
return false
}
const listA = versionA.split('.')
const listB = versionB.split('.')
let a = []
let b = []
for (let i = 0; i < 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 < listA.length; i++) {
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
}
}
这里找不到我想要的函数。所以我自己写了。这就是我的贡献。我希望有人觉得它有用。
优点:
处理任意长度的版本字符串。'1'或'1.1.1.1.1'。 如果没有指定，则默认为0。仅仅因为字符串更长并不意味着它是一个更大的版本。(“1”应与“1.0”和“1.0.0.0”相同。) 比较数字而不是字符串。('3'<'21'应为真。不是假的。) 不要把时间浪费在无用的比较上。(比较for ==) 你可以选择你自己的比较器。
缺点:
它不处理版本字符串中的字母。(我不知道这是怎么回事?)
我的代码，类似于Jon接受的答案:
function compareVersions(v1, comparator, v2) {
"use strict";
var comparator = comparator == '=' ? '==' : comparator;
if(['==','===','<','<=','>','>=','!=','!=='].indexOf(comparator) == -1) {
throw new Error('Invalid comparator. ' + comparator);
}
var v1parts = v1.split('.'), v2parts = v2.split('.');
var maxLen = Math.max(v1parts.length, v2parts.length);
var part1, part2;
var cmp = 0;
for(var i = 0; i < maxLen && !cmp; i++) {
part1 = parseInt(v1parts[i], 10) || 0;
part2 = parseInt(v2parts[i], 10) || 0;
if(part1 < part2)
cmp = 1;
if(part1 > part2)
cmp = -1;
}
return eval('0' + comparator + cmp);
}
例子:
compareVersions('1.2.0', '==', '1.2'); // true
compareVersions('00001', '==', '1.0.0'); // true
compareVersions('1.2.0', '<=', '1.2'); // true
compareVersions('2.2.0', '<=', '1.2'); // false
我写了一个排序版本的节点模块，你可以在这里找到它:version-sort
特点:
序列“1.0.1.5.53.54654.114.1.154.45”不受限制 不限制序列长度:'1.1546515465451654654654654138754431574364321353734'工作 可以根据版本对对象进行排序(参见README) 阶段(如alpha, beta, rc1, rc2)
如果您需要其他功能，请不要犹豫，打开一个问题。
我喜欢@mar10的版本，尽管从我的角度来看，有误用的可能(如果版本与Semantic Versioning文档兼容，似乎不是这样，但如果使用了一些“构建号”，则可能是这样):
versionCompare( '1.09', '1.1'); // returns 1, which is wrong: 1.09 < 1.1
versionCompare('1.702', '1.8'); // returns 1, which is wrong: 1.702 < 1.8
这里的问题是，在某些情况下，版本号的子数字被删除了后面的零(至少我最近在使用不同的软件时看到的)，这类似于数字的有理数部分，因此:
5.17.2054 > 5.17.2
5.17.2 == 5.17.20 == 5.17.200 == ...
5.17.2054 > 5.17.20
5.17.2054 > 5.17.200
5.17.2054 > 5.17.2000
5.17.2054 > 5.17.20000
5.17.2054 < 5.17.20001
5.17.2054 < 5.17.3
5.17.2054 < 5.17.30
但是，第一个(或第一个和第二个)版本子号始终被视为它实际等于的整数值。
如果你使用这种版本控制，你可以只改变例子中的几行:
// replace this:
p1 = parseInt(v1parts[i], 10);
p2 = parseInt(v2parts[i], 10);
// with this:
p1 = i/* > 0 */ ? parseFloat('0.' + v1parts[i], 10) : parseInt(v1parts[i], 10);
p2 = i/* > 0 */ ? parseFloat('0.' + v2parts[i], 10) : parseInt(v2parts[i], 10);
因此，除了第一个子数字外，每个子数字都将作为浮点数进行比较，因此09和1将相应地变成0.09和0.1，并以这种方式进行正确比较。2054和3将变成0.2054和0.3。
那么，完整的版本是(归功于@mar10):
/** Compare two dotted version strings (like '10.2.3').
* @returns {Integer} 0: v1 == v2, -1: v1 < v2, 1: v1 > v2
*/
function versionCompare(v1, v2) {
var v1parts = ("" + v1).split("."),
v2parts = ("" + v2).split("."),
minLength = Math.min(v1parts.length, v2parts.length),
p1, p2, i;
// Compare tuple pair-by-pair.
for(i = 0; i < minLength; i++) {
// Convert to integer if possible, because "8" > "10".
p1 = i/* > 0 */ ? parseFloat('0.' + v1parts[i], 10) : parseInt(v1parts[i], 10);;
p2 = i/* > 0 */ ? parseFloat('0.' + v2parts[i], 10) : parseInt(v2parts[i], 10);
if (isNaN(p1)){ p1 = v1parts[i]; }
if (isNaN(p2)){ p2 = v2parts[i]; }
if (p1 == p2) {
continue;
}else if (p1 > p2) {
return 1;
}else if (p1 < p2) {
return -1;
}
// one operand is NaN
return NaN;
}
// The longer tuple is always considered 'greater'
if (v1parts.length === v2parts.length) {
return 0;
}
return (v1parts.length < v2parts.length) ? -1 : 1;
}
注:这是比较慢的，但也可以考虑重用相同的比较函数来操作字符串实际上是字符数组的事实:
function cmp_ver(arr1, arr2) {
// fill the tail of the array with smaller length with zeroes, to make both array have the same length
while (min_arr.length < max_arr.length) {
min_arr[min_arr.lentgh] = '0';
}
// compare every element in arr1 with corresponding element from arr2,
// but pass them into the same function, so string '2054' will act as
// ['2','0','5','4'] and string '19', in this case, will become ['1', '9', '0', '0']
for (i: 0 -> max_length) {
var res = cmp_ver(arr1[i], arr2[i]);
if (res !== 0) return res;
}
}
