Rendezés
TapHome szkript rendező függvények — ORDER, ORDERINDEX és STRICT, valamint csökkenő változataik értékek rendezéséhez vagy rendezett pozícióindexek visszaadásához.
Különböző ORDER változatok érhetők el:
Növekvő – ORDER, ORDERSTRICT – ORDERINDEX, ORDERINDEXSTRICT;
Csökkenő – ORDERDESC, ORDERDESCSTRICT – ORDERINDEXDESC, ORDERINDEXDESCSTRICT
ORDER
Az ORDER függvény a megadott bemeneti értékeket növekvő sorrendbe rendezi, és egy új gyűjteményben adja vissza. N értékig (legfeljebb 100 argumentumig) vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatónak kell lenniük (pl. számok, TIMESPAN, DATETIME, szövegek). Kevert típusok (pl. számok és szövegek) nem megengedettek. A NaN és NULL értékeket figyelmen kívül hagyja, és ezek nem szerepelnek a visszaadott gyűjteményben.
ORDER( n1, n2, n3 , … )
ORDER( collection )Példák:
ORDER(3, 1, 2) = {1, 2, 3}
ORDER(1) = {1}
ORDER(3, NaN, 2, NaN) = {2, 3}
ORDER(NaN) = {}
ORDER('Z', 'a', 'X') = {'X', 'Z', 'a'}
ORDER(“str1”, “STR2”, “stR1”) = {"STR2", "stR1", "str1"}
ORDER(“str1”, NULL, “STR2”, “stR1”) = {"STR2", "stR1", "str1"}
ORDER(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)) = {TIMESPAN(0,0,0,0,99), TIMESPAN(0,0,0,0,100)}
ORDER(NULL, TIMESPAN(0,0,0,0,99)) = {TIMESPAN(0,0,0,0,99)}ORDERINDEX
Az ORDERINDEX függvény a megadott bemeneti értékeket növekvő sorrendbe rendezi, hasonlóan az ORDER‑höz. A rendezett értékek helyett azonban egy indexgyűjteményt ad vissza, amely megmutatja a kiindulási értékek helyét a rendezett sorrendben. 1–100 argumentumot vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatóknak kell lenniük.
ORDERINDEX( n1, n2, n3 , … )
ORDERINDEX( collection )Példák:
ORDERINDEX(3, 1, 2) = {1, 2, 0}
ORDERINDEX(1) = {0}
ORDERINDEX(3, NaN, 2, NaN) = {2, 0}
ORDERINDEX(NaN) = {}
ORDERINDEX('Z', 'a', 'X') = {2, 0, 1}
ORDERINDEX(“str1”, “STR2”, “stR1”) = {1, 2, 0}
ORDERINDEX(“str1”, NULL, “STR2”, “stR1”) = {2, 3, 0}
ORDERINDEX(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)) = {1, 0}
ORDERINDEX(NULL, TIMESPAN(0,0,0,0,99)) = {1}ORDERSTRICT
Az ORDERSTRICT függvény növekvő sorrendben rendezi a megadott bemeneti értékeket, és egy új gyűjteményt ad vissza. 1–100 értéket vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell numerikusnak lenniük, de összehasonlíthatóknak kell lenniük. A NaN és NULL értékek mindig az eredmény elejére kerülnek.
ORDERSTRICT( n1, n2, n3 , … )
ORDERSTRICT( collection )Példák:
ORDERSTRICT(3, 1, 2) = {1, 2, 3}
ORDERSTRICT(1) = {1}
ORDERSTRICT(3, NaN, 2, NaN) = {NaN, NaN, 2, 3}
ORDERSTRICT(NaN) = {NaN}
ORDERSTRICT('Z', 'a', 'X') = {'X', 'Z', 'a'}
ORDERSTRICT(“str1”, “STR2”, “stR1”) = {"STR2", "stR1", "str1"}
ORDERSTRICT(“str1”, NULL, “STR2”, “stR1”) = {NULL, "STR2", "stR1", "str1"}
ORDERSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)) = {TIMESPAN(0,0,0,0,99), TIMESPAN(0,0,0,0,100)}
ORDERSTRICT(NULL, TIMESPAN(0,0,0,0,99)) = {NULL, TIMESPAN(0,0,0,0,99)}ORDERINDEXSTRICT
Az ORDERINDEXSTRICT függvény a megadott bemeneti értékeket növekvő sorrendbe rendezi, hasonlóan az ORDERSTRICT‑hez. A rendezett értékek helyett azonban egy indexgyűjteményt ad vissza, amely megmutatja a kiindulási értékek helyét a rendezett sorrendben. 1–100 argumentumot vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatóknak kell lenniük. A NaN és NULL értékek mindig az eredmény elejére kerülnek.
ORDERINDEXSTRICT( n1, n2, n3 , … )
ORDERINDEXSTRICT( collection )Példák:
ORDERINDEXSTRICT(3, 1, 2) = {1, 2, 0}
ORDERINDEXSTRICT(1) = {0}
ORDERINDEXSTRICT(3, NaN, 2, NaN) = {1, 3, 2, 0}
ORDERINDEXSTRICT(NaN) = {0}
ORDERINDEXSTRICT('Z', 'a', 'X') = {2, 0, 1}
ORDERINDEXSTRICT(“str1”, “STR2”, “stR1”) = {1, 2, 0}
ORDERINDEXSTRICT(“str1”, NULL, “STR2”, “stR1”) = {1, 2, 3, 0}
ORDERINDEXSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)) = {1, 0}
ORDERINDEXSTRICT(NULL, TIMESPAN(0,0,0,0,99)) = {0, 1}ORDERDESC
Az ORDERDESC függvény a megadott bemeneti értékeket csökkenő sorrendbe rendezi, és egy új gyűjteményben adja vissza. N értékig (legfeljebb 100 argumentumig) vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatóknak kell lenniük. Kevert típusok (például számok és szövegek) nem megengedettek. A NaN és NULL értékeket figyelmen kívül hagyja.
ORDERDESC( n1, n2, n3 , … )
ORDERDESC( collection )Példák:
ORDERDESC(3, 1, 2) = {3, 2, 1}
ORDERDESC(1) = {1}
ORDERDESC(3, NaN, 2, NaN) = {3, 2}
ORDERDESC(NaN) = {}
ORDERDESC('Z', 'a', 'X') = {'a', 'Z', 'X'}
ORDERDESC(“str1”, “STR2”, “stR1”) = {"str1", "stR1", "STR2"}
ORDERDESC(“str1”, NULL, “STR2”, “stR1”) = {"str1", "stR1", "STR2"}
ORDERDESC(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)) = {TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)}
ORDERDESC(NULL, TIMESPAN(0,0,0,0,99)) = {TIMESPAN(0,0,0,0,99)}ORDERINDEXDESC
Az ORDERINDEXDESC függvény a megadott bemeneti értékeket csökkenő sorrendbe rendezi, hasonlóan az ORDERDESC‑hez. A rendezett értékek helyett azonban egy indexgyűjteményt ad vissza, amely megmutatja a kiindulási értékek helyét a rendezett sorrendben. 1–100 argumentumot vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatóknak kell lenniük. A NaN és NULL értékeket mindig figyelmen kívül hagyja.
ORDERINDEXDESC( n1, n2, n3 , … )
ORDERINDEXDESC( collection )Példák:
ORDERINDEXDESC(3, 1, 2) = {0, 2, 1}
ORDERINDEXDESC(1) = {0}
ORDERINDEXDESC(3, NaN, 2) = {0, 2}
ORDERINDEXDESC(NaN) = {}
ORDERINDEXDESC('Z', 'a', 'X') = {1, 0, 2}
ORDERINDEXDESC(“str1”, “STR2”, “stR1”) = {0, 2, 1}
ORDERINDEXDESC(“str1”, NULL, “STR2”, “stR1”) = {0, 3, 2}
ORDERINDEXDESC(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)) = {0, 1}
ORDERINDEXDESC(NULL, TIMESPAN(0,0,0,0,99)) = {1}ORDERDESCSTRICT
Az ORDERDESCSTRICT függvény a megadott bemeneti értékeket csökkenő sorrendbe rendezi, és egy új gyűjteményben adja vissza. 1–100 értéket vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell numerikusnak lenniük, de összehasonlíthatóknak kell lenniük. A NaN és NULL értékek szerepelnek az eredményben, és mindig az elejére kerülnek.
ORDERDESCSTRICT( n1, n2, n3 , … )
ORDERDESCSTRICT( collection )Példák:
ORDERDESCSTRICT(3, 1, 2) = {3, 2, 1}
ORDERDESCSTRICT(1) = {1}
ORDERDESCSTRICT(3, NaN, 2, NaN) = {NaN, NaN, 3, 2}
ORDERDESCSTRICT(NaN) = {NaN}
ORDERDESCSTRICT('Z', 'a', 'X') = {'a', 'Z', 'X'}
ORDERDESCSTRICT(“str1”, “STR2”, “stR1”) = {"str1", "stR1", "STR2"}
ORDERDESCSTRICT(“str1”, NULL, “STR2”, “stR1”) = {NULL, "str1", "stR1", "STR2"}
ORDERDESCSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)) = {TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)}
ORDERDESCSTRICT(NULL, TIMESPAN(0,0,0,0,99)) = {NULL, TIMESPAN(0,0,0,0,99)}ORDERINDEXDESCSTRICT
Az ORDERINDEXDESCSTRICT függvény a megadott bemeneti értékeket csökkenő sorrendbe rendezi, hasonlóan az ORDERDESCSTRICT‑hez. A rendezett értékek helyett azonban egy indexgyűjteményt ad vissza, amely megmutatja a kiindulási értékek helyét a rendezett sorrendben. 1–100 argumentumot vagy egyetlen gyűjteményt fogad. Az értékeknek nem feltétlenül kell számoknak lenniük, de összehasonlíthatóknak kell lenniük. A NaN és NULL értékek szerepelnek az eredményben, és mindig az elejére kerülnek.
ORDERINDEXDESCSTRICT( n1, n2, n3 , … )
ORDERINDEXDESCSTRICT( collection )Példák:
ORDERINDEXDESCSTRICT(3, 1, 2) = {0, 2, 1}
ORDERINDEXDESCSTRICT(1) = {0}
ORDERINDEXDESCSTRICT(3, NaN, 2, NaN) = {1, 3, 0, 2}
ORDERINDEXDESCSTRICT(NaN) = {0}
ORDERINDEXDESCSTRICT('Z', 'a', 'X') = {1, 0, 2}
ORDERINDEXDESCSTRICT(“str1”, “STR2”, “stR1”) = {0, 2, 1}
ORDERINDEXDESCSTRICT(“str1”, NULL, “STR2”, “stR1”) = {1, 0, 3, 2}
ORDERINDEXDESCSTRICT(TIMESPAN(0,0,0,0,100), TIMESPAN(0,0,0,0,99)) = {0, 1}
ORDERINDEXDESCSTRICT(NULL, TIMESPAN(0,0,0,0,99)) = {0, 1}