Lua Academy · Lektion

Teilzeichenketten finden und extrahieren

Verwenden Sie string.find und string.sub, um Text zu suchen und zu extrahieren

Teilzeichenketten finden und extrahieren ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Grundlagen von string.find

string.find(s, pattern, init, plain) sucht ab init (Standardwert 1) in s nach einem Muster. Die Funktion gibt die Start- und Endposition des Treffers zurück oder nil, wenn nichts gefunden wurde. Mit plain=true wird das Muster als literaler String behandelt (ohne Sonderzeichen).

local s = "hello world"
local i, j = string.find(s, "world")
print(i, j)    -- 7  11

-- Plain search (literal string)
local i2, j2 = string.find("a+b=5", "+", 1, true)
print(i2, j2)  -- 2  2

-- Not found
print(string.find(s, "xyz"))  -- nil

string.sub zum Extrahieren

string.sub(s, i, j) extrahiert den Teilstring von Position i bis einschließlich j. Negative Indizes werden vom Ende aus gezählt: -1 ist das letzte Zeichen. Wenn j fehlt, wird standardmäßig das Ende des Strings verwendet.

local s = "hello world"
print(string.sub(s, 1, 5))    -- hello
print(string.sub(s, 7))       -- world
print(string.sub(s, -5))      -- world
print(string.sub(s, 1, -7))   -- hello
print(s:sub(7, 11))           -- world (method syntax)

find und sub kombinieren

Kombinieren Sie string.find und string.sub, um Teilstrings zu finden und zu extrahieren. Suchen Sie zuerst das Trennzeichen und extrahieren Sie anschließend die Teile darum herum. Dies ist der grundlegende Ansatz zum Aufteilen von Strings.

local s = "key=value"
local i = string.find(s, "=")
if i then
  local key = string.sub(s, 1, i - 1)
  local val = string.sub(s, i + 1)
  print(key, val)   -- key  value
end

string.match zum Erfassen von Mustern

string.match(s, pattern, init) gibt die Teilstrings zurück, die dem Muster entsprechen und erfasst wurden. Enthält das Muster keine Erfassungsgruppen, gibt die Funktion den gesamten Treffer zurück. Wenn nichts übereinstimmt, wird nil zurückgegeben. Erfassungsgruppen werden im Muster mit Klammern definiert.

local date = "2024-03-15"
local y, m, d = string.match(date, "(%d+)-(%d+)-(%d+)")
print(y, m, d)   -- 2024  03  15

-- No capture: returns the whole match
local num = string.match("price: 42.5 USD", "%d+%.%d+")
print(num)       -- 42.5

Das letzte Vorkommen finden

Um das letzte Vorkommen eines Teilstrings zu finden, suchen Sie in einer Schleife und verschieben Sie die Startposition weiter oder suchen Sie vom Ende aus. Der übliche Ansatz besteht darin, string.find wiederholt mit der Position direkt nach dem vorherigen Treffer aufzurufen, bis nil zurückgegeben wird.

local function findLast(s, sub)
  local last_i, last_j
  local i, j = string.find(s, sub, 1, true)
  while i do
    last_i, last_j = i, j
    i, j = string.find(s, sub, j + 1, true)
  end
  return last_i, last_j
end

local i, j = findLast("a/b/c/d", "/")
print(i, j)   -- 6  6

Dateierweiterungen extrahieren

Eine praktische Anwendung von string.match ist das Extrahieren der Erweiterung eines Dateinamens. Das Muster "([^%.]+)$" erfasst die letzte Folge von Zeichen ohne Punkt am Ende des Strings. Mit "%.([^%.]+)$" erfassen Sie nur die Zeichen direkt nach dem letzten Punkt.

local function getExt(filename)
  return string.match(filename, "%.([^%.]+)$")
end

print(getExt("photo.jpg"))        -- jpg
print(getExt("archive.tar.gz"))   -- gz
print(getExt("README"))           -- nil
print(getExt("config.lua.bak"))   -- bak

Strings aufteilen

Lua bietet keine integrierte Funktion zum Aufteilen von Strings. Sie können eine solche Funktion jedoch mit string.gmatch implementieren. Iterieren Sie über alle Sequenzen ohne Trennzeichen oder verwenden Sie ein Muster, das den Inhalt zwischen den Trennzeichen erfasst.

local function split(s, sep)
  local result = {}
  local pattern = "([^" .. sep .. "]+)"
  for part in string.gmatch(s, pattern) do
    result[#result+1] = part
  end
  return result
end

local parts = split("one,two,three,four", ",")
for i, p in ipairs(parts) do
  print(i, p)
end
-- 1 one  2 two  3 three  4 four

Leerraum entfernen

Entfernen Sie führenden und nachfolgenden Leerraum, indem Sie ihn suchen und verwerfen. Das Muster "^%s*(.-)%s*$" verwendet den gierigen Quantifizierer .-, um den minimalen Inhalt zwischen optionalem führendem und nachfolgendem Leerraum zu erfassen.

local function trim(s)
  return string.match(s, "^%s*(.-)%s*$")
end

print("|" .. trim("  hello  ") .. "|")  -- |hello|
print("|" .. trim("  \t\n") .. "|")    -- ||
print("|" .. trim("no spaces") .. "|")  -- |no spaces|

Zahlen aus Text extrahieren

Verwenden Sie string.gmatch mit einem Zahlenmuster, um alle Zahlen aus einem String zu extrahieren. Das Muster %-?%d+%.?%d* erfasst ein optionales Minuszeichen, Ziffern, einen optionalen Dezimalpunkt und weitere Ziffern.

local text = "Revenue: $1,234.56 Expenses: $567.89 Net: $666.67"
local numbers = {}
for n in string.gmatch(text, "%d+%.?%d*") do
  numbers[#numbers+1] = tonumber(n)
end
for _, v in ipairs(numbers) do
  io.write(v .. " ")
end
print()  -- 1 234.0 56.0 567.89 666.67

Stringpositionen normalisieren

Mit negativen Indizes können Sie in Lua vom Ende eines Strings aus arbeiten. string.sub(s, -n) ruft die letzten n Zeichen ab. Kombinieren Sie dies mit #s, um Positionen zu berechnen. Wenn Sie das Verhältnis zwischen positiven und negativen Indizes verstehen, vermeiden Sie Off-by-one-Fehler.

local s = "abcdefgh"

-- Last 3 characters
print(s:sub(-3))     -- fgh

-- All but last 2
print(s:sub(1, -3))  -- abcdef

-- Character at position from end
print(s:sub(-1, -1)) -- h
print(s:sub(-4, -2)) -- efg

Kurze Prüfung

Was gibt string.sub("hello", 2, -2) zurück?

Zusammenfassung: Suchen und Extrahieren

Zusammenfassung:

string.find(s, pat, init, plain) – gibt Startposition und Endposition oder nil zurück
string.sub(s, i, j) – extrahiert anhand der Position; negative Indizes zählen vom Ende
string.match(s, pat) – gibt Erfassungsgruppen oder den vollständigen Treffer zurück
Verwenden Sie plain=true für eine literale Suche (ohne Sonderzeichen)
Implementieren Sie das Aufteilen mit string.gmatch
Leerraum entfernen: Muster "^%s*(.-)%s*$"

Häufig gestellte Fragen

Ist die Lektion „Teilzeichenketten finden und extrahieren“ kostenlos?

Ja — der vollständige Text von „Teilzeichenketten finden und extrahieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Teilzeichenketten finden und extrahieren“?

Verwenden Sie string.find und string.sub, um Text zu suchen und zu extrahieren Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Teilzeichenketten finden und extrahieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Grundlagen von Zeichenketten: Verketten und Länge
Teilzeichenketten finden und extrahieren
string.format für Ausgaben
string.gsub und string.gmatch

← Zurück zu Lua Academy