logo标签列表

如何获得像“1.2.5.4”和“1.2.5.3”这样的字符串的最大值？

javascript
3

我有一个包含数字点记法的字符串数组，例如：

var arr = ['1.2.5.4', '1.2.5.3'];

我希望能找到表示最高值的字符串。

我已经尝试过：

Math.max.apply(null, arr)

由于有多个小数，它根本行不通。
3
“var arr = [1.2.5.4, 1.2.5.3];” 不是有效的代码，这会引起解释器错误。正确的写法是“var arr = ['1.2.5.4', '1.2.5.3'];”。至于哪个是最大值，很难说。你是按照左到右排序还是从右到左排序呢？ - Jonathan M
那些是字符串，不是数字。 - Diodeus - James MacFarlane
1
我会去掉非数字字符，然后将结果视为整数。 - hafichuk
2
@hafichuk 这可能适用于简单的例子，但在 '1.24.2.1' 和 1.2.52.1' 等情况下会失败。1.24 > 1.2，但 12421 < 12521。 - Jonathan Lonowski
@Louis，所以不会有任何像1.3a.2这样的字母，对吗？ - Jonathan M
显示剩余10条评论
4个回答
2

针对这个问题，您需要创建自己的排序子程序，因为它们需要被视为版本号。您需要进行从左到右的比较，逐个比较由句点分隔的每个数字。

以下是从另一个答案中借鉴的一段很好的代码，完全符合我所提到的要求：

function assert(x) {
    if (!x) {
        alert("Assert failed");
        debugger;
    }
}

function isPositiveInteger(x) {
    // https://dev59.com/VXNA5IYBdhLWcg3wS70m#1019526
    return /^\d+$/.test(x);
}

/**
 * Compare two software version numbers (e.g. 1.7.1)
 * Returns:
 *
 *  0 if they're identical
 *  negative if v1 < v2
 *  positive if v1 > v2
 *  Nan if they in the wrong format
 *
 *  E.g.:
 *
 *  assert(version_number_compare("1.7.1", "1.6.10") > 0);
 *  assert(version_number_compare("1.7.1", "1.7.10") < 0);
 *
 *  "Unit tests": http://jsfiddle.net/ripper234/Xv9WL/28/
 *
 *  Taken from https://dev59.com/DWw15IYBdhLWcg3wGn5c#6832721
 */
function compareVersionNumbers(v1, v2){
    var v1parts = v1.split('.');
    var v2parts = v2.split('.');

    // First, validate both numbers are true version numbers
    function validateParts(parts) {
        for (var i = 0; i < parts.length; ++i) {
            if (!isPositiveInteger(parts[i])) {
                return false;
            }
        }
        return true;
    }
    if (!validateParts(v1parts) || !validateParts(v2parts)) {
        return NaN;
    }

    for (var i = 0; i < v1parts.length; ++i) {
        if (v2parts.length === i) {
            return 1;
        }

        if (v1parts[i] === v2parts[i]) {
            continue;
        }
        if (v1parts[i] > v2parts[i]) {
            return 1;
        }
        return -1;
    }

    if (v1parts.length != v2parts.length) {
        return -1;
    }

    return 0;
}


assert(compareVersionNumbers("1.7.1", "1.7.10") < 0);
assert(compareVersionNumbers("1.6.1", "1.7.10") < 0);
assert(compareVersionNumbers("1.6.20", "1.7.10") < 0);
assert(compareVersionNumbers("1.7.1", "1.7.10") < 0);
assert(compareVersionNumbers("1.7", "1.7.0") < 0);
assert(compareVersionNumbers("1.7", "1.8.0") < 0);

assert(compareVersionNumbers("1.7.10", "1.7.1") > 0);
assert(compareVersionNumbers("1.7.10", "1.6.1") > 0);
assert(compareVersionNumbers("1.7.10", "1.6.20") > 0);
assert(compareVersionNumbers("1.7.0", "1.7") > 0);
assert(compareVersionNumbers("1.8.0", "1.7") > 0);

assert(compareVersionNumbers("1.7.10", "1.7.10") === 0);
assert(compareVersionNumbers("1.7", "1.7") === 0);

