나는 배열입니다 JavaScript 객체:
var objs = [
{ first_nom: 'Lazslo', last_nom: 'Jamf' },
{ first_nom: 'Pig', last_nom: 'Bodine' },
{ first_nom: 'Pirate', last_nom: 'Prentice' }
];
'그들' 의 JavaScript 의 값에 따라 last_nom 정렬하려면 어떻게 해야 합니까?
(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 마르코 데마이어):
objs.sort((a,b) => (a.last_nom > b.last_nom) ? 1 : ((b.last_nom > a.last_nom) ? -1 : 0));
동적 기능을 통해 자신의 가치를 신규인지 객체에는 만들 수도 있습니다 정렬하려면 전달하십시오 합니다.
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"}
];
이 작업을 할 때 .and 작동합니다.
People.sort(dynamicSort("Name"));
People.sort(dynamicSort("Surname"));
People.sort(dynamicSort("-Surname"));
실제로 이 질문에 대한 답을 이미. 때문에 많은 사람들이 나를 부품이 기록되었으므로 아래에 있는) 에 불만을 it doesn& # 39, t 작동합니까 여러 매개변수입니다.
아래 여러 기능을 사용할 수 있는 기능을 발령합니다 정렬하려면 정렬하려면 매개변수입니다.
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.apply(null, args));
}
}
그렇게 되면 이 활성화하십시오.
MyArray.from(People).sortBy("Name", "-Surname");
[7]: https://github.com/zenparsing/es-function-bind " 바인딩하지 작동자 proposal";
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)
});
[언더스코엘가이스] [1]
밑줄, 크기가 작아 사용 및 멋집니다.
>. sortBy_.sortBy (목록, 반복자가 [컨텍스트로]) 는 되돌려줍니다 정렬할지 복제본입니다 >. 랭킹 오름차순으로 실행 결과를 통해 각 값마다 목록 >. 통해 반복자가. String name 속성 반복자가 될 수도 있습니다. >. 정렬하려면 (예: 길이).
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' );
[1]: http://underscorejs.org/ # 조르트비
이 문제에 대한 해결 방안을 쉽고 빠르게 프로토타입을 사용하는 상속:
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"}]
2018년 기준으로, 우아한 솔루션이므로 훨씬 짧은 있습니다. 됩니다. 아리스프로토티페이소르 ().
예:
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;
});
사용자 정의 비교 함수를 사용하여 문자를 사용하는 대신, 객체를 만들 수도 있습니다 () '맞춤형' tostring 방법, 즉 비교 함수를 호출하는 기본값입니다):
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();
(https://lodash.com/docs/4.17.10 # 러더비)
이 방법은 이 같은 점을 제외하고는 정렬 순서를 정렬하려면 이트라테스 _.sortBy 지정할 수 있다. 이 경우, 모든 값은 명령이라구요 미지정을 오름차순으로 정렬된. 그렇지 않으면, desc" 대체하십시오 " 목이다. 또는 " 대한 내림차순을 asc"; 올림차순 정렬 순서를 대해 해당 속성값으로.
수집 (어레이입니다 객체): The collection 반복할. [이트라테스 = [_.identity]] ([] [] [] 객체에는 어레이입니다 함수은 문자열 []). 이 이트라테스 정렬하려면. [명령이라구요] (문자열 []). 이 정렬 순서를 이트라테스 있다.
(Array): 새로운 되돌려줍니다 정렬할지 어레이입니다.
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']);
함수형 프로그래밍 코드를 만들어 청소하십시오 로다시 개선하고 더 스타일, 이로 인해 매우 적은 버그. 이 코드는 보는 경우 어떤 의도를 분명히 한 됩니다.
const sortedObjs = _.sortBy(objs, 'last_nom');
자세한 정보? E. g. 우리는 다음과 같은 네스트된 객체에는:
const users = [
{ 'user': {'name':'fred', 'age': 48}},
{ 'user': {'name':'barney', 'age': 36 }},
{ 'user': {'name':'wilma'}},
{ 'user': {'name':'betty', 'age': 32}}
];
[_.Property] [3] 이제 사용할 수 있는 경로를 지정합니다 저리지 '대표' 속성 할 일치시킵니다. 사용자가 대화할거에요 정렬하려면 의해 객체에는 네스트된 기간보다오래된 재산이잖아 예, 이 네스트된 속성 일치하는 사용할 수 있습니다!
const sortedObjs = _.sortBy(users, ['user.age']);
반전됩니다 want it? 괜찮서라 [_.Reverse] [4] 사용합니다.
const sortedObjs = _.reverse(_.sortBy(users, ['user.age']));
[체인식으로 연결] [5] 모두 합칩니다 정렬할지 사용하는 대신?
const sortedObjs = _.chain(users).sortBy('user.age').reverse().value();
[3]: https://lodash.com/docs/4.17.4 # 속성 [4]: https://lodash.com/docs/4.17.4 # 역동기화 [5]: https://lodash.com/docs/4.17.4 # 체인
하지만 여러 가지 좋은 점을 지적하고 싶다 여기에 대답을 얻기 위해 매우 복잡한 분류 단순히 훨씬 더 연장될 수 있습니다. 할 일은 정말 유일한 OR 연산자를 사용하여 다음과 같은 기능을 체인으로 비교
objs.sort((a,b)=> fn1(a,b) || fn2(a,b) || fn3(a,b) )
여기서 'fn1 fn2', ','. [- 1.0,1] 복귀하십시오 정렬하려면 있는 기능이 있다. 그 결과,, fn1" 순으로 정렬 " " fn2" 순으로 정렬. sql 에서 오더하려면 원하는거요 거의 같다.
이 솔루션은 '평가' 를 기반으로 하는 동작은 연산자입니다 [첫 번째 평가하실 표현식에서는 변환될 수 있는 진정한] [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])
이 기능을 확장할 수 있을 경우, 데이터 형식, 숫자 필드용 지원하기 위해 센스티티 인해 임의 상술합니다.
이 기능을 사용하여 체인식으로 연결 정렬하려면 우선_순위 함으로써 이를 수 있습니다.
// 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 를 기능 외곽진입 너희에의 시행하십시오 코드. 또한 매우 효과적인 방법이 없으므로 문자열 구문 분석 작업을 수행해야 한다.
[1]: # Logical_operators https://developer.mozilla.org/en-us/docs/web/javascript/guide/expressions_and_operators [2]: # 매개변수입니다 https://developer.mozilla.org/en-us/docs/web/javascript/reference/global_objects/string/localecompare
사용 예시:
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;
};
};
내가 본 haven& # 39, t, s # 39 는 특정 외곽진입 제안됩니다 도왔으매 here& 간결한 싶어요 '문자열 비교 방법을 사용하여 모두 적합한' 와 '숫자'.
<! - begin 스니핏: js 숨기십시오: 거짓값 콘솔: 진정한 바벨. > 거짓값 -;
const objs = [
{ first_nom: 'Lazslo', last_nom: 'Jamf' },
{ first_nom: 'Pig', last_nom: 'Bodine' },
{ first_nom: 'Pirate', last_nom: 'Prentice' }
];
const sortBy = fn => (a, b) => {
const fa = fn(a)
const fb = fn(b)
return -(fa < fb) || +(fa > fb)
}
const getLastName = o => o.last_nom
const sortByLastName = sortBy(getLastName)
objs.sort(sortByLastName)
console.log(objs.map(getLastName))
끝 - < 스니핏 >;!
'조르트비 ()' 에서 'a' 로 사용할 수 있는 어떤 가치를 fn 선택함 객체에는 되돌려줍니다 직접 전달될 수 있는 '아리스프로토티페이소르 비교, 함수 ()'. 이 예에서 보는 순간 ',' 를 사용하여 o.last_nom we& # 39 의 값을 비교, 그래서 우리는 두 개의 천체 () '등' 아리스프로토티페이소르 통해 받을 때마다
{ first_nom: 'Lazslo', last_nom: 'Jamf' }
및
{ first_nom: 'Pig', last_nom: 'Bodine' }
우리가 사용하는
(a, b) => {
const fa = fn(a)
const fb = fn(b)
return -(fa < fb) || +(fa > fb)
}
그 비교할 수 있습니다.
기억해야 할 것 '>, fn = o = '우리는 할 수 있는 기능을 avamer 확장하십시오 o.last_nom 비교
(a, b) => {
const fa = a.last_nom
const fb = b.last_nom
return -(fa < fb) || +(fa > fb)
}
if (fa < fb) return -1
return +(fa > fb)
만일 'fa <. '-', ',' 우리는 그렇지 않은 경우 fa > 복귀하십시오 fb 그리고 우리는 ',' +1 = fb fb '복귀하십시오 신앙이니라' '다음' fa, fa < fb '와' fa >. fb '이' 거짓 '때문에' +0 되돌려줍니다 '.
<! - begin 스니핏: js 숨기십시오: 거짓값 콘솔: 진정한 바벨. > 거짓값 -;
var objs = [
{ first_nom: 'Lazslo', last_nom: 'Jamf' },
{ first_nom: 'Pig', last_nom: 'Bodine' },
{ first_nom: 'Pirate', last_nom: 'Prentice' }
];
var sortBy = function (fn) {
return function (a, b) {
var fa = fn(a)
var fb = fn(b)
return -(fa < fb) || +(fa > fb)
}
}
var getLastName = function (o) { return o.last_nom }
var sortByLastName = sortBy(getLastName)
objs.sort(sortByLastName)
console.log(objs.map(getLastName))
끝 - < 스니핏 >;!
하지만 난 그러니까말이야 이 질문은 너무 나이가 비슷한 내거냐 구축현 didn& # 39, 볼 수 없다. 이 버전은 따라 [슈바르츠이언 변형 관용구] (https://en.wikipedia.org/wiki/Schwartzian_transform).
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);
}
예를 들어 here& # 39 의 how to use it.
let games = [
{ name: 'Pako', 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'));
아마 나라면 이렇게 만난 이후 더 복잡한 데이터 구조를 어레이이며 확장하십시오 솔루션입니다.
>. 더 많이 플러깅이 지원되는 기반한 확장본을 [@ege-& # 214, 스칸], [답변] 아주 멋진 & # 39 (https://stackoverflow.com/users/300011/ege-%C3%96zcan) (https://stackoverflow.com/a/4760279/3580261).
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' 과 '에서' 피오프레스나미.서나미 부수적으로 정렬하려면 주로 정보기술 (it)
이제 브래킷에서 표기법을 사용하여 계산할 수 있는 기본 솔루션 정렬하려면 속성을 동적으로. 하지만 여기 있을 뿐만 아니라 고객이 기대하는 것 때문에 무중단으로 chunghwa 브래킷에 표기법 (Name.name) ' [& # 39, 일부 사람들은' t # 39, & # 39;] - 어떤 doesn& 협력할 것이라고 말했다.
하는 사람들은 단순히 ' [& # 39, Name& # 39;] [# 39, & # 39, name&]' 는 낮아질 수 있는 반면, 정적 유일한 레벨이네 n-t *
여기에서 주 걷는 게 아니라 다운되어도 객체에는 진단트리는 결정하고, 마지막 잎새 값을 지정해야 할 뿐만 아니라 모든 중간 이용하지 않는다.
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;
}
}
Apc® 예 [켜짐이 이스빈] (http://jsbin.com/lotifa/2/edit? js, 콘솔)
한 번 더 옵션:
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));
기본적으로 올림차순 신규인지.
간단한 함수를 통해 해당 정렬함으로써 배열입니다 객체에는 속성
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