Lua Logo
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

nach obenstring.byte

string.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.
Beispiele:

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.

nach obenstring.char

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.
Beispiel:

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.


nach obenstring.dump

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

nach obenstring.find

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
Diese Funktion sucht in cString nach cWas. Die Suche Beginnt bei nAbWo.
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.


nach obenstring.format

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)
Im Formatierungsstring kommen aneinandergereiht die Formatierungswünsche beginnend mit %. Dazwischen kann beliebiger Text oder andere Formatierungen stehen.
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
Beispiele:

%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"



nach obenstring.len

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.
Beispiele:

laenge = string.len ("abc")
print( laenge ) --> 3
laenge = string.len ("abc\ndef")
print( laenge ) --> 7 weil hier \n als ein Zeichen gewertet wird

nach obenstring.lower

string.lower (meinString)

Wandelt einen String in Kleinbuchstaben um.

Parameter:
  • Der String (Zeichenkette), den ich umwandeln möchte.
Beispiel:

rueckGabe = string.lower ("AbC5")
print( rueckGabe ) --> abc5

nach obenstring.rep

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.
Beispiele:

rueckGabe = string.rep ("Lua ", 5)
print( rueckGabe ) --> Lua Lua Lua Lua Lua
rueckGabe = string.rep ("Lua", 5)
print( rueckGabe ) --> LuaLuaLuaLuaLua


nach obenstring.sub

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)
Der letzte Parameter ist optional. D.h. er muss nicht angegeben werden. Fehlt er wird bis zum Ende alles ausgegeben.

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


nach obenstring.upper

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


nach obenstring.gfind

string.gsub (cString, cWas )

Parameter
  • Der String in dem gesucht werden soll.
  • Was gesucht werden soll
Diese Funktion liefert eine Funktion zurück, die in cString nach cWas sucht und gibt es dann zurück.
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

nach obenstring.gsub

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)
Diese Funktion sucht in cString nach cWas. Und ersetzt es dann durch cWodurch.
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
Die Vervielfältigung der auf diesen Seiten enthaltenen Informationen und Grafiken ist untersagt, ausgenommen davon ist sämtlicher auf diesen Seiten angezeigter Quellcode.
Siehe auch: Haftungsausschluss
Copyright © Robert Schmitz 2006