Javascript 如何对整数数组进行正确排序

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

var numArray=[140000,104,99]；
numArray=numArray.sort（）；
log（numArray）

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

var numArray=[140000,104,99]；
排序（函数（a，b）{
返回a-b；
});
控制台日志（numArray）默认情况下进行字典排序，对于数字排序，提供您自己的函数。下面是一个简单的例子：

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

numArray.sort(compareNumbers);

还要注意，sort可以“就地”工作，不需要赋值。
在JavaScript中，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

以下是我在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]

但是，我同意aks，而不是使用

return a - b;

你应该使用

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

返回a>b？1:a

更新！滚动至答案底部，查看
smartSort
prop addition，它会带来更多乐趣
对任何内容的数组进行排序

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

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


尝试以下代码：

HTML:



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点=[40100,1,5,25,10]；
document.getElementById（“demo”）.innerHTML=points；
sort（函数（a，b）{返回a-b}）；
document.getElementById（“demo”）.innerHTML=points；
})();
此答案与一些现有答案相当，但ECMAScript 6提供了更简洁的语法，允许我们在不牺牲可读性的情况下定义内联排序函数：

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

它在。
数组中受支持。prototype.sort（）是排序数组的go-to方法，但我们需要注意几个问题

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

因此，我们应该像下面那样定制sort（）和reverse（）方法


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

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

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

用于在阵列内反转数字

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

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

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

插入排序

升序：
var numArray=[140000,104,99]；
对于（var i=0；i=0&&（numArray[j]>target）；j--）{
努马拉伊[j+1]=努马拉伊[j]；
}
努马拉伊[j+1]=目标
}
控制台日志（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]**

元素排序函数（arrayToSort）{
功能比较元件（a、b）{
if（ab）
返回1；
返回0；
}
返回arrayToSort.sort（比较元素）；
}
e、 g.1：
var array1=[1,2545676,64,2,24]
**输出：[1,2,2,24,64545676]**
var array2=[“v”，“a”，545676,64,2，“24”]
**输出：[“a”、“v”、2、“24”、64545676]**

对于对象数组：

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

函数排序对象（数组排序，键）{
函数比较对象（a、b）{
如果（a[键]b[键]）
返回1；
返回0；
}
返回arrayToSort.sort（比较对象）；
}
e、 g.1:var array1=[{“name”：“User4”，“value”：4}，{“name”：“User3”，“value”：3}，{“name”：“User2”，“value”：2}]
**输出：[{“名称”：“用户2”，“值”：2}，{“名称”：“用户3”，“值”：3}，{“名称”：“用户4”，“值”：4}]**
排序函数行为如此怪异的原因
从：

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

如果打印阵列的图像，则图像将变得清晰


console.log（“140000.charCodeAt（0））；
console.log（“104.charCodeAt（0））；
console.log（“99.charCodeAt（0））；
//请注意，我们只查看数字“charCodeAt（0）”的第一个索引
来处理未定义、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]

在新的ES6世界中，排序要容易得多

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

这就是您所需要的：）
我很惊讶为什么每个人都建议将比较器函数传递给
sort（）
，这使得排序速度非常慢

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


var numArray=new Float64Array（[140000,104,99]）；
numArray=numArray.sort（）；
console.log（numArray）
下面的函数“numerical”在许多情况下作为回调函数提供，用于对数字数组进行数字排序：

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

数字函数（a，b）{
if（ab）{
返回1；
}否则{
返回0；
}
}
这是已经提出并接受的解决方案，作为阵列原型的一种方法：

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

As sort方法将数组元素转换为字符串。所以，下面的方法也适用于带数组元素的十进制数

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

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

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

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

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

myArray.sort(compareNumbers)

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

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

const arrNames = [
    { name: 'Andrzej' },
    { name: 'Mikolaj' },
    { name: 'Witalik' },
    { name: 'Iwan' },
    { name: 'Kasia' },
    { name: 'Joanna' },
    { name: 'Zuzanna' },
    { name: 'Anatol' },
  ];

 arrNames.sort(function (a, b): number {
   const x = a.name.toUpperCase();
   const y = b.name.toUpperCase();
   return x === y ? 0 : +(x > y) || -1; // change ">" for sorting
 });

arrNames.sort((a, b) => a.name.localeCompare(b.name));

arrNames.sort((a, b) => b.name.localeCompare(a.name));

const arrNum = [1, 80, 3, 2, 4, 6, 5, 12, 20, 100000];

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

[arrNames or arrNum].sort((a, b) => (a === b ? 0 : +(a > b) || -1));

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

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