string-Funktionen

Die zusätzlichen string-Funktionen werden mit dem Namensraum str angesprochen. Da Lua Indices byteweise und nicht zeichenweise interpretiert, können diese Funktionen als Alternative zu den Lua-Stringfunktionen dienen, die bei Umlauten Probleme bereiten können.

Als Parametertypen bei der Eingabe sind in der Regel string, int, double, bool -Werte verwendbar, nachfolgend als VAR_ARG bezeichnet ,diese werden entsprechend konvertiert.

Im Ordner

DATENORDNER/luascript/other

befindet sich die Datei test_str.lua mit Beispielen.

arg: Formatiert die Eingaben zu einer Zeichenkette. Die Platzhalter sind dabei %1-%n und können mehrfach verwendet werden. Zum Ersetzen werden jeweils die zu n passenden Werte in {} verwendet. Wird mehr als eine Variable verwendet, muss eine zwei-dimensionale Tabelle verwendet werden ({{}}).

Parameter:

1) arg(string a, string b, int breite = 0, string fill = '  ')

Sofern breite ungleich 0 ist, wird die Restbreite mit dem Füllzeichen (fill) ausgefüllt. Ist breite negativ, wird links ausgerichtet, ansonsten rechts.

2) arg(int a, int breite = 0, int base = 10, string fill = '  ')

base ist die Zahlenbasis (2-36), normalerweise 10.

3) arg(double a, int breite = 0, string format = 'f', int precision = -1, string fill = '  ')

Wird format als 'g' eingestellt, wird kürzeste Darstellung verwendet.

Mit precision kann die Anzahl der Nachkommastellen festgelegt werden.

Beispiel:

assert(str.arg("%1", {1.23556789, 0, 'f', 2}) == "1.24");

assert(str.arg("%1|test|%2|%3|%4|%1",  { {"AB"}, {4.5666, 0, "f", 2}, {33,-10,10,'x'}, {"Chicken"} } )=="AB|test|4.57|33xxxxxxxx|Chicken|AB");

chopped: Gibt eine Zeichenkette zurück, die rechts um len Zeichen gekürzt ist.

chopped(VAR_ARG v, int len)

Beispiel:

assert(str.chopped("1234567890", 1)=="123456789");

compare: Vergleicht Werte als Zeichenkette. Gibt 0, zurück, falls diese identisch ist, -1, falls der erste Wert kleiner ist, ansonsten 1.

compare(VAR_ARG v1, VAR_ARG v2, bool case_sensitive=true, locale_aware=false, int precision=-1)

Mit case_sensitive kann eingestellt werden, ob Groß/Kleinschreibung ignoriert werden soll.

Mit locale_aware kann eingestellt werden, ob die aktuell eingestellt Locale verwendet werden soll.

Mit precision kann bei Zahlenwerten gerundet werden.

Beispiel:

assert(str.compare("A", "A")==0);

compare_num: Vergleicht Werte als Zahl. Gibt 0, zurück, falls diese identisch ist, -1, falls der erste Wert kleiner ist, ansonsten 1.

compare(VAR_ARG v1, VAR_ARG v2, int precision=-1)

Mit precision kann bei double-Werten gerundet werden.

Beispiel:

assert(str.compare_num(100000000000000, 100000000000001)==-1);

contains: Sucht einen Wert in einer Zeichenkette. Gibt true oder false zurück.

contains(VAR_ARG v1, VAR_ARG v2, bool case_sensitive=true)

Beispiel:

assert(str.contains("123äöüß", "ß"));

Flags für Funktionen mit regulären Ausdrücken:

REGEX_MATCH: Eine Wert wird gefunden, wenn die gesamte Suchzeichenkette mit dem Suchtext übereinstimmt.

REGEX_FIND: Eine Wert wird auch gefunden, wenn Teilzeichenkette in dem Suchtext übereinstimmt.

REGEX_EXT: Erweiterte Suche mit logischen Verknüpfungen. Siehe dazu unter Suche mit Platzhaltern.

Beispiel:

assert(str.contains_regex_wild("MüllerRechnung", "Rechnung{and}M{*}ller{;}Rechnung{and}Meier", str.REGEX_EXT |  str.REGEX_FIND));

REGEX_ICASE: Bei der Suche wird Groß/Kleinschreibung ignoriert. Dies ist bei Verwendung von REGEX_EXT immer der Fall.

REGEX_WILDCARD: Es wird mit Wildcards(*, ?) gesucht.

contains_regex: Sucht einen Wert in einer Zeichenkette mittels eines regulären Ausdrucks. Gibt true oder false zurück.

contains_regex(VAR_ARG v1, VAR_ARG v2, bool case_sensitive=true, int flags)

Zu flags siehe weiter oben.

Beispiel:

assert(str.contains_regex("(\\+|-)?[[:digit:]]+", find, str.REGEX_MATCH));

contains_regex_wild: Sucht einen Wert in einer Zeichenkette mittels Wildcards. Gibt true oder false zurück.

contains_regex(VAR_ARG v1, VAR_ARG v2, int flags)

Zu flags siehe weiter oben.

Beispiel:

assert(str.contains_regex_wild("123meineFirma.DBB", "m*.dbb", str.REGEX_FIND|str.REGEX_ICASE));

assert(str.contains_regex_wild("MüllerRechnung", "Rechnung{and}M{*}ller{;}Rechnung{and}Meier", str.REGEX_EXT |str.REGEX_MATCH));

count: Zählt die Anzahl des Vorkommens eines Wertes in einem Wert und gibt diese zurück.

count(VAR_ARG v1, VAR_ARG v2, bool case_sensitive=true)

Beispiel:

assert(str.count("äöüääää", "Ä", false)==5);

endsWith: Überprüft ob ein Wert mit einem Wert endet. Gibt true oder false zurück.

endsWith(VAR_ARG v1, VAR_ARG v2, bool case_sensitive=true)

Beispiel:

assert(str.endsWith("auto.Tüv", "tüv", false));

find_regex: Sucht in einem Wert mit einem regulären Ausdruck nach einem Wert und gibt die Ergebnisse als Tabelle (ein- oder zwei-dimensional) oder als Zeichenkette (REGEX_RET_AS_STRING) zurück. Captures sind möglich.

find_regex(VAR_ARG v1, VAR_ARG v2, int flags)

Zu flags siehe weiter oben, zusätzlich, können folgende Wert dazukombiniert werden:

REGEX_RET_MATCH: Es wird der gesuchte Wert zurückgegeben.

REGEX_RET_MATCH_INDEX: Es wird die Position des gesuchten Werts zurückgegeben.

REGEX_RET_CAPTURE: Es wird es wird ein optionales Capture zurückgegeben.

REGEX_RET_CAPTURE_INDEX:  Es wird die Position eines optionalen Capture zurückgegeben.

REGEX_RET_ALL = (REGEX_RET_MATCH|REGEX_RET_MATCH_INDEX|REGEX_RET_CAPTURE|REGEX_RET_CAPTURE_INDEX);

REGEX_RET_AS_STRING: Nur für REGEX_RET_MATCH oder REGEX_RET_CAPTURE. Gibt anstelle einer Tabelle eine Zeichenkette zurück, diese entspricht dem ersten gefundenen Eintrag, sofern zusätzlich REGEX_RET_COMBINED angegeben wurde, werden alle Zeichenketten addiert.

Beispiel:

local t={{"cX", 3, "X", 4}, {"cX", 7, "X", 8}, {"cX", 11, "X", 12}};

assert(str.compare_table(str.find_regex("abcXabcXabcX", "c(X)"), t));

Hinweis: Sofern nur einer der vier möglichen Ergebniswerte zurückgegeben werden soll (hier die Captures), ist die Tabelle eindimensional:

assert(str.compare_table(str.find_regex("abcXabcXabcX", "c(x)", str.REGEX_ICASE|str.REGEX_RET_CAPTURE), {"X", "X", "X"}));

Anmerk: compare_table vergleicht zwei Tabellen (maximal zwei-dimensional).

assert(        str.find_regex("Bank-1024", "\\d+", str.REGEX_ICASE|str.REGEX_RET_MATCH|str.REGEX_RET_AS_STRING)=="1024");

indexOf: Überprüft, ob ein Wert in einem einem Wert vorkommt, und gibt dessen Position oder nil zurück.

indexOf(VAR_ARG v1, VAR_ARG v2, int pos=1, bool case_sensitive=true)

pos ist die Position, ab der gesucht werden soll.

Beispiel:

local x = "sticky question";

local y = "sti";

assert(str.indexOf(x, y) == 1);              

assert(str.indexOf(x, y, 2) == 11);          

assert(str.indexOf(x, y, 11) == 11);          

assert(str.indexOf(x, y, 12) == nil);          

insert: Fügt einen Wert in einen anderen Wert an der Stelle pos ein, und gibt das Ergebnis zurück.

insert( int pos, VAR_ARG v1, VAR_ARG v2)

Beispiel:

assert(str.insert(1, "1234567890", "x")=="x1234567890");  

assert(str.insert(20, "1234567890", "x")=="1234567890         x");

lastIndexOf: Überprüft, ob ein Wert in einem einem Wert vorkommt, und gibt dessen letzte Position oder nil zurück. Um die gesamte Zeichenkette zu durchsuchen, muss pos -1 sein.

lastIndexOf(VAR_ARG v1, VAR_ARG v2, int pos=-1, bool case_sensitive=true)

Beispiel:

local x = "crazy azimuths";

local y = "az";

assert(str.lastIndexOf(x, y) == 7);        

assert(str.lastIndexOf(x, y, 7) == 7);      

assert(str.lastIndexOf(x, y, 6) == 3);    

assert(str.lastIndexOf(x, y, 2) == nil);  

left: Extrahiert len Zeichen aus einem Wert und gibt die resultierende Zeichenkette zurück.

left(VAR_ARG v1, int len)

Beispiel:

assert(str.left("1234", 3)=="123");

length: Ermittelt die Länge eines Werts (Anzahl Zeichen) und gibt diese zurück.

length(VAR_ARG v1)

Beispiel:

assert(str.length(1.3456789)==9);

mid: Extrahiert len Zeichen ab der Position pos aus einem Wert und gibt die resultierende Zeichenkette zurück. Ist len -1, werden alle Zeichen nach pos verwendet.

mid(VAR_ARG v1, int pos, int len=-1)

Beispiel:

assert(str.mid("1234567890", 5, 2)=="56");

assert(str.mid("1234567890", 5)=="567890");

assert(str.mid("1234567890", 5, -1)=="567890");

remove: Entfernt entweder len Zeichen ab der Position pos oder einen gesuchten Wert aus einem Wert und gibt die resultierende Zeichenkette zurück.

1) remove(VAR_ARG v1, int pos, int len)

2) remove(VAR_ARG v1, VAR_ARG v2, bool case_sensitive=true)

Beispiel:

assert(str.remove("1234567890", 5, 3)=="1234890");

assert(str.remove("12345678901234567890", "890")=="12345671234567");

replace: Ersetzt entweder len Zeichen ab der Position pos oder einen gesuchten Wert aus einem Wert mit einem anderen Wert und gibt die resultierende Zeichenkette zurück.

replace(VAR_ARG v1, int pos, int len, VAR_ARG v2)

replace(VAR_ARG v1, VAR_ARG v2, VAR_ARG v3, bool case_sensitive=true)

Beispiel:

assert(str.replace("1234567890", 5, 3, "ABC")=="1234ABC890");

assert(str.replace("ä12345678901234567890ä", "Ä", "abc", false)=="abc12345678901234567890abc");

replace_regex: Sucht mit einem regulären Ausdruck nach einem Wert, ersetzt das Vorkommen mit einem anderen Wert und gibt die resultierende Zeichenkette zurück.

replace_regex(VAR_ARG v1, VAR_ARG v2, VAR_ARG v3, int flags=0)

Zu flags siehe weiter oben.

Beispiel:

assert(str.replace_regex("Quick brown fox","a|e|i|o|u", "*")=="Q**ck br*wn f*x");

assert(str.replace_regex("Quick brown fox","Qu?", "S", str.REGEX_WILDCASE)=="Sick brown fox");

assert(str.replace_regex("sunflowers, sunburn, sunshine","(sun)(.*)", "$1")=="sun"); --capture

right: Extrahiert die letzten len Zeichen aus einem Wert und gibt die resultierende Zeichenkette zurück.

right(VAR_ARG v1, int len)

Beispiel:

assert(str.right("1234567890", 3)=="890");

startsWith: Überprüft ob ein Wert mit einem Wert anfängt. Gibt true oder false zurück.

startsWith(VAR_ARG v1, VAR_ARG v2, bool case_sensitive=true)

Beispiel:

assert(str.startsWith("auto.tüv", "AUTO.", false));

toLower, toUpper: Konvertiert eine Zeichenkette nach Groß-/ oder Kleinbuchstaben und gibt die resultierende Zeichenkette zurück.

toLower(VAR_ARG v1)

toUpper(VAR_ARG v1)

Beispiel:

local s="TextÄöüß";

assert(str.toLower(s)=="textäöüß");

assert(str.toUpper(s)=="TEXTÄÖÜß");

trimmed: Entfernt Zeichen vom Anfang, Ende oder Beides und gibt die resultierende Zeichenkette zurück.Wird als zu entfernendes Zeichen eine Leerzeichenkette übergeben, werden alle Spaces (\r\n\t\f\v) entfernt.

trimmed(VAR_ARG v1, VAR_ARG v2, trimflags=TRIM_ALL)

trimflags:

TRIM_ALL

TRIM_LEFT

TRIM_RIGHT

assert(str.trimmed("\r\n\t\"\'123     \t\t\f\v")=="\"\'123");

assert(str.trimmed("  1234567890\r\n  ", " ")=="1234567890\r\n");