---
title: "Sortieren"
description: "Sortierfunktionen in TapHome-Skripten: ORDER, ORDERSTRICT, ORDERINDEX, ORDERINDEXSTRICT und absteigende Varianten (ORDERDESC, ORDERINDEXDESC usw.) mit Behandlung von NaN/NULL."
url: "https://taphome.com/de/docs/script/sorting/"
language: de
lastmod: 2026-11-06
generator: hugo
ai:
  topics: ["sorting","collections","ordering","scripting-language"]
  questions: ["Wie sortiere ich in einem TapHome-Skript Werte in aufsteigender Reihenfolge?","Wie sortiere ich in TapHome Werte in absteigender Reihenfolge?","Was ist der Unterschied zwischen ORDER und ORDERINDEX?","Wie behandeln die Sortiervarianten STRICT Werte NaN und NULL?","Wie erhalte ich die Indizes der Werte in sortierter Reihenfolge?","Wie behandelt TapHome NaN und NULL beim Sortieren?","Wie finde ich die günstigste Stunde aus einer Preisliste?"]
---

# Sortieren

Sortierfunktionen der TapHome-Skripte — ORDER, ORDERINDEX und ihre Varianten STRICT und absteigend zum Sortieren von Werten oder zur Rückgabe der Indizes in Sortierreihenfolge.

Zuletzt aktualisiert: 2026-11-06

Die Funktionen `ORDER` sortieren Werte und geben eine neue Sammlung zurück — entweder die sortierten Werte oder, in den Varianten `ORDERINDEX`, die ursprünglichen nullbasierten Positionen der Werte in sortierter Reihenfolge.

| Funktion | Reihenfolge | Gibt zurück | Unbekannte Werte (`Null`, `NaN`) |
|---|---|---|---|
| `ORDER` | aufsteigend | Werte | entfernt |
| `ORDERSTRICT` | aufsteigend | Werte | behalten, an den Anfang gestellt |
| `ORDERDESC` | absteigend | Werte | entfernt |
| `ORDERDESCSTRICT` | absteigend | Werte | behalten, an den Anfang gestellt |
| `ORDERINDEX` | aufsteigend | Indizes | entfernt |
| `ORDERINDEXSTRICT` | aufsteigend | Indizes | behalten, an den Anfang gestellt |
| `ORDERINDEXDESC` | absteigend | Indizes | entfernt |
| `ORDERINDEXDESCSTRICT` | absteigend | Indizes | behalten, an den Anfang gestellt |

Regeln, die für alle acht Funktionen gelten:

- Sie nehmen 1 bis 100 Werte oder genau eine Sammlung. Die Quellsammlung wird nicht geändert.
- Die Werte müssen vergleichbar und von einer Art sein — Zahlen, Zeichen, Strings, `datetime` oder `timespan`; das Mischen von Zahlen und Strings ist ein Fehler.
- Strings und Zeichen werden nach dem Zeichencode sortiert, daher kommen Großbuchstaben vor Kleinbuchstaben.
- Gleiche Werte behalten ihre ursprüngliche Reihenfolge.
- Die Varianten `STRICT` stellen unbekannte Werte an den Anfang, auch in den absteigenden Varianten.
- Eine leere Sammlung ist ein Fehler: *Collection is null or empty*.

**Beispiel — die günstigste Stunde aus einer Preisliste**

```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` gibt die Werte aufsteigend sortiert zurück, ohne `Null` und `NaN`.

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

```taphome
# Zahlen aufsteigend
ORDER(3, 1, 2);
# Result: {1, 2, 3}
# NaN-Werte werden entfernt
ORDER(3, NaN, 2, NaN);
# Result: {2, 3}
# Zeichen nach Zeichencode
ORDER('Z', 'a', 'X');
# Result: {'X', 'Z', 'a'}
# Zeichenfolgen nach Zeichencode, NULL entfernt
ORDER("str1", NULL, "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# Zeitspannen, NULL entfernt
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` gibt die Werte aufsteigend sortiert zurück und behält `Null` und `NaN` am Anfang.

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

```taphome
# NaN-Werte bleiben vorn
ORDERSTRICT(3, NaN, 2, NaN);
# Result: {NaN, NaN, 2, 3}
# Zeichenfolgen nach Zeichencode
ORDERSTRICT("str1", "STR2", "stR1");
# Result: {"STR2", "stR1", "str1"}
# NULL bleibt vorn
ORDERSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {NULL, TIMESPAN(0, 0, 0, 0, 99)}
```

## ORDERDESC

`ORDERDESC` gibt die Werte absteigend sortiert zurück, ohne `Null` und `NaN`.

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

```taphome
# Zahlen absteigend
ORDERDESC(3, 1, 2);
# Result: {3, 2, 1}
# NaN-Werte werden entfernt
ORDERDESC(3, NaN, 2, NaN);
# Result: {3, 2}
# Zeichen absteigend nach Code
ORDERDESC('Z', 'a', 'X');
# Result: {'a', 'Z', 'X'}
# Zeichenfolgen absteigend, NULL entfernt
ORDERDESC("str1", NULL, "STR2", "stR1");
# Result: {"str1", "stR1", "STR2"}
```

## ORDERDESCSTRICT

`ORDERDESCSTRICT` gibt die Werte absteigend sortiert zurück und behält `Null` und `NaN` am Anfang.

```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` gibt die Positionen der Werte in aufsteigender Reihenfolge des Werts zurück, ohne die Positionen von `Null` und `NaN`.

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

**Rückgabewert** — `collection<int>` mit nullbasierten Positionen in der Eingabe. Das erste Element ist die Position des kleinsten Werts.

```taphome
# Positionen der Zahlen aufsteigend
ORDERINDEX(3, 1, 2);
# Result: {1, 2, 0}
# Positionen von NaN entfallen
ORDERINDEX(3, NaN, 2, NaN);
# Result: {2, 0}
# Positionen der Zeichenfolgen, NULL entfällt
ORDERINDEX("str1", NULL, "STR2", "stR1");
# Result: {2, 3, 0}
```

## ORDERINDEXSTRICT

`ORDERINDEXSTRICT` gibt die Positionen der Werte in aufsteigender Reihenfolge des Werts zurück, mit den Positionen von `Null` und `NaN` zuerst.

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

```taphome
# Positionen der Zahlen aufsteigend
ORDERINDEXSTRICT(3, 1, 2);
# Result: {1, 2, 0}
# Positionen von NaN stehen zuerst
ORDERINDEXSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 2, 0}
# Position von NULL steht zuerst
ORDERINDEXSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}
```

## ORDERINDEXDESC

`ORDERINDEXDESC` gibt die Positionen der Werte in absteigender Reihenfolge des Werts zurück, ohne die Positionen von `Null` und `NaN`.

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

```taphome
# Positionen der Zahlen absteigend
ORDERINDEXDESC(3, 1, 2);
# Result: {0, 2, 1}
# Positionen von NaN entfallen
ORDERINDEXDESC(3, NaN, 2);
# Result: {0, 2}
# Positionen der Zeichenfolgen, NULL entfällt
ORDERINDEXDESC("str1", NULL, "STR2", "stR1");
# Result: {0, 3, 2}
```

## ORDERINDEXDESCSTRICT

`ORDERINDEXDESCSTRICT` gibt die Positionen der Werte in absteigender Reihenfolge des Werts zurück, mit den Positionen von `Null` und `NaN` zuerst.

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

```taphome
# Positionen der Zahlen absteigend
ORDERINDEXDESCSTRICT(3, 1, 2);
# Result: {0, 2, 1}
# Positionen von NaN stehen zuerst
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN);
# Result: {1, 3, 0, 2}
# Position von NULL steht zuerst
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0, 0, 0, 0, 99));
# Result: {0, 1}
```

**Siehe auch** — [Text und Sammlungen](https://taphome.com/de/docs/script/text-string-and-byte-array/), [Mathematische Funktionen](https://taphome.com/de/docs/script/mathematical-functions/).