---
title: "Sortiranje"
description: "Funkcije skripte TapHome za sortiranje: ORDER, ORDERSTRICT, ORDERINDEX, ORDERINDEXSTRICT i silazne varijante (ORDERDESC, ORDERINDEXDESC itd.) s obradom vrijednosti NaN/NULL."
url: "https://taphome.com/hr/docs/script/sorting/"
language: hr
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["sorting","collections","ordering","scripting-language"]
  questions: ["Kako u skripti TapHome sortirati vrijednosti uzlaznim redoslijedom?","Kako u sustavu TapHome sortirati vrijednosti silaznim redoslijedom?","Koja je razlika između ORDER i ORDERINDEX?","Kako varijante sortiranja STRICT obrađuju vrijednosti NaN i NULL?","Kako dobiti indekse vrijednosti u sortiranom redoslijedu?","Kako TapHome pri sortiranju obrađuje NaN i NULL?","Kako iz popisa cijena pronaći najjeftiniji sat?"]
---

# Sortiranje

Funkcije skripte TapHome za sortiranje — ORDER, ORDERINDEX i njihove varijante STRICT i silazne varijante za sortiranje vrijednosti ili vraćanje indeksa redoslijeda.

Posljednje ažuriranje: 2026-11-06

Funkcije `ORDER` sortiraju vrijednosti i vraćaju novu zbirku — sortirane vrijednosti ili, u varijantama `ORDERINDEX`, izvorne položaje vrijednosti (od nule) u sortiranom redoslijedu.

| Funkcija | Redoslijed | Vraća | Nepoznate vrijednosti (`Null`, `NaN`) |
|---|---|---|---|
| `ORDER` | uzlazno | vrijednosti | uklonjene |
| `ORDERSTRICT` | uzlazno | vrijednosti | zadržane, na početku |
| `ORDERDESC` | silazno | vrijednosti | uklonjene |
| `ORDERDESCSTRICT` | silazno | vrijednosti | zadržane, na početku |
| `ORDERINDEX` | uzlazno | indekse | uklonjene |
| `ORDERINDEXSTRICT` | uzlazno | indekse | zadržane, na početku |
| `ORDERINDEXDESC` | silazno | indekse | uklonjene |
| `ORDERINDEXDESCSTRICT` | silazno | indekse | zadržane, na početku |

Pravila zajednička svim osam funkcija:

- Primaju 1 do 100 vrijednosti ili točno jednu zbirku. Izvorna zbirka se ne mijenja.
- Vrijednosti moraju biti usporedive i iste vrste — brojevi, znakovi, nizovi znakova, `datetime` ili `timespan`; miješanje brojeva i nizova znakova je pogreška.
- Nizovi znakova i znakovi sortiraju se prema kodu znaka, pa velika slova dolaze prije malih.
- Jednake vrijednosti zadržavaju izvorni redoslijed.
- Varijante `STRICT` stavljaju nepoznate vrijednosti na početak, i u silaznim varijantama.
- Prazna zbirka je pogreška: *Collection is null or empty*.

**Primjer — najjeftiniji sat iz popisa cijena**

```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` vraća vrijednosti sortirane uzlaznim redoslijedom, bez `Null` i `NaN`.

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

```taphome
# brojevi uzlazno
ORDER(3, 1, 2);
# Result: {1, 2, 3}
# vrijednosti NaN se uklanjaju
ORDER(3, NaN, 2, NaN);
# Result: {2, 3}
# znakovi prema kodu znaka
ORDER('Z', 'a', 'X');
# Result: {'X', 'Z', 'a'}
# nizovi prema kodu znakova, NULL se uklanja
ORDER("str1", NULL, "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# vremenski rasponi, NULL se uklanja
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` vraća vrijednosti sortirane uzlaznim redoslijedom i zadržava `Null` i `NaN` na početku.

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

```taphome
# vrijednosti NaN ostaju na početku
ORDERSTRICT(3, NaN, 2, NaN);
# Result: {NaN, NaN, 2, 3}
# nizovi prema kodu znakova
ORDERSTRICT("str1", "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# NULL ostaje na početku
ORDERSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {NULL, TIMESPAN(0, 0, 0, 0, 99)}
```

## ORDERDESC

`ORDERDESC` vraća vrijednosti sortirane silaznim redoslijedom, bez `Null` i `NaN`.

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

```taphome
# brojevi silazno
ORDERDESC(3, 1, 2);
# Result: {3, 2, 1}
# vrijednosti NaN se uklanjaju
ORDERDESC(3, NaN, 2, NaN);
# Result: {3, 2}
# znakovi silazno prema kodu
ORDERDESC('Z', 'a', 'X');
# Result: {'a', 'Z', 'X'}
# nizovi silazno, NULL se uklanja
ORDERDESC("str1", NULL, "STR2", "stR1");
# Result: {"str1", "stR1", "STR2"}
```

## ORDERDESCSTRICT

`ORDERDESCSTRICT` vraća vrijednosti sortirane silaznim redoslijedom i zadržava `Null` i `NaN` na početku.

```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` vraća položaje vrijednosti uzlaznim redoslijedom vrijednosti, bez položaja vrijednosti `Null` i `NaN`.

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

**Vraća** — `collection<int>` položaja u ulazu, od nule. Prvi element je položaj najmanje vrijednosti.

```taphome
# položaji brojeva uzlazno
ORDERINDEX(3, 1, 2);
# Result: {1, 2, 0}
# položaji NaN se izostavljaju
ORDERINDEX(3, NaN, 2, NaN);
# Result: {2, 0}
# položaji nizova, NULL se izostavlja
ORDERINDEX("str1", NULL, "STR2", "stR1");
# Result: {2, 3, 0}
```

## ORDERINDEXSTRICT

`ORDERINDEXSTRICT` vraća položaje vrijednosti uzlaznim redoslijedom vrijednosti, s položajima vrijednosti `Null` i `NaN` na početku.

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

```taphome
# položaji brojeva uzlazno
ORDERINDEXSTRICT(3, 1, 2);
# Result: {1, 2, 0}
# položaji NaN su na početku
ORDERINDEXSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 2, 0}
# položaj NULL je na početku
ORDERINDEXSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}
```

## ORDERINDEXDESC

`ORDERINDEXDESC` vraća položaje vrijednosti silaznim redoslijedom vrijednosti, bez položaja vrijednosti `Null` i `NaN`.

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

```taphome
# položaji brojeva silazno
ORDERINDEXDESC(3, 1, 2);
# Result: {0, 2, 1}
# položaji NaN se izostavljaju
ORDERINDEXDESC(3, NaN, 2);
# Result: {0, 2}
# položaji nizova, NULL se izostavlja
ORDERINDEXDESC("str1", NULL, "STR2", "stR1");
# Result: {0, 3, 2}
```

## ORDERINDEXDESCSTRICT

`ORDERINDEXDESCSTRICT` vraća položaje vrijednosti silaznim redoslijedom vrijednosti, s položajima vrijednosti `Null` i `NaN` na početku.

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

```taphome
# položaji brojeva silazno
ORDERINDEXDESCSTRICT(3, 1, 2);
# Result: {0, 2, 1}
# položaji NaN su na početku
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 0, 2}
# položaj NULL je na početku
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}
```

**Vidi također** — [Tekst i zbirke](https://taphome.com/hr/docs/script/text-string-and-byte-array/), [Matematičke funkcije](https://taphome.com/hr/docs/script/mathematical-functions/).
