Ragazzi sono figurativamente scioccato! Certo, tutte le risposte sono piuttosto vecchie, ma nessuno ha nemmeno menzionato la stabilità nell'ordinamento! Quindi abbi pazienza, farò del mio meglio per rispondere alla domanda stessa e per entrare nei dettagli qui. Quindi mi scuserò ora che sarà molto da leggere.
Dato che è il 2018 userò solo ES6, i Polyfill sono tutti disponibili nei documenti MDN, che collegherò alla parte data.
Rispondi alla domanda:
Se le tue chiavi sono solo numeri, puoi tranquillamente utilizzarlo Object.keys()insieme Array.prototype.reduce()per restituire l'oggetto ordinato:
// Only numbers to show it will be sorted.
const testObj = {
'2000': 'Articel1',
'4000': 'Articel2',
'1000': 'Articel3',
'3000': 'Articel4',
};
// I'll explain what reduces does after the answer.
console.log(Object.keys(testObj).reduce((accumulator, currentValue) => {
accumulator[currentValue] = testObj[currentValue];
return accumulator;
}, {}));
/**
* expected output:
* {
* '1000': 'Articel3',
* '2000': 'Articel1',
* '3000': 'Articel4',
* '4000': 'Articel2'
* }
*/
// if needed here is the one liner:
console.log(Object.keys(testObj).reduce((a, c) => (a[c] = testObj[c], a), {}));
Tuttavia, se lavori con le stringhe, ti consiglio vivamente di concatenare Array.prototype.sort()tutto ciò:
// String example
const testObj = {
'a1d78eg8fdg387fg38': 'Articel1',
'z12989dh89h31d9h39': 'Articel2',
'f1203391dhj32189h2': 'Articel3',
'b10939hd83f9032003': 'Articel4',
};
// Chained sort into all of this.
console.log(Object.keys(testObj).sort().reduce((accumulator, currentValue) => {
accumulator[currentValue] = testObj[currentValue];
return accumulator;
}, {}));
/**
* expected output:
* {
* a1d78eg8fdg387fg38: 'Articel1',
* b10939hd83f9032003: 'Articel4',
* f1203391dhj32189h2: 'Articel3',
* z12989dh89h31d9h39: 'Articel2'
* }
*/
// again the one liner:
console.log(Object.keys(testObj).sort().reduce((a, c) => (a[c] = testObj[c], a), {}));
Se qualcuno si chiede cosa riduce:
// Will return Keys of object as an array (sorted if only numbers or single strings like a,b,c).
Object.keys(testObj)
// Chaining reduce to the returned array from Object.keys().
// Array.prototype.reduce() takes one callback
// (and another param look at the last line) and passes 4 arguments to it:
// accumulator, currentValue, currentIndex and array
.reduce((accumulator, currentValue) => {
// setting the accumulator (sorted new object) with the actual property from old (unsorted) object.
accumulator[currentValue] = testObj[currentValue];
// returning the newly sorted object for the next element in array.
return accumulator;
// the empty object {} ist the initial value for Array.prototype.reduce().
}, {});
Se necessario, ecco la spiegazione per la copertina:
Object.keys(testObj).reduce(
// Arrow function as callback parameter.
(a, c) =>
// parenthesis return! so we can safe the return and write only (..., a);
(a[c] = testObj[c], a)
// initial value for reduce.
,{}
);
Perché l'ordinamento è un po 'complicato:
In breve Object.keys()restituirà un array con lo stesso ordine che otteniamo con un normale ciclo:
const object1 = {
a: 'somestring',
b: 42,
c: false
};
console.log(Object.keys(object1));
// expected output: Array ["a", "b", "c"]
Object.keys () restituisce un array i cui elementi sono stringhe corrispondenti alle proprietà enumerabili trovate direttamente sull'oggetto. L'ordinamento delle proprietà è uguale a quello fornito eseguendo il ciclo manualmente sulle proprietà dell'oggetto.
Sidenote: è possibile utilizzare anche Object.keys()su array, tenere presente che l'indice verrà restituito:
// simple array
const arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']
Ma non è così facile come mostrato da quegli esempi, gli oggetti del mondo reale possono contenere numeri e caratteri alfabetici o persino simboli (per favore non farlo).
Ecco un esempio con tutti in un oggetto:
// This is just to show what happens, please don't use symbols in keys.
const testObj = {
'1asc': '4444',
1000: 'a',
b: '1231',
'#01010101010': 'asd',
2: 'c'
};
console.log(Object.keys(testObj));
// output: [ '2', '1000', '1asc', 'b', '#01010101010' ]
Ora se usiamo Array.prototype.sort()sull'array sopra l'output cambia:
console.log(Object.keys(testObj).sort());
// output: [ '#01010101010', '1000', '1asc', '2', 'b' ]
Ecco una citazione dai documenti:
Il metodo sort () ordina gli elementi di un array sul posto e restituisce l'array. L'ordinamento non è necessariamente stabile. L'ordinamento predefinito è in base ai punti di codice Unicode stringa.
La complessità temporale e spaziale dell'ordinamento non può essere garantita in quanto dipende dall'implementazione.
Devi assicurarti che uno di essi restituisca l'output desiderato per te. Negli esempi di vita reale le persone tendono a mescolare le cose soprattutto se si utilizzano insieme input di informazioni diverse come API e database.
Quindi qual è il grosso problema?
Bene, ci sono due articoli che ogni programmatore dovrebbe capire:
Algoritmo sul posto :
Nell'informatica, un algoritmo sul posto è un algoritmo che trasforma l'input senza alcuna struttura di dati ausiliaria. Tuttavia, è consentita una piccola quantità di spazio di archiviazione aggiuntivo per le variabili ausiliarie. L'input viene in genere sovrascritto dall'output durante l'esecuzione dell'algoritmo. L'algoritmo sul posto aggiorna la sequenza di input solo attraverso la sostituzione o lo scambio di elementi. Un algoritmo che non è sul posto è talvolta chiamato non sul posto o fuori posto.
Quindi in pratica il nostro vecchio array verrà sovrascritto! Questo è importante se si desidera mantenere il vecchio array per altri motivi. Quindi tienilo a mente.
Algoritmo di ordinamento
Gli algoritmi di ordinamento stabili ordinano gli elementi identici nello stesso ordine in cui compaiono nell'input. Quando si ordinano alcuni tipi di dati, solo una parte dei dati viene esaminata quando si determina l'ordinamento. Ad esempio, nell'esempio di ordinamento delle carte a destra, le carte vengono ordinate in base al loro valore e il loro seme viene ignorato. Ciò consente la possibilità di più diverse versioni ordinate correttamente dell'elenco originale. Gli algoritmi di ordinamento stabile scelgono uno di questi, secondo la seguente regola: se due elementi si confrontano come uguali, come le due 5 carte, il loro ordine relativo verrà preservato, in modo che se uno venisse prima dell'altro nell'input, anche venire prima dell'altro nell'output.
Un esempio di ordinamento stabile sulle carte da gioco. Quando le carte sono ordinate per rango con un ordinamento stabile, i due 5 devono rimanere nello stesso ordine nell'output ordinato in cui erano originariamente. Quando sono ordinati con un ordinamento non stabile, i 5 possono finire nel contrario ordine nell'output ordinato.
Ciò dimostra che l'ordinamento è corretto ma è cambiato. Quindi, nel mondo reale, anche se l'ordinamento è corretto, dobbiamo assicurarci di ottenere ciò che ci aspettiamo! Questo è molto importante tenere presente anche questo. Per ulteriori esempi JavaScript, consultare Array.prototype.sort () - docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort
