TapHome

Sortare

Funcțiile de sortare ale scripturilor TapHome — ORDER, ORDERINDEX și variantele lor STRICT și descrescătoare pentru sortarea valorilor sau returnarea indicilor ordinii de sortare.

Ultima actualizare:

Funcțiile ORDER sortează valori și returnează o colecție nouă — fie valorile sortate, fie, în variantele ORDERINDEX, pozițiile originale ale valorilor (numerotate de la zero) în ordinea sortată.

FuncțieOrdineReturneazăValori necunoscute (Null, NaN)
ORDERcrescătoarevalorieliminate
ORDERSTRICTcrescătoarevaloripăstrate, plasate primele
ORDERDESCdescrescătoarevalorieliminate
ORDERDESCSTRICTdescrescătoarevaloripăstrate, plasate primele
ORDERINDEXcrescătoareindicieliminate
ORDERINDEXSTRICTcrescătoareindicipăstrate, plasate primele
ORDERINDEXDESCdescrescătoareindicieliminate
ORDERINDEXDESCSTRICTdescrescătoareindicipăstrate, plasate primele

Reguli comune tuturor celor opt funcții:

  • Primesc între 1 și 100 de valori sau exact o colecție. Colecția sursă nu se modifică.
  • Valorile trebuie să fie comparabile și de același fel — numere, caractere, șiruri de caractere, datetime sau timespan; amestecarea numerelor cu șiruri de caractere este o eroare.
  • Șirurile de caractere și caracterele se sortează după codul caracterului, așa că literele mari vin înaintea celor mici.
  • Valorile egale își păstrează ordinea originală.
  • Variantele STRICT plasează valorile necunoscute primele, și în variantele descrescătoare.
  • O colecție goală este o eroare: Collection is null or empty.

Exemplu — cea mai ieftină oră dintr-o listă de prețuri

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 returnează valorile sortate în ordine crescătoare, fără Null și NaN.

1
2
ORDER(value1, value2, ...)
ORDER(collection)
# numere în ordine crescătoare
ORDER(3, 1, 2);
# Result: {1, 2, 3}
# valorile NaN sunt eliminate
ORDER(3, NaN, 2, NaN);
# Result: {2, 3}
# caractere după codul caracterului
ORDER('Z', 'a', 'X');
# Result: {'X', 'Z', 'a'}
# șiruri după codul caracterelor, NULL eliminat
ORDER("str1", NULL, "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# intervale de timp, NULL eliminat
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 returnează valorile sortate în ordine crescătoare și păstrează Null și NaN la început.

1
2
ORDERSTRICT(value1, value2, ...)
ORDERSTRICT(collection)
# valorile NaN rămân la început
ORDERSTRICT(3, NaN, 2, NaN);
# Result: {NaN, NaN, 2, 3}
# șiruri după codul caracterelor
ORDERSTRICT("str1", "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# NULL rămâne la început
ORDERSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {NULL, TIMESPAN(0, 0, 0, 0, 99)}

ORDERDESC

ORDERDESC returnează valorile sortate în ordine descrescătoare, fără Null și NaN.

1
2
ORDERDESC(value1, value2, ...)
ORDERDESC(collection)
# numere în ordine descrescătoare
ORDERDESC(3, 1, 2);
# Result: {3, 2, 1}
# valorile NaN sunt eliminate
ORDERDESC(3, NaN, 2, NaN);
# Result: {3, 2}
# caractere descrescător după cod
ORDERDESC('Z', 'a', 'X');
# Result: {'a', 'Z', 'X'}
# șiruri descrescător, NULL eliminat
ORDERDESC("str1", NULL, "STR2", "stR1");
# Result: {"str1", "stR1", "STR2"}

ORDERDESCSTRICT

ORDERDESCSTRICT returnează valorile sortate în ordine descrescătoare și păstrează Null și NaN la început.

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 returnează pozițiile valorilor în ordinea crescătoare a valorii, fără pozițiile lui Null și NaN.

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

Returnează — collection<int> cu pozițiile din intrare, numerotate de la zero. Primul element este poziția celei mai mici valori.

# pozițiile numerelor, crescător
ORDERINDEX(3, 1, 2);
# Result: {1, 2, 0}
# pozițiile NaN sunt omise
ORDERINDEX(3, NaN, 2, NaN);
# Result: {2, 0}
# pozițiile șirurilor, NULL omis
ORDERINDEX("str1", NULL, "STR2", "stR1");
# Result: {2, 3, 0}

ORDERINDEXSTRICT

ORDERINDEXSTRICT returnează pozițiile valorilor în ordinea crescătoare a valorii, cu pozițiile lui Null și NaN primele.

1
2
ORDERINDEXSTRICT(value1, value2, ...)
ORDERINDEXSTRICT(collection)
# pozițiile numerelor, crescător
ORDERINDEXSTRICT(3, 1, 2);
# Result: {1, 2, 0}
# pozițiile NaN sunt primele
ORDERINDEXSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 2, 0}
# poziția lui NULL este prima
ORDERINDEXSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}

ORDERINDEXDESC

ORDERINDEXDESC returnează pozițiile valorilor în ordinea descrescătoare a valorii, fără pozițiile lui Null și NaN.

1
2
ORDERINDEXDESC(value1, value2, ...)
ORDERINDEXDESC(collection)
# pozițiile numerelor, descrescător
ORDERINDEXDESC(3, 1, 2);
# Result: {0, 2, 1}
# pozițiile NaN sunt omise
ORDERINDEXDESC(3, NaN, 2);
# Result: {0, 2}
# pozițiile șirurilor, NULL omis
ORDERINDEXDESC("str1", NULL, "STR2", "stR1");
# Result: {0, 3, 2}

ORDERINDEXDESCSTRICT

ORDERINDEXDESCSTRICT returnează pozițiile valorilor în ordinea descrescătoare a valorii, cu pozițiile lui Null și NaN primele.

1
2
ORDERINDEXDESCSTRICT(value1, value2, ...)
ORDERINDEXDESCSTRICT(collection)
# pozițiile numerelor, descrescător
ORDERINDEXDESCSTRICT(3, 1, 2);
# Result: {0, 2, 1}
# pozițiile NaN sunt primele
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 0, 2}
# poziția lui NULL este prima
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}

Consultați și — Text și colecții, Funcții matematice.