---
title: "Rendezés"
description: "TapHome szkript rendezőfüggvények: ORDER, ORDERSTRICT, ORDERINDEX, ORDERINDEXSTRICT és a csökkenő változatok (ORDERDESC, ORDERINDEXDESC stb.) a NaN és NULL értékek kezelésével."
url: "https://taphome.com/hu/docs/script/sorting/"
language: hu
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["sorting","collections","ordering","scripting-language"]
  questions: ["Hogyan rendezhetek értékeket növekvő sorrendbe egy TapHome szkriptben?","Hogyan rendezhetek értékeket csökkenő sorrendbe a TapHome-ban?","Mi a különbség az ORDER és az ORDERINDEX között?","Hogyan kezelik a STRICT rendezési változatok a NaN és a NULL értékeket?","Hogyan kaphatom meg az értékek indexeit rendezett sorrendben?","Hogyan kezeli a TapHome a NaN és a NULL értékeket rendezéskor?","Hogyan találhatom meg a legolcsóbb órát egy árlistából?"]
---

# Rendezés

A TapHome szkript rendezőfüggvényei — ORDER, ORDERINDEX és ezek STRICT és csökkenő változatai az értékek rendezésére vagy a rendezési sorrend indexeinek visszaadására.

Utoljára frissítve: 2026-11-06

Az `ORDER` függvények rendezik az értékeket, és új gyűjteményt adnak vissza — vagy a rendezett értékeket, vagy az `ORDERINDEX` változatokban az értékek eredeti, nullától kezdődő pozícióit rendezett sorrendben.

| Függvény | Sorrend | Visszatérési érték | Ismeretlen értékek (`Null`, `NaN`) |
|---|---|---|---|
| `ORDER` | növekvő | értékek | eltávolítja |
| `ORDERSTRICT` | növekvő | értékek | megtartja, az elejére teszi |
| `ORDERDESC` | csökkenő | értékek | eltávolítja |
| `ORDERDESCSTRICT` | csökkenő | értékek | megtartja, az elejére teszi |
| `ORDERINDEX` | növekvő | indexek | eltávolítja |
| `ORDERINDEXSTRICT` | növekvő | indexek | megtartja, az elejére teszi |
| `ORDERINDEXDESC` | csökkenő | indexek | eltávolítja |
| `ORDERINDEXDESCSTRICT` | csökkenő | indexek | megtartja, az elejére teszi |

Mind a nyolc függvényre érvényes szabályok:

- 1–100 értéket fogadnak, vagy pontosan egy gyűjteményt. A forrásgyűjtemény nem változik.
- Az értékeknek összehasonlíthatónak és egyfajtának kell lenniük — számok, karakterek, szövegek, `datetime` vagy `timespan`; számok és szövegek keverése hibát okoz.
- A szövegek és a karakterek rendezése karakterkód szerint történik, így a nagybetűk a kisbetűk elé kerülnek.
- Az egyenlő értékek megtartják eredeti sorrendjüket.
- A `STRICT` változatok az ismeretlen értékeket az elejére teszik, a csökkenő változatokban is.
- Az üres gyűjtemény hibát okoz: *Collection is null or empty*.

**Példa — a legolcsóbb óra egy árlistából**

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

Az `ORDER` az értékeket növekvő sorrendbe rendezve adja vissza, `Null` és `NaN` nélkül.

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

```taphome
# számok, növekvő sorrendben
ORDER(3, 1, 2);
# Result: {1, 2, 3}
# a NaN értékek kimaradnak
ORDER(3, NaN, 2, NaN);
# Result: {2, 3}
# karakterek karakterkód szerint
ORDER('Z', 'a', 'X');
# Result: {'X', 'Z', 'a'}
# szövegek karakterkód szerint, a NULL kimarad
ORDER("str1", NULL, "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# időtartamok, a NULL kimarad
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

Az `ORDERSTRICT` az értékeket növekvő sorrendbe rendezve adja vissza, a `Null` és a `NaN` értékeket az elején megtartja.

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

```taphome
# a NaN értékek elöl maradnak
ORDERSTRICT(3, NaN, 2, NaN);
# Result: {NaN, NaN, 2, 3}
# szövegek karakterkód szerint
ORDERSTRICT("str1", "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# a NULL elöl marad
ORDERSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {NULL, TIMESPAN(0, 0, 0, 0, 99)}
```

## ORDERDESC

Az `ORDERDESC` az értékeket csökkenő sorrendbe rendezve adja vissza, `Null` és `NaN` nélkül.

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

```taphome
# számok, csökkenő sorrendben
ORDERDESC(3, 1, 2);
# Result: {3, 2, 1}
# a NaN értékek kimaradnak
ORDERDESC(3, NaN, 2, NaN);
# Result: {3, 2}
# karakterek csökkenően kód szerint
ORDERDESC('Z', 'a', 'X');
# Result: {'a', 'Z', 'X'}
# szövegek csökkenően, a NULL kimarad
ORDERDESC("str1", NULL, "STR2", "stR1");
# Result: {"str1", "stR1", "STR2"}
```

## ORDERDESCSTRICT

Az `ORDERDESCSTRICT` az értékeket csökkenő sorrendbe rendezve adja vissza, a `Null` és a `NaN` értékeket az elején megtartja.

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

Az `ORDERINDEX` az értékek pozícióit adja vissza az értékek növekvő sorrendjében, a `Null` és a `NaN` pozíciói nélkül.

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

**Visszatérési érték** — a bemeneten belüli, nullától kezdődő pozíciók `collection<int>` gyűjteménye. Az első elem a legkisebb érték pozíciója.

```taphome
# a számok pozíciói, növekvően
ORDERINDEX(3, 1, 2);
# Result: {1, 2, 0}
# a NaN pozíciói kimaradnak
ORDERINDEX(3, NaN, 2, NaN);
# Result: {2, 0}
# a szövegek pozíciói, a NULL kimarad
ORDERINDEX("str1", NULL, "STR2", "stR1");
# Result: {2, 3, 0}
```

## ORDERINDEXSTRICT

Az `ORDERINDEXSTRICT` az értékek pozícióit adja vissza az értékek növekvő sorrendjében, elöl a `Null` és a `NaN` pozícióival.

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

```taphome
# a számok pozíciói, növekvően
ORDERINDEXSTRICT(3, 1, 2);
# Result: {1, 2, 0}
# a NaN pozíciói elöl vannak
ORDERINDEXSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 2, 0}
# a NULL pozíciója elöl van
ORDERINDEXSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}
```

## ORDERINDEXDESC

Az `ORDERINDEXDESC` az értékek pozícióit adja vissza az értékek csökkenő sorrendjében, a `Null` és a `NaN` pozíciói nélkül.

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

```taphome
# a számok pozíciói, csökkenően
ORDERINDEXDESC(3, 1, 2);
# Result: {0, 2, 1}
# a NaN pozíciói kimaradnak
ORDERINDEXDESC(3, NaN, 2);
# Result: {0, 2}
# a szövegek pozíciói, a NULL kimarad
ORDERINDEXDESC("str1", NULL, "STR2", "stR1");
# Result: {0, 3, 2}
```

## ORDERINDEXDESCSTRICT

Az `ORDERINDEXDESCSTRICT` az értékek pozícióit adja vissza az értékek csökkenő sorrendjében, elöl a `Null` és a `NaN` pozícióival.

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

```taphome
# a számok pozíciói, csökkenően
ORDERINDEXDESCSTRICT(3, 1, 2);
# Result: {0, 2, 1}
# a NaN pozíciói elöl vannak
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 0, 2}
# a NULL pozíciója elöl van
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}
```

**Lásd még** — [Szöveg és gyűjtemények](https://taphome.com/hu/docs/script/text-string-and-byte-array/), [Matematikai függvények](https://taphome.com/hu/docs/script/mathematical-functions/).