如何正确排序整数数组

最新推荐文章于 2024-09-12 09:27:30 发布

asdfgh0077

最新推荐文章于 2024-09-12 09:27:30 发布

阅读量1.6k

点赞数

文章标签： javascript arrays sorting numbers

原文链接：https://stackoom.com/question/4SXH/如何正确排序整数数组

版权

博客讨论了JavaScript中数组排序的问题，特别是当数组包含整数时，默认的`sort()`方法会按照字典顺序而非数值大小排序。文章提供了一系列方法和示例，包括自定义比较函数、使用箭头函数以及扩展`Array.prototype`来实现智能排序，以确保整数能正确按数值大小排序。同时，还提到了处理`undefined`、`null`和`NaN`的情况，以及在不同场景下的排序优化策略。

摘要由CSDN通过智能技术生成

尝试从我知道仅包含整数的数组中获取最高和最低值似乎比我想象的要难。

 var numArray = [140000, 104, 99]; numArray = numArray.sort(); alert(numArray)

我希望它显示99, 104, 140000 。而是显示104, 140000, 99 。因此，似乎排序将值作为字符串处理。

有没有一种方法可以使sort函数对整数值进行实际排序？

#1楼

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

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

在ES6中，您可以使用箭头功能简化此操作：

numArray.sort((a, b) => a - b); // For ascending sort
numArray.sort((a, b) => b - a); // For descending sort

说明文件：

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

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

#2楼

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

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

numArray.sort(compareNumbers);

另请注意，排序工作“就地”进行，无需分配。

#3楼

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

要按数字排序，您必须定义一个数字排序函数（非常简单）：

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

numArray = numArray.sort(sortNumber);

#4楼

只是基于以上所有答案，它们也可以像这样一行完成：

var numArray = [140000, 104, 99];

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

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

//outputs: 99, 104, 140000

#5楼

这是我在utils库中的排序数组函数：

sortArray: function(array) {
    array.sort(function(a, b) {
        return a > b;
    });
},

# Let's test a string array
var arr = ['bbc', 'chrome', 'aux', 'ext', 'dog'];
utils.sortArray(arr);
console.log(arr);
>>> ["aux", "bbc", "chrome", "dog", "ext", remove: function]

# Let's test a number array
var arr = [55, 22, 1425, 12, 78];
utils.sortArray(arr);
console.log(arr);
>>> [12, 22, 55, 78, 1425, remove: function]

#6楼

我同意aks，但是不要使用

return a - b;

你应该用

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

#7楼

更新！滚动到底部的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

或代码段示例在这里！

 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) } }; 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); return b }, a = function(a) { var b = $("<tr/>"), c = $("<th/>").prependTo(b); $("<td/>", { text: intArraySort(d(), a).join(", ") }).appendTo(b); switch (a) { case 1: case "d": case "dc": case "desc": c.addClass("desc").text("Descending"); break; default: c.addClass("asc").text("Ascending") } return b }; return $("tbody").empty().append(a(), a(1), a(), a(1), a(), a(1), a(), a(1), a(), a(1), a(), a(1)) }; tableExample();

 table { border-collapse: collapse; } th, td { border: 1px solid; padding: .25em .5em; vertical-align: top; } .asc { color: red; } .desc { color: blue }

 <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script> <table><tbody></tbody></table>

.smartSort（'asc'|'desc'）

现在，使用排序方法将数组中包含多个项目的排序方法变得更加有趣！当前不涵盖“关联”（又称字符串键），但涵盖了几乎每种类型的值！它不仅将对多个值asc或desc相应排序，而且还将保持“组”值的恒定“位置”。换一种说法; 整数始终是第一个，然后是字符串，然后是数组（是，我正在制作多维！），然后是对象（未过滤，元素，日期），最后是undefined和null！

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

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

/* 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”）

#8楼

试试这个代码：

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>

#9楼

此答案与某些现有答案相同，但是ECMAScript 6 箭头函数提供了更为紧凑的语法，使我们能够定义内联排序函数而不会牺牲可读性：

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

当今大多数浏览器都支持它。

#10楼

Array.prototype.sort（）是用于对数组进行排序的go方法，但是我们需要注意一些问题。

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

因此，我们是否需要自定义如下的sort（）和reverse（）方法。

引荐网址

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

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

用于反转数组中的数字

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

引荐网址

#11楼

这个问题已经回答了，最短的方法是使用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] = target } 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] < target); j--) { numArray[j+1] = numArray[j]; } numArray[j+1] = target } console.log(numArray);

选择排序：

上升：

 var numArray = [140000, 104, 99]; for (var i = 0; i < numArray.length - 1; i++) { var min = i; for (var j = i + 1; j < numArray.length; j++) { if (numArray[j] < numArray[min]) { min = j; } } if (min != i) { var target = numArray[i]; numArray[i] = numArray[min]; numArray[min] = target; } } console.log(numArray);

降序：

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

玩得开心

#12楼

尝试如下代码

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

#13楼

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

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

#14楼

排序功能如此奇怪的原因

从文档中：

数组根据每个字符的Unicode代码点值以及每个元素的字符串转换来排序。

如果打印数组的unicode点值，则它将变得清晰。

 console.log("140000".charCodeAt(0)); console.log("104".charCodeAt(0)); console.log("99".charCodeAt(0)); //Note that we only look at the first index of the number "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)); //Note that we only look at the first index of the number "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(); console.log(numArray)

104, 140000, 99

结论：

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

为了正确排序，您必须像这里解释的那样将一个比较函数传递给sort() 。

#15楼

处理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]

#16楼

在新的ES6世界中，进行分类要容易得多

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

那就是你所需要的:)

#17楼

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

要对数字排序，只需创建任何 TypedArray ：

 var numArray = new Uint32Array([140000, 104, 99]); numArray = numArray.sort(); alert(numArray)

#18楼

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

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

#19楼

var numArray = [140000, 104, 99];
numArray = numArray.sort((a,b) => a-b);
alert(numArray)

#20楼

这是已经提出并被接受的解决方案，作为Array原型上的一种方法：

Array.prototype.sortNumeric = function () {
    return this.sort((a, b) => a - b);
};
Array.prototype.sortNumericDesc = function () {
    return this.sort((a, b) => b - a);
};

#21楼

as sort方法将Array元素转换为字符串。因此，下面的方法也可以很好地处理带有数组元素的十进制数字。

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

并给您预期的结果。

asdfgh0077

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