.sort()

Il metodo sort() ordina gli elementi di un array sul posto e restituisce il riferimento allo stesso array, ora ordinato. L'ordinamento predefinito è crescente basato sulla conversione degli elementi in stringhe, quindi sul confornto delle loro sequenze di valori delle unità di codice UTF-16. 

La complessità temporale e spaziale dell'ordinamento non può essere garantita in quanto dipende dall'implementazione.

Sintassi

// Functionless
sort()

// Arrow function
sort((a, b) => { /* … */ } )

// Compare function
sort(compareFn)

// Inline compare function
sort(function compareFn(a, b) { /* … */ })

Parametri

compareFn - opzionale: Specifica una funzione che definisce l'ordinamento. Se omesso, gli elementi dell'array vengono convertiti in stringhe, quindi ordinati in base al valore del punto di codice Unicode di ciascun carattere.

a : Il primo elemento di confronto.

b : il secondo elemento di confronto

Return

Il riferimento all'array originale, ora ordinato. Si noti che l'array viene ordinato sul posto e non viene eseguita alcuna copia.

Descrizione

Se compareFn non viene fornito, tutti gli elementi dell'array non definiti vengono ordinati convertendoli in stringhe e confrontando le stringhe nell'ordine di codice UTF-16. 

Ad  esempio, "banana" viene prima di "ciliegia". in un ordinamento numerico. In un ordinamento numerico "9" viene prima di "50" ma poichè i numeri vengono convertiti in stringhe, "50" viene prima di "9" nell'ordine Unicode. Tutti gli elemeti non definiti vengono ordinati alla fine dell'array.

Se viene fornito compareFn tutti gli elementi dell'array non definiti vengono ordinati in base al valore restituito dalla funzione di confronto (tutti gli elementi non definiti vengono ordinati alla fine dell'array, senza alcuna chiamata a compareFn) .

Quindi la funzione di confronto ha la seguente forma:

function compareFn(a, b) {
  if (a è minore di b) {
    return -1;
  }
  if (a è maggiore di b) {
    return 1;
  }
  // a è uguale b
  return 0;
}

Ci si aspetta che il comparatore abbia le seguenti proprietà al fine di garantire un corretto comportamento di ordinamento:

• Puro: Il comparatore non muta gli oggetti confrontati o qualsiasi stato esterno.
• Stabile: Il comparatore restituisce lo stesso risultato con la stessa coppia di input.
• Riflessivo: compareFn(a,a) === 0.
• Antisimmetrico: compareFn(a,b) e compareFn(b,a) devono essere entrambi 0 o avere segni opposti.
• Transitivo:  se compareFn(a,b) e compareFn(b,c) sono entrambi positivi, zero o negativi, allora compareFn(a,c) ha la stessa positività dei due precedenti.

Un comparatore conforme ai vincoli di cui sopra sarà sempre in grado di restituire valori 1,0 e -1 o restituisce costantemente 0. Ad esempio, se un comparatore restituisce solo 1 e 0 o restituisce solo 0 e -1, non è in grado di ordinare in modo affidabile perchè l'antisimmetria è rotta. Un comparatore che restiruisce sempre 0 farà si che l'array non venga modificato ma è comunque affidabile.

Il comparatore lessicografico predefinito soddisfa tutti i vincoli di cui sopra.

Per confrontare numeri anzichè stringhe, la funzione di confronto può sottrare b da a. La seguente funzione ordinerà l'array in ordine crescente.

function compareNumbers(a, b) {
  return a - b;
}

Il metodo .sort() è generico. Si aspetta solo che il valore this abbia una proprietà lenght e proprietà con chiave intera. Sebbene anche le stringhe siano simili ad array, questo metodo non è adatto per essere applicato su di esse, poichè le stringhe sono immutabili.

Esempi

Creazione e ordinamento di array

In questo esempio creiamo e riordiniamo diversi array prima con il metodo .sort() di default e poi utilizzando una comapreFn.

const stringArray = ["Blu", "Verde", "Giallo"];
const numberArray = [40, 1, 5, 200];
const numericStringArray = ["80", "9", "700"];
const mixedNumericArray = ["80", "9", "700", 40, 1, 5, 200];

function compareNumbers(a, b) {
  return a - b;
}

stringArray.sort(); // ["Blu", "Giallo", "Verde"]

numberArray.sort(); // [1, 200, 40, 5]
numberArray.sort(compareNumbers); // [1, 5, 40, 200]

numericStringArray.sort(); // ['700', '80', '9']
numericStringArray.sort(compareNumbers); // ['9', '80', '700']

mixedNumericArray.sort(); // [1, 200, 40, 5, '700', '80', '9']
mixedNumericArray.sort(compareNumbers); // [1, 5, '9', 40, '80', 200, '700']

Array di oggetti

Gli array di oggetti possono essere ordinati comparando una delle loro proprietà.

const 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((a, b) => a.value - b.value);

/*
[
  { name: "The", value: -12 },
  { name: "Magnetic", value: 13 },
  { name: "Edward", value: 21 },
  { name: "Sharpe", value: 37 },
  { name: "Zeros", value: 37 },
  { name: "And", value: 45 },
]
*/

// Ordinamento per nome
items.sort((a, b) => {
  const nameA = a.name.toUpperCase(); // ignore upper and lowercase
  const nameB = b.name.toUpperCase(); // ignore upper and lowercase
  if (nameA < nameB) {
    return -1;
  }
  if (nameA > nameB) {
    return 1;
  }

  // names must be equal
  return 0;
});

/*
[
  { name: "And", value: 45 },
  { name: "Edward", value: 21 },
  { name: "Magnetic", value: 13 },
  { name: "Sharpe", value: 37 },
  { name: "The", value: -12 },
  { name: "Zeros", value: 37 },
]
*/

Ordinare caratteri non-ASCII

Per ordinare stringhe con caratteri non ASCII, cioè stringhe con caratteri accentati (e, é, è, a, ä, ecc.), stringhe da lingue diverse dall'inglese, utilizzare String.prototype.localeCompare(). Questa funzione può confrontare quei caratteri in modo che appaiano nell'ordine corretto.

const items = ["réservé", "premier", "communiqué", "café", "adieu", "éclair"];
items.sort((a, b) => a.localeCompare(b));

// order ['adieu', 'café', 'communiqué', 'éclair', 'premier', 'réservé']