Funktionen im table string
string.byte (s [, i])
string.char (i1, i2, ...)
string.dump (function)
string.find (s, pattern [, init [, plain]])
string.format (formatstring, e1, e2, ...)
string.len (s)
string.lower (s)
string.rep (s, n)
string.sub (s, i [, j])
string.upper (s)
string.gfind (s, pat)
string.gsub (s, pat, repl [, n])
mit * sind noch nicht fertig
string.bytestring.byte (meinString [, position])
Diese Funktion gibt den numerischen Wert des Zeichens an der Position aus. Liegt die Position außerhalb des Strings so wird nil zurückgegeben. Ist position negativ wird von hinten begonnen.
Parameter:
- Der String, aus dem ich den numerischen Wert eines Zeichens wissen will
- Die Position des Zeichens. Ist diese nicht angegeben, so wird das 1. genommen.
nChar = string.byte("abcdefg",5)
print( nChar) --> 101 da e in der ASCII - Tabelle den Wert 101 besitzt
nChar = string.byte("abcdefg",-3)
print( nChar) --> 101 da das dritte Zeichen von hinten wiederum e ist
nChar = string.byte("abcdefg", 8)
print( nChar) --> nil, weil wir außerhalb liegen
nChar = string.byte("abcdefg", 0)
print( nChar) --> nil, weil das Zählen mit eins beginnt
Zu beachten ist noch, dass dies nicht auf allen Plattformen gleich ist.
string.char (zahl1, zahl2, ...)
Diese Funktion reiht die als numerichen Wert eines Zeichens übergebenen Werte zu einem String zusammen. Wird nichts angegeben, so wird eine leerer String zurückgegeben.
Parameter:
- Die Zahlen, aus der Zeichentabelle, die ich aneinanderreihen will.
rueckGabe = string.char(65,66,67)
print (rueckGabe) --> ABC
resultat = string.char (68,97,115,32,105,115,116,32,100,97,115,32,72,97,117,115,32,
118,111,109,32,78,105,107,111,108,97,117,115,46 )
print ( resultat ) --> Das ist das Haus vom Nikolaus.
string.dump (MyFunktion)
Parameter
- Die Funktion, die in eine binäre Form umgewandelt werden soll
Hier fällt mir auch nichts mehr als eine freie Übersetzung des englischen ein.
Diese Funktion wandelt eine Lua-Funktion in eine binäre Form um. Die Funktion loadstring kann sie dann wieder in eine Funktion umwandeln.
Strings kann man abspeichern. Funktionen nicht. Oder nur als Lua-Text.
Dann dürfen auch keine upvalues drin sein (weiß der Teufel, was das ist).
Eine englische Erklärung dazu
string.find (cString, cWas [, nAbWo [, lAuchFormatierung]])
Parameter
- Der String in dem gesucht werden soll.
- Was gesucht werden soll
- Ab wo gesucht werden soll (wenn nicht angegeben von Beginn an)
- Ob Formatierungszeichen auch gesucht werden sollen
Ist lAuchFormatierung true, dann werden Formatierungszeichen als einfacher Text behandelt. In dem Fall muss nAbWo auch angegeben werden.
Rückgaben
- wo cWas beginnt
- wo cWas endet
- oder nil wenn nicht gefunden.
- Dann der Reihe nach die gefundenen Stücke (je nach Formatierungszeichen)
Beispiele:
nBeginn, nEnde = string.find("Hello Lua user", "Lua")
print( nBeginn, nEnde ) --> 7 9
nBeginn, nEnde =string.find("Hello Lua user", "Lua" , 8)
print( nBeginn, nEnde ) --> nil nil
Für die folgenden Beispiele benötigen wir ein Formatierungszeichen
%s -- bedeutet Leerzeichen
wir vollen ein Leerzeichen gefolgt von einem u suchen.
nBeginn, nEnde = string.find("Hello Lua user", "%su")
print( nBeginn, nEnde ) --> 11 12 Es wurde nach " u" gesucht und gefunden
jetzt benutzen wir den letzten Parameter, dass heißt er soll die genaue Zeichenfolge suchen. Ungeachtet ob es sich um ein Steuerzeichen handelt.
nBeginn, nEnde = string.find("Hello Lua user", "%su", 1, true)
print( nBeginn, nEnde ) --> nil nil Es wurde nach "%su" gesucht und nicht gefunden.
string.format(Formatierungsstring, teil1, teil2, teil3, ....)
Formatiert einen String in gewünschter Weise
Parameter:
- Der Formatierungsstring (wie man es wünscht)
- Die einzelnen Teilstrings (oder Zahlen)
Jede mit % anfangende Zeichen wird für den entsprechenden Teilstring genommen.
string.format( "%s %q", "Hello", "Lua user!")
Hier gilt %s für "Hello" dann ein Leerzeichen dann %q für "Lua user!". Immer der Reihe nach.
Die Möglichkeiten einen String zu formatieren
- %c Wandelt eine Zahl in ein ASCII - Zeichen um
- %d
- %E, %e Gibt eine Zahl mit Exponentialwert aus E+00 oder e+00
- %f Gibt eine Zahl mit maximal 6 Stellen hinter dem Komma aus
- %g, %G Gibt eine Zahl mit insgesamt 6 Stellen aus. Wenn nötig mit e+00 oder E+00
- %i
- %o Wandelt eine Zahl in octal um
- %u
- %X, %x Wandelt eine Zahl in hexadezimal um.
- %q Umgibt einen String mit Anführungszeichen
- %s gibt den String unverändert aus
%c
Wandelt eine Zahl in ein ASCII - Zeichen um
rueckGabe = string.format("%c%c%c", 76,117,97)
print (rueckGabe) --> Lua
%E, %e
Gibt eine Zahl mit Exponentialwert aus. Bei kleinem e wird das e klein geschrieben und umgekehrt.
Maximal 6 Stellen hinter dem Komma
rueckGabe = string.format("%E, %e",99948750.98470861,9994875011)
print (rueckGabe) --> 9.994875E+07, 9.994875e+09
Wir haben ein Komma und ein Leerzeichen dazwischen.
%f
Gibt eine Zahl mit 6 Stellen hinter dem Komma aus und rundet wenn nötig
rueckGabe = string.format("%f", 76.1179)
print (rueckGabe) --> 76.117900
rueckGabe = string.format("%f", 76.11798888)
print (rueckGabe) --> 76.117989 -- gerundet --
rueckGabe = string.format("%f", 7611798888)
print (rueckGabe) --> 7611798888.000000
%g, %G
Gibt eine Zahl mit insgesamt 6 Stellen aus. Wenn nötig mit e+00 oder E+00. Groß- und Kleinschreibung wie oben.
rueckGabe = string.format("%g", 76117988088)
print (rueckGabe) --> 7.6118e+10
rueckGabe = string.format("%G", 76117988088)
print (rueckGabe) --> 7.6118E+10
rueckGabe = string.format("%G", 76117)
print (rueckGabe) --> 76117
%o
Wandelt eine Zahl in octal um
rueckGabe = string.format("%o", 7)
print (rueckGabe) --> 7
rueckGabe = string.format("%o", 8)
print (rueckGabe) --> 10
rueckGabe = string.format("%o", 9)
print (rueckGabe) --> 11
%X, %x
Wandelt eine Zahl in hexadezimal um. Groß- und Kleinschreibung wie oben.
rueckGabe = string.format("%x", 9)
print (rueckGabe) --> 9
rueckGabe = string.format("%x", 10)
print (rueckGabe) --> a
rueckGabe = string.format("%X", 11)
print (rueckGabe) --> B
rueckGabe = string.format("%x", 17)
print (rueckGabe) --> 11
%s
Gibt einfach den String so wie er eingegeben ist aus
rueckGabe = string.format("%s", "Hallo ihr")
print (rueckGabe) --> Hallo ihr
%q
Umgibt den String mit Anführungszeichen.
rueckGabe = string.format("%q", "Hallo ihr")
print (rueckGabe) --> "Hallo ihr"
string.len (meinString)
Diese Funktion gibt die Länge des Strings zurück. Zu beachten ist, dass Formatierungszeichen jeweils nur 1 Stelle haben.
Parameter:
- Der String (Zeichenkette), dessen Länge ich gerne wüßte.
laenge = string.len ("abc")
print( laenge ) --> 3
laenge = string.len ("abc\ndef")
print( laenge ) --> 7 weil hier \n als ein Zeichen gewertet wird
string.lower (meinString)
Wandelt einen String in Kleinbuchstaben um.
Parameter:
- Der String (Zeichenkette), den ich umwandeln möchte.
rueckGabe = string.lower ("AbC5")
print( rueckGabe ) --> abc5
string.rep (string, nAnzahl)
Diese Funktion vervielfältigt string nAnzahl mal
Parameter:
- Der String (Zeichenkette), den ich vervielfältigen möchte.
- Wie oft ich das möchte.
rueckGabe = string.rep ("Lua ", 5)
print( rueckGabe ) --> Lua Lua Lua Lua Lua
rueckGabe = string.rep ("Lua", 5)
print( rueckGabe ) --> LuaLuaLuaLuaLua
Diese Funktion gibt einen Teil-String des originalen Strings zurück.
Als Parameter ist folgendes zu übergeben:
- Der originale String
- Ab wo er ausschneiden soll
- Bis wo er ausschneiden soll (optional)
resultat = string.sub (orginalString, abWo[, bisWo])
Beispiele:
orginalString = "Der Wind bläst sehr stark."
resultat= string.sub (orginalString, 5, 8)
--> resultat = "Wind" weil Nr. 5 = W und Nr. 8 = d
-------------------------------------------------------
orginalString = "Der Wind bläst sehr stark."
resultat= string.sub (orginalString, 5)
--> resultat = "Wind bläst sehr stark." weil Nr. 5 = W und kein Ende gesetzt
string.upper (meinString)
Wandelt einen String in Großbuchstaben um.
Parameter:
Der String (Zeichenkette), den ich umwandeln möchte.
Beispiel:
rueckGabe = string.upper ("AbC5")
print( rueckGabe ) --> ABC5
string.gsub (cString, cWas )
Parameter
- Der String in dem gesucht werden soll.
- Was gesucht werden soll
Die zurückgegebene Funktion merkt sich, bis wo sie schon gesucht hat und gibt bein nächsten Aufruf auch das nächte Vorkommen zurück. Bis der String abgearbeitet ist. Ex und hop ;)
Rückgabe
- Die Such-Funktion.
"%a" sucht nach Buchstaben.
"%a+" sucht nach Buchstaben, solange welche folgen.
Zunächst eine einfache Anwendung:
cString = "hello wor1ld from Lua" -- man beachte die 1
MyFunc=string.gfind(s, "%a+")
print( MyFunc() ) --> hello
print( MyFunc() ) --> wor Die 1 ist kein Buchstabe
print( MyFunc() ) --> ld
print( MyFunc() ) --> from
print( MyFunc() ) --> Lua
print( MyFunc() ) --> Die Funktion liefert ab jetzt nichts mehr
Sie ist also nutzlos geworden.
1. Anwendung mit der generischen for-Schleife:
cString = "hello world from Lua"
for wort in string.gfind(cString, "%a+") do
print(wort)
end
Ausgabe:
hello
world
from
Lua
2. Anwendung mit der generischen for-Schleife:
myTable = {}
cString = "from=world, to=Lua"
for k, v in string.gfind(cString, "(%w+)=(%w+)") do
myTable[k] = v
end
Hier wird nach einem Wort gesucht, gefolgt von einem Gleichheitszeichen dann gefolgt von einem Wort
Wort 1 kommt in die erste Variable k
Wort 2 kommt dann in v
Dann ist myTable wie folgt besetzt:
myTable["from"] == "world"
myTabel["to"] == "Lua"
oder, um ein wenig Tablekunde zu machen:
myTable.from == "world"
myTabel.to == "Lua"
3. Anwendung mit der generischen for-Schleife:
myTable = {}
cString = "from=world*auto, to=Lua*bauto"
for k, v, n in string.gfind(cString, "(%w+)=(%w+)*(%w+)") do
print(k)
print(v)
print(n)
end
Ausgabe:
from
world
auto
to
Lua
bauto
string.gsub (cString, cWas , cWodurch [, nWieOft]])
Parameter
- Der String in dem getauscht werden soll.
- Was getauscht werden soll
- Wodurch es ersetzt werden soll
- Wie oft es getauscht werden soll (wenn nicht angegeben: alle Vorkommen)
Ist nWieOft angegeben, so wird nur so oft getauscht.
Die Funktion ist sehr mächtig. Und wie alles, was viel kann, ist die Bedienung etwas schwieriger.
zwei Rückgaben
- Der neue String.
- Wie oft getauscht wurde.
Der einfachste Weg diese Funktion zu gebrauchen ist das Tauschen von zwei verschiedenen Stringteilen.
cNeuString, nWieOft = string.gsub("Das ist das Haus vom Nikolaus", "D", "d")
print (cNeuString, nWieOft) --> das ist das Haus vom Nikolaus 1
cNeuString, nWieOft = string.gsub("Das ist das Haus vom Nikolaus", "as", "ies")
print (cNeuString, nWieOft) --> Dies ist dies Haus vom Nikolaus 2
Für alles weitere sollte man sich mit den Formatierungszeichen auskennen.
Ist etwas in cWas eingeklammert, so ist das wie ein Parameter zu sehen, der in cWodurch mit %1 ersetzt werden kann ( %2, %3, ....)
"a(s)" hier ist das "s" der Parameter %1
cNeuString, nWieOft = string.gsub("Das ist das Haus vom Nikolaus", "a(us)", "i%1") --hier ist das "us" = %1
print (cNeuString, nWieOft) --> Das ist das Hius vom Nikolius 2
cNeuString, nWieOft = string.gsub("Das ist das Haus vom Nikolaus", "(a)(us)", "%2%1") --hier ist das "us" = %2 und "a" = %1
print (cNeuString, nWieOft) --> Das ist das Husa vom Nikolusa 2
Hier wird also getauscht.
Man kann auch beliebige Zeichen zufügen.
cNeuString, nWieOft = string.gsub("Das ist das Haus vom Nikolaus", "(a)(us)", "--%2++%1()")
print (cNeuString, nWieOft) --> Das ist das H--us++a() vom Nikol--us++a() 2
Wird als dritter Parameter eine Funktion angegeben, so durchläuft es die Funktion mit dem Gefundenen als Parameter. Gibt die Funktion einen String oder eine Zahl zurück, so wird das Gefundene mit diesem Wert ersetzt. Ansonsten wird das Gefundene ausgeschnitten.
Fur Beispiele benötigen wir Wissen um:
"%w" sucht nach Buchstaben und Zahlen.
"%w+" sucht nach Buchstaben und Zahlen, solange welche folgen.
Beispiele:
cNeuString, nWieOft = string.gsub("Das ist das Haus vom Nikolaus", "%w+", print)
print (cNeuString, nWieOft)
--> durch die Funktion print wird zuerst gedruckt:
Das
ist
das
Haus
vom
Nikolaus
Dann die Rückgabe: 5 Leerzeichen, und die 6 ; print gibt ja nicht zurück. Alle Worte sind daher weg und es bleiben die Leerzeichen übrig. 6 Worte sind gefunden worden.
Wir machen uns eine eigene primitive print-Funktion
function MyPrint(_wert)
print(_wert)
return "(".._wert..")"
end
cNeuString, nWieOft = string.gsub("Das ist das Haus vom Nikolaus", "%w+", MyPrint)
print (cNeuString, nWieOft)
--> durch die Funktion print in MyPrint wird zuerst gedruckt:
Das
ist
das
Haus
vom
Nikolaus
Dann die Rückgabe: (Das) (ist) (das) (Haus) (vom) (Nikolaus) 6