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.

arr.sort()
arr.sort([compareFunction])

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.

L'array ordinato. Nota che l'array è ordinato in place, e non viene fatta alcuna copia.

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, posiziona a in un indice inferiore di b, quindi a viene prima.
• Se compareFunction(a, b) ritorna 0, lascia a e b 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, posiziona b con un indice più basso di a, 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;
});

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

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é']

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];
});

• Array.prototype.reverse()
• String.prototype.localeCompare() (en-US)