Zeichenfolgen

Der Zeichenfolgen-Datentyp ist eine Folge von Zeichen, wie Buchstaben, Zahlen und Symbole. Es ist der Datentyp zur Speicherung der meisten textbasierten Informationen.

Zeichenfolgen deklarieren

Um eine Zeichenfolgenvariable zu deklarieren, setzen Sie Anführungszeichen um die Zeichen. Es ist üblicher, doppelte Anführungszeichen (" zu verwenden, aber einfache Anführungszeichen (') funktionieren ebenfalls. Wenn Sie ein einfaches oder doppelte Anführungszeichen in Ihrer Zeichenfolge einfügen möchten, schließen Sie Ihre Zeichenfolge in den anderen Anführungszeichenart ein oder verwenden Sie ein escaped quote.

local string1 = "Hallo Welt!"
print(string1)  --> Hallo Welt!

local string2 = 'Hallo "Welt"!'
print(string2)  --> Hallo "Welt"!

Um sowohl einfache als auch doppelte Anführungszeichen in einer Zeichenfolge einzufügen oder mehrzeilige Zeichenfolgen zu erstellen, deklarieren Sie sie mit doppelten Klammern:

local string1 = [[Hallo
Welt!
Hallo "Welt"!
Hallo 'Welt'!]]

print(string1)
--> Hallo
--> Welt!
--> Hallo "Welt"!
--> Hallo 'Welt'!

Falls notwendig, können Sie mehrere Klammern innerhalb einer Zeichenfolge verschachteln, indem Sie die gleiche Anzahl von gleichmäßigen Zeichen sowohl in der Anfangs- als auch in der Endklammer verwenden:

local string1 = [=[Hallo
[[Welt!]]
]=]

print(string1)
--> Hallo
--> [[Welt!]]

Zeichenfolgen kombinieren

Um Zeichenfolgen zu kombinieren, konkatenieren Sie sie mit zwei Punkten (..). Das Konkatenieren von Zeichenfolgen fügt keinen Raum zwischen ihnen ein, daher müssen Sie Leerzeichen am Ende/Beginn der vorhergehenden/nächsten Zeichenfolge einschließen oder ein Leerzeichen zwischen die beiden Zeichenfolgen hinzufügen.

local hello = "Hallo"
local helloWithSpace = "Hallo "
local world = "Welt!"

local string1 = hello .. world
local string2 = helloWithSpace .. world
local string3 = hello .. " " .. world

print(string1)  --> Hellowelt!
print(string2)  --> Hallo Welt!
print(string3)  --> Hallo Welt!

Beachten Sie, dass der print()-Befehl mehrere Argumente akzeptiert und sie mit Leerzeichen kombiniert, sodass Sie , anstelle von .. verwenden können, um Leerzeichen in print()-Ausgaben zu erzeugen.

local hello = "Hallo"
local world = "Welt"
local exclamationMark = "!"

print(hello .. world .. exclamationMark)  --> Hellowelt!
print(hello, world .. exclamationMark)  --> Hallo Welt!
print(hello, world, exclamationMark)  --> Hallo Welt !

Zeichenfolgen konvertieren

Um eine Zeichenfolge in eine Zahl zu konvertieren, verwenden Sie die Funktion tonumber(). Wenn die Zeichenfolge keine Zahlendarstellung hat, gibt tonumber() nil zurück.

local numericString = "123"
print(tonumber(numericString))  --> 123

local alphanumericString = "Hallo123"
print(tonumber(alphanumericString))  --> nil

Zeichenfolgen escapen

Um eine Zeichenfolgen-Deklaration mit doppelten oder einfachen Anführungszeichen zu escapen und fast jedes Zeichen einzubetten, setzen Sie einen Rückwärtsschrägstrich (\) vor das Zeichen. Zum Beispiel:

• Um ein einfaches Anführungszeichen in einer einfachen Anführungszeichen-Zeichenfolge einzubetten, verwenden Sie \'.
• Um ein doppeltes Anführungszeichen in einer doppelten Anführungszeichen-Zeichenfolge einzubetten, verwenden Sie \".

local string1 = 'Hallo \'Welt\'!'
print(string1)  --> Hallo 'Welt'!

local string2 = "Hallo \"Welt\"!"
print(string2)  --> Hallo "Welt"!

Einige Zeichen, die auf Rückwärtsschrägstriche folgen, erzeugen spezielle Zeichen anstelle von escaped Zeichen:

• Um eine neue Zeile einzubetten, verwenden Sie \n.
• Um einen horizontalen Tabulator einzubetten, verwenden Sie \t.

local string1 = "Hallo\nWelt!"
print(string1)
--> Hallo
--> Welt!

local string2 = "Hallo\tWelt!"
print(string2)  --> Hallo	Welt!

Zeichenfolgeninterpolation

Luau unterstützt Zeichenfolgeninterpolation, eine Funktion, mit der Sie Ausdrücke in Zeichenfolgen einfügen können. Verwenden Sie Rückwärtsnutzungen (`), um eine interpolierte Zeichenfolge zu deklarieren, und fügen Sie dann Ausdrücke in geschweifte Klammern ein:

local world = "Welt"

local string1 = `Hallo {world}!`
print(string1)  --> Hallo Welt!

Obwohl Variablen die häufigste Verwendung sind, können Sie jeden Ausdruck verwenden, einschließlich Mathematik:

local world = "Welt"
local number = 1
local letters = {"w", "o", "r", "l", "d"}

local string1 = `Hallo {world}, {number} Mal!`
local string2 = `Hallo {world}, {number + 1} Mal!`
local string3 = `Hallo {table.concat(letters)} ein drittes Mal!`

print(string1)  --> Hallo Welt, 1 Mal!
print(string2)  --> Hallo Welt, 2 Mal!
print(string3)  --> Hallo Welt ein drittes Mal!

Die Standard-escape-Regeln gelten auch für Rückwärtsnutzungen, geschweifte Klammern und Rückwärtsschrägstriche:

local string1 = `Hallo \`\{world\}\`!`
print(string1)  --> Hallo `{world}`!

Mathematische Konvertierung

Wenn Sie mathematische Operationen auf einer Zeichenfolge durchführen, konvertiert Luau die Zeichenfolge automatisch in eine Zahl. Wenn die Zeichenfolge keine Zahlendarstellung hat, wird ein Fehler ausgegeben.

print("55" + 10)  --> 65
print("55" - 10)  --> 45
print("55" * 10)  --> 550
print("55" / 10)  --> 5.5
print("55" % 10)  --> 5
print("Hallo" + 10)	 --> print("Hallo" + 10):1: Versuch, arithmetische (Addition) auf Zeichenfolge und Zahl durchzuführen

Vergleiche

Zeichenfolgen können mit den Operatoren <, <=, > und >= verglichen werden, die lexikografische Ordnung basierend auf den ASCII-Codes jedes Zeichens in einer Zeichenfolge verwenden. Dies führt dazu, dass Zahlen in Zeichenfolgen nicht korrekt verglichen werden, z. B. wird "100" weniger als "20" sein, da die Bytes "0" und "1" niedrigere ASCII-Codes haben als das Byte "2".

print("Apfel" < "apfel") --> true
print("Banane" < "apfel") --> true (B kommt vor a im ASCII)
print("nummer100" < "nummer20") --> true

Zeichenfolgenmusterreferenz

Ein Zeichenfolgenmuster ist eine Kombination von Zeichen, die Sie mit string.match(), string.gmatch() und anderen Funktionen verwenden können, um ein Stück oder eine Teilzeichenfolge aus einer längeren Zeichenfolge zu finden.

Direkte Übereinstimmungen

Sie können direkte Übereinstimmungen in einer Luau-Funktion wie string.match() verwenden, mit Ausnahme von magischen Zeichen. Zum Beispiel suchen diese Befehle nach dem Wort Roblox innerhalb einer Zeichenfolge:

local match1 = string.match("Willkommen bei Roblox!", "Roblox")
local match2 = string.match("Willkommen bei meinem tollen Spiel!", "Roblox")
print(match1)  --> Roblox
print(match2)  --> nil

Zeichenklasssen

Zeichenklassen sind für fortgeschrittenere Zeichenfolgensuchen unerlässlich. Sie können sie verwenden, um nach etwas zu suchen, das nicht unbedingt zeichen-spezifisch ist, aber in eine bekannte Kategorie (Klasse) wie Buchstaben, Ziffern, Leerzeichen, Interpunktion und mehr passt.

Die folgende Tabelle zeigt die offiziellen Zeichenklassen für Luau-Zeichenfolgenmuster:

Für einbuchstabige Zeichenklassen wie %a und %s repräsentiert der entsprechende Großbuchstabe das "Gegenteil" der Klasse. Zum Beispiel repräsentiert %p ein Interpunktionszeichen, während %P alle Zeichen repräsentiert, die keine Interpunktion sind.

Magische Zeichen

Es gibt 12 "magische Zeichen", die für spezielle Zwecke in Mustern reserviert sind:

Sie können magische Zeichen mit dem %-Symbol escapen und danach suchen. Um zum Beispiel nach roblox.com zu suchen, escapen Sie das . (Punkt) Symbol, indem Sie es mit einem % voranstellen, wie in %..

-- "roblox.com" passt auf "roblox#com", da der Punkt als "jedes Zeichen" interpretiert wird
local match1 = string.match("Was ist roblox#com?", "roblox.com")
print(match1)  --> roblox#com

-- Entkommen Sie dem Punkt mit % , damit er als literales Punktzeichen interpretiert wird
local match2 = string.match("Ich liebe roblox.com!", "roblox%.com")
print(match2)  --> roblox.com

Anker

Sie können nach einem Muster am Anfang oder am Ende einer Zeichenfolge suchen, indem Sie die Symbole ^ und $ verwenden.

local start1 = string.match("erstes zweites drittes", "^erstes")  -- Passt, weil "erstes" am Anfang ist
print(start1)  --> erstes

local start2 = string.match("drittes zweites erstes", "^erstes")  -- Passt nicht, weil "erstes" nicht am Anfang ist
print(start2)  --> nil

local end1 = string.match("erstes zweites drittes", "drittes$")  -- Passt, weil "drittes" am Ende ist
print(end1)  --> drittes

local end2 = string.match("drittes zweites erstes", "drittes$")  -- Passt nicht, weil "drittes" nicht am Ende ist
print(end2)  --> nil

Sie können auch sowohl ^ als auch $ zusammen verwenden, um sicherzustellen, dass ein Muster nur die vollständige Zeichenfolge und nicht nur einen Teil davon übereinstimmt.

-- Verwendung von ^ und $ um eine volle Zeichenfolge zu entsprechen
local match1 = string.match("Roblox", "^Roblox$")  -- Passt, weil "Roblox" die gesamte Zeichenfolge ist (Gleichheit)
print(match1)  --> Roblox

local match2 = string.match("Ich spiele Roblox", "^Roblox$")  -- Passt nicht, weil "Roblox" nicht am Anfang UND am Ende ist
print(match2)  --> nil

local match3 = string.match("Ich spiele Roblox", "Roblox")  -- Passt, weil "Roblox" in "Ich spiele Roblox" enthalten ist
print(match3)  --> Roblox

Klassenmodifikatoren

Für sich allein passt eine Zeichenklasse nur ein Zeichen in einer Zeichenfolge. Zum Beispiel beginnt das folgende Muster ("%d") damit, die Zeichenfolge von links nach rechts zu lesen, findet die erste Ziffer (2) und stoppt.

local match = string.match("Das Cloud-Königreich hat 25 Kraft-Juwelen", "%d")
print(match)  --> 2

Sie können Modifikatoren mit beliebiger Zeichenklasse verwenden, um das Ergebnis zu steuern:

Das Hinzufügen eines Modifikators zum selben Muster ("%d+" anstelle von "%d"), gibt 25 anstelle von 2 zurück:

local match1 = string.match("Das Cloud-Königreich hat 25 Kraft-Juwelen", "%d")
print(match1)  --> 2

local match2 = string.match("Das Cloud-Königreich hat 25 Kraft-Juwelen", "%d+")
print(match2)  --> 25

Klassensätze

Mengen sollten verwendet werden, wenn eine einzelne Zeichenklasse den gesamten Job nicht erledigen kann. Zum Beispiel möchten Sie möglicherweise sowohl Kleinbuchstaben (%l) als auch Interpunktion (%p) mit einem einzigen Muster übereinstimmen.

Mengen werden durch eckige Klammern [] um sie herum definiert. Im folgenden Beispiel bemerken Sie den Unterschied zwischen der Verwendung einer Menge ("[%l%p]+") und nicht der Verwendung einer Menge ("%l%p+").

local match1 = string.match("Hallo!!! Ich bin eine andere Zeichenfolge.", "[%l%p]+")  -- Menge
print(match1)  --> ello!!!

local match2 = string.match("Hallo!!! Ich bin eine andere Zeichenfolge.", "%l%p+")  -- Nicht-Menge
print(match2)  --> o!!!

Der erste Befehl (Menge) sagt Luau, dass es sowohl Kleinbuchstaben als auch Interpunktion finden soll. Mit dem hinzugefügten +-Quantifizierer findet es alle diese Zeichen (ello!!!), und stoppt, wenn es den Raum erreicht.

Im zweiten Befehl (Nicht-Menge) bezieht sich der +-Quantifizierer nur auf die %p-Klasse davor, sodass Luau nur das erste Kleinbuchstabenzeichen (o) vor der Reihe von Interpunktionen (!!!) erfasst.

Wie Zeichenklassen können Mengen die "Gegenteile" ihrer selbst sein. Dies geschieht, indem Sie ein ^-Zeichen zu Beginn der Menge hinzufügen, direkt nach der öffnenden [. Zum Beispiel repräsentiert "[%%p%s]+" sowohl Interpunktion als auch Leerzeichen, während "[^%p%s]+" alle Zeichen außer Interpunktion und Leerzeichen repräsentiert.

Mengen unterstützen auch Bereiche, mit denen Sie einen gesamten Bereich von Übereinstimmungen zwischen einem Start- und einem Endzeichen finden können. Dies ist eine erweiterte Funktion, die im Detail im Lua 5.1 Handbuch umrissen wird.

Zeichenfolgenfänge

Zeichenfolgen-fänge sind Teilmuster innerhalb eines Musters. Diese sind in Klammern () eingeschlossen und werden verwendet, um (zu erfassen) übereinstimmende Teilzeichenfolgen und sie in Variablen zu speichern. Zum Beispiel enthält das folgende Muster zwei Fänge, (%a+) und (%d+), die zwei Teilzeichenfolgen bei einem erfolgreichen Match zurückgeben.

local pattern = "(%a+)%s?=%s?(%d+)"

local key1, val1 = string.match("Einundzwanzig = 21", pattern)
print(key1, val1)  --> Einundzwanzig 21

local key2, val2 = string.match("Zweitausend= 2000", pattern)
print(key2, val2)  --> Zweitausend 2000

local key3, val3 = string.match("Eine Million=1000000", pattern)
print(key3, val3)  --> Eine Millionen 1000000

Der ?-Quantifizierer, der beiden %s-Klassen folgt, ist eine sichere Ergänzung, da er den Raum auf beiden Seiten des =-Zeichens optional macht. Das bedeutet, dass die Übereinstimmung erfolgreich ist, wenn eines (oder beide) Leerzeichen um das Gleichheitszeichen fehlt.

In der Funktion string.gsub() können Sie Fanggruppen im Ersetzungsstring mit %1, %2, %3 usw. bis %9 einfügen. Obwohl Luau bis zu 32 Fanggruppen unterstützt, bevor ein Fehler auftritt, können Sie nur die ersten neun mit dieser Syntax referenzieren:

local str = "liebe2spielen Roblox"
local pattern = "(%w+)(%d+)(%w+)%s+(%w+)"
local replacement = "Ich %1 %2 %3 %4!"

local result = string.gsub(str, pattern, replacement)
print(result) --> Ich liebe 2 spielen Roblox!

Sie können auch Zeichenfolgenfänge verschachteln:

local places = "Das Cloud-Königreich ist himmlisch, Das Wald-Königreich ist friedlich"
local pattern = "(Das%s(%a+%sKönigreich)[%w%s]+)"

for description, kingdom in string.gmatch(places, pattern) do
	print(description)
	print(kingdom)
end
--> Das Cloud-Königreich ist himmlisch
--> Cloud-Königreich
--> Das Wald-Königreich ist friedlich
--> Wald-Königreich

Diese Mustersuche funktioniert wie folgt:

Der string.gmatch()-Iterator sucht nach einer Übereinstimmung mit dem gesamten "Beschreibung"-Muster, das durch das äußere Klammernpaar definiert ist. Dies stoppt beim ersten Komma und erfasst Folgendes:

Mit seinem erfolgreichen ersten Fang sucht der Iterator dann nach einer Übereinstimmung mit dem "Königreich"-Muster, das durch das innere Klammernpaar definiert ist. Dieses verschachtelte Muster erfasst einfach Folgendes:

Der Iterator geht dann zurück und sucht weiter in der gesamten Zeichenfolge und erfasst Folgendes:

Zusätzlich zu all dem oben genannten gibt es einen Sonderfall mit einem leeren Fang (()). Wenn ein Fang leer ist, wird die Position in der Zeichenfolge erfasst:

local match1 = "Wo passiert der Fang? Wer weiß das schon!"
local match2 = "Diese Zeichenfolge ist länger als die erste. Wo passiert der Fang? Wer weiß das schon?!"

local pattern = "()Wo passiert der Fang%? Wer weiß!"

local start1, finish1 = string.match(match1, pattern)
print(start1, finish1)  --> 1 42

local start2, finish2 = string.match(match2, pattern)
print(start2, finish2)  --> 43 84

Diese speziellen Fänge können wie normale Fänge geschachtelt werden:

local places = "Das Cloud-Königreich ist himmlisch, Das Wald-Königreich ist friedlich."
local pattern = "Das (%a+()) Königreich ist %a+"

for kingdom, position in string.gmatch(places, pattern) do
	print(kingdom, position)
end
--> Cloud 10
--> Wald 42

Die zurückgegebenen Werte sind insofern ungewöhnlich, als sie Zahlen anstelle von Zeichenfolgen sind:

local match = "Das ist ein Beispiel"
local pattern = "Das ist ein ()Beispiel"

local position = string.match(match, pattern)
print(typeof(position))  --> zahl