Ordinamento

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.

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

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.

1
2

ORDER(value1, value2, ...)
ORDER(collection)

# 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.

1
2

ORDERSTRICT(value1, value2, ...)
ORDERSTRICT(collection)

# 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.

1
2

ORDERDESC(value1, value2, ...)
ORDERDESC(collection)

# 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.

1
2

ORDERDESCSTRICT(value1, value2, ...)
ORDERDESCSTRICT(collection)

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.

1
2

ORDERINDEX(value1, value2, ...)
ORDERINDEX(collection)

Valore restituito — collection<int> di posizioni nell’ingresso, contate da zero. Il primo elemento è la posizione del valore più piccolo.

# 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.

1
2

ORDERINDEXSTRICT(value1, value2, ...)
ORDERINDEXSTRICT(collection)

# 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.

1
2

ORDERINDEXDESC(value1, value2, ...)
ORDERINDEXDESC(collection)

# 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.

1
2

ORDERINDEXDESCSTRICT(value1, value2, ...)
ORDERINDEXDESCSTRICT(collection)

# 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, Funzioni matematiche.