如何正确排序整数数组

845

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

var numArray = [140000, 104, 99];
numArray = numArray.sort();
alert(numArray)
展开摘要

我希望这能显示出来99, 104, 140000。相反，它显示104, 140000, 99。因此，似乎排序将值作为字符串处理。

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

javascript  arrays  sorting  numbers 
— 佩里克斯
source
10
注意，最重要的答案中没有一个正确地处理所有浮点值。特别是它们都不处理NaN。看到一个涉及的排名很高的答案，将是非常高兴的NaN。
— Quuxplusone 2015年
3
顺便说一句，如果您要对很多整数进行排序，那么使用整数排序算法（例如对sort进行计数）将是有利的。时间计数排序将按照数组的大小O（n）线性运行小数位数。此处所有解决方案均使用效率较低的比较排序：O（n * log n）。
— Web_Designer
1
@Web_Designer计数排序是线性的，关于数字范围，而不是数组。例如，对[1,1000000]进行排序将需要2个以上的步骤，因为该算法将必须扫描介于1到1000000之间的每个数组索引，以查看哪个单元格的值大于
— 0。– yters
2
@yters使用哈希图，您只能注意排序数组中显示的整数。这使得排序与数组大小成线性关系。
— 凯文（Kevin）
1
最快的方法是使用同构排序数组模块，该模块可在浏览器和节点中本机运行，支持任何类型的输入，计算字段和自定义排序顺序。
— 劳埃德

Answers:

1230

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

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

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

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

— 阿克斯
source
147
真好 但是，实际上没有从javascript中获取数字排序的现成方法吗？
— peirix
39
啊，这是开箱即用的！但是，如果您确实不切实际，可以在JavaScript的最开始就将函数绑定到数组类类：// Array.prototype.sortNormal = function（）{返回this.sort（function（a，b）{返回a -b}）} //现在在任何数组上调用.sortNormal（）都会对其进行数字排序
— Jack Franzen 2013年
13
为什么是ab而不是a> b。我建议使用最后一个以避免操作机器错误
— Luca Davanzo
35
@Velthune比较函数应返回-1、0或+1。a> b将仅返回true或false。
— 伊万·佩雷斯
48
可以使用箭头功能来缩短此代码。numberArray.sort((a, b) => (a - b));好极了！我认为这接近开箱即用的方式。注意：请检查您的JS引擎是否支持箭头功能。
— КонстантинВан
173

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

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
— MarzSocks
source
8
@bodyflex固定：var arr = [140000, 104, 99].sort(function(a,b) { return a-b; });。或更紧凑的let arr = [140000, 104, 99].sort((a,b) => a-b);
— 机型
1
正如我在上面的评论中所说，箭头功能在这里不合适，我不鼓励任何人以这种方式使用它们。您正在使用arrow语法的副作用来切出单词functionand return，但实际上并没有使用arrow函数传递的真正目的this。这段代码暗示发生了一些this上下文传递，但是没有。混淆其他开发人员阅读您的代码，只是节省了一些字符。不要依赖副作用-有目的的代码！
— bambery '16
12
@bambery我认为您不需要专门使用箭头功能来进行上下文更改…
— Ted Morin
7
@bambery，您实际上误解了箭头功能的作用。您认为它以某种方式传递this到函数中，但事实并非如此。它实际上忽略了创建一个this和arguments变量，这些变量通常会覆盖父变量。可以this在箭头函数中使用的唯一原因是词法作用域。
— Cuth
2
@bambery的年龄不佳...三年后，现代javascript开发几乎完全使用了箭头功能。:)
— Kip
71

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

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

numArray.sort(compareNumbers);

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

— 保罗·迪克森
source
我不理解上面的代码，升序如何“返回a-b”？
— vikramvi
如果a <b，则compareNumbers返回负数。如果a> b，它将为正。如果相等，则返回0
— 保罗·迪克森
38

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

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

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

— j
source
1
“不牺牲可读性”。这是主观的。使用一些简单的整数，它是可读的。当使用更复杂的对象并且您希望对属性进行排序时，不需要太多。
— Tristan
3
@Tristan，仍然可以使用此语法非常干净地对对象的属性进行排序。如果要排序的对象的属性是数字，则可以执行以下操作：objArray=objArray.sort((a,b)=>a.numProperty - b.numProperty);如果该属性是字符串，则可以执行以下操作：话objArray=objArray.sort((a,b)=>a.strProperty.localeCompare(b.strProperty))‌​;虽如此，该问题专门询问有关对整数数组进行排序的问题
— jjjjs
34

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

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

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

— dy_
source
4
使用TypedArray可使排序速度提高约5倍。如果您想更快一些，hpc-algorithms npm包将实现“基数排序”和“计数排序”，这里有一些答案。
— DragonSpit '19
哇，不知道这个存在！
— pixelearth
21

排序功能如此奇怪的原因

从文档中：

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

— 黑色
source
提示：这仅是我的解释，我实际上没有查看代码。因此，请不要完全相信这个答案。
— 黑色
17

我同意aks，但是不要使用 

return a - b;

你应该用

return a > b ? 1 : a < b ? -1 : 0;
— 用户名
source
18
您能解释为什么有人应该使用您更难以理解的三元运算吗？据我所知，它将有相同的结果。
— stefannew
6
该答案还考虑了相等的值，并将它们放在同一位置。
— Maarten00 2015年
23
a-b不是吗？
— 布莱恩·雷纳
12
“ return ab”对于这个问题的特定情况（javascript，以及所有输入项都是ints）可能就足够了，但是我个人更喜欢三元形式，因为它更规范-在更多情况下，在更多编程语言中都可以使用，具有更多数据类型。例如，在C中，ab可能会溢出，从而导致无休止的循环，破坏内存，崩溃等。也就是说，如果涉及NaN或混合类型，则即使是三元形式也无法正常工作。
— 唐·哈奇
8
在>和<仍然比较A和B作为字符串。
— vriesdemichael '16
11

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

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

那就是你所需要的:)

— 查特
source
10

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

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

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

numArray = numArray.sort(sortNumber);
— 彼得·莫滕森
source
8

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

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

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

推荐网址

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

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

用于反转数组中的数字

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

推荐网址

— 梅宾·乔
source
6

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

玩得开心

— 商业自杀
source
对于微型数组来说，这些方法实际上比sort()在TypedArray上使用这样的答案所提示的速度要快吗？当然，对于中型到大型阵列，它们不会更快，因为它们是O（n ^ 2）算法。
— 彼得·科德斯
5

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

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;
   }
}
— leet101
source
1
JavaScript数字是浮点数。IEEE754定义了上溢和下溢规则，包括上溢至+ -Infinity和下溢至次标准或+ -0.0。我认为即使两个数字都很大且附近相等，两个数字相减也不会下溢至+ -0.0。两个双打之间的差异始终可以表示为另一个非零双打（除非它像一样溢出DBL_MIN - DBL_MAX），但不可能发生下溢。灾难性的取消使结果不精确，丢失了大部分“有效数字”，但a-b始终为非零，并具有正确的a！= b符号。
— 彼得·科德斯
4

处理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]
— 阿里·科斯罗（Ali Khosro）
source
3

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

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}]**
— 乌梅什
source
2

更新！滚动到答案底部，以获取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.protoypeObject。这样便于自然使用，例如：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”）

— SpYk3HH
source
2

试试这个代码：

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>
— 阳光SM
source
2

尝试如下代码

var a = [5, 17, 29, 48, 64, 21];
function sortA(arr) {
return arr.sort(function(a, b) {
return a - b;
})
;} 
alert(sortA(a));
— 用户名
source
是不是？
— user7125929
1 
var numArray = [140000, 104, 99];
numArray = numArray.sort((a,b) => a-b);
alert(numArray)
— 瓦尔达曼PK
source
4
欢迎使用StackOverflow。您的答案与接受的答案相同。您能否在答案中添加任何解释，以说明为什么应优先于接受的答案？
— Simply Ged
1

尽管在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不支持。

— 格兰特·米勒
source
0

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

Array.prototype.sortNumeric = function () {
    return this.sort((a, b) => a - b);
};
Array.prototype.sortNumericDesc = function () {
    return this.sort((a, b) => b - a);
};
— 错误404
source
0

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

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

并给您预期的结果。

— 安舒尔·乔亚西亚
source
0

覆盖排序方法。

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


numbers = [12,8,21,5,1,34];
numbers.sortInt()
//output -> [1,5,8,12,21,34]
— 桑德斯
source
0

默认排序功能是按字典顺序排序：

var ar = [10000,3,200];
console.log(ar.sort());
//it will sort like :=> [10000, 200, 3]

以上不是我们想要的数字。因此，如果您有整数并且默认排序功能不起作用（因为它按字典顺序排序），则必须实现自己的功能：

var ar = [10000,3,-09,200];
function customSortHelpForNumber(number1, number2){
     return number1-number2;
}
console.log(ar.sort(customSortHelpForNumber));
//it will sort like :=> [3, 200, 10000]

我希望您能想到一个问题，它是如何工作的？在这里，当我们在sort函数中提供一个方法时，它每次传递两个数字，如果数字返回

  • -ve值或0，它将第一个数字保留在其位置
  • + ve重视它交换的地方。

通过对所有数字遵循此规则，它将对整数数组进行排序。

如果您使用的是ES6，请编写箭头功能：

console.log(ar.sort((num1,num2)=> num1-num2));
    //it will sort like :=> [3, 200, 10000]
— 贾斯汀
source
-1

这是我在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]
— 火
source
3
这是完全错误的！sort函数需要返回负数，0或正数，而不是true或false。
— jperelli
正如@jperelli提到的那样，sort函数需要返回一个数字（而不是布尔值）（并给出如何有3种可能的状态，等于，高于和低于该状态，这对于保持稳定的排序是必要的）。如您的回答所述，它不起作用。a-b应该改为使用。（您可以看中并执行Number(a>b)-0.5，但这仍然不是一个稳定的排序）。
— ecc521
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.