Попытка получить наивысшее и низкое значение из массива, который, как я знаю, будет содержать только целые числа, кажется сложнее, чем я думал.
var numArray = [140000, 104, 99];
numArray = numArray.sort();
alert(numArray)По умолчанию метод сортировки сортирует элементы по алфавиту. Для числовой сортировки просто добавьте новый метод, который обрабатывает числовые сортировки (sortNumber, показанный ниже) -
function sortNumber(a, b) {
return a - b;
}
var numArray = [140000, 104, 99];
numArray.sort(sortNumber);
console.log(numArray);Просто основываясь на всех вышеперечисленных ответах, они также могут быть выполнены в одной строке следующим образом:
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
array.sort делает лексикографический вид по умолчанию, для числовой сортировки, предоставляет вашу собственную функцию. Вот простой пример:
function compareNumbers(a, b)
{
return a - b;
}
numArray.sort(compareNumbers);
Также обратите внимание, что сортировка работает "на месте", нет необходимости в присваивании.
Этот ответ эквивалентен некоторым из существующих ответов, но ECMAScript 6 функции стрелок обеспечивают гораздо более компактный синтаксис, который позволяет нам определить встроенная функция сортировки, не жертвуя удобочитаемостью:
numArray = numArray.sort((a, b) => a - b);
В настоящее время поддерживается большинство браузеров.
Из документации:
[...] массив сортируется в соответствии с каждым символьным значением кодовой точки Юникода в соответствии с преобразованием строки каждого элемента.
Если вы печатаете значения точек юникода массива, тогда он станет понятным.
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 )"Я согласен с 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)В JavaScript поведение метода sort() по умолчанию - сортировка значений в массиве в алфавитном порядке.
Для сортировки по номеру вы должны определить числовую функцию сортировки (что очень просто):
...
function sortNumber(a, b)
{
return a - b;
}
numArray = numArray.sort(sortNumber);
Array.prototype.sort() - это метод сортировки массивов, но есть несколько проблем, о которых нам нужно знать.
Порядок сортировки по умолчанию является лексикографическим, а не числовым, независимо от типов значений в массиве. Даже если массив всех чисел, все значения будут преобразованы в строку и отсортированы лексикографически.
Поэтому нам нужно настроить метод 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);
Это все, что вам нужно :)
Вопрос уже ответил, самый короткий способ - использовать метод 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);Функция "численно", приведенная ниже, служит для сортировки массива чисел во многих случаях, когда она предоставляется в качестве функции обратного вызова:
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;
}
}
Попробуйте этот код, как показано ниже
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]**
Для массива объектов:
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}]**
Update! Прокрутите до нижней части ответа для
smartSortprop 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);
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>Попробуйте этот код:
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>
для обработки неопределенных, нулевых и 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]
Вот моя функция массива 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]
//мой код, чтобы поместить число в нужное место в списке
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)" вставляет указанный элемент в указанную позицию в этом списке. Соответственно сдвигает другие элементы.
Простой способ с 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
Большую часть времени я буду придерживаться метода, предложенного в других ответах - то есть создать массив возможностей, перемешать его, а затем взять первые 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)
var numArray = [140000, 104, 99];
numArray = numArray.sort((a,b) => a-b);
alert(numArray)
Это уже предложенное и принятое решение в качестве метода на прототипе Array:
Array.prototype.sortNumeric = function () {
return this.sort((a, b) => a - b);
};
Array.prototype.sortNumericDesc = function () {
return this.sort((a, b) => b - a);
};
es6 и реагировать гораздо красивее, чем некоторые из этих очень сложных ответов. Замените this.state.ages массивом, который вы хотите фильтровать.
const filter = this.state.ages.filter(filter => filter >=0);