두 필드로 자바 스크립트 정렬 배열

88 
grouperArray.sort(function (a, b) {
    var aSize = a.gsize;
    var bSize = b.gsize;
    var aLow = a.glow;
    var bLow = b.glow;
    console.log(aLow + " | " + bLow);      
    return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : 0;
});

따라서 위의 코드는 가장 작은 것부터 가장 큰 것까지 gsize별로 배열을 정렬합니다. 잘 작동합니다. 그러나 gsize가 같으면 글로우별로 정렬하고 싶습니다.

감사.

javascript  arrays 
— 표
소스
정렬 기능은 긍정, 부정 또는 0 결과에 반응합니다. 그래서 "return aSize-bSize"라고 쓸 수 있습니다. 더 간단하고 읽기 쉬운 코드가 될 것입니다.

답변:

107 
grouperArray.sort(function (a, b) {
    var aSize = a.gsize;
    var bSize = b.gsize;
    var aLow = a.glow;
    var bLow = b.glow;
    console.log(aLow + " | " + bLow);

    if(aSize == bSize)
    {
        return (aLow < bLow) ? -1 : (aLow > bLow) ? 1 : 0;
    }
    else
    {
        return (aSize < bSize) ? -1 : 1;
    }
});
— 크리스에 벌레
소스
170 
grouperArray.sort(function (a, b) {   
    return a.gsize - b.gsize || a.glow - b.glow;
});

짧은 버전

— 안모로 조프 23
소스
좋은 지름길! 나와 함께 .. 더 복잡한 솔루션을 도왔다 stackoverflow.com/questions/6101475/...
— 조셉 Poirier의
3
좋고 깨끗합니다! 숫자에 대해서만 작동합니다.
— Afanasii Kurakin 19
여기에 논리를 설명 할 수 있습니까?!. 그것은 나를 위해 일한 sort an array with a key's value first후sort the result with another key's value
— KTM
1
@KTM 논리는 다음과 같습니다. 두 gsize가 모두 같으면 조건의 첫 번째 부분이 0과 같고 이는 거짓으로 간주되고 조건의 두 번째 부분이 실행됩니다.
— Scalpweb
@Scalpweb 예 :) 그래서 이것은 하나의 키로 배열을 정렬하는 데 작동합니다. 멋진 트릭
— KTM
14

나는 이것이 얼마 전에 요청되었다는 것을 알고 있지만 내 솔루션을 추가 할 것이라고 생각했습니다.

이 함수는 정렬 방법을 동적으로 생성합니다. 오름차순 또는 내림차순을 나타 내기 위해 +/-가 추가 된 정렬 가능한 각 하위 속성 이름을 제공하기 만하면됩니다. 재사용이 매우 가능하며 함께 만든 데이터 구조에 대해 알 필요가 없습니다. 멍청한 증거로 만들 수는 있지만 필요하지 않은 것 같습니다.

function getSortMethod(){
    var _args = Array.prototype.slice.call(arguments);
    return function(a, b){
        for(var x in _args){
            var ax = a[_args[x].substring(1)];
            var bx = b[_args[x].substring(1)];
            var cx;

            ax = typeof ax == "string" ? ax.toLowerCase() : ax / 1;
            bx = typeof bx == "string" ? bx.toLowerCase() : bx / 1;

            if(_args[x].substring(0,1) == "-"){cx = ax; ax = bx; bx = cx;}
            if(ax != bx){return ax < bx ? -1 : 1;}
        }
    }
}

사용 예 :

items.sort (getSortMethod ( '-price', '+ priority', '+ name'));

이것은 items가장 낮은 price항목부터 정렬 하고 가장 높은 항목에 연결됩니다 priority. 추가 관계는 항목에 의해 끊어집니다name

항목은 다음과 같은 배열입니다. 

var items = [
    { name: "z - test item", price: "99.99", priority: 0, reviews: 309, rating: 2 },
    { name: "z - test item", price: "1.99", priority: 0, reviews: 11, rating: 0.5 },
    { name: "y - test item", price: "99.99", priority: 1, reviews: 99, rating: 1 },
    { name: "y - test item", price: "0", priority: 1, reviews: 394, rating: 3.5 },
    { name: "x - test item", price: "0", priority: 2, reviews: 249, rating: 0.5 } ...
];

라이브 데모 : http://gregtaff.com/misc/multi_field_sort/

수정 : Chrome 문제가 수정되었습니다.

— Nihlton
소스
이것은 훌륭합니다
— Azure
천재 대답!
— Marius
typescript의 경우 (를 얻지 못한 경우 error TS2554: Expected 0 arguments, but got ..) 다음 구문을 사용하십시오. stackoverflow.com/a/4116634/5287221
— Chananel P
6

삼항 연산자 ((aSize < bSize) ? -1 : (aSize > bSize) ? 1 : 0;)가 당신을 혼란스럽게 할 것으로 예상합니다 . 더 잘 이해하려면 링크를 확인해야합니다.

그때까지 완전한 if / else 코드는 다음과 같습니다.

grouperArray.sort(function (a, b) {
    if (a.gsize < b.gsize)
    {
        return -1;
    }
    else if (a.gsize > b.gsize)
    {
        return 1;
    }
    else
    {
        if (a.glow < b.glow)
        {
            return -1;
        }
        else if (a.glow > b.glow)
        {
            return 1;
        }
        return 0;
    }
});
— 존 그린
소스
6

다음은 여러 필드에서 작동하는보다 일반적인 것을 원하는 사용자를위한 구현입니다.

Array.prototype.sortBy = function (propertyName, sortDirection) {

    var sortArguments = arguments;
    this.sort(function (objA, objB) {

        var result = 0;
        for (var argIndex = 0; argIndex < sortArguments.length && result === 0; argIndex += 2) {

            var propertyName = sortArguments[argIndex];
            result = (objA[propertyName] < objB[propertyName]) ? -1 : (objA[propertyName] > objB[propertyName]) ? 1 : 0;

            //Reverse if sort order is false (DESC)
            result *= !sortArguments[argIndex + 1] ? 1 : -1;
        }
        return result;
    });

}

기본적으로 속성 이름 / 정렬 방향을 얼마든지 지정할 수 있습니다.

var arr = [{
  LastName: "Doe",
  FirstName: "John",
  Age: 28
}, {
  LastName: "Doe",
  FirstName: "Jane",
  Age: 28
}, {
  LastName: "Foo",
  FirstName: "John",
  Age: 30
}];

arr.sortBy("LastName", true, "FirstName", true, "Age", false);
//Will return Jane Doe / John Doe / John Foo

arr.sortBy("Age", false, "LastName", true, "FirstName", false);
//Will return John Foo / John Doe / Jane Doe
— The_Black_Smurf
소스
3 
grouperArray.sort(function (a, b) {
  var aSize = a.gsize;
  var bSize = b.gsize;
  var aLow = a.glow;
  var bLow = b.glow;
  console.log(aLow + " | " + bLow);      
  return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : ( (aLow < bLow ) ? -1 : (aLow > bLow ) ? 1 : 0 );
});
— 실 렉스
소스
3 
grouperArray.sort(function (a, b) {
     var aSize = a.gsize;     
     var bSize = b.gsize;     
     var aLow = a.glow;
     var bLow = b.glow;
     console.log(aLow + " | " + bLow);
     return (aSize < bSize) ? -1 : (aSize > bSize) ? 1 : (aLow < bLow) ? -1 : (aLow > bLow) ? 1 : 0); });
— 팀 윌리엄스
소스
3

다음은 재귀를 사용하여 1부터 무한까지 임의의 수의 정렬 필드를 기준으로 정렬하는 구현입니다. 정렬 할 결과 개체의 배열 인 결과 배열과 정렬을 정의하는 정렬 개체의 배열 인 정렬 배열을 전달합니다. 각 정렬 개체에는 정렬 기준이되는 키 이름에 대한 "선택"키와 "오름차순"또는 "내림차순"을 나타내는 문자열 인 "순서"키가 있어야합니다. 

sortMultiCompare = (a, b, sorts) => {
    let select = sorts[0].select
    let order = sorts[0].order
    if (a[select] < b[select]) {
        return order == 'ascending' ? -1 : 1
    } 
    if (a[select] > b[select]) {
        return order == 'ascending' ? 1 : -1
    }
    if(sorts.length > 1) {
        let remainingSorts = sorts.slice(1)
        return this.sortMultiCompare(a, b, remainingSorts)
    }
    return 0
}

sortResults = (results, sorts) => {
    return results.sort((a, b) => {
        return this.sortMultiCompare(a, b, sorts)
    })
}

// example inputs
const results = [
    {
        "LastName": "Doe",
        "FirstName": "John",
        "MiddleName": "Bill"
    },
    {
        "LastName": "Doe",
        "FirstName": "Jane",
        "MiddleName": "Bill"
    },
    {
        "LastName": "Johnson",
        "FirstName": "Kevin",
        "MiddleName": "Bill"
    }
]

const sorts = [
    {
        "select": "LastName",
        "order": "ascending"
    },
    {
        "select": "FirstName",
        "order": "ascending"
    },
    {
        "select": "MiddleName",
        "order": "ascending"
    }    
]

// call the function like this:
let sortedResults = sortResults(results, sorts)
— 벤자민 포트만
소스
2

다중 키로이를 수행하는 동적 방법 :

  • 정렬의 각 열 / 키에서 고유 값 필터링
  • 순서를 정하거나 반대로
  • indexOf (value) 키 값을 기반으로 각 개체에 대한 가중치 너비 제로 패드 추가
  • caclutated 가중치를 사용하여 정렬

여기에 이미지 설명 입력

Object.defineProperty(Array.prototype, 'orderBy', {
value: function(sorts) { 
    sorts.map(sort => {            
        sort.uniques = Array.from(
            new Set(this.map(obj => obj[sort.key]))
        );

        sort.uniques = sort.uniques.sort((a, b) => {
            if (typeof a == 'string') {
                return sort.inverse ? b.localeCompare(a) : a.localeCompare(b);
            }
            else if (typeof a == 'number') {
                return sort.inverse ? (a < b) : (a > b ? 1 : 0);
            }
            else if (typeof a == 'boolean') {
                let x = sort.inverse ? (a === b) ? 0 : a? -1 : 1 : (a === b) ? 0 : a? 1 : -1;
                return x;
            }
            return 0;
        });
    });

    const weightOfObject = (obj) => {
        let weight = "";
        sorts.map(sort => {
            let zeropad = `${sort.uniques.length}`.length;
            weight += sort.uniques.indexOf(obj[sort.key]).toString().padStart(zeropad, '0');
        });
        //obj.weight = weight; // if you need to see weights
        return weight;
    }

    this.sort((a, b) => {
        return weightOfObject(a).localeCompare( weightOfObject(b) );
    });

    return this;
}
});

사용하다:

// works with string, number and boolean
let sortered = your_array.orderBy([
    {key: "type", inverse: false}, 
    {key: "title", inverse: false},
    {key: "spot", inverse: false},
    {key: "internal", inverse: true}
]);

여기에 이미지 설명 입력

— 레오나르도 필리페
소스
1

이것이 내가 사용하는 것입니다

function sort(a, b) {
    var _a = "".concat(a.size, a.glow);
    var _b = "".concat(b.size, b.glow);
    return _a < _b;
}

두 항목을 문자열로 연결하면 문자열 값으로 정렬됩니다. 원하는 경우 _a 및 _b를 parseInt로 래핑하여 숫자가 될 것이라는 것을 알고 있으면 숫자로 비교할 수 있습니다.

— 블록 루프
소스
1

다음은 특정 항목에 없을 수있는 우선 순위 정렬 키가있는 경우에 대한 해결책입니다. 따라서 대체 키를 기준으로 정렬해야합니다.

입력 데이터 예 ( id2 는 우선 순위 정렬 키임 ) :

const arr = [
    {id: 1},
    {id: 2, id2: 3},
    {id: 4},
    {id: 3},
    {id: 10, id2: 2},
    {id: 7},
    {id: 6, id2: 1},
    {id: 5},
    {id: 9, id2: 2},
    {id: 8},
];

출력은 다음과 같아야합니다. 

[ { id: 6, id2: 1 },
  { id: 9, id2: 2 },
  { id: 10, id2: 2 },
  { id: 2, id2: 3 },
  { id: 1 },
  { id: 3 },
  { id: 4 },
  { id: 5 },
  { id: 7 },
  { id: 8 } ]

비교기 기능은 다음과 같습니다. 

arr.sort((a,b) => {
  if(a.id2 || b.id2) {
    if(a.id2 && b.id2) {
      if(a.id2 === b.id2) {
        return a.id - b.id;
      }
      return a.id2 - b.id2;
    }
    return a.id2 ? -1 : 1;
  }
  return a.id - b.id
});

경우 PS에서이 경우 .ID 의 .id2는 0을 할 수 있습니다 사용하는 것을 고려 typeof.

— 델리 아즈
소스
0 
grouperArray.sort(
  function(a,b){return a.gsize == b.gsize ? a.glow - b.glow : a.gsize - b.gsize}
);
— ic3b3rg
소스
0 
grouperArray.sort(function (a, b) {
    var aSize = a.gsize;
    var bSize = b.gsize;
    if (aSize !== aSize)
        return aSize - bSize;
    return a.glow - b.glow;
});

테스트되지 않았지만 작동해야한다고 생각합니다.

— 잰더
소스
0

제 경우에는 매개 변수 '중요'및 '날짜'별로 알림 목록을 정렬합니다.

  • 1 단계 : '중요'및 중요하지 않음으로 알림 필터링

    let importantNotifications = notifications.filter(
        (notification) => notification.isImportant);

  let unImportantNotifications = notifications.filter(
        (notification) => !notification.isImportant);

  • 2 단계 : 날짜별로 정렬

      sortByDate = (notifications) => {
  return notifications.sort((notificationOne, notificationTwo) => {
    return notificationOne.date - notificationTwo.date;
  });
};

  • 3 단계 : 병합

    [
    ...this.sortByDate(importantNotifications),
    ...this.sortByDate(unImportantNotifications),
  ];
— Phạm Hùng
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.