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

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

文档：

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

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

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

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

另请注意，排序工作“就位”，不需要赋值。

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

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

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

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

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

我同意Aks的观点，但不是使用

return a - b;

你应该用

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

更新！滚动到答案底部为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;}();
//    AscendingintArraySort(ara);console.log(ara);
//    DescendingintArraySort(ara, 1);console.log(ara);
//    AscendingintArraySort(ara, 'a');console.log(ara);
//    DescendingintArraySort(ara, 'dc');console.log(ara);
//    AscendingintArraySort(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>

.智能排序（'asc'|'desc'）

现在有了一个排序方法，可以对包含多个项目的数组进行排序！目前还不涵盖“关联”（也就是字符串键），但它确实涵盖了所有类型的值！它不仅会相应地对多个值asc或desc进行排序，而且还会保持值“组”的恒定“位置”。换句话说；int总是排在第一位，然后是字符串，然后是数组（是的，我正在制作这个多维！），然后是Object（未过滤，元素，日期），最后是未定义和空值！

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

现在有两种风格！第一种需要更新的浏览器，因为它使用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 */

jsFiddleArray.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'); // Ascendingz.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'); // Ascendingz = smartSort(z, 'desc'); // Descending

jsFiddle方法智能排序（数组，"asc|desc"）

试试这个代码：

超文本标记语言：

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

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

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

它在当今大多数浏览器中得到支持。

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

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

因此，我们是否需要像下面这样自定义排序（）和反向（）方法。

引用的URL

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

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

用于反转数组内的数字

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

引用的URL

这个问题已经回答了，最短的方法是使用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);

玩得开心点

试试下面的代码

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

仅对于元素值的正常数组：

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

排序函数行为如此怪异的原因

从留档：

[…]数组根据每个字符的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()不关心整数是否比另一个大，它比较数字的Unicode值，如果有两个相等的Unicode值，则检查是否有下一个数字并进行比较。

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

处理未定义、null和NaN：Null的行为类似于0，NaN和未定义的行为结束。

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]

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

要对数字进行排序，只需创建任何类型化数组：

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

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

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

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

因此，用数字函数编写函数的更好方法如下：

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

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

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

给你预期的结果。

虽然在JavaScript中不需要，但如果您希望#0compareFunction严格返回-1、0或1（类似于宇宙飞船操作员在PHP中的工作方式），那么您可以使用#2。

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

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

备注：Math.sign()在Internet Explorer中不受支持。

对>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.stringify(result))})

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

sort_mixed

Object.defineProperty(Array.prototype,"sort_mixed",{value: function () { // do not use arrow functionvar 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)

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

按字母顺序排列：

默认情况下，sor（）方法将值按字母顺序和升序排序为字符串。

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

升序为#0：

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

来自w3学校的解释：

compareFunction定义了一个替代排序顺序。该函数应该返回负值、零值或正值，具体取决于参数，例如：函数（a， b）{返回a-b}当sort（）方法比较两个值时，它会将值发送到比较函数，并根据返回的（负、零、正）值对值进行排序。

示例：

比较40和100时，sort（）方法调用比较函数（40,100）。

该函数计算40-100，并返回-60（负值）。

排序函数将40排序为小于100的值。

#0的降序：

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）计算，它返回一个正值。

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

const num=[13,17,14,19,16];let temp;for(let i=0;i<num.length;i++){for(let j=i+1;j<num.length;j++){if(num[i]>num[j]){temp=num[i]num[i]=num[j]num[j]=temp}}}
console.log(num);

TypeScript变体

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

1. 上升

   const移动=[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-下一个值。

2. 递减

   movements.sort（a， b）=>{如果（a>b）返回-1; // - (保持）如果（a

！改进，最佳解决方案！

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

如果a

您可以通过使用最大值和min（）内置函数简单地获得高度和最低数字

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

如果你想按升序或降序排序

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

了解更多

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

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

这会对NaN（或任何非数字，如'foo'或{}）进行排序，就好像它是0一样。最后的|| 0需要处理a和b相等无穷大的情况。

上升

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

下降

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

只是为了好玩：

降序=升序+反向

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

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

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

        const myJson = [{ id: 1, name: 'one'},{ id: 4, name: 'four'},{ id: 2, name: 'two'},{ id: 3, name: 'three'}];
// provide the sort method to checkconst myNewSort = myJson.sort(function(a, b) {return a.id - b.id;});
console.log('my new sort',myNewSort)

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

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

如果您需要从字符串列表中计算和排序最大的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;});

Array.sort使用字母按默认排序而不是数字。

要支持数字，请添加如下内容

var numArray = [140000, 104, 99];numArray.sort((a, b) =>  a - b); // <-- AscendingnumArray.sort((a, b) =>  b - a); // <-- Descendingconsole.log(numArray);

输出：