Array.prototype.sort()
Il metodo sort()
ordina gli elementi di un array in place e ritorna l'array. L'ordinamento non è necessariamente stable. L'ordinamento predefinito è in base ai punti di codice Unicode della stringa.
Il tempo e la complessità dell'ordinamento dipendono dall'implementazione, perciò non possono essere garantiti.
var fruit = ['cherries', 'apples', 'bananas'];
fruit.sort(); // ['apples', 'bananas', 'cherries']
var scores = [1, 10, 21, 2];
scores.sort(); // [1, 10, 2, 21]
// Nota che 10 viene prima di 2,
// perché '10' è l'insieme di due caratteri '1' e '0' così '10' viene prima di '2' nell'ordine dei codici Unicode code .
var things = ['word', 'Word', '1 Word', '2 Words'];
things.sort(); // ['1 Word', '2 Words', 'Word', 'word']
// In Unicode, i numeri vengono prima delle lettere maiuscole,
// che vengono prima delle lettere minuscole.
Sintassi
arr.sort() arr.sort([compareFunction])
Parametri
compareFunction
Optional- Specifica una funzione che definisce il tipo di ordinamento. Se viene omessa, l'array è ordinato in base ai valori dei suoi caratteri Unicode code , basandosi sulle stringhe di ogni elemento convertito.
Valore ritornato
L'array ordinato. Nota che l'array è ordinato in place, e non viene fatta alcuna copia.
Descrizione
Se non viene fornita una compareFunction
, gli elementi vengono ordinati convertendoli in stringhe e confrontando le stringhe nell'ordine dei codici Unicode . Per esempio, "Banana" viene prima di "cherry". In ordine numerico, 9 arriva prima dell'80, ma poiché i numeri vengono convertiti in stringhe, "80" viene prima di "9" nell'ordine Unicode.
Se viene fornita una compareFunction
, gli elementi dell'array vengono ordinati in base al valore restituito della funzione di confronto. Se a e b sono due elementi da confrontare, allora:
- Se
compareFunction(a, b)
è minore di 0, posizionaa
in un indice inferiore dib
, quindia
viene prima. - Se
compareFunction(a, b)
ritorna 0, lasciaa
eb
invariati l'uno rispetto all'altro, ma ordinati rispetto a tutti i diversi elementi. Nota: lo standard ECMAscript non garantisce questo comportamento, quindi non tutti i browser (ad esempio versioni di Mozilla risalenti almeno al 2003) rispettano questo. - Se
compareFunction(a, b)
è maggiore di 0, posizionab
con un indice più basso dia
, cioèb
viene prima. compareFunction(a, b)
deve sempre restituire lo stesso valore quando viene data una coppia specifica di elementi a e b come i suoi due argomenti. Se vengono restituiti risultati non coerenti, l'ordinamento non è definito.
Quindi, la funzione di confronto ha la seguente forma:
function compare(a, b) {
if (a è inferiore a b secondo un criterio di ordinamento) {
return -1;
}
if (a è maggiore di b secondo un criterio di ordinamento) {
return 1;
}
// a deve essere uguale a b
return 0;
}
Per confrontare i numeri anziché le stringhe, la funzione di confronto può semplicemente sottrarre b
da a
. La seguente funzione ordinerà l'array in ordine crescente (se non contiene Infinity
e NaN
):
function compareNumbers(a, b) {
return a - b;
}
Il metodo sort
può essere usato bene con function expressions (en-US) ( e closures):
var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
return a - b;
});
console.log(numbers);
// [1, 2, 3, 4, 5]
ES2015 fornisce le arrow function, che consentono una sintassi più compatta:
let numbers = [4, 2, 5, 1, 3];
numbers.sort((a, b) => a - b);
console.log(numbers);
// [1, 2, 3, 4, 5]
Gli Object possono essere ordinati passando il valore di una delle loro proprietà.
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 }
];
// ordinamento per valore
items.sort(function (a, b) {
return a.value - b.value;
});
// ordinamento per nome
items.sort(function(a, b) {
var nameA = a.name.toUpperCase(); // ignora maiuscole e minuscole
var nameB = b.name.toUpperCase(); // ignora maiuscole e minuscole
if (nameA < nameB) {
return -1;
}
if (nameA > nameB) {
return 1;
}
// i nomi devono essere uguali
return 0;
});
Esempi
Creare, visualizzare, ed ordinare un array
L'esempio seguente crea quattro array , visualizza l'array originale e successivamente l'array ordinato. Gli array numerici sono ordinati prima senza e poi con una funzione di comparazione .
var stringArray = ['Blue', 'Humpback', 'Beluga'];
var numericStringArray = ['80', '9', '700'];
var numberArray = [40, 1, 5, 200];
var mixedNumericArray = ['80', '9', '700', 40, 1, 5, 200];
function compareNumbers(a, b) {
return a - b;
}
console.log('stringArray:', stringArray.join());
console.log('Ordinato:', stringArray.sort());
console.log('numberArray:', numberArray.join());
console.log('Ordinato senza funzione compare:', numberArray.sort());
console.log('Ordinato con compareNumbers:', numberArray.sort(compareNumbers));
console.log('numericStringArray:', numericStringArray.join());
console.log('Ordinato senza funzione compare:', numericStringArray.sort());
console.log('Ordinato con compareNumbers:', numericStringArray.sort(compareNumbers));
console.log('mixedNumericArray:', mixedNumericArray.join());
console.log('Ordinato senza funzione compare:', mixedNumericArray.sort());
console.log('Ordinato con compareNumbers:', mixedNumericArray.sort(compareNumbers));
Questo esempio produce il seguente output. Come viene mostrato, quando viene usata una funzione comparativa, i numeri vengono ordinati correttamente sia nel caso siano numeri che nel caso siano stringhe di numeri.
stringArray: Blue,Humpback,Beluga Ordinato: Beluga,Blue,Humpback numberArray: 40,1,5,200 Ordinato senza funzione compare: 1,200,40,5 Ordinato con compareNumbers: 1,5,40,200 numericStringArray: 80,9,700 Ordinato senza funzione compare: 700,80,9 Ordinato con compareNumbers: 9,80,700 mixedNumericArray: 80,9,700,40,1,5,200 Ordinato senza funzione compare: 1,200,40,5,700,80,9 Ordinato con compareNumbers: 1,5,9,40,80,200,700
Ordinare caratteri non-ASCII
Per ordinare stringhe con caratteri non-ASCII, cioè stringhe con caratteri accentati (e, é, è, a, ä, etc.), stringhe da lingue diverse dall'inglese: si usa String.localeCompare
(en-US). Questa funzione può confrontare quei caratteri in modo che compaiano nel giusto ordine.
var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];
items.sort(function (a, b) {
return a.localeCompare(b);
});
// items is ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']
Ordinare con map
La compareFunction
può essere invocata più volte per elemento all'interno dell'array. In base alla natura della compareFunction
, si potrebbe produrre un sovraccarico elevato. Maggiore è il lavoro svolto da compareFunction
e maggiori sono gli elementi da ordinare, potrebbe essere saggio utilizzare una map per l'ordinamento. L'idea è di percorrere una volta l'array per estrarre i valori effettivi usati per l'ordinamento in un array temporaneo, ordinare l'array temporaneo e quindi percorrere l'array temporaneo per ottenere l'ordine giusto.
// l'array da ordinare
var list = ['Delta', 'alpha', 'CHARLIE', 'bravo'];
// l'array temporaneo contiene oggetti con posizione e valore di ordinamento
var mapped = list.map(function(el, i) {
return { index: i, value: el.toLowerCase() };
})
// ordinamento dell'array mappato contenente i valori ridotti
mapped.sort(function(a, b) {
if (a.value > b.value) {
return 1;
}
if (a.value < b.value) {
return -1;
}
return 0;
});
// contenitore per l'ordine risultante
var result = mapped.map(function(el){
return list[el.index];
});
Specifiche
Specifica | Stato | Osservazione |
---|---|---|
ECMAScript 1st Edition (ECMA-262) | Standard | Definizione iniziale. |
ECMAScript 5.1 (ECMA-262) The definition of 'Array.prototype.sort' in that specification. |
Standard | |
ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Array.prototype.sort' in that specification. |
Standard | |
ECMAScript (ECMA-262) The definition of 'Array.prototype.sort' in that specification. |
Living Standard |
Compatibilità con il browser
BCD tables only load in the browser