---
title: "Třídění"
description: "Funkce skriptu TapHome pro třídění: ORDER, ORDERSTRICT, ORDERINDEX, ORDERINDEXSTRICT a sestupné varianty (ORDERDESC, ORDERINDEXDESC atd.) s ošetřením NaN/NULL."
url: "https://taphome.com/cs/docs/script/sorting/"
language: cs
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["sorting","collections","ordering","scripting-language"]
  questions: ["Jak ve skriptu TapHome seřadit hodnoty vzestupně?","Jak v TapHome seřadit hodnoty sestupně?","Jaký je rozdíl mezi ORDER a ORDERINDEX?","Jak varianty třídění STRICT zacházejí s hodnotami NaN a NULL?","Jak získat indexy hodnot v seřazeném pořadí?","Jak TapHome při třídění zachází s NaN a NULL?","Jak najít nejlevnější hodinu ze seznamu cen?"]
---

# Třídění

Funkce skriptu TapHome pro třídění — ORDER, ORDERINDEX a jejich varianty STRICT a sestupné, které třídí hodnoty nebo vracejí indexy v pořadí třídění.

Poslední aktualizace: 2026-11-06

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

| Funkce | Pořadí | Vrací | Neznámé hodnoty (`Null`, `NaN`) |
|---|---|---|---|
| `ORDER` | vzestupně | hodnoty | odstraněny |
| `ORDERSTRICT` | vzestupně | hodnoty | zachovány, na začátku |
| `ORDERDESC` | sestupně | hodnoty | odstraněny |
| `ORDERDESCSTRICT` | sestupně | hodnoty | zachovány, na začátku |
| `ORDERINDEX` | vzestupně | indexy | odstraněny |
| `ORDERINDEXSTRICT` | vzestupně | indexy | zachovány, na začátku |
| `ORDERINDEXDESC` | sestupně | indexy | odstraněny |
| `ORDERINDEXDESCSTRICT` | sestupně | indexy | zachovány, na začátku |

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**

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

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

```taphome
# čí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.

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

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

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

```taphome
# čí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.

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

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

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

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

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

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

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

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

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

```taphome
# 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](https://taphome.com/cs/docs/script/text-string-and-byte-array/), [Matematické funkce](https://taphome.com/cs/docs/script/mathematical-functions/).