assert(isNaN(compareVersionNumbers("1.7", "1..7")));
assert(isNaN(compareVersionNumbers("1.7", "Bad")));
assert(isNaN(compareVersionNumbers("1..7", "1.7")));
assert(isNaN(compareVersionNumbers("Bad", "1.7")));

alert("All done");
​
警告：对于某些次要版本，此方法似乎会给出错误的答案： compareVersionNumbers("1.7.10", "1.66.10") 的结果为 1。 - Max Strater
2
这似乎是一个更简单的解决方案：
function latest (versions) {
  versions.sort (function (a, b) {
    a = a.split ('.');
    b = b.split ('.');   
    for (var i = 0; i < a.length && i < b.length && a[i] === b[i]; i++);
    return ((i === a.length) || (+a[i] < +b[i])) ? 1 : -1;
  });
  return versions[0]; 
}

[
  latest (['1.2.5.4', '1.3.5.3', '1.2.3.4.5', '1.24.2.1', '1.2.52']),
  latest (['1.2.5.4', '1.3.5.3', '1.2.3.4.5', '1.2.52']),
  latest (['1.2.5.4', '1.2.3.4.5', '1.2.52']),
  latest (['1.2.5.4', '1.2.3.4.5'])
]

/* Displays on JS console

    ["1.24.2.1", "1.3.5.3", "1.2.52", "1.2.5.4"]
*/

感谢您的支持，在审查中我注意到了一个错误，已在上面的代码中进行了更正。

警告：此函数会对原始数组进行排序！您应该使用reduce函数，将数组“缩减为单个值，即最新版本”，而不是对其进行排序并取第一个项目。 - M'sieur Toph'
0

在我看来，这里有一个“更好”的解决方案（因为已检查的解决方案修改了原始数组，这是不好的；）：

function latest(versions) {
    return versions.reduce(function(latest, current){
        var l = latest.split('.'),
            c = current.split('.');
        for (var i=0,len=Math.min(l.length, c.length); i<len; i++){
            if (+l[i] === +c[i]) {
                continue;
            } else {
                return +l[i] < +c[i] ? current : latest;
            }
        }
        return l.length < c.length ? current : latest;
    }, "0");
}

结果与已检查的答案完全相同，唯一不同的是原始数组仍然保持原样。

[
  latest (['1.2.5.4', '1.3.5.3', '1.2.3.4.5', '1.24.2.1', '1.2.52']),
  latest (['1.2.5.4', '1.3.5.3', '1.2.3.4.5', '1.2.52']),
  latest (['1.2.5.4', '1.2.3.4.5', '1.2.52']),
  latest (['1.2.5.4', '1.2.3.4.5'])
]

/* Displays on JS console

    ["1.24.2.1", "1.3.5.3", "1.2.52", "1.2.5.4"]
*/

它利用了reduce函数，该函数正是为此而设计的。

0
这是一个人类排序的实现：
Array.prototype.humanSort = function() {
  return this.sort(function(a, b) {
    aa = a.split('.');
    bb = b.split('.');

    for(var x = 0; x < Math.max(aa.length, bb.length); x++) {
      if(aa[x] != bb[x]) {
        var cmp1 = (isNaN(parseInt(aa[x],10)))? aa[x] : parseInt(aa[x],10);
        var cmp2 = (isNaN(parseInt(bb[x],10)))? bb[x] : parseInt(bb[x],10);
        if(cmp1 == undefined || cmp2 == undefined)
          return aa.length - bb.length;
        else
          return (cmp1 < cmp2) ? -1 : 1;
      }
    }
    return 0;
  });
}

这样调用：

 ['1.12.5.4', '1.2.5.3'].humanSort(); // => ['1.2.5.3', '1.12.5.4']
你至少按照评论中提到的所有场景测试了上述代码吗？ - bPratik
1.12.5.4 必须大于1.2.5.3。因为12 > 2。 - Louis
1
我已经测试了评论中提到的所有情况。所提供的排序算法按升序对元素进行排序，这意味着排序后数组中的最后一个元素是最大的。 - Kvam
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接