정수 배열을 올바르게 정렬하는 방법

847

내가 정수를 포함한다는 것을 알고있는 배열에서 가장 높은 값과 가장 낮은 값을 얻으려고하면 생각보다 어려워 보입니다.

var numArray = [140000, 104, 99];
numArray = numArray.sort();
alert(numArray)
스 니펫 확장

나는 이것이 보일 것으로 기대한다 99, 104, 140000. 대신에이 표시 104, 140000, 99됩니다. 따라서 정렬이 값을 문자열로 처리하는 것 같습니다.

정수 함수를 실제로 정렬하기 위해 정렬 함수를 얻는 방법이 있습니까?

javascript  arrays  sorting  numbers 
— 페이 릭스
소스
10
상위 응답 중 어느 것도 모든 부동 소수점 값을 올바르게 처리하지 않습니다 . 특히, 그들 중 누구도 처리하지 않습니다 NaN. 를 다루는 높은 순위의 답변을 보는 것이 좋을 것입니다 NaN.
— Quuxplusone
3
당신이 정렬하는 경우 BTW, 많은 및 많은 정수를이 같은 정수 정렬 알고리즘을 사용하는 장점이 될 것입니다 종류의 계산 . 시간 계산 정렬은 배열의 크기에 따라 선형으로 스케일을 실행하는 데 소요됩니다 : O (n). 여기에있는 모든 솔루션은 비교 정렬을 덜 효율적으로 사용하지만 O (n * log n).
— Web_Designer 2016 년
1
@Web_Designer 카운팅 정렬은 배열이 아닌 숫자 범위와 관련하여 선형입니다. 예를 들어, [1,1000000] 정렬은 2 단계 이상이 걸립니다. 알고리즘은 1에서 1000000 사이의 각 배열 인덱스를 스캔하여 어떤 셀 값이 0보다 큰지 확인해야하기 때문입니다.
— yters
2
@yters 해시 맵을 사용하면 정렬되는 배열에 나타나는 정수에만주의를 기울일 수 있습니다. 이것은 정렬 선형을 배열 크기로 만듭니다.
— Kevin
1
가장 빠른 방법은 브라우저와 노드 모두에서 기본적으로 작동하는 모든 유형의 입력, 계산 필드 및 사용자 정의 정렬 순서를 지원 하는 동형 정렬 배열 모듈 을 사용하는 것 입니다.
— Lloyd

답변:

1234

기본적으로 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

선적 서류 비치:

Mozilla Array.prototype.sort()는 Infinity 또는 NaN을 포함하지 않는 배열에 대해이 비교 기능을 권장합니다. ( Inf - Inf0이 아닌 NaN 이므로 ).

키별로 객체를 정렬하는 예제도 있습니다.

— 방주
소스
148
좋은. 그러나 실제로 자바 스크립트에서 숫자 정렬을 얻는 기본 방법이 있습니까?
— peirix 2016 년
39
아아 이것은 상자에서 벗어났습니다! 그러나 실제로 실용적이지 않으면 자바 스크립트의 맨 처음에 배열 클래스 클래스에 함수를 바인딩 할 수 있습니다. // Array.prototype.sortNormal = function () {return this.sort (function (a, b) {return a -b})} // 이제 모든 배열에서 .sortNormal ()을 호출하면 숫자로 정렬됩니다.
— Jack Franzen
13
왜 a> b가 아닌 ab. 나는 기계 오류를 피하기 위해 마지막 것을 제안한다
— Luca Davanzo
35
@Velthune 비교 함수는 -1, 0 또는 +1을 반환해야합니다. a> b는 true 또는 false 만 반환합니다.
— Iván Pérez
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
소스
8
@bodyflex 고정 : var arr = [140000, 104, 99].sort(function(a,b) { return a-b; });. ES6let arr = [140000, 104, 99].sort((a,b) => a-b);
— 00500005
1
위의 주석에서 말했듯이 화살표 기능은 여기에 적합하지 않으므로 누구나이 방법으로 사용하지 못하게하십시오. 당신은 단어를 잘라 화살표 구문의 부작용을 사용 function하고 return, 실제로 전달하는 화살표 기능의 진정한 목적을 사용하고 있지 않습니다 this. 이 코드는 일부 this컨텍스트 전달이 발생하지만 그렇지 않은 것을 의미합니다 . 다른 개발자가 코드를 읽는 데 혼란을 주면 몇 문자를 절약 할 수 있습니다. 부작용에 의존하지 마십시오-목적이있는 코드!
— bambery
12
@bambery 문맥 변경에만 독점적으로 화살표 기능을 사용해야한다고 생각하지 않습니다…
— Ted Morin
7
@ bambery, 실제로 화살표 기능이하는 일을 오해합니다. 어떻게 든 this함수에 전달된다고 생각 하지만 사실이 아닙니다. 실제로 부모 변수를 덮어 쓰는 변수 this와 arguments변수 를 만드는 것은 무시 합니다. this화살표 함수 안에서 사용할 수있는 유일한 이유 는 어휘 범위입니다.
— cuth
2
3 년이 지난 지금의 자바 스크립트 개발은 현대의 자바 스크립트 개발에서 거의 독점적으로 화살표 기능을 사용합니다. :)
— Kip
71

array.sort 는 기본적으로 사전 식 정렬을 수행하며, 숫자 정렬의 경우 고유 한 기능을 제공합니다. 다음은 간단한 예입니다.

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

numArray.sort(compareNumbers);

또한 정렬은 "제자리에서"작동하므로 할당 할 필요가 없습니다.

— 폴 딕슨
소스
위의 코드를 이해하지 못했습니다. "return a-b"는 오름차순 정렬을 어떻게 수행합니까?
— vikramvi
a <b 인 경우 compareNumbers는 음수를 반환합니다. a> b이면 양수입니다. 같으면 0을 반환합니다.
— Paul Dixon
38

이 답변은 기존 답변 중 일부와 동일하지만 ECMAScript 6 화살표 함수 는 가독성을 희생하지 않고 인라인 정렬 함수를 정의 할 수있는 훨씬 더 간단한 구문을 제공합니다.

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

오늘날 대부분의 브라우저 에서 지원됩니다 .

— jjjjs
소스
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_
소스
4
TypedArray를 사용하면 정렬 속도가 약 5 배가됩니다. 더 빠른 hpc-algorithms npm 패키지를 원한다면 여기에 몇 가지 대답이 제안하는 기수 정렬 및 계산 정렬을 구현합니다.
— DragonSpit
와우, 이것이 존재하는지 몰랐다!
— pixelearth
21

정렬 기능이 너무 이상하게 작동하는 이유

로부터 문서 :

[...] 배열은 각 요소의 문자열 변환에 따라 각 문자의 유니 코드 코드 포인트 값에 따라 정렬됩니다.

배열 의 유니 코드 포인트 값 을 인쇄하면 명확 해집니다.

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()정수가 다른 숫자보다 큰지 신경 쓰지 않고 숫자의 유니 코드 값을 비교하고 두 개의 동일한 유니 코드 값이 있으면 다음 숫자가 있는지 확인하고 비교합니다.

올바르게 정렬하려면 여기에sort() 설명 된 것처럼 비교 함수를 전달해야합니다 .

— 검은
소스
힌트 : 이것은 단지 내 설명 일 뿐이며 실제로 코드를 찾지 않았습니다. 따라서이 답변을 완전히 신뢰하지 마십시오.
— Black
17

그러나 사용하는 대신 aks에 동의합니다. 

return a - b;

사용해야합니다

return a > b ? 1 : a < b ? -1 : 0;
— 사용자 3587638
소스
18
왜 읽을 수없는 삼항 연산을 사용 해야하는지 설명 할 수 있습니까 ? 내가 알 수있는 한 동일한 결과를 얻을 것입니다.
— stefannew
6
이 답변은 동일한 가치를 고려하여 같은 장소에 둡니다.
— Maarten00
23
그리고 a-b는 그렇지 않습니까?
— Bryan Rayner
12
"return ab"는이 질문의 특정 경우 (javascript 및 ints로 알려진 모든 입력 항목)에 적합 할 수 있지만 개인적으로 더 정식이기 때문에 3 진 형식을 선호합니다. 더 많은 경우 더 많은 프로그래밍 언어에서 작동합니다 데이터 유형이 더 많습니다. 예를 들어 C에서 ab는 오버플로가 발생하여 끝없는 반복, 메모리 손상, 충돌 등을 초래할 수 있습니다. 즉, NaN 또는 혼합 유형이 있으면 삼항 형식조차 제대로 작동하지 않습니다.
— 돈 해치
8
>와 <여전히 문자열로 A와 B를 비교합니다.
— vriesdemichael
11

새로운 ES6 세계에서 훨씬 쉬운 정렬 

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

그게 당신이 필요한 전부 :)

— 채트
소스
10

JavaScript에서 sort () 메서드의 기본 동작은 배열의 값을 알파벳순으로 정렬하는 것입니다.

숫자로 정렬하려면 숫자 정렬 기능을 정의해야합니다 (매우 쉽습니다).

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

numArray = numArray.sort(sortNumber);
— 피터 모텐슨
소스
8

Array.prototype.sort ()는 배열을 정렬하는 방법으로 이동하지만 알아야 할 몇 가지 문제가 있습니다.

정렬 순서는 기본적으로 사전 식이며 배열의 값 유형에 관계없이 숫자가 아닙니다. 배열이 모두 숫자 인 경우에도 모든 값은 문자열로 변환되어 사전 식으로 정렬됩니다.

따라서 아래와 같이 sort () 및 reverse () 메소드를 사용자 정의해야합니다.

추천 URL

배열 내부의 숫자를 정렬

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

배열 내부의 숫자를 뒤집기 위해

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

추천 URL

— 머빈 조
소스
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);
스 니펫 확장

즐기세요

— 상업용 자살
소스
이들의인가 실제로 사용하는 것보다 작은 배열에 대한 빠른을 sort()같이하는 TypedArray에 이 대답에서 알 수 . 확실히 그것들은 O (n ^ 2) 알고리즘이기 때문에 중간에서 큰 배열에 대해서는 더 빠르지 않을 것입니다.
— Peter Cordes
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
소스
1
JavaScript 숫자는 부동 소수점입니다. IEEE754는 + -Infinity 로의 오버플로 및 비정상 이하 또는 + -0.0으로의 언더 플로를 포함하여 오버플로 및 언더 플로 규칙을 정의합니다. 두 숫자의 뺄셈이 크거나 근처에 있더라도 + -0.0으로 흘러 갈 수 있다고 생각하지 않습니다. 두 더블의 차이는 항상 0이 아닌 다른 더블로 표현할 수 DBL_MIN - DBL_MAX있지만 ( 과 같이 오버플로되지 않는 한 ) 언더 플로는 불가능합니다. 치명적인 취소는 결과를 부정확하게하여 대부분의 "유효 숫자"를 잃지 만, a-b항상 0이
— Peter Cordes
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]
— 알리 코로
소스
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}]**
— 우 메쉬
소스
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')

이제 여러 항목으로 구성된 배열을 정렬하는 정렬 방법으로 훨씬 더 재미있게 보내십시오! 현재 "associative"(일명 문자열 키)는 다루지 않지만 모든 유형의 값에 대해서는 다루지 않습니다! 뿐만 아니라 그것은 여러 값을 정렬합니다 asc또는desc 그에 따라 "그룹"값의 "위치"를 일정하게 유지합니다. 다시 말해; ints는 항상 맨 먼저오고 문자열을오고 배열 (예,이 다차원을 만들고 있습니다!), 객체 (필터링되지 않은, 요소, 날짜) 및 마지막으로 정의되지 않은 null입니다!

"왜?" 물어. 왜 안돼!

이제 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 (배열, "asc | desc")

— SpYk3HH
소스
2

이 코드를 사용해보십시오 :

HTML :

<div id="demo"></div>

자바 스크립트 코드 :

<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
소스
2

아래 코드를 사용해보십시오

var a = [5, 17, 29, 48, 64, 21];
function sortA(arr) {
return arr.sort(function(a, b) {
return a - b;
})
;} 
alert(sortA(a));
— 사용자
소스
사실이 아닙니까?
— user7125929
1 
var numArray = [140000, 104, 99];
numArray = numArray.sort((a,b) => a-b);
alert(numArray)
— 바르다 만 PK
소스
4
StackOverflow에 오신 것을 환영합니다. 귀하의 답변은 허용 된 답변과 동일합니다. 수락 된 답변보다 왜 이것이 선호되어야하는지 설명하기 위해 답변에 설명을 추가 할 수 있습니까?
— 간단히 Ged
1

JavaScript에서는 필요하지 않지만 -1, 0 또는 1 ( PHP에서 우주선 연산자의 작동 방식과 유사)을 엄격하게 반환 하려면을 사용할 수 있습니다 .sort() compareFunctionMath.sign()

는 compareFunction아래 엄격하게 반환 -1, 0, 또는 1 :

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

참고 : Math.sign() Internet Explorer에서는 지원되지 않습니다.

— 그랜트 밀러
소스
0

이것은 Array 프로토 타입의 방법으로 이미 제안되고 수용된 솔루션입니다.

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

sort 메소드는 Array 요소를 문자열로 변환합니다. 따라서 아래 방법은 배열 요소가있는 10 진수에서도 잘 작동합니다.

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

그리고 당신에게 예상 결과를 제공합니다.

— 안슐 차 우라 시아
소스
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]
— 샌즈
소스
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, 그 자리에 첫 번째 숫자를 유지
  • 그것은 장소를 교환 + 가치.

이것을 모든 숫자에 따라 정수 배열을 정렬합니다.

ES6을 사용하는 경우 화살표 기능을 작성하십시오.

console.log(ar.sort((num1,num2)=> num1-num2));
    //it will sort like :=> [3, 200, 10000]
— JustIn
소스
-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]
— 불
소스
3
이것은 명백한 잘못입니다! sort 함수는 true 또는 false가 아닌 음수, 0 또는 양수를 반환해야합니다.
— jperelli
@jperelli가 언급했듯이 정렬 함수는 부울이 아닌 숫자를 반환해야합니다 (그리고 동일한 위, 아래 및 아래 3 가지 가능한 상태가있는 경우 안정적인 정렬이 필요합니다). 답변이 명시되어 있지만 작동하지 않습니다. a-b대신 사용해야합니다. (당신은 공상을 얻을 수 Number(a>b)-0.5있지만 여전히 안정적인 정렬은 아닙니다).
— ecc521
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.