如何正确排序整数数组

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

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

尽管在JavaScript中不是必需的，但如果您希望严格返回-1、0或1（类似于PHP中的spaceship运算符），则可以使用。sort() compareFunctionMath.sign()

在compareFunction以下严格返回-1，0，或1：

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

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

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

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

并给您预期的结果。

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

试试这个代码：

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>

尝试如下代码

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

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

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

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

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

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

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

玩得开心

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

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

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

引荐网址

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

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

用于反转数组中的数字

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

引荐网址

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

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

那就是你所需要的:)

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

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

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

numArray = numArray.sort(sortNumber);

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

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

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

我同意aks，但是不要使用

return a - b;

你应该用

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

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

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

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

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

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

numArray.sort(compareNumbers);

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

排序功能如此奇怪的原因

从文档中：

数组是根据每个字符的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()像解释这里。

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

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

默认情况下，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

说明文件：

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

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