---
title: "Sortare"
description: "Funcțiile de sortare din scripturile TapHome: ORDER, ORDERSTRICT, ORDERINDEX, ORDERINDEXSTRICT și variantele descrescătoare (ORDERDESC, ORDERINDEXDESC etc.) cu tratarea valorilor NaN/NULL."
url: "https://taphome.com/ro/docs/script/sorting/"
language: ro
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["sorting","collections","ordering","scripting-language"]
  questions: ["Cum se sortează valorile în ordine crescătoare într-un script TapHome?","Cum se sortează valorile în ordine descrescătoare în TapHome?","Care este diferența dintre ORDER și ORDERINDEX?","Cum tratează variantele de sortare STRICT valorile NaN și NULL?","Cum se obțin indicii valorilor în ordinea sortată?","Cum tratează TapHome valorile NaN și NULL la sortare?","Cum se găsește cea mai ieftină oră dintr-o listă de prețuri?"]
---

# 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: 2026-11-06

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ție | Ordine | Returnează | Valori necunoscute (`Null`, `NaN`) |
|---|---|---|---|
| `ORDER` | crescătoare | valori | eliminate |
| `ORDERSTRICT` | crescătoare | valori | păstrate, plasate primele |
| `ORDERDESC` | descrescătoare | valori | eliminate |
| `ORDERDESCSTRICT` | descrescătoare | valori | păstrate, plasate primele |
| `ORDERINDEX` | crescătoare | indici | eliminate |
| `ORDERINDEXSTRICT` | crescătoare | indici | păstrate, plasate primele |
| `ORDERINDEXDESC` | descrescătoare | indici | eliminate |
| `ORDERINDEXDESCSTRICT` | descrescătoare | indici | pă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**

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

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

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

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

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

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

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

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

```text
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.

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

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

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

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

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

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

```taphome
# 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](https://taphome.com/ro/docs/script/text-string-and-byte-array/), [Funcții matematice](https://taphome.com/ro/docs/script/mathematical-functions/).
