Ответ 1

По умолчанию метод сортировки сортирует элементы по алфавиту. Для числовой сортировки просто добавьте новый метод, который обрабатывает числовые сортировки (sortNumber, показанный ниже) -

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

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

console.log(numArray);

Ответ 2

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

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

Ответ 3

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

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

numArray.sort(compareNumbers);

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

Ответ 4

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

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

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

Ответ 5

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

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

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

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

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

Ответ 6

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

return a - b;

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

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

Ответ 7

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

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

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

Ответ 8

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

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

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

numArray = numArray.sort(sortNumber);

Ответ 9

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

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

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

Ссылка на URL

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

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

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

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

Ссылка на URL

Ответ 10

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

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

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

Ответ 11

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

Ответ 12

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

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

Ответ 13

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

var a = [5, 17, 29, 48, 64, 21];
function sortA(arr) {
return arr.sort(function(a, b) {
return a - b;
})
;} 
alert(sortA(a));

Ответ 14

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

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

Ответ 15

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>

Ответ 16

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

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>

Ответ 17

для обработки неопределенных, нулевых и 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]

Ответ 18

Вот моя функция массива 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]

Ответ 19

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

        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)" вставляет указанный элемент в указанную позицию в этом списке. Соответственно сдвигает другие элементы.

Ответ 20

Простой способ с 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 

Ответ 21

Большую часть времени я буду придерживаться метода, предложенного в других ответах - то есть создать массив возможностей, перемешать его, а затем взять первые 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)

Ответ 22

var numArray = [140000, 104, 99];
numArray = numArray.sort((a,b) => a-b);
alert(numArray)

Ответ 23

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

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

Ответ 24

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

const filter = this.state.ages.filter(filter => filter >=0);