Sortuj tablicę według imienia (alfabetycznie) w JavaScript

Mam tablicę (patrz poniżej jeden obiekt w tablicy), którą muszę posortować według imienia za pomocą JavaScript. Jak mogę to zrobić?

var user = {
   bio: null,
   email:  "user@domain.com",
   firstname: "Anna",
   id: 318,
   lastAvatar: null,
   lastMessage: null,
   lastname: "Nickson",
   nickname: "anny"
};

Załóżmy, że masz tablicę users. Możesz użyćusers.sort i przekazać funkcję, która pobiera dwa argumenty i porównać je (komparator)

Powinien powrócić

• coś negatywnego, jeśli pierwszy argument jest mniejszy niż drugi (powinien zostać umieszczony przed drugim w wynikowej tablicy)
• coś pozytywnego, jeśli pierwszy argument jest większy (powinien zostać umieszczony po drugim)
• 0, jeśli te dwa elementy są równe.

W naszym przypadku, jeśli dwa elementy są ai bchcemy porównać a.firstnameib.firstname

Przykład:

users.sort(function(a, b){
    if(a.firstname < b.firstname) { return -1; }
    if(a.firstname > b.firstname) { return 1; }
    return 0;
})

Ten kod będzie działał z dowolnym typem.

Zauważ, że w „prawdziwym życiu” ™ często chcesz ignorować wielkość liter, poprawnie sortować znaki diakrytyczne, dziwne symbole, takie jak ß itp. Podczas porównywania ciągów, więc możesz chcieć użyć localeCompare. Zobacz inne odpowiedzi dla jasności.

Najkrótszy możliwy kod z ES6!

users.sort((a, b) => a.firstname.localeCompare(b.firstname))

Podstawowa obsługa String.prototype.localeCompare () jest uniwersalna!

Coś takiego:

array.sort(function(a, b){
 var nameA=a.name.toLowerCase(), nameB=b.name.toLowerCase();
 if (nameA < nameB) //sort string ascending
  return -1;
 if (nameA > nameB)
  return 1;
 return 0; //default return value (no sorting)
});

W porównaniu struny zawierać znaki Unicode można użyć localeComparefunkcji z Stringklasy tak:

users.sort(function(a,b){
    return a.firstname.localeCompare(b.firstname);
})

Miły mały jeden wkładka ES6:

users.sort((a, b) => a.firstname !== b.firstname ? a.firstname < b.firstname ? -1 : 1 : 0);

Możemy użyć localeCompare, ale musimy również sprawdzić klucze pod kątem wartości falsey

Poniższy kod nie będzie działał, jeśli brakuje jednej nazwy lname.

obj.sort((a, b) => a.lname.localeCompare(b.lname))

Musimy więc sprawdzić wartość falsey jak poniżej

let obj=[
{name:'john',lname:'doe',address:'Alaska'},
{name:'tom',lname:'hopes',address:'California'},
{name:'harry',address:'Texas'}
]
let field='lname';
console.log(obj.sort((a, b) => (a[field] || "").toString().localeCompare((b[field] || "").toString())));

LUB

możemy użyć lodash, to bardzo proste. Wykryje zwrócone wartości, tj. Liczbę lub ciąg znaków, i odpowiednio posortuje.

import sortBy from 'lodash/sortBy';
sortBy(obj,'name')

https://lodash.com/docs/4.17.5#sortBy

underscorejs oferuje bardzo przyjemną funkcję _.sortBy:

_.sortBy([{a:1},{a:3},{a:2}], "a")

lub możesz użyć niestandardowej funkcji sortowania:

_.sortBy([{a:"b"},{a:"c"},{a:"a"}], function(i) {return i.a.toLowerCase()})

W przypadku, gdy mamy do sortowania nazw lub coś ze znaków specjalnych, takich jak ń lub aeiou (świetlicy w języku hiszpańskim) możemy wykorzystać params lokalizacje ( es dla hiszpańskiego w tym przypadku) i opcje jak poniżej:

let user = [{'firstname': 'Az'},{'firstname': 'Áb'},{'firstname':'ay'},{'firstname': 'Ña'},{'firstname': 'Nz'},{'firstname': 'ny'}];


user.sort((a, b) => a.firstname.localeCompare(b.firstname, 'es', {sensitivity: 'base'}))


console.log(user)

Oficjalne opcje ustawień regionalnych można znaleźć tutaj w iana , es (hiszpański), de (niemiecki), fr (francuski). O podstawie wrażliwości oznacza:

Tylko ciągi, które różnią się literami podstawowymi, są porównywane jako nierówne. Przykłady: a ≠ b, a = á, a = A.

Zasadniczo możesz sortować tablice za pomocą metody sortowania, ale jeśli chcesz sortować obiekty, musisz przekazać funkcję, aby posortować metodę tablicy, więc dam ci przykład za pomocą tablicy

user = [{
bio: "<null>",
email: "user@domain.com",
firstname: 'Anna',
id: 318,
"last_avatar": "<null>",
"last_message": "<null>",
lastname: 'Nickson',
nickname: 'anny'
},
{
bio: "<null>",
email: "user@domain.com",
firstname: 'Senad',
id: 318,
"last_avatar": "<null>",
"last_message": "<null>",
lastname: 'Nickson',
nickname: 'anny'
},
{
bio: "<null>",
email: "user@domain.com",
firstname: 'Muhamed',
id: 318,
"last_avatar": "<null>",
"last_message": "<null>",
lastname: 'Nickson',
nickname: 'anny'
}];

var ar = user.sort(function(a, b)
{
  var nA = a.firstname.toLowerCase();
  var nB = b.firstname.toLowerCase();

  if(nA < nB)
    return -1;
  else if(nA > nB)
    return 1;
 return 0;
});

Zainspirowany tą odpowiedzią

users.sort((a,b) => (a.firstname  - b.firstname));

Bardziej zwarta notacja:

user.sort(function(a, b){
    return a.firstname === b.firstname ? 0 : a.firstname < b.firstname ? -1 : 1;
})

także dla sortowania asec i desc, możesz użyć tego: załóżmy, że mamy zmienną SortType, która określa sortowanie rosnące lub malejące, jakie chcesz:

 users.sort(function(a,b){
            return   sortType==="asc"? a.firstName.localeCompare( b.firstName): -( a.firstName.localeCompare(  b.firstName));
        })

Uogólnioną funkcję można zapisać jak poniżej

    function getSortedData(data, prop, isAsc) {
        return data.sort((a, b) => (a[prop] < b[prop] ? -1 : 1) * (isAsc ? 1 : -1));
   }

możesz przekazać poniższe parametry

1. Dane, które chcesz posortować
2. Właściwość w danych według niej powinna zostać posortowana
3. Ostatni parametr jest typu logicznego. Sprawdza, czy chcesz sortować rosnąco lub malejąco

próbować

users.sort((a,b)=> (a.firstname>b.firstname)*2-1)

var users = [
  { firstname: "Kate", id: 318, /*...*/ },
  { firstname: "Anna", id: 319, /*...*/ },
  { firstname: "Cristine", id: 317, /*...*/ },
]

console.log(users.sort((a,b)=> (a.firstname>b.firstname)*2-1) );

Możesz użyć tego do obiektów

transform(array: any[], field: string): any[] {
return array.sort((a, b) => a[field].toLowerCase() !== b[field].toLowerCase() ? a[field].toLowerCase() < b[field].toLowerCase() ? -1 : 1 : 0);}

jednym słowem możesz użyć tej metody

users.sort(function(a,b){return a.firstname < b.firstname ? -1 : 1});

Możesz użyć wbudowanej metody tablicowej sort. Ta metoda przyjmuje parametr zwrotny jako parametr

    // custom sort function to be passed as param/callback to the Array's sort method
    function myCustomSort(a, b) {
        return (a.toLowerCase() > b.toLowerCase()) ? 1 : -1;
    }

    // Actual method to be called by entity that needs sorting feature
    function sortStrings() {
        var op = Array.prototype.sort.call(arguments, myCustomSort);
    }

    // Testing the implementation
    var sortedArray = sortStrings("Burger", "Mayo1", "Pizza", "boxes", "Apples", "Mayo");
    console.log(sortedArray); //["Apples", "boxes", "Burger", "Mayo", "Mayo1", "Pizza"]

Kluczowe punkty, na które należy zwrócić uwagę, aby zrozumieć ten kod.

1. W tym przypadku metoda niestandardowa myCustomSortpowinna zwracać +1 lub -1 dla każdej pary elementów (z tablicy wejściowej).
2. Użyj toLowerCase()/ toUpperCase()w niestandardowej metodzie zwrotnej sortowania, aby różnica wielkości liter nie wpływała na poprawność procesu sortowania.

Mam nadzieję, że to dość jasne wytłumaczenie. Jeśli uważasz, że możesz dodać komentarz, potrzebujesz więcej informacji.

Twoje zdrowie!

Wrzuciłem najlepsze odpowiedzi do prototypu, aby posortować według klucza.

Array.prototype.alphaSortByKey= function (key) {
    this.sort(function (a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    });
    return this;
};

Możesz użyć czegoś podobnego, aby pozbyć się rozróżniania wielkości liter

users.sort(function(a, b){

  //compare two values
  if(a.firstname.toLowerCase() < b.firstname.toLowerCase()) return -1;
  if(a.firstname.toLowerCase() > b.firstname.toLowerCase()) return 1;
  return 0;

})

Moja implementacja działa świetnie w starszych wersjach ES:

sortObject = function(data) {
    var keys = Object.keys(data);
    var result = {};

    keys.sort();

    for(var i = 0; i < keys.length; i++) {
        var key = keys[i];

        result[key] = data[key];
    }

    return result;
};

Dla przypomnienia, jeśli chcesz mieć nazwaną funkcję sortowania, składnia jest następująca:

let sortFunction = (a, b) => {
 if(a.firstname < b.firstname) { return -1; }
 if(a.firstname > b.firstname) { return 1; }
 return 0;
})
users.sort(sortFunction)

Pamiętaj, że następujące NIE działa:

users.sort(sortFunction(a,b))