如何正确排序整数数组

M

Machavity

默认情况下， sort 方法按字母顺序对元素进行排序。要进行数字排序，只需添加一个处理数字排序的新方法（sortNumber，如下所示） -

var numArray = [140000, 104, 99]; numArray.sort(function(a, b) { return a - b; });控制台.log(numArray);

文档：

Mozilla Array.prototype.sort() 建议对不包含 Infinity 或 NaN 的数组使用此比较函数。（因为 Infinity - Infinity 是 NaN，而不是 0）。

还有按键排序对象的示例。

好的。但是真的没有开箱即用的方法可以从 javascript 中获取数字排序吗？

啊，这是开箱即用的！但是如果你真的不切实际，你可以在你的 JavaScript 的最开始将函数绑定到数组类类： // Array.prototype.sortNormal = function(){return this.sort(function(a,b){return a - b})} // 现在在任何数组上调用 .sortNormal() 都会对其进行数字排序

为什么是 ab 而不是 a>b。为了避免操作机器错误我建议最后一个

@Velthune 比较函数应该返回 -1、0 或 +1。 a>b 只会返回真或假。

可以使用 Arrow Function 缩短此代码。 numberArray.sort((a, b) => (a - b)); 耶！我认为这接近于开箱即用的方式。 注意：检查你的 JS 引擎是否支持箭头函数。

M

Machavity

仅在上述所有答案的基础上，它们也可以像这样在一行中完成：

var numArray = [140000, 104, 99];
numArray = numArray.sort(function (a, b) {  return a - b;  });

//outputs: 99, 104, 140000

我认为你的意思是一种表达方式。

@bodyflex 已修复：var arr = [140000, 104, 99].sort(function(a,b) { return a-b; });。或者更紧凑，在 ES6 let arr = [140000, 104, 99].sort((a,b) => a-b);

d

dy_

我很惊讶为什么每个人都建议将比较器函数传递给 sort()，这使得排序非常慢！

要对数字进行排序，只需创建 any TypedArray：

var numArray = new Float64Array([140000, 104, 99]); numArray = numArray.sort();控制台.log(numArray)

使用 TypedArray 将排序速度提高了大约 5 倍。如果你想跑得更快 hpc-algorithms npm 包实现了基数排序和计数排序，这里有几个答案建议。

我用负数尝试了这个，结果很奇怪：> new Uint32Array([ -4, -7, 1, 4 ]).sort() 返回了 Uint32Array(4) [ 1, 4, 4294967289, 4294967292 ]。

@Nikolay D 那些没有签名。您可以使用 Int32Array。

确保对类型化数组进行排序更快。但是如果你有一个常规数组，将它转换为类型化数组来排序它不是一个好的解决方案（速度和内存）

@Gio 不确定这是真的。内存要求仅为 O(2n)，对于数百万个项目的数组来说，这只有几兆字节。至于速度 - 将数组转换为类型化数组，排序和转换回来仍然比使用函数对数组进行排序要快。

P

Paul Dixon

array.sort 默认进行字典排序，对于数字排序，提供您自己的函数。这是一个简单的例子：

function compareNumbers(a, b)
{
    return a - b;
}

numArray.sort(compareNumbers);

另请注意，排序“就地”工作，不需要分配。

我没看懂上面的代码，“return a - b”是怎么升序排序的？

如果 a < b，compareNumbers 返回一个负数。如果 a > b，则为正。如果相等，则返回 0。

@AliMertCakar 因为它只返回真或假，比较函数需要返回负数、零或正数。

P

Peter Mortensen

这个答案等同于现有的一些答案，但 ECMAScript 6 arrow functions 提供了更紧凑的语法，允许我们在不牺牲可读性的情况下定义内联排序函数：

numArray = numArray.sort((a, b) => a - b);

most browsers today 支持它。

B

Black

排序函数表现如此怪异的原因

从 documentation：

[...] 数组根据每个字符的 Unicode 码位值，根据每个元素的字符串转换进行排序。

如果您打印数组的 unicode point values，那么它将变得清晰。

console.log("140000".charCodeAt(0)); console.log("104".charCodeAt(0)); console.log("99".charCodeAt(0)); //注意我们只看数字“charCodeAt(0)”的第一个索引

