Sortieren

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.

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

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.

1
2

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

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

1
2

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

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

1
2

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

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

1
2

ORDERDESCSTRICT(value1, value2, ...)
ORDERDESCSTRICT(collection)

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.

1
2

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

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

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

1
2

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

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

1
2

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

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

1
2

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

# 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, Mathematische Funktionen.