---
title: "Triedenie"
description: "Funkcie na triedenie v skriptovacom jazyku TapHome: ORDER, ORDERSTRICT, ORDERINDEX, ORDERINDEXSTRICT a zostupné varianty (ORDERDESC, ORDERINDEXDESC a ďalšie) so spracovaním NaN a NULL."
url: "https://taphome.com/sk/docs/script/sorting/"
language: sk
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["sorting","collections","ordering","scripting-language"]
  questions: ["Ako zoradím hodnoty vzostupne v TapHome skripte?","Ako zoradím hodnoty zostupne v TapHome?","Aký je rozdiel medzi ORDER a ORDERINDEX?","Ako varianty triedenia STRICT spracúvajú hodnoty NaN a NULL?","Ako získam indexy hodnôt v zoradenom poradí?","Ako TapHome spracúva NaN a NULL pri zoraďovaní?","Ako nájdem najlacnejšiu hodinu zo zoznamu cien?"]
---

# Triedenie

Funkcie na triedenie v skripte TapHome — ORDER, ORDERINDEX a ich varianty STRICT a zostupné varianty na zoradenie hodnôt alebo vrátenie indexov poradia.

Posledná aktualizácia: 2026-11-06

Funkcie `ORDER` zoraďujú hodnoty a vracajú novú kolekciu — buď zoradené hodnoty, alebo vo variantoch `ORDERINDEX` pôvodné pozície hodnôt (počítané od nuly) v zoradenom poradí.

| Funkcia | Poradie | Vracia | Neznáme hodnoty (`Null`, `NaN`) |
|---|---|---|---|
| `ORDER` | vzostupne | hodnoty | odstránené |
| `ORDERSTRICT` | vzostupne | hodnoty | ponechané, na začiatku |
| `ORDERDESC` | zostupne | hodnoty | odstránené |
| `ORDERDESCSTRICT` | zostupne | hodnoty | ponechané, na začiatku |
| `ORDERINDEX` | vzostupne | indexy | odstránené |
| `ORDERINDEXSTRICT` | vzostupne | indexy | ponechané, na začiatku |
| `ORDERINDEXDESC` | zostupne | indexy | odstránené |
| `ORDERINDEXDESCSTRICT` | zostupne | indexy | ponechané, na začiatku |

Pravidlá spoločné pre všetkých osem funkcií:

- Berú 1 až 100 hodnôt alebo presne jednu kolekciu. Zdrojová kolekcia sa nemení.
- Hodnoty musia byť porovnateľné a jedného druhu — čísla, znaky, reťazce, `datetime` alebo `timespan`; miešanie čísel a reťazcov je chyba.
- Reťazce a znaky sa zoraďujú podľa kódu znaku, preto veľké písmená idú pred malými.
- Rovnaké hodnoty si zachovajú pôvodné poradie.
- Varianty `STRICT` dávajú neznáme hodnoty na začiatok, aj pri zostupných variantoch.
- Prázdna kolekcia je chyba: *Collection is null or empty*.

**Príklad — najlacnejšia hodina zo zoznamu cien**

```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áti hodnoty zoradené vzostupne, bez `Null` a `NaN`.

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

```taphome
# čísla vzostupne
ORDER(3, 1, 2);
# Result: {1, 2, 3}
# hodnoty NaN sa odstránia
ORDER(3, NaN, 2, NaN);
# Result: {2, 3}
# znaky podľa kódu znaku
ORDER('Z', 'a', 'X');
# Result: {'X', 'Z', 'a'}
# reťazce podľa kódu znakov, NULL sa odstráni
ORDER("str1", NULL, "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# časové intervaly, NULL sa odstráni
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áti hodnoty zoradené vzostupne a `Null` a `NaN` ponechá na začiatku.

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

```taphome
# hodnoty NaN ostanú na začiatku
ORDERSTRICT(3, NaN, 2, NaN);
# Result: {NaN, NaN, 2, 3}
# reťazce podľa kódu znakov
ORDERSTRICT("str1", "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# NULL ostane na začiatku
ORDERSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {NULL, TIMESPAN(0, 0, 0, 0, 99)}
```

## ORDERDESC

`ORDERDESC` vráti hodnoty zoradené zostupne, bez `Null` a `NaN`.

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

```taphome
# čísla zostupne
ORDERDESC(3, 1, 2);
# Result: {3, 2, 1}
# hodnoty NaN sa odstránia
ORDERDESC(3, NaN, 2, NaN);
# Result: {3, 2}
# znaky zostupne podľa kódu
ORDERDESC('Z', 'a', 'X');
# Result: {'a', 'Z', 'X'}
# reťazce zostupne, NULL sa odstráni
ORDERDESC("str1", NULL, "STR2", "stR1");
# Result: {"str1", "stR1", "STR2"}
```

## ORDERDESCSTRICT

`ORDERDESCSTRICT` vráti hodnoty zoradené zostupne a `Null` a `NaN` ponechá na začiatku.

```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áti pozície hodnôt vo vzostupnom poradí hodnôt, bez pozícií `Null` a `NaN`.

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

**Návratová hodnota** — `collection<int>` pozícií vo vstupe, počítaných od nuly. Prvý prvok je pozícia najmenšej hodnoty.

```taphome
# pozície čísel vzostupne
ORDERINDEX(3, 1, 2);
# Result: {1, 2, 0}
# pozície NaN sa vynechajú
ORDERINDEX(3, NaN, 2, NaN);
# Result: {2, 0}
# pozície reťazcov, NULL sa vynechá
ORDERINDEX("str1", NULL, "STR2", "stR1");
# Result: {2, 3, 0}
```

## ORDERINDEXSTRICT

`ORDERINDEXSTRICT` vráti pozície hodnôt vo vzostupnom poradí hodnôt, pričom pozície `Null` a `NaN` sú na začiatku.

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

```taphome
# pozície čísel vzostupne
ORDERINDEXSTRICT(3, 1, 2);
# Result: {1, 2, 0}
# pozície NaN sú na začiatku
ORDERINDEXSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 2, 0}
# pozícia NULL je na začiatku
ORDERINDEXSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}
```

## ORDERINDEXDESC

`ORDERINDEXDESC` vráti pozície hodnôt v zostupnom poradí hodnôt, bez pozícií `Null` a `NaN`.

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

```taphome
# pozície čísel zostupne
ORDERINDEXDESC(3, 1, 2);
# Result: {0, 2, 1}
# pozície NaN sa vynechajú
ORDERINDEXDESC(3, NaN, 2);
# Result: {0, 2}
# pozície reťazcov, NULL sa vynechá
ORDERINDEXDESC("str1", NULL, "STR2", "stR1");
# Result: {0, 3, 2}
```

## ORDERINDEXDESCSTRICT

`ORDERINDEXDESCSTRICT` vráti pozície hodnôt v zostupnom poradí hodnôt, pričom pozície `Null` a `NaN` sú na začiatku.

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

```taphome
# pozície čísel zostupne
ORDERINDEXDESCSTRICT(3, 1, 2);
# Result: {0, 2, 1}
# pozície NaN sú na začiatku
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 0, 2}
# pozícia NULL je na začiatku
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}
```

**Pozrite aj** — [Text a kolekcie](https://taphome.com/sk/docs/script/text-string-and-byte-array/), [Matematické funkcie](https://taphome.com/sk/docs/script/mathematical-functions/).