这将返回：“49、49、57”。

49 (unicode value of first number at 140000)
49 (unicode value of first number at 104)
57 (unicode value of first number at 99)

现在，因为 140000 和 104 返回相同的值 (49)，所以它会剪切第一个索引并再次检查：

console.log("40000".charCodeAt(0)); console.log("04".charCodeAt(0)); //注意我们只看数字“charCodeAt(0)”的第一个索引

52 (unicode value of first number at 40000)
40 (unicode value of first number at 04)

如果我们对此进行排序，那么我们将得到：

40 (unicode value of first number at 04)
52 (unicode value of first number at 40000)

所以 104 在 140000 之前。

所以最终的结果将是：

var numArray = [140000, 104, 99]; numArray = numArray.sort();控制台.log(numArray)

104, 140000, 99

结论：

sort() 仅通过查看数字的第一个索引进行排序。 sort() 不关心一个整数是否大于另一个，它比较数字的 unicode 值，如果有两个相等的 unicode 值，则检查是否有下一个数字并进行比较。

要正确排序，您必须像解释的 here 一样将比较函数传递给 sort()。

提示：这只是我的解释，我实际上并没有查看代码。所以不要完全相信这个答案。

n

norbekoff

只做 .sort((a, b) => a - b) 而不是 .sort() 本身

var numArray = [140000, 104, 99]; numArray.sort((a, b) => a - b);控制台.log(numArray)

很有帮助！

u

user3587638

我同意 aks，但不是使用

return a - b;

你应该使用

return a > b ? 1 : a < b ? -1 : 0;

你能解释一下为什么有人应该使用你更不可读的三元运算吗？据我所知，它会产生相同的结果。

该答案还考虑了相等的值并将它们留在同一位置。

对于这个问题的特定情况（javascript，以及所有已知为整数的输入项），“return ab”可能就足够了，但我个人更喜欢三元形式，因为它更规范——它适用于更多的情况，更多的编程语言，具有更多的数据类型。例如，在 C 中，ab 可能会溢出，导致排序无限循环、破坏内存、崩溃等。也就是说，如果涉及 NaN 或混合类型，即使三元形式也无法正常工作。

> 和 < 仍将 a 和 b 作为字符串进行比较。

@stefannew 在一种情况下，此答案会返回对 a - b 没有的数字的正确评估。其中 a = b = -Infinity，a - b = NaN，但三元返回 0。但这似乎并没有影响排序，它仍然可以完美地完成。 (a > b) - (a < b) 是一个较短的版本，相当于这个三元组。

R

R.M. Reza

上升

arr.sort((a, b) => a - b);

降序

arr.sort((a, b) => b - a);

纯娱乐：

降序 = 升序 + 逆序

arr.sort((a, b) => a - b).reverse();

P

Peter Mortensen

在 JavaScript 中，sort() 方法的默认行为是按字母顺序对数组中的值进行排序。

要按数字排序，您必须定义一个数字排序函数（这很容易）：

...
function sortNumber(a, b)
{
  return a - b;
}

numArray = numArray.sort(sortNumber);

C

Commercial Suicide

问题已经回答了，最简单的方法是使用sort()方法。但是，如果您正在寻找更多方法来对数字数组进行排序，并且您也喜欢循环，请检查以下内容

插入排序

上升：

var numArray = [140000, 104, 99]; for (var i = 0; i < numArray.length; i++) { var target = numArray[i]; for (var j = i - 1; j >= 0 && (numArray[j] > target); j--) { numArray[j+1] = numArray[j]; } numArray[j+1] = 目标 } console.log(numArray);

降序：

var numArray = [140000, 104, 99]; for (var i = 0; i < numArray.length; i++) { var target = numArray[i]; for (var j = i - 1; j >= 0 && (numArray[j] < 目标); j--) { numArray[j+1] = numArray[j]; } numArray[j+1] = 目标 } console.log(numArray);

选择排序：

上升：

降序：

玩得开心

对于微型数组，这些实际上是否比在像 this answer suggests 这样的 TypedArray 上使用 sort() 更快。当然，对于中型到大型阵列，它们不会更快，因为这些是 O(n^2) 算法。

P

Peter Mortensen

Array.prototype.sort() 是排序数组的首选方法，但我们需要注意几个问题。

默认情况下，排序顺序是字典顺序而不是数字，无论数组中的值类型如何。即使数组全是数字，所有值都将转换为字符串并按字典顺序排序。

那么我们是否需要像下面这样自定义 sort() 和 reverse() 方法。

Referred URL

用于对数组内的数字进行排序

numArray.sort(function(a, b)
{
    return a - b;
});

用于反转数组内的数字

numArray.sort(function(a, b)
{
    return b - a;
});

Referred URL

s

stackphish

当作为回调函数提供时，下面的函数“numerically”在许多情况下用于对数字数组进行数字排序：

function numerically(a, b){
    return a-b;
}

array.sort(numerically);

但是在一些罕见的情况下，当数组包含非常大的负数时，可能会发生溢出错误，因为 ab 的结果小于 JavaScript 可以处理的最小数字。

所以一个更好的写数值函数的方法如下：

function numerically(a, b){
   if(a < b){
      return -1;
   } else if(a > b){
      return 1;
   } else {
      return 0;
   }
}

JavaScript 数字是浮点数。 IEEE754 定义了上溢和下溢规则，包括上溢到+-Infinity，下溢到subnormal 或+-0.0。我认为两个数字的减法不会下溢到 +-0.0，即使它们都很大并且接近相等。两个双精度值之间的差异始终可以表示为另一个非零双精度值（除非它溢出，如 DBL_MIN - DBL_MAX），但下溢是不可能的。灾难性取消使结果不精确，丢失了大部分“有效数字”，但 a-b 将始终为非零，并且具有正确的 a!=b 符号。

A

Ali Khosro

处理 undefined、null 和 NaN：Null 的行为类似于 0、NaN 和 undefined 到结束。

array = [3, 5, -1, 1, NaN, 6, undefined, 2, null]
array.sort((a,b) => isNaN(a) || a-b)
// [-1, null, 1, 2, 3, 5, 6, NaN, undefined]

语言规范要求 compare 函数在数组的任意两个元素上调用时始终返回 NaN 以外的数字。当 b 为 NaN 或未定义且 a 和 b 均为 Infinity 或均为 -Infinity 时，此函数返回 NaN。

检查 NaN 的想法还不错，但是这段代码并没有把 NaN 放在最后

G

Grant Miller

虽然在 JavaScript 中不需要，但如果您希望 sort() compareFunction 严格返回 -1、0 或 1（类似于 spaceship operator 在 PHP 中的工作方式），那么您可以使用 Math.sign()。

下面的 compareFunction 严格返回 -1、0 或 1：

numArray.sort((a, b) => Math.sign(a - b));

注意： Internet Explorer 不支持 Math.sign()。

U

Umesh

仅对于元素值的普通数组：

function sortArrayOfElements(arrayToSort) {
    function compareElements(a, b) {
        if (a < b)
            return -1;
        if (a > b)
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareElements);
}

e.g. 1:
var array1 = [1,2,545,676,64,2,24]
**output : [1, 2, 2, 24, 64, 545, 676]**

var array2 = ["v","a",545,676,64,2,"24"]
**output: ["a", "v", 2, "24", 64, 545, 676]**

对于对象数组：

function sortArrayOfObjects(arrayToSort, key) {
    function compareObjects(a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareObjects);
}

e.g. 1: var array1= [{"name": "User4", "value": 4},{"name": "User3", "value": 3},{"name": "User2", "value": 2}]

**output : [{"name": "User2", "value": 2},{"name": "User3", "value": 3},{"name": "User4", "value": 4}]**

S

SpYk3HH

更新！滚动到答案底部，寻找更有趣的 smartSort 道具添加剂！排序任何东西的数组！

我个人最喜欢的此函数形式允许使用升序或降序参数：

function intArraySort(c, a) {
    function d(a, b) { return b - a; }
    "string" == typeof a && a.toLowerCase();
    switch (a) {
        default: return c.sort(function(a, b) { return a - b; });
        case 1:
                case "d":
                case "dc":
                case "desc":
                return c.sort(d)
    }
};

用法很简单：

var ara = function getArray() {
        var a = Math.floor(Math.random()*50)+1, b = [];
        for (i=0;i<=a;i++) b.push(Math.floor(Math.random()*50)+1);
        return b;
    }();

//    Ascending
intArraySort(ara);
console.log(ara);

//    Descending
intArraySort(ara, 1);
console.log(ara);

//    Ascending
intArraySort(ara, 'a');
console.log(ara);

//    Descending
intArraySort(ara, 'dc');
console.log(ara);

//    Ascending
intArraySort(ara, 'asc');
console.log(ara);

jsFiddle

或代码片段示例在这里！

函数 intArraySort(c, a) { function d(a, b) { return b - a } "string" == typeof a && a.toLowerCase(); switch (a) { default: return c.sort(function(a, b) { return a - b });案例 1：案例“d”：案例“dc”：案例“desc”：返回 c.sort(d) } }; function tableExample() { var d = function() { var a = Math.floor(50 * Math.random()) + 1, b = []; for (i = 0; i <= a; i++) b.push(Math.floor(50 * Math.random()) + 1);返回 b }, a = function(a) { var b = $(""), c = $("").prependTo(b); $("", { text: intArraySort(d(), a).join(", ") }).appendTo(b); switch (a) { case 1: case "d": case "dc": case "desc": c.addClass("desc").text("Descending");休息;默认值：c.addClass("asc").text("Ascending") } return b }; return $("tbody").empty().append(a(), a(1), a(), a(1), a(), a(1), a(), a(1),一（），一（1），一（），一（1））};表格示例（）；表{边框折叠：折叠； } th, td { 边框：1px 实心；填充：.25em .5em；垂直对齐：顶部； } .asc { 颜色：红色； } .desc { 颜色：蓝色 }

.smartSort('asc' | 'desc')

现在，使用对包含多个项目的数组进行排序的排序方法获得更多乐趣！目前不涵盖“关联”（又名字符串键），但它确实涵盖了每种类型的值！它不仅会相应地对多个值 asc 或 desc 进行排序，而且还会保持值“组”的恒定“位置”。换句话说; ints 总是第一个，然后是字符串，然后是数组（是的，我正在制作这个多维的！），然后是 Objects（未过滤，元素，日期），&最后是未定义和空值！

“为什么？”你问。为什么不！

现在有2种口味！第一个需要较新的浏览器，因为它使用 Object.defineProperty 将方法添加到 Array.protoype 对象。这便于自然使用，例如：myArray.smartSort('a')。如果您需要为旧版浏览器实现，或者您只是不喜欢修改原生对象，请向下滚动到 Method Only 版本。

/* begin */
/* KEY NOTE! Requires EcmaScript 5.1 (not compatible with older browsers) */
;;(function(){if(Object.defineProperty&&!Array.prototype.smartSort){var h=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return a-b;if(/^stringstring$/ig.test(e))return a>b;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.smartSort("a");b instanceof Array&&b.smartSort("a");if(a instanceof Date&&b instanceof Date)return a-b;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=e.concat(g).smartSort("a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=[a[c],b[c]].smartSort("a"),a[c]==d[0]?-1:1;var f=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("a");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=[a.id,b.id].smartSort("a"),a.id==e[0]?1:-1;e=[a.tagName, b.tagName].smartSort("a");return a.tagName==e[0]?1:-1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);e.concat(g).smartSort("a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=[a[d].id,b[f].id].smartSort("a"),a[d].id==c[0]?-1:1;c=[a[d].tagName,b[f].tagName].smartSort("d"); return a[d].tagName==c[0]?1:-1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=[a[d],b[f]].smartSort("a"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element||!a.hasOwnProperty(d))return-1;if(!b.hasOwnProperty(d))return 1}c=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]>g[1]},k=function(a,b){if(null== a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return b-a;if(/^stringstring$/ig.test(e))return b>a;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.smartSort("d");b instanceof Array&&b.smartSort("d");if(a instanceof Date&&b instanceof Date)return b-a;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=e.concat(g).smartSort("a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=[a[c],b[c]].smartSort("d"),a[c]==d[0]?-1:1;var f=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=[a.id,b.id].smartSort("d"),a.id==e[0]?-1:1;e=[a.tagName,b.tagName].smartSort("d");return a.tagName==e[0]?-1:1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);e.concat(g).smartSort("a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=[a[d].id,b[f].id].smartSort("d"),a[d].id==c[0]?-1:1;c=[a[d].tagName,b[f].tagName].smartSort("d");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=[a[d],b[f]].smartSort("d"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element)return-1;if(!a.hasOwnProperty(d))return 1;if(!b.hasOwnProperty(d))return-1}c=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]<g[1]};Object.defineProperty(Array.prototype,"smartSort",{value:function(){return arguments&& (!arguments.length||1==arguments.length&&/^a([sc]{2})?$|^d([esc]{3})?$/i.test(arguments[0]))?this.sort(!arguments.length||/^a([sc]{2})?$/i.test(arguments[0])?h:k):this.sort()}})}})();
/* end */

jsFiddle Array.prototype.smartSort('asc|desc')

使用很简单！首先制作一些疯狂的数组，例如：

window.z = [ 'one', undefined, $('<span />'), 'two', null, 2, $('<div />', { id: 'Thing' }), $('<div />'), 4, $('<header />') ];
z.push(new Date('1/01/2011'));
z.push('three');
z.push(undefined);
z.push([ 'one', 'three', 'four' ]);
z.push([ 'one', 'three', 'five' ]);
z.push({ a: 'a', b: 'b' });
z.push({ name: 'bob', value: 'bill' });
z.push(new Date());
z.push({ john: 'jill', jack: 'june' });
z.push([ 'abc', 'def', [ 'abc', 'def', 'cba' ], [ 'cba', 'def', 'bca' ], 'cba' ]);
z.push([ 'cba', 'def', 'bca' ]);
z.push({ a: 'a', b: 'b', c: 'c' });
z.push({ a: 'a', b: 'b', c: 'd' });

然后简单地排序！

z.smartSort('asc'); // Ascending
z.smartSort('desc'); // Descending

仅方法

同上，只是一个简单的方法！

/* begin */
/* KEY NOTE! Method `smartSort` is appended to native `window` for global use. If you'd prefer a more local scope, simple change `window.smartSort` to `var smartSort` and place inside your class/method */
window.smartSort=function(){if(arguments){var a,b,c;for(c in arguments)arguments[c]instanceof Array&&(a=arguments[c],void 0==b&&(b="a")),"string"==typeof arguments[c]&&(b=/^a([sc]{2})?$/i.test(arguments[c])?"a":"d");if(a instanceof Array)return a.sort("a"==b?smartSort.asc:smartSort.desc)}return this.sort()};smartSort.asc=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return a-b;if(/^stringstring$/ig.test(e))return a> b;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.sort(smartSort.asc);b instanceof Array&&b.sort(smartSort.asc);if(a instanceof Date&&b instanceof Date)return a-b;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=smartSort(e.concat(g),"a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=smartSort([a[c], b[c]],"a"),a[c]==d[0]?-1:1;var f=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"a");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=smartSort([a.id,b.id],"a"),a.id==e[0]?1:-1;e=smartSort([a.tagName,b.tagName],"a");return a.tagName==e[0]?1:-1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);smartSort(e.concat(g), "a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=smartSort([a[d].id,b[f].id],"a"),a[d].id==c[0]?-1:1;c=smartSort([a[d].tagName,b[f].tagName],"a");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=smartSort([a[d],b[f]],"a"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1; if(b.hasOwnProperty(f)&&b[f]instanceof Element||!a.hasOwnProperty(d))return-1;if(!b.hasOwnProperty(d))return 1}c=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"a");return a[Object.keys(a)[0]]==c[0]?1:-1}g=[a,b].sort();return g[0]>g[1]};smartSort.desc=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return b-a;if(/^stringstring$/ig.test(e))return b>a;if(/(string|number){2}/ig.test(e))return/string/i.test(c)? 1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.sort(smartSort.desc);b instanceof Array&&b.sort(smartSort.desc);if(a instanceof Date&&b instanceof Date)return b-a;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=smartSort(e.concat(g),"a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=smartSort([a[c],b[c]],"d"),a[c]==d[0]?-1:1;var f=smartSort([a[Object.keys(a)[0]], b[Object.keys(b)[0]]],"d");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=smartSort([a.id,b.id],"d"),a.id==e[0]?-1:1;e=smartSort([a.tagName,b.tagName],"d");return a.tagName==e[0]?-1:1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);smartSort(e.concat(g),"a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&& b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=smartSort([a[d].id,b[f].id],"d"),a[d].id==c[0]?-1:1;c=smartSort([a[d].tagName,b[f].tagName],"d");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=smartSort([a[d],b[f]],"d"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element)return-1; if(!a.hasOwnProperty(d))return 1;if(!b.hasOwnProperty(d))return-1}c=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]<g[1]}
/* end */

利用：

z = smartSort(z, 'asc'); // Ascending
z = smartSort(z, 'desc'); // Descending

jsFiddle 方法 smartSort(Array, "asc|desc")

P

Peter Mortensen

试试这个代码：

HTML：

<div id="demo"></div>

JavaScript 代码：

<script>
    (function(){
        var points = [40, 100, 1, 5, 25, 10];
        document.getElementById("demo").innerHTML = points;
        points.sort(function(a, b){return a-b});
        document.getElementById("demo").innerHTML = points;
    })();
</script>

M

Marek Urbanowicz

试试这个代码如下

var a = [5, 17, 29, 48, 64, 21];
function sortA(arr) {
return arr.sort(function(a, b) {
return a - b;
})
;} 
alert(sortA(a));

C

Chris Kobrzak

TypeScript 变体

const compareNumbers = (a: number, b: number): number => a - b

myArray.sort(compareNumbers)

A

Adam M. Costello

当数组仅包含没有无穷大或 NaN 的数字时，可接受的答案和 numArray.sort((a,b) => a - b) 等等价物非常有用。它们可以扩展为处理无穷大和 NaN，如下所示：

numArray.sort((a,b) => (+a || 0) - (+b || 0) || 0);

这会将 NaN（或任何非数字，如 'foo' 或 {}）排序为 0。最后的 || 0 用于处理 a 和 b 相等无穷大的情况。

C

Coffezilla

为了创建这种排序，您必须传递一个函数来检查哪个先出现。

在函数内部定义您要检查的值：a.id - a.id

f

fcdt

您可以简单地对数字数组进行排序

常量数=[13,17,14,19,16];让温度； for(let i=0;inum[j]){ temp=num [i] num[i]=num[j] num[j]=temp } } } console.log(num);

问题是如何使用数组方法 sort() 对数字进行排序。

b

bortunac

排序混合

Object.defineProperty(Array.prototype,"sort_mixed",{
    value: function () { // do not use arrow function
        var N = [], L = [];
        this.forEach(e => {
            Number.isFinite(e) ? N.push(e) : L.push(e);
        });
        N.sort((a, b) => a - b);
        L.sort();
        [...N, ...L].forEach((v, i) => this[i] = v);
        return this;
    })

试试a =[1,'u',"V",10,4,"c","A"].sort_mixed(); console.log(a)

M

Mejan

如果有人不了解 Array.sort() 如何处理整数，请阅读此答案。

按字母顺序：

默认情况下， sort() 方法按字母和升序将值排序为字符串。

const myArray = [104, 140000, 99];
myArray.sort();
console.log(myArray); // output is [104, 140000, 99]

使用 array.sort(compareFunction) 升序：

const myArray = [104, 140000, 99];
myArray.sort(function(a, b){
  return a - b;
});
console.log(myArray); // output is [99, 104, 140000]

w3schools 的解释：

compareFunction 定义了另一种排序顺序。该函数应返回负值、零值或正值，具体取决于参数，例如： function(a, b){return ab} 当 sort() 方法比较两个值时，它将值发送到比较函数，并且根据返回的（负、零、正）值对值进行排序。示例：比较 40 和 100 时，sort() 方法调用比较函数 (40,100)。该函数计算 40-100，并返回 -60（负值）。 sort 函数会将 40 排序为小于 100 的值。

使用 array.sort(compareFunction) 的降序：

const myArray = [104, 140000, 99];
myArray.sort(function(a, b){
  return b - a;
});
console.log(myArray); // output is [140000, 104, 99]

这次我们用返回正值的 b - a（即 100-40）进行计算。

M

MD SHAYON

您只需使用 max() 和 min() 内置函数即可获得高度和最低数字

var numArray = [140000, 104, 99];
console.log(Math.max(...numArray));
console.log(Math.min(...numArray));

如果要按升序或降序排序

numArray.sort((a, b)=> a - b);

Know more

T

Tesla

如果您需要从字符串列表中计算和排序最大的 charCodeAt，这是正确的方法。

const arrayLines = '1.1.1.1\n1.0.1.1\n1.1.1.2\n1.1.1.0'.split('\n');

// Response: (4) ['1.0.1.1', '1.1.1.0', '1.1.1.1', '1.1.1.2']
arrayLines.sort((a, b) => {
    let a_charCodeSize = 0,
        b_charCodeSize = 0;

    // Loop true a & b characters and calculate the charCodeAt size.
    for (const aChar of a) a_charCodeSize += aChar.charCodeAt(0);
    for (const bChar of b) b_charCodeSize += bChar.charCodeAt(0);

    return a_charCodeSize - b_charCodeSize;
});

为什么需要编写任何实现，javascript sort 本机做完全相同的事情，它通过从起始索引开始的字符代码比较字符串并向前移动。 arrayLines.sort() 以相同的方式响应，不传递任何自定义函数

@SajidAli 本机排序不会一一比较所有字符，而是评估给定的整个值。在那种情况下，这不会导致正确的响应。

在上面的示例中尝试原生排序并查看... sort() 对数组的元素进行就地排序并返回排序后的数组。默认排序顺序是升序，基于将元素转换为字符串，然后比较它们的 UTF-16 代码单元值序列如果未提供函数，则通过将所有未定义的数组元素转换为字符串并比较 UTF- 16 个代码单元订购。例如，“香蕉”出现在“樱桃”之前。在数字排序中，9 在 80 之前，但由于数字被转换为字符串，因此在 Unicode 顺序中，“80”在“9”之前。参考：MDN

@SajidAli 我试过了，但它没有产生所需的输出。使用 ab 排序返回 ['1.1.1.1', '1.0.1.1', '1.1.1.2', '1.1.1.0'] 没有意义。

那是你的问题。根本不需要添加ab，只需使用sort而不传递任何回调函数。 arrayLines.sort()，它会显示与实现自己的自定义回调方法相同的结果

A

Anshul Chaurasia

由于 sort 方法将 Array 元素转换为字符串。因此，以下方式也适用于带有数组元素的十进制数。

let productPrices = [10.33, 2.55, 1.06, 5.77];
console.log(productPrices.sort((a,b)=>a-b));

并为您提供预期的结果。

“因为 sort 方法将 Array 元素转换为字符串。” ——不，它没有。

P

Putzi San

对大于 0 的整数进行排序，跳出框框思考：

function sortArray(arr) { return new Promise((resolve) => { const result = [] arr.forEach((item) => { setTimeout(() => { result.push(item) if (result.length = == arr.length) resolve(result) }, item) }) }) } sortArray([4, 2, 42, 128, 56, 2]).then((result) => { document.write(JSON.字符串化（结果））}）

请注意，这不应该被有效地使用， .sort() 更适合这个，检查其他答案

你能解释一下为什么要使用异步调用来对数字进行排序吗？

2

2 revs

升常运动 = [200, 450, -400, 3000, -650, -130, 70, 1300];

如果我们返回的东西 < 0 那么 A 将在 B 之前如果我们返回的东西 > 0 那么 B 将在 A 之前

 movements.sort((a, b) => {
      if (a > b) return 1; //- (Switch order)
      if (a < b) return -1; //- (Keep order)
    });

a - 当前值，b - 下一个值。

降序移动.sort((a, b) => { if (a > b) return -1; // - (Keep) if (a < b) return 1; // - (Switch) });

！改进，最佳解决方案！

movements.sort ((a, b) => a - b); // Same result!

如果 a < b 是负数（切换）如果 a < b 是负数（保持）

你的最后一点有一个错字，导致矛盾。您的第一位没有解决 a==b 的情况。为了格式化内联代码，它被单个反引号包围。

如何正确排序整数数组

关注公众号

想领先一步获取最新的外包任务吗？

相似问题

平台

支持

联系我们