source

문자열 속성 값을 기준으로 개체 배열 정렬

gigabyte 2022. 10. 30. 17:54

문자열 속성 값을 기준으로 개체 배열 정렬

JavaScript 객체 배열:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

을 「」의 할 수 있을까요?last_nomJavaScript?

에 대해서 알고 있습니다.sort(a,b)하지만 그것은 문자열과 숫자에서만 작동하는 것 같습니다.★★★★★★★★★★★★★★★★★★★★를 추가해야 하나요?toString()서드를내내 ?용?? ?????

사용자 고유의 비교 함수를 쉽게 작성할 수 있습니다.

function compare( a, b ) {
  if ( a.last_nom < b.last_nom ){
    return -1;
  }
  if ( a.last_nom > b.last_nom ){
    return 1;
  }
  return 0;
}

objs.sort( compare );

또는 인라인(c/o Marco Demaio):

objs.sort((a,b) => (a.last_nom > b.last_nom) ? 1 : ((b.last_nom > a.last_nom) ? -1 : 0))

또는 숫자(C/o Andre Figueerdo):

objs.sort((a,b) => a.last_nom - b.last_nom); // b - a for reverse sort

전달한 값을 기준으로 개체를 정렬하는 동적 정렬 함수를 만들 수도 있습니다.

function dynamicSort(property) {
    var sortOrder = 1;
    if(property[0] === "-") {
        sortOrder = -1;
        property = property.substr(1);
    }
    return function (a,b) {
        /* next line works with strings and numbers, 
         * and you may want to customize it to your needs
         */
        var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
        return result * sortOrder;
    }
}

따라서 다음과 같은 객체 배열을 가질 수 있습니다.

var People = [
    {Name: "Name", Surname: "Surname"},
    {Name:"AAA", Surname:"ZZZ"},
    {Name: "Name", Surname: "AAA"}
];

...그러면 효과가 있습니다.

People.sort(dynamicSort("Name"));
People.sort(dynamicSort("Surname"));
People.sort(dynamicSort("-Surname"));

사실 이것은 이미 그 질문에 대한 해답이다.아래 부분은 여러 파라미터로 동작하지 않는다고 연락이 많이 와서 쓴 것입니다.

다중 파라미터

아래 함수를 사용하여 여러 정렬 매개 변수를 사용하여 정렬 함수를 생성할 수 있습니다.

function dynamicSortMultiple() {
    /*
     * save the arguments object as it will be overwritten
     * note that arguments object is an array-like object
     * consisting of the names of the properties to sort by
     */
    var props = arguments;
    return function (obj1, obj2) {
        var i = 0, result = 0, numberOfProperties = props.length;
        /* try getting a different result from 0 (equal)
         * as long as we have extra properties to compare
         */
        while(result === 0 && i < numberOfProperties) {
            result = dynamicSort(props[i])(obj1, obj2);
            i++;
        }
        return result;
    }
}

이를 통해 다음과 같은 작업을 수행할 수 있습니다.

People.sort(dynamicSortMultiple("Name", "-Surname"));

어레이 서브클래싱

네이티브 오브젝트를 확장할 수 있는 ES6를 사용할 수 있는 행운의 고객:

class MyArray extends Array {
    sortBy(...args) {
        return this.sort(dynamicSortMultiple(...args));
    }
}

이를 통해 다음이 가능합니다.

MyArray.from(People).sortBy("Name", "-Surname");

ES6/ES2015 이상에서는 다음과 같이 할 수 있습니다.

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

ES6/ES2015 이전

objs.sort(function(a, b) {
    return a.last_nom.localeCompare(b.last_nom)
});

언더스코어.삭제

언더스코어 사용, 작고 멋진...

sortBy_.sortBy(리스트, 리터레이터, [콘텍스트])반복기를 통해 각 값을 실행한 결과에 따라 오름차순으로 정렬된 목록 복사본을 반환합니다.반복기는 정렬할 속성의 문자열 이름일 수도 있습니다(예:길이)

var objs = [ 
  { first_nom: 'Lazslo',last_nom: 'Jamf' },
  { first_nom: 'Pig', last_nom: 'Bodine'  },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

var sortedObjs = _.sortBy( objs, 'first_nom' );

대소문자를 구분하다

arr.sort((a, b) => a.name > b.name ? 1 : -1);

대소문자를 구분하지 않음

arr.sort((a, b) => a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1);

유용한 주의사항

이 없는 문자열의 ), 「」( 「」)이 됩니다.>하여 실패하다-1그런데 이 하면 1이나 -1이 올바르게 됩니다.

다른 , 하다, 하다, 하다, 이렇게 쓸 수 요.>=" " 가 ">

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];


// Define a couple of sorting callback functions, one with hardcoded sort key and the other with an argument sort key
const sorter1 = (a, b) => a.last_nom.toLowerCase() > b.last_nom.toLowerCase() ? 1 : -1;
const sorter2 = (sortBy) => (a, b) => a[sortBy].toLowerCase() > b[sortBy].toLowerCase() ? 1 : -1;

objs.sort(sorter1);
console.log("Using sorter1 - Hardcoded sort property last_name", objs);

objs.sort(sorter2('first_nom'));
console.log("Using sorter2 - passed param sortBy='first_nom'", objs);

objs.sort(sorter2('last_nom'));
console.log("Using sorter2 - passed param sortBy='last_nom'", objs);

성이 중복되어 있으면 이름으로 정렬할 수 있습니다.

obj.sort(function(a,b){
  if(a.last_nom< b.last_nom) return -1;
  if(a.last_nom >b.last_nom) return 1;
  if(a.first_nom< b.first_nom) return -1;
  if(a.first_nom >b.first_nom) return 1;
  return 0;
});

2018년 현재 훨씬 짧고 우아한 솔루션이 있습니다.그냥 써.Array.protype.sort().

예:

var items = [
  { name: 'Edward', value: 21 },
  { name: 'Sharpe', value: 37 },
  { name: 'And', value: 45 },
  { name: 'The', value: -12 },
  { name: 'Magnetic', value: 13 },
  { name: 'Zeros', value: 37 }
];

// sort by value
items.sort(function (a, b) {
  return a.value - b.value;
});

프로토타입 상속을 사용하여 이 문제를 간단하고 빠르게 해결:

Array.prototype.sortBy = function(p) {
  return this.slice(0).sort(function(a,b) {
    return (a[p] > b[p]) ? 1 : (a[p] < b[p]) ? -1 : 0;
  });
}

예 / 사용방법

objs = [{age:44,name:'vinay'},{age:24,name:'deepak'},{age:74,name:'suresh'}];

objs.sortBy('age');
// Returns
// [{"age":24,"name":"deepak"},{"age":44,"name":"vinay"},{"age":74,"name":"suresh"}]

objs.sortBy('name');
// Returns
// [{"age":24,"name":"deepak"},{"age":74,"name":"suresh"},{"age":44,"name":"vinay"}]

업데이트: 원래 어레이는 더 이상 수정되지 않습니다.

정답이 아닌 오래된 답변:

arr.sort((a, b) => a.name > b.name)

갱신하다

뷰챔프의 코멘트에서:

arr.sort((a, b) => a.name < b.name ? -1 : (a.name > b.name ? 1 : 0))

읽기 쉬운 형식:

arr.sort((a, b) => {
  if (a.name < b.name) return -1
  return a.name > b.name ? 1 : 0
})

네스트된 삼항식이 없는 경우:

arr.sort((a, b) => a.name < b.name ? - 1 : Number(a.name > b.name))

명::Number()캐스트true로로 합니다.1 ★★★★★★★★★★★★★★★★★」false로로 합니다.0.

Lodash.js(Underscore.js 슈퍼셋)

간단한 논리 부분마다 프레임워크를 추가하는 것은 좋지만, 잘 테스트된 유틸리티 프레임워크에 의존하면 개발 속도를 높이고 버그를 줄일 수 있습니다.

Lodash는 매우 깨끗한 코드를 생성하며 보다 기능적인 프로그래밍 스타일을 촉진합니다.한눈에 코드의 의도가 무엇인지 알 수 있습니다.

OP의 문제는 다음과 같이 간단히 해결할 수 있습니다.

const sortedObjs = _.sortBy(objs, 'last_nom');

더 많은 정보예를 들어 다음과 같은 중첩된 개체가 있습니다.

const users = [
  { 'user': {'name':'fred', 'age': 48}},
  { 'user': {'name':'barney', 'age': 36 }},
  { 'user': {'name':'wilma'}},
  { 'user': {'name':'betty', 'age': 32}}
];

이제 _.property 속기를 사용할 수 있습니다.user.age이치노사용자 개체를 중첩된 기간 속성별로 정렬합니다.이 가능합니다!, 네스트된 속성 매칭이 가능합니다.

const sortedObjs = _.sortBy(users, ['user.age']);

거꾸로 할까요?괜찮아요._.reverse 를 사용합니다.

const sortedObjs = _.reverse(_.sortBy(users, ['user.age']));

체인을 사용하여 둘을 결합하시겠습니까?

const { chain } = require('lodash');
const sortedObjs = chain(users).sortBy('user.age').reverse().value();

또는 체인보다 플로우를 선호할 때

const { flow, reverse, sortBy } = require('lodash/fp');
const sortedObjs = flow([sortBy('user.age'), reverse])(users);

가장 쉬운 방법: Lodash

(https://lodash.com/docs/4.17.10#orderBy)

은 이법 this this 와 같은 것입니다._.sortBy다만, 반복의 정렬 순서를 지정할 수 있습니다.순서가 지정되지 않은 경우 모든 값이 오름차순으로 정렬됩니다.그렇지 않으면 해당 값의 내림차순으로 "desc" 또는 오름차순으로 "asc"를 지정합니다.

논쟁들

컬렉션(Array|Object):반복할 컬렉션입니다.[반복]=[.pariet] (어레이[]|기능[]|오브젝트[]|string[]:정렬할 반복입니다.[orders](문자열[]):반복의 순서입니다.

돌아온다

(어레이):정렬된 새 배열을 반환합니다.

var _ = require('lodash');
var homes = [
    {"h_id":"3",
     "city":"Dallas",
     "state":"TX",
     "zip":"75201",
     "price":"162500"},
    {"h_id":"4",
     "city":"Bevery Hills",
     "state":"CA",
     "zip":"90210",
     "price":"319250"},
    {"h_id":"6",
     "city":"Dallas",
     "state":"TX",
     "zip":"75000",
     "price":"556699"},
    {"h_id":"5",
     "city":"New York",
     "state":"NY",
     "zip":"00010",
     "price":"962500"}
    ];
    
_.orderBy(homes, ['city', 'state', 'zip'], ['asc', 'desc', 'asc']);

는 이런 이 없기 에 두 가지 을 모두 할 수 하겠습니다.그래서 여기 양쪽에서 효과가 있는 간결한 비교 방법이 있습니다.string ★★★★★★★★★★★★★★★★★」number 삭제:

const objs = [ 
  { first_nom: 'Lazslo', last_nom: 'Jamf'     },
  { first_nom: 'Pig',    last_nom: 'Bodine'   },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

const sortBy = fn => {
  const cmp = (a, b) => -(a < b) || +(a > b);
  return (a, b) => cmp(fn(a), fn(b));
};

const getLastName = o => o.last_nom;
const sortByLastName = sortBy(getLastName);

objs.sort(sortByLastName);
console.log(objs.map(getLastName));

★★의 `sortBy()`

sortBy()fn는 비교할 개체에서 값을 선택하고 에 전달할 수 있는 함수를 반환합니다.이 예에서는, 다음과 같이 비교하고 있습니다.o.last_nom. 과 같은 두 다음과 같은 두 개의 오브젝트를 받을 때마다

a = { first_nom: 'Lazslo', last_nom: 'Jamf' }
b = { first_nom: 'Pig', last_nom: 'Bodine' }

을 리리와 한다.(a, b) => cmp(fn(a), fn(b))

fn = o => o.last_nom

을 ''으로 할 수 .(a, b) => cmp(a.last_nom, b.last_nom)JavaScript에서는 논리 ||OR()이 동작하기 때문에cmp(a.last_nom, b.last_nom) 상당하다

if (a.last_nom < b.last_nom) return -1;
if (a.last_nom > b.last_nom) return 1;
return 0;

덧붙여서, 이것은 다른 언어에서는 3방향 비교 "spaceship"()<=> 연산자라고 불립니다.

마지막으로 화살표 기능을 사용하지 않는 ES5 호환 구문은 다음과 같습니다.

var objs = [ 
  { first_nom: 'Lazslo', last_nom: 'Jamf'     },
  { first_nom: 'Pig',    last_nom: 'Bodine'   },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];

function sortBy(fn) {
  function cmp(a, b) { return -(a < b) || +(a > b); }
  return function (a, b) { return cmp(fn(a), fn(b)); };
}

function getLastName(o) { return o.last_nom; }
var sortByLastName = sortBy(getLastName);

objs.sort(sortByLastName);
console.log(objs.map(getLastName));

기능을 커스텀 비교 기능을 .toString() 함수에 : (( （ 본본기 function function function function function function 。

function Person(firstName, lastName) {
    this.firtName = firstName;
    this.lastName = lastName;
}

Person.prototype.toString = function() {
    return this.lastName + ', ' + this.firstName;
}

var persons = [ new Person('Lazslo', 'Jamf'), ...]
persons.sort();

여기에는 좋은 답변이 많이 있지만, 저는 그것들을 매우 간단하게 확장하여 훨씬 더 복잡한 분류를 할 수 있다는 것을 지적하고 싶습니다.OR 연산자를 사용하여 다음과 같은 비교 함수를 연결하기만 하면 됩니다.

objs.sort((a,b)=> fn1(a,b) || fn2(a,b) || fn3(a,b) )

서 ★★★★★fn1,fn2 [-을 반환하는 입니다."Sorting by fn1" "Sorting by fn2" "Sorting by fn2" 입니다.

this this this음 。||true로 변환할 수 있는 첫 번째 평가식으로 평가되는 연산자.

가장 단순한 형식에는 다음과 같은 인라인 함수가1개만 있습니다.

// ORDER BY last_nom
objs.sort((a,b)=> a.last_nom.localeCompare(b.last_nom) )

는 last_nom ,first_nom정렬 순서는 다음과 같습니다.

// ORDER_BY last_nom, first_nom
objs.sort((a,b)=> a.last_nom.localeCompare(b.last_nom) || 
                  a.first_nom.localeCompare(b.first_nom)  )

일반 비교 함수는 다음과 같습니다.

// ORDER BY <n>
let cmp = (a,b,n)=>a[n].localeCompare(b[n])

이 함수는 숫자 필드, 대소문자 민감도, 임의 데이터 유형 등을 지원하도록 확장될 수 있습니다.

소트 priority에 따라 체인으로 설정할 수 있습니다.

// ORDER_BY last_nom, first_nom
objs.sort((a,b)=> cmp(a,b, "last_nom") || cmp(a,b, "first_nom") )
// ORDER_BY last_nom, first_nom DESC
objs.sort((a,b)=> cmp(a,b, "last_nom") || -cmp(a,b, "first_nom") )
// ORDER_BY last_nom DESC, first_nom DESC
objs.sort((a,b)=> -cmp(a,b, "last_nom") || -cmp(a,b, "first_nom") )

여기서 중요한 것은 기능적 접근 방식을 갖춘 순수 JavaScript는 외부 라이브러리나 복잡한 코드 없이도 오랜 시간이 걸릴 수 있다는 것입니다.또한 문자열 해석을 수행할 필요가 없기 때문에 매우 효과적입니다.

이거 드셔보세요.

UPTO ES5

//Ascending Sort
items.sort(function (a, b) {
   return a.value - b.value;
});


//Descending Sort
items.sort(function (a, b) {
   return b.value - a.value;
});


IN ES6 & above:

// Ascending sort
items.sort((a, b) => a.value - b.value);

// Descending Sort
 items.sort((a, b) => b.value - a.value);

사용 예:

objs.sort(sortBy('last_nom'));

스크립트:

/**
 * @description
 * Returns a function which will sort an
 * array of objects by the given key.
 *
 * @param  {String}  key
 * @param  {Boolean} reverse
 * @return {Function}
 */
const sortBy = (key, reverse) => {

  // Move smaller items towards the front
  // or back of the array depending on if
  // we want to sort the array in reverse
  // order or not.
  const moveSmaller = reverse ? 1 : -1;

  // Move larger items towards the front
  // or back of the array depending on if
  // we want to sort the array in reverse
  // order or not.
  const moveLarger = reverse ? -1 : 1;

  /**
   * @param  {*} a
   * @param  {*} b
   * @return {Number}
   */
  return (a, b) => {
    if (a[key] < b[key]) {
      return moveSmaller;
    }
    if (a[key] > b[key]) {
      return moveLarger;
    }
    return 0;
  };
};

이 질문이 너무 오래되었다는 것은 알지만, 제 것과 유사한 구현은 보지 못했습니다.
이 버전은 Schwartzian 변환 관용구를 기반으로 합니다.

function sortByAttribute(array, ...attrs) {
  // generate an array of predicate-objects contains
  // property getter, and descending indicator
  let predicates = attrs.map(pred => {
    let descending = pred.charAt(0) === '-' ? -1 : 1;
    pred = pred.replace(/^-/, '');
    return {
      getter: o => o[pred],
      descend: descending
    };
  });
  // schwartzian transform idiom implementation. aka: "decorate-sort-undecorate"
  return array.map(item => {
    return {
      src: item,
      compareValues: predicates.map(predicate => predicate.getter(item))
    };
  })
  .sort((o1, o2) => {
    let i = -1, result = 0;
    while (++i < predicates.length) {
      if (o1.compareValues[i] < o2.compareValues[i]) result = -1;
      if (o1.compareValues[i] > o2.compareValues[i]) result = 1;
      if (result *= predicates[i].descend) break;
    }
    return result;
  })
  .map(item => item.src);
}

다음은 사용 예를 제시하겠습니다.

let games = [
  { name: 'Mashraki',          rating: 4.21 },
  { name: 'Hill Climb Racing', rating: 3.88 },
  { name: 'Angry Birds Space', rating: 3.88 },
  { name: 'Badland',           rating: 4.33 }
];

// sort by one attribute
console.log(sortByAttribute(games, 'name'));
// sort by mupltiple attributes
console.log(sortByAttribute(games, '-rating', 'name'));

짧은 코드를 쓰는 게 어때요?

objs.sort((a, b) => a.last_nom > b.last_nom ? 1 : -1)

를 사용합니다.`sort`

이 메서드는 비교 기능을 사용하여 숫자, 문자열, 심지어 개체 배열과 같은 모든 항목을 정렬하도록 수정할 수 있습니다.

비교 함수는 정렬 방법에 대한 임의 인수로서 전달된다.

이 비교 함수는 일반적으로 a와 b라고 불리는2개의 인수를 받아들입니다.이러한 2개의 인수에 근거해, 소트 방법을 필요에 따라서 변경할 수 있습니다.

0보다 값을 보다 작은 값을 한다.sort()method는 a를 b보다 낮은 인덱스로 정렬합니다.단순히 a는 b보다 앞에 올 것이다.
되면 "0"은 "0"으로 반환됩니다.sort() 유지합니다.
보다 큰 0보다 큰 값이 됩니다.sort()method는 a를 b보다 큰 인덱스로 정렬합니다.단순히 a는 b 뒤에 올 것이다.

위의 개념을 사용하여 가 오브젝트 속성이 되는 오브젝트에 적용합니다.

var objs = [
  { first_nom: 'Lazslo', last_nom: 'Jamf' },
  { first_nom: 'Pig', last_nom: 'Bodine' },
  { first_nom: 'Pirate', last_nom: 'Prentice' }
];
function compare(a, b) {
  if (a.last_nom > b.last_nom) return 1;
  if (a.last_nom < b.last_nom) return -1;
  return 0;
}
objs.sort(compare);
console.log(objs)
// for better look use console.table(objs)

복잡한 객체 배열 정렬(더 많은)

이 어레이와 같은 보다 복잡한 데이터 구조가 발생할 수 있으므로 솔루션을 확장하겠습니다.

TL;DR

@ege-özcan의 매우 사랑스러운 답변에 기반한 플러그형 버전입니다.

문제

아래와 같은 것을 발견하여 변경할 수 없었습니다.나는 또한 그 물체를 일시적으로 평평하게 만들고 싶지 않았다.또한 성능상의 이유와 직접 구현의 재미를 위해 언더스코어/로다시를 사용하고 싶지도 않았습니다.

var People = [
   {Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
   {Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
   {Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];

목표

목표는 주로 다음과 같이 분류하는 것입니다.People.Name.name 둘째로는 그 and and and and and and and and and and andPeople.Name.surname

장애물

기본 솔루션에서는 괄호 표기법을 사용하여 동적으로 정렬할 속성을 계산합니다. ,, 기, 기, 여, 여, 여, 여, 여, notation, notation, notation, notation, notation, notation, notation, notation, notation, notation, notation, notation, notation, notation, notation, notation, notation, like, like, like, People['Name.name']★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

하는 것만으로People['Name']['name']한편, 는 스태틱이며, n번째 레벨로 내려갈 수 있습니다.

솔루션

여기서의 주요 추가 사항은 오브젝트 트리를 따라 내려가 사용자가 지정해야 하는 마지막 리프 및 중간 리프 값을 결정하는 것입니다.

var People = [
   {Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
   {Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
   {Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];

People.sort(dynamicMultiSort(['Name','name'], ['Name', '-surname']));
// Results in...
// [ { Name: { name: 'AAA', surname: 'ZZZ' }, Middlename: 'Abrams' },
//   { Name: { name: 'Name', surname: 'Surname' }, Middlename: 'JJ' },
//   { Name: { name: 'Name', surname: 'AAA' }, Middlename: 'Wars' } ]

// same logic as above, but strong deviation for dynamic properties 
function dynamicSort(properties) {
  var sortOrder = 1;
  // determine sort order by checking sign of last element of array
  if(properties[properties.length - 1][0] === "-") {
    sortOrder = -1;
    // Chop off sign
    properties[properties.length - 1] = properties[properties.length - 1].substr(1);
  }
  return function (a,b) {
    propertyOfA = recurseObjProp(a, properties)
    propertyOfB = recurseObjProp(b, properties)
    var result = (propertyOfA < propertyOfB) ? -1 : (propertyOfA > propertyOfB) ? 1 : 0;
    return result * sortOrder;
  };
}

/**
 * Takes an object and recurses down the tree to a target leaf and returns it value
 * @param  {Object} root - Object to be traversed.
 * @param  {Array} leafs - Array of downwards traversal. To access the value: {parent:{ child: 'value'}} -> ['parent','child']
 * @param  {Number} index - Must not be set, since it is implicit.
 * @return {String|Number}       The property, which is to be compared by sort.
 */
function recurseObjProp(root, leafs, index) {
  index ? index : index = 0
  var upper = root
  // walk down one level
  lower = upper[leafs[index]]
  // Check if last leaf has been hit by having gone one step too far.
  // If so, return result from last step.
  if (!lower) {
    return upper
  }
  // Else: recurse!
  index++
  // HINT: Bug was here, for not explicitly returning function
  // https://stackoverflow.com/a/17528613/3580261
  return recurseObjProp(lower, leafs, index)
}

/**
 * Multi-sort your array by a set of properties
 * @param {...Array} Arrays to access values in the form of: {parent:{ child: 'value'}} -> ['parent','child']
 * @return {Number} Number - number for sort algorithm
 */
function dynamicMultiSort() {
  var args = Array.prototype.slice.call(arguments); // slight deviation to base

  return function (a, b) {
    var i = 0, result = 0, numberOfProperties = args.length;
    // REVIEW: slightly verbose; maybe no way around because of `.sort`-'s nature
    // Consider: `.forEach()`
    while(result === 0 && i < numberOfProperties) {
      result = dynamicSort(args[i])(a, b);
      i++;
    }
    return result;
  }
}

예

JSBin에서의 작업 예시

또 하나의 옵션:

var someArray = [...];

function generateSortFn(prop, reverse) {
    return function (a, b) {
        if (a[prop] < b[prop]) return reverse ? 1 : -1;
        if (a[prop] > b[prop]) return reverse ? -1 : 1;
        return 0;
    };
}

someArray.sort(generateSortFn('name', true));

기본적으로는 오름차순 정렬합니다.

간단한 방법:

objs.sort(function(a,b) {
  return b.last_nom.toLowerCase() < a.last_nom.toLowerCase();
});

를 참조해 주세요.'.toLowerCase()'스트링 비교 시 에러스를 방지하기 위해 필요합니다.

속성별로 객체 배열을 정렬하는 단순 함수입니다.

function sortArray(array, property, direction) {
    direction = direction || 1;
    array.sort(function compare(a, b) {
        let comparison = 0;
        if (a[property] > b[property]) {
            comparison = 1 * direction;
        } else if (a[property] < b[property]) {
            comparison = -1 * direction;
        }
        return comparison;
    });
    return array; // Chainable
}

사용방법:

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

sortArray(objs, "last_nom"); // Asc
sortArray(objs, "last_nom", -1); // Desc

이에 대한 제 견해는 이렇습니다.

order파라미터는 옵션이며 오름차순의 경우 기본적으로 "ASC"로 설정됩니다.

악센트가 있는 문자에서 작동하며 대소문자를 구분하지 못합니다.

메모: 원래 어레이를 정렬하여 반환합니다.

function sanitizeToSort(str) {
  return str
    .normalize('NFD')                   // REMOVE ACCENTED AND DIACRITICS
    .replace(/[\u0300-\u036f]/g,'')     // REMOVE ACCENTED AND DIACRITICS
    .toLowerCase()                      // SORT WILL BE CASE INSENSITIVE
  ;
}

function sortByProperty(arr, property, order="ASC") {
  arr.forEach((item) => item.tempProp = sanitizeToSort(item[property]));
  arr.sort((a,b) => order === "ASC" ?
      a.tempProp > b.tempProp ?  1 : a.tempProp < b.tempProp ? -1 : 0
    : a.tempProp > b.tempProp ? -1 : a.tempProp < b.tempProp ?  1 : 0
  );
  arr.forEach((item) => delete item.tempProp);
  return arr;
}

단편

function sanitizeToSort(str) {
  return str
    .normalize('NFD')                   // REMOVE ACCENTED CHARS
    .replace(/[\u0300-\u036f]/g,'')     // REMOVE DIACRITICS
    .toLowerCase()
  ;
}

function sortByProperty(arr, property, order="ASC") {
  arr.forEach((item) => item.tempProp = sanitizeToSort(item[property]));
  arr.sort((a,b) => order === "ASC" ?
      a.tempProp > b.tempProp ?  1 : a.tempProp < b.tempProp ? -1 : 0
    : a.tempProp > b.tempProp ? -1 : a.tempProp < b.tempProp ?  1 : 0
  );
  arr.forEach((item) => delete item.tempProp);
  return arr;
}

const rockStars = [
  { name: "Axl",
    lastname: "Rose" },
  { name: "Elthon",
    lastname: "John" },
  { name: "Paul",
    lastname: "McCartney" },
  { name: "Lou",
    lastname: "Reed" },
  { name: "freddie",             // WORKS ON LOWER/UPPER CASE
    lastname: "mercury" },
  { name: "Ámy",                 // WORKS ON ACCENTED CHARS TOO
    lastname: "winehouse"}
  
];

sortByProperty(rockStars,"name");

console.log("Ordered by name A-Z:");
rockStars.forEach((item) => console.log(item.name + " " + item.lastname));

sortByProperty(rockStars,"lastname","DESC");

console.log("\nOrdered by lastname Z-A:");
rockStars.forEach((item) => console.log(item.lastname + ", " + item.name));

경!!
이 솔루션은 배열이 정렬되지 않으므로 사용하지 않는 것이 좋습니다.그 아이디어는 드물지 않기 때문에 나중에 참고할 수 있도록 여기에 남겨져 있다.

objs.sort(function(a,b){return b.last_nom>a.last_nom})

Ege의 역동적인 솔루션과 Vinay의 아이디어를 결합하면 다음과 같은 우수한 견고한 솔루션을 얻을 수 있습니다.

Array.prototype.sortBy = function() {
  function _sortByAttr(attr) {
    var sortOrder = 1;
    if (attr[0] == "-") {
      sortOrder = -1;
      attr = attr.substr(1);
    }
    return function(a, b) {
      var result = (a[attr] < b[attr]) ? -1 : (a[attr] > b[attr]) ? 1 : 0;
      return result * sortOrder;
    }
  }

  function _getSortFunc() {
    if (arguments.length == 0) {
      throw "Zero length arguments not allowed for Array.sortBy()";
    }
    var args = arguments;
    return function(a, b) {
      for (var result = 0, i = 0; result == 0 && i < args.length; i++) {
        result = _sortByAttr(args[i])(a, b);
      }
      return result;
    }
  }
  return this.sort(_getSortFunc.apply(null, arguments));
}

Usage:

  // Utility for printing objects
  Array.prototype.print = function(title) {
    console.log("************************************************************************");
    console.log("**** " + title);
    console.log("************************************************************************");
    for (var i = 0; i < this.length; i++) {
      console.log("Name: " + this[i].FirstName, this[i].LastName, "Age: " + this[i].Age);
    }
  }

// Setup sample data
var arrObj = [{
    FirstName: "Zach",
    LastName: "Emergency",
    Age: 35
  },
  {
    FirstName: "Nancy",
    LastName: "Nurse",
    Age: 27
  },
  {
    FirstName: "Ethel",
    LastName: "Emergency",
    Age: 42
  },
  {
    FirstName: "Nina",
    LastName: "Nurse",
    Age: 48
  },
  {
    FirstName: "Anthony",
    LastName: "Emergency",
    Age: 44
  },
  {
    FirstName: "Nina",
    LastName: "Nurse",
    Age: 32
  },
  {
    FirstName: "Ed",
    LastName: "Emergency",
    Age: 28
  },
  {
    FirstName: "Peter",
    LastName: "Physician",
    Age: 58
  },
  {
    FirstName: "Al",
    LastName: "Emergency",
    Age: 51
  },
  {
    FirstName: "Ruth",
    LastName: "Registration",
    Age: 62
  },
  {
    FirstName: "Ed",
    LastName: "Emergency",
    Age: 38
  },
  {
    FirstName: "Tammy",
    LastName: "Triage",
    Age: 29
  },
  {
    FirstName: "Alan",
    LastName: "Emergency",
    Age: 60
  },
  {
    FirstName: "Nina",
    LastName: "Nurse",
    Age: 54
  }
];

//Unit Tests
arrObj.sortBy("LastName").print("LastName Ascending");
arrObj.sortBy("-LastName").print("LastName Descending");
arrObj.sortBy("LastName", "FirstName", "-Age").print("LastName Ascending, FirstName Ascending, Age Descending");
arrObj.sortBy("-FirstName", "Age").print("FirstName Descending, Age Ascending");
arrObj.sortBy("-Age").print("Age Descending");

Ege Ozcan 코드에 대한 추가 설명 매개 변수

function dynamicSort(property, desc) {
    if (desc) {
        return function (a, b) {
            return (a[property] > b[property]) ? -1 : (a[property] < b[property]) ? 1 : 0;
        }   
    }
    return function (a, b) {
        return (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
    }
}

원래의 예를 다음에 나타냅니다.

var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

여러 필드별로 정렬:

objs.sort(function(left, right) {
    var last_nom_order = left.last_nom.localeCompare(right.last_nom);
    var first_nom_order = left.first_nom.localeCompare(right.first_nom);
    return last_nom_order || first_nom_order;
});

메모들

a.localeCompare(b)일반적으로 지원되며 -1,0,1을 반환합니다.a<b ,a==b ,a>b각각 다음과 같다.
|| 것은 " " " 입니다.last_nom over 」first_nom.
됩니다.var age_order = left.age - right.age;
하다.return -last_nom_order || -first_nom_order || -age_order;

function compare(propName) {
    return function(a,b) {
        if (a[propName] < b[propName])
            return -1;
        if (a[propName] > b[propName])
            return 1;
        return 0;
    };
}

objs.sort(compare("last_nom"));

람다를 사용하여

npm 설치 ramda

import R from 'ramda'
var objs = [ 
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];
var ascendingSortedObjs = R.sortBy(R.prop('last_nom'), objs)
var descendingSortedObjs = R.reverse(ascendingSortedObjs)

언급URL : https://stackoverflow.com/questions/1129216/sort-array-of-objects-by-string-property-value

'source' 카테고리의 다른 글

PHP에서 GET 요청을 보내려면 어떻게 해야 합니까? (0)	2022.10.30
jQuery를 사용하여 픽셀 단위의 패딩 또는 여백 값(픽셀 단위) (0)	2022.10.30
Selenium WebDriver에서 JavaScript를 사용하여 XPath로 요소를 가져오는 방법이 있습니까? (0)	2022.10.30
이행 시 부동이지만 이중화되지 않는 필드를 작성하는 방법 (0)	2022.10.30
테이블 nestj 자동 생성에 대한 TypeORM 요청 (0)	2022.10.30

현재글문자열 속성 값을 기준으로 개체 배열 정렬

각종 프로그래밍 정보를 다루는 블로그입니다.

SWiFT, AngularJS, spring-boot, Excel, JavaScript, JSON, MySQL, C, reactjs, WordPress, oracle, Ajax, Python, mariaDB, PHP, vuejs2, Java, vuex, WPF, sql-server,

Today :
Yesterday :

gigabyte

문자열 속성 값을 기준으로 개체 배열 정렬

문자열 속성 값을 기준으로 개체 배열 정렬

다중 파라미터

어레이 서브클래싱

가장 쉬운 방법: Lodash

★★의 `sortBy()`

를 사용합니다.`sort`

복잡한 객체 배열 정렬(더 많은)

TL;DR

문제

목표

장애물

솔루션

예

'source' 카테고리의 다른 글

'source'의 다른글

티스토리툴바

« 2025/01 »
일	월	화	수	목	금	토
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

문자열 속성 값을 기준으로 개체 배열 정렬

문자열 속성 값을 기준으로 개체 배열 정렬

다중 파라미터

어레이 서브클래싱

가장 쉬운 방법: Lodash

★★의 sortBy()

를 사용합니다.sort

복잡한 객체 배열 정렬(더 많은)

TL;DR

문제

목표

장애물

솔루션

예

'source' 카테고리의 다른 글

'source'의 다른글

관련글

티스토리툴바

★★의 `sortBy()`

를 사용합니다.`sort`