Как правильно отсортировать массив целых чисел

Попытка получить наивысшее и низкое значение из массива, который, как я знаю, будет содержать только целые числа, кажется сложнее, чем я думал.

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

Я ожидаю, что это покажет 99, 104, 140000. Вместо этого он показывает 104, 140000, 99. Таким образом, кажется, что сортировка обрабатывает значения как строки.

Есть ли способ получить функцию сортировки для фактического сортировки по целочисленному значению?

+696
30 июн. '09 в 10:43
источник поделиться
24 ответа

По умолчанию метод сортировки сортирует элементы по алфавиту. Для числовой сортировки просто добавьте новый метод, который обрабатывает числовые сортировки (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
+999
30 июн. '09 в 10:47
источник

Просто основываясь на всех вышеперечисленных ответах, они также могут быть выполнены в одной строке следующим образом:

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
+162
06 февр. '14 в 6:07
источник

Связанные вопросы


Похожие вопросы

array.sort делает лексикографический вид по умолчанию, для числовой сортировки, предоставляет вашу собственную функцию. Вот простой пример:

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

numArray.sort(compareNumbers);

Также обратите внимание, что сортировка работает "на месте", нет необходимости в присваивании.

+69
30 июн. '09 в 10:47
источник

Этот ответ эквивалентен некоторым из существующих ответов, но ECMAScript 6 функции стрелок обеспечивают гораздо более компактный синтаксис, который позволяет нам определить встроенная функция сортировки, не жертвуя удобочитаемостью:

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

В настоящее время поддерживается большинство браузеров.

+36
03 февр. '16 в 20:07
источник

Причина, по которой функция сортировки ведет себя так странно

Из документации:

[...] массив сортируется в соответствии с каждым символьным значением кодовой точки Юникода в соответствии с преобразованием строки каждого элемента.

Если вы печатаете значения точек юникода массива, тогда он станет понятным.

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, тогда он проверяет, есть ли следующая цифра и сравнивает ее.

Чтобы правильно сортировать, вы должны передать функцию сравнения для sort() как описано здесь.

+17
26 мая '18 в 7:07
источник

Я согласен с aks, однако вместо использования

return a - b;

Вы должны использовать

return a > b ? 1 : a < b ? -1 : 0;
+15
18 нояб. '14 в 19:41
источник

Я удивлен, почему все рекомендуют передавать функцию сравнения в sort(), что делает сортировку очень медленной!

Чтобы отсортировать числа, просто создайте любой TypedArray:

var numArray = new Uint32Array([140000, 104, 99]);
numArray = numArray.sort();
alert(numArray)
+13
17 нояб. '18 в 21:01
источник

В JavaScript поведение метода sort() по умолчанию - сортировка значений в массиве в алфавитном порядке.

Для сортировки по номеру вы должны определить числовую функцию сортировки (что очень просто):

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

numArray = numArray.sort(sortNumber);
+10
30 июн. '09 в 10:48
источник

Array.prototype.sort() - это метод сортировки массивов, но есть несколько проблем, о которых нам нужно знать.

Порядок сортировки по умолчанию является лексикографическим, а не числовым, независимо от типов значений в массиве. Даже если массив всех чисел, все значения будут преобразованы в строку и отсортированы лексикографически.

Поэтому нам нужно настроить метод sort() и reverse(), как показано ниже.

Ссылка на URL

Для сортировки чисел внутри массива

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

Для изменения чисел внутри массива

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

Ссылка на URL

+8
02 мар. '16 в 7:53
источник

В новом мире ES6 гораздо проще сделать

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

Это все, что вам нужно :)

+7
16 нояб. '18 в 18:17
источник

Функция "численно", приведенная ниже, служит для сортировки массива чисел во многих случаях, когда она предоставляется в качестве функции обратного вызова:

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;
   }
}
+4
26 янв. '19 в 7:58
источник

Вопрос уже ответил, самый короткий способ - использовать метод 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);

Удачи

+4
26 июн. '16 в 18:34
источник

Только для обычного массива значений элементов:

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}]**
+2
07 февр. '18 в 11:04
источник

Попробуйте этот код, как показано ниже

var a = [5, 17, 29, 48, 64, 21];
function sortA(arr) {
return arr.sort(function(a, b) {
return a - b;
})
;} 
alert(sortA(a));
+2
07 февр. '18 в 10:58
источник

Update! Прокрутите до нижней части ответа для smartSort prop additive, которая дает еще больше удовольствия!
Сортирует массивы ничего!

Моя личная любимая форма этой функции позволяет указать параметр для восходящего или нисходящего:

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 соответственно, но также будет поддерживать постоянную "позицию" "групп" значений. Другими словами; ints всегда первыми, затем идут строки, затем массивы (да, я делаю это многомерным!), затем объекты (нефильтрованный, элемент, дата) и, наконец, undefineds и nulls!

"Почему?" ты спрашиваешь. Почему бы и нет!

Теперь идет 2 аромата! Первый из них требует новых браузеров, поскольку он использует 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 */

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

+1
07 дек. '14 в 19:02
источник

для обработки неопределенных, нулевых и 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]
+1
11 окт. '18 в 22:40
источник

Попробуйте этот код:

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>
+1
17 нояб. '15 в 5:48
источник

Большую часть времени я буду придерживаться метода, предложенного в других ответах - то есть создать массив возможностей, перемешать его, а затем взять первые n значений в качестве образца.

Однако это не очень хорошо, если диапазон возможностей велик по сравнению с тем, сколько памяти вы хотите использовать, или по сравнению с тем, сколько случайных значений вы хотите извлечь.

Решение, аналогичное предложенному вашему вопросу, может выглядеть следующим образом:

// select n integers from the range [from, to] (inclusive at both sides),
// taking random values from the randomSource as needed
function randomNumbersWithoutReplacement(n, from, to, randomSource = Math.random) {
    const result = [];
    for (let i = 0; i < n; ++i) {
        // i values have already been taken
        // the +1 makes it inclusive
        const rangeWidth = to - from - i + 1

        let value = Math.floor(rangeWidth * randomSource()) + from

        // correct the value compared to the already sampled integers
        for (let j = 0; j < result.length; ++j) {
            if (result[j] <= value) {
                value++
            }
        }

        result.push(value)

        // sorting makes the correction loop simpler
        // (and it nice to report the result sorted too)
        result.sort((a, b) => a - b)
    }
    return result
}

Хотя, если память не имеет значения, и она просто хранит количество случайных чисел, которые вы рисуете, о которых вы заботитесь, вы также можете реализовать это, используя множество возможностей, подобных этой:

function randomNumbersWithoutReplacement(n, from, to, randomSource = Math.random) {
    const possibilities = Array.from({length: to - from + 1}, (_, i) => i + from);
    const result = []

    for (let i = 0; i < n; ++i) {
        const index = Math.floor(randomSource() * possibilities.length)
        result.push(possibilities.splice(index, 1)[0])
    }

    // sorted for beauty
    result.sort()
    return result
}

И зачем тебе это?

const quantumLottoNumbers = randomNumbersWithoutReplacement(6, 1, 59, quantumRandomSource)
0
12 янв. '19 в 15:52
источник

Это уже предложенное и принятое решение в качестве метода на прототипе Array:

Array.prototype.sortNumeric = function () {
    return this.sort((a, b) => a - b);
};
Array.prototype.sortNumericDesc = function () {
    return this.sort((a, b) => b - a);
};
0
14 июн. '19 в 23:49
источник
var numArray = [140000, 104, 99];
numArray = numArray.sort((a,b) => a-b);
alert(numArray)
0
21 мая '19 в 16:55
источник

//мой код, чтобы поместить число в нужное место в списке

        int nr = 5;  // just a test number
        boolean foundPlace = false;

        for(int i = 0; i < integerList.size(); i++){

            if(nr <= integerList.get(i)){
                integerList.add(i,nr);
                foundPlace = true;
                break;
            }

        }
        if (!foundPlace)
            integerList.add(integerList.size(), nr);

"integerList.add(element)" вставляет указанный элемент в указанную позицию в этом списке. Соответственно сдвигает другие элементы.

0
04 дек. '17 в 6:07

Простой способ с ECMAScript 5:

var arr = [16,17,18,2,22,23,24,25,26,27,3,4,5,6,7,8,9,1,10,11,13,14,15];
arr=arr.sort(function(a,b){return a-b});

console.log(arr);
1,2,3,4,5,6,7,8,9,10,11,13,14,15,16,17,18,22,23,24,25,26,27 
0
15 авг. '18 в 10:09
источник

Вот моя функция массива sort в библиотеке utils:

sortArray: function(array) {
    array.sort(function(a, b) {
        return a > b;
    });
},

# Let 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 test a number array
var arr = [55, 22, 1425, 12, 78];
utils.sortArray(arr);
console.log(arr);
>>> [12, 22, 55, 78, 1425, remove: function]
0
27 июн. '14 в 6:10
источник

es6 и реагировать гораздо красивее, чем некоторые из этих очень сложных ответов. Замените this.state.ages массивом, который вы хотите фильтровать.

const filter = this.state.ages.filter(filter => filter >=0);
-3
04 дек. '17 в 6:07

Посмотрите другие вопросы по меткам или Задайте вопрос