Třídění

Funkce ORDER třídí hodnoty a vracejí novou kolekci — buď seřazené hodnoty, nebo ve variantách ORDERINDEX původní pozice hodnot (počítané od nuly) v seřazeném pořadí.

Pravidla společná všem osmi funkcím:

• Přijímají 1 až 100 hodnot, nebo právě jednu kolekci. Zdrojová kolekce se nemění.
• Hodnoty musí být porovnatelné a jednoho druhu — čísla, znaky, řetězce, datetime nebo timespan; míchání čísel a řetězců je chyba.
• Řetězce a znaky se třídí podle kódu znaku, takže velká písmena jsou před malými.
• Shodné hodnoty si zachovají původní pořadí.
• Varianty STRICT dávají neznámé hodnoty na začátek, i v sestupných variantách.
• Prázdná kolekce je chyba: Collection is null or empty.

Příklad — nejlevnější hodina ze seznamu cen

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 vrátí hodnoty seřazené vzestupně, bez Null a NaN.

1
2

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

# čísla vzestupně
ORDER(3, 1, 2);
# Result: {1, 2, 3}
# hodnoty NaN se odstraní
ORDER(3, NaN, 2, NaN);
# Result: {2, 3}
# znaky podle kódu znaku
ORDER('Z', 'a', 'X');
# Result: {'X', 'Z', 'a'}
# řetězce podle kódu znaků, NULL se odstraní
ORDER("str1", NULL, "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# časové intervaly, NULL se odstraní
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 vrátí hodnoty seřazené vzestupně a Null a NaN ponechá na začátku.

1
2

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

# hodnoty NaN zůstanou na začátku
ORDERSTRICT(3, NaN, 2, NaN);
# Result: {NaN, NaN, 2, 3}
# řetězce podle kódu znaků
ORDERSTRICT("str1", "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# NULL zůstane na začátku
ORDERSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {NULL, TIMESPAN(0, 0, 0, 0, 99)}

ORDERDESC#

ORDERDESC vrátí hodnoty seřazené sestupně, bez Null a NaN.

1
2

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

# čísla sestupně
ORDERDESC(3, 1, 2);
# Result: {3, 2, 1}
# hodnoty NaN se odstraní
ORDERDESC(3, NaN, 2, NaN);
# Result: {3, 2}
# znaky sestupně podle kódu
ORDERDESC('Z', 'a', 'X');
# Result: {'a', 'Z', 'X'}
# řetězce sestupně, NULL se odstraní
ORDERDESC("str1", NULL, "STR2", "stR1");
# Result: {"str1", "stR1", "STR2"}

ORDERDESCSTRICT#

ORDERDESCSTRICT vrátí hodnoty seřazené sestupně a Null a NaN ponechá na začátku.

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 vrátí pozice hodnot ve vzestupném pořadí hodnot, bez pozic Null a NaN.

1
2

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

Vrací — collection<int> pozic ve vstupu počítaných od nuly. První prvek je pozice nejmenší hodnoty.

# pozice čísel vzestupně
ORDERINDEX(3, 1, 2);
# Result: {1, 2, 0}
# pozice NaN se vynechají
ORDERINDEX(3, NaN, 2, NaN);
# Result: {2, 0}
# pozice řetězců, NULL se vynechá
ORDERINDEX("str1", NULL, "STR2", "stR1");
# Result: {2, 3, 0}

ORDERINDEXSTRICT#

ORDERINDEXSTRICT vrátí pozice hodnot ve vzestupném pořadí hodnot, s pozicemi Null a NaN na začátku.

1
2

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

# pozice čísel vzestupně
ORDERINDEXSTRICT(3, 1, 2);
# Result: {1, 2, 0}
# pozice NaN jsou na začátku
ORDERINDEXSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 2, 0}
# pozice NULL je na začátku
ORDERINDEXSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}

ORDERINDEXDESC#

ORDERINDEXDESC vrátí pozice hodnot v sestupném pořadí hodnot, bez pozic Null a NaN.

1
2

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

# pozice čísel sestupně
ORDERINDEXDESC(3, 1, 2);
# Result: {0, 2, 1}
# pozice NaN se vynechají
ORDERINDEXDESC(3, NaN, 2);
# Result: {0, 2}
# pozice řetězců, NULL se vynechá
ORDERINDEXDESC("str1", NULL, "STR2", "stR1");
# Result: {0, 3, 2}

ORDERINDEXDESCSTRICT#

ORDERINDEXDESCSTRICT vrátí pozice hodnot v sestupném pořadí hodnot, s pozicemi Null a NaN na začátku.

1
2

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

# pozice čísel sestupně
ORDERINDEXDESCSTRICT(3, 1, 2);
# Result: {0, 2, 1}
# pozice NaN jsou na začátku
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 0, 2}
# pozice NULL je na začátku
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}

Viz také — Text a kolekce, Matematické funkce.