--- title: "Ordinamento" description: "Funzioni di ordinamento degli script TapHome: ORDER, ORDERSTRICT, ORDERINDEX, ORDERINDEXSTRICT e varianti decrescenti (ORDERDESC, ORDERINDEXDESC ecc.) con gestione di NaN e NULL." url: "https://taphome.com/it/docs/script/sorting/" language: it lastmod: 2026-11-06 generator: hugo ai: topics: ["sorting","collections","ordering","scripting-language"] questions: ["Come si ordinano valori in ordine crescente in uno script TapHome?","Come si ordinano valori in ordine decrescente in TapHome?","Qual è la differenza tra ORDER e ORDERINDEX?","Come gestiscono le varianti di ordinamento STRICT i valori NaN e NULL?","Come si ottengono gli indici dei valori in ordine?","Come gestisce TapHome NaN e NULL durante l'ordinamento?","Come si trova l'ora più economica in un elenco di prezzi?"] --- # Ordinamento Funzioni di ordinamento degli script TapHome — ORDER, ORDERINDEX e le loro varianti STRICT e decrescenti per ordinare valori o restituire gli indici dell'ordinamento. Ultimo aggiornamento: 2026-11-06 Le funzioni `ORDER` ordinano valori e restituiscono una nuova collezione — oppure i valori ordinati oppure, nelle varianti `ORDERINDEX`, le posizioni originali dei valori, contate da zero, nell'ordine ottenuto. | Funzione | Ordine | Restituisce | Valori sconosciuti (`Null`, `NaN`) | |---|---|---|---| | `ORDER` | crescente | valori | rimossi | | `ORDERSTRICT` | crescente | valori | mantenuti, messi all'inizio | | `ORDERDESC` | decrescente | valori | rimossi | | `ORDERDESCSTRICT` | decrescente | valori | mantenuti, messi all'inizio | | `ORDERINDEX` | crescente | indici | rimossi | | `ORDERINDEXSTRICT` | crescente | indici | mantenuti, messi all'inizio | | `ORDERINDEXDESC` | decrescente | indici | rimossi | | `ORDERINDEXDESCSTRICT` | decrescente | indici | mantenuti, messi all'inizio | Regole comuni a tutte e otto le funzioni: - Accettano da 1 a 100 valori, oppure esattamente una collezione. La collezione di origine non viene modificata. - I valori devono essere confrontabili e di un solo genere — numeri, caratteri, stringhe, `datetime` o `timespan`; mescolare numeri e stringhe è un errore. - Le stringhe e i caratteri vengono ordinati per codice di carattere, quindi le lettere maiuscole vengono prima delle minuscole. - I valori uguali mantengono il loro ordine originale. - Le varianti `STRICT` mettono i valori sconosciuti all'inizio, anche nelle varianti decrescenti. - Una collezione vuota è un errore: *Collection is null or empty*. **Esempio — l'ora più economica da un elenco di prezzi** ```taphome VAR prices := {12.5, 8.1, 20.0, 9.9}; VAR cheapest := GETAT(ORDER(prices), 0); # cheapest = 8.1 VAR cheapestHour := GETAT(ORDERINDEX(prices), 0); # cheapestHour = 1 ``` ## ORDER `ORDER` restituisce i valori ordinati in modo crescente, senza `Null` e `NaN`. ```text ORDER(value1, value2, ...) ORDER(collection) ``` ```taphome # numeri in ordine crescente ORDER(3, 1, 2); # Result: {1, 2, 3} # i valori NaN vengono rimossi ORDER(3, NaN, 2, NaN); # Result: {2, 3} # caratteri in base al codice del carattere ORDER('Z', 'a', 'X'); # Result: {'X', 'Z', 'a'} # stringhe in base al codice dei caratteri, NULL rimosso ORDER("str1", NULL, "STR2", "stR1"); # Result: {"STR2", "stR1", "str1"} # intervalli di tempo, NULL rimosso ORDER(NULL, TIMESPAN(0, 0, 0, 0, 100), TIMESPAN(0, 0, 0, 0, 99)); # Result: {TIMESPAN(0, 0, 0, 0, 99), TIMESPAN(0, 0, 0, 0, 100)} ``` ## ORDERSTRICT `ORDERSTRICT` restituisce i valori ordinati in modo crescente e mantiene `Null` e `NaN` all'inizio. ```text ORDERSTRICT(value1, value2, ...) ORDERSTRICT(collection) ``` ```taphome # i valori NaN restano all'inizio ORDERSTRICT(3, NaN, 2, NaN); # Result: {NaN, NaN, 2, 3} # stringhe in base al codice dei caratteri ORDERSTRICT("str1", "STR2", "stR1"); # Result: {"STR2", "stR1", "str1"} # NULL resta all'inizio ORDERSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99)); # Result: {NULL, TIMESPAN(0, 0, 0, 0, 99)} ``` ## ORDERDESC `ORDERDESC` restituisce i valori ordinati in modo decrescente, senza `Null` e `NaN`. ```text ORDERDESC(value1, value2, ...) ORDERDESC(collection) ``` ```taphome # numeri in ordine decrescente ORDERDESC(3, 1, 2); # Result: {3, 2, 1} # i valori NaN vengono rimossi ORDERDESC(3, NaN, 2, NaN); # Result: {3, 2} # caratteri decrescenti in base al codice ORDERDESC('Z', 'a', 'X'); # Result: {'a', 'Z', 'X'} # stringhe decrescenti, NULL rimosso ORDERDESC("str1", NULL, "STR2", "stR1"); # Result: {"str1", "stR1", "STR2"} ``` ## ORDERDESCSTRICT `ORDERDESCSTRICT` restituisce i valori ordinati in modo decrescente e mantiene `Null` e `NaN` all'inizio. ```text ORDERDESCSTRICT(value1, value2, ...) ORDERDESCSTRICT(collection) ``` ```taphome ORDERDESCSTRICT(3, NaN, 2, NaN); # Result: {NaN, NaN, 3, 2} ORDERDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99), TIMESPAN(0, 0, 0, 0, 100)); # Result: {NULL, TIMESPAN(0, 0, 0, 0, 100), TIMESPAN(0, 0, 0, 0, 99)} ``` ## ORDERINDEX `ORDERINDEX` restituisce le posizioni dei valori in ordine crescente di valore, senza le posizioni di `Null` e `NaN`. ```text ORDERINDEX(value1, value2, ...) ORDERINDEX(collection) ``` **Valore restituito** — `collection` di posizioni nell'ingresso, contate da zero. Il primo elemento è la posizione del valore più piccolo. ```taphome # posizioni dei numeri, crescenti ORDERINDEX(3, 1, 2); # Result: {1, 2, 0} # le posizioni di NaN sono omesse ORDERINDEX(3, NaN, 2, NaN); # Result: {2, 0} # posizioni delle stringhe, NULL omesso ORDERINDEX("str1", NULL, "STR2", "stR1"); # Result: {2, 3, 0} ``` ## ORDERINDEXSTRICT `ORDERINDEXSTRICT` restituisce le posizioni dei valori in ordine crescente di valore, con le posizioni di `Null` e `NaN` all'inizio. ```text ORDERINDEXSTRICT(value1, value2, ...) ORDERINDEXSTRICT(collection) ``` ```taphome # posizioni dei numeri, crescenti ORDERINDEXSTRICT(3, 1, 2); # Result: {1, 2, 0} # le posizioni di NaN vengono prima ORDERINDEXSTRICT(3, NaN, 2, NaN); # Result: {1, 3, 2, 0} # la posizione di NULL viene prima ORDERINDEXSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99)); # Result: {0, 1} ``` ## ORDERINDEXDESC `ORDERINDEXDESC` restituisce le posizioni dei valori in ordine decrescente di valore, senza le posizioni di `Null` e `NaN`. ```text ORDERINDEXDESC(value1, value2, ...) ORDERINDEXDESC(collection) ``` ```taphome # posizioni dei numeri, decrescenti ORDERINDEXDESC(3, 1, 2); # Result: {0, 2, 1} # le posizioni di NaN sono omesse ORDERINDEXDESC(3, NaN, 2); # Result: {0, 2} # posizioni delle stringhe, NULL omesso ORDERINDEXDESC("str1", NULL, "STR2", "stR1"); # Result: {0, 3, 2} ``` ## ORDERINDEXDESCSTRICT `ORDERINDEXDESCSTRICT` restituisce le posizioni dei valori in ordine decrescente di valore, con le posizioni di `Null` e `NaN` all'inizio. ```text ORDERINDEXDESCSTRICT(value1, value2, ...) ORDERINDEXDESCSTRICT(collection) ``` ```taphome # posizioni dei numeri, decrescenti ORDERINDEXDESCSTRICT(3, 1, 2); # Result: {0, 2, 1} # le posizioni di NaN vengono prima ORDERINDEXDESCSTRICT(3, NaN, 2, NaN); # Result: {1, 3, 0, 2} # la posizione di NULL viene prima ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99)); # Result: {0, 1} ``` **Vedi anche** — [Testo e collezioni](https://taphome.com/it/docs/script/text-string-and-byte-array/), [Funzioni matematiche](https://taphome.com/it/docs/script/mathematical-functions/).