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

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

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

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

var numArray=[140000,104,99]；
排序（函数（a，b）{
返回a-b；
});
控制台日志（numArray）默认情况下，排序方法按字母顺序对元素进行排序。要进行数字排序，只需添加一个处理数字排序的新方法（sortNumber，如下所示）——


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

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

numArray.sort(compareNumbers);

还请注意，排序“就地”工作，不需要赋值。
默认情况下进行字典排序，对于数字排序，提供您自己的功能。下面是一个简单的例子：

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

numArray.sort(compareNumbers);

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

基于以上所有答案，也可以在一行中完成，如下所示：

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]

以下是我在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
我同意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);



更新！滚动至答案底部，查看
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；
})();
尝试以下代码：

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

它在中受支持。
此答案相当于一些现有答案，但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;
});

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

插入排序

升序：
var numArray=[140000,104,99]；
对于（var i=0；i 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);