Textverarbeitung

Reguläre Ausdrücke, Text-Diffing und semantisches Text-Splitting.

Laden

local text = require("text")

Reguläre Ausdrücke

Kompilieren

local re, err = text.regexp.compile("[0-9]+")

Gibt zurück: Regexp, error

Match

local ok = re:match_string("abc123")

Gibt zurück: boolean

Find

local match = re:find_string("abc123def")

Gibt zurück: string | nil

Find All

local matches = re:find_all_string("a1b2c3")

Gibt zurück: string[]

Find mit Gruppen

local match = re:find_string_submatch("user@example.com")

Gibt zurück: string[] | nil (vollständiger Match + Capture-Gruppen)

Find All mit Gruppen

local matches = re:find_all_string_submatch("a=1 b=2")

Gibt zurück: string[][]

Find Index

local pos = re:find_string_index("abc123")

Gibt zurück: table | nil ({start, end}, 1-basiert)

Find All Index

local positions = re:find_all_string_index("a1b2c3")

Gibt zurück: table[]

Ersetzen

local result = re:replace_all_string("a1b2", "X")

Gibt zurück: string

Split

local parts = re:split("a,b,c", -1)

Gibt zurück: string[]

Unterausdrucks-Anzahl

local count = re:num_subexp()

Gibt zurück: number

Unterausdrucks-Namen

local names = re:subexp_names()

Gibt zurück: string[]

Muster-String

local pattern = re:string()

Gibt zurück: string

Text-Diffing

Textversionen vergleichen und Patches generieren. Basiert auf go-diff (Googles diff-match-patch).

Differ erstellen

local diff, err = text.diff.new()
local diff, err = text.diff.new(options)

Gibt zurück: Differ, error

Optionen {id="diff-options"}

Vergleichen

Unterschiede zwischen zwei Texten finden. Gibt ein Array von Operationen zurück, die beschreiben, wie text1 in text2 transformiert wird.

local diff, _ = text.diff.new()
local diffs, err = diff:compare("hello world", "hello there")

-- diffs enthält:
-- {operation = "equal", text = "hello "}
-- {operation = "delete", text = "world"}
-- {operation = "insert", text = "there"}

Gibt zurück: table, error (Array von {operation, text})

Operationen: "equal", "delete", "insert"

Zusammenfassen

Geänderte Zeichen zwischen Versionen zählen.

local diffs, _ = diff:compare("hello world", "hello there")
local summary = diff:summarize(diffs)

-- summary.equals = 6 (unveränderte Zeichen)
-- summary.deletions = 5 (entfernte Zeichen)
-- summary.insertions = 5 (hinzugefügte Zeichen)

Gibt zurück: table ({insertions, deletions, equals})

Pretty Text

Diff mit ANSI-Farben für Terminal-Anzeige formatieren.

local formatted, err = diff:pretty_text(diffs)
print(formatted)

Gibt zurück: string, error

Pretty HTML

Diff als HTML mit <del>- und <ins>-Tags formatieren.

local html, err = diff:pretty_html(diffs)
-- Gibt zurück: "hello <del>world</del><ins>there</ins>"

Gibt zurück: string, error

Patches erstellen

Patches generieren, die angewendet werden können, um einen Text in einen anderen zu transformieren. Patches können serialisiert und später angewendet werden.

local text1 = "The quick brown fox jumps over the lazy dog"
local text2 = "The quick red fox jumps over the lazy cat"

local patches, err = diff:patch_make(text1, text2)

Gibt zurück: table, error

Patches anwenden

Patches anwenden, um Text zu transformieren. Gibt das Ergebnis und ob alle Patches erfolgreich angewendet wurden zurück.

local result, success = diff:patch_apply(patches, text1)
-- result = "The quick red fox jumps over the lazy cat"
-- success = true

Gibt zurück: string, boolean

Text-Splitting

Große Dokumente in kleinere Chunks aufteilen, während semantische Grenzen erhalten bleiben. Basiert auf langchaingo Text-Splitter.

Rekursiver Splitter

Teilt Text mit einer Hierarchie von Trennzeichen. Versucht zuerst bei doppelten Zeilenumbrüchen (Absätze) zu teilen, dann einzelne Zeilenumbrüche, dann Leerzeichen, dann Zeichen. Fällt auf kleinere Trennzeichen zurück, wenn Chunks die Größenbegrenzung überschreiten.

local splitter, err = text.splitter.recursive({
    chunk_size = 1000,
    chunk_overlap = 100
})

local long_text = "This is a long text that needs splitting..."
local chunks, err = splitter:split_text(long_text)
-- chunks = {"This is a long...", "...text that needs...", "...splitting..."}

Gibt zurück: Splitter, error

Optionen {id="recursive-splitter-options"}

Markdown-Splitter

Teilt Markdown-Dokumente unter Beachtung der Struktur. Versucht Überschriften mit ihrem Inhalt zusammenzuhalten, Code-Blöcke intakt zu lassen und Tabellenzeilen zusammenzuhalten.

local splitter, err = text.splitter.markdown({
    chunk_size = 2000,
    code_blocks = true,
    heading_hierarchy = true
})

local readme = fs.read("README.md")
local chunks, err = splitter:split_text(readme)

Gibt zurück: Splitter, error

Optionen {id="markdown-splitter-options"}

Text teilen

Einzelnes Dokument in Array von Chunks aufteilen.

local chunks, err = splitter:split_text(document)

for i, chunk in ipairs(chunks) do
    -- Jeden Chunk verarbeiten (z.B. Embedding erstellen, an LLM senden)
    process(chunk)
end

Gibt zurück: string[], error

Batch teilen

Mehrere Dokumente teilen, während ihre Metadaten erhalten bleiben. Jedes Eingabedokument kann mehrere Ausgabe-Chunks produzieren. Alle Chunks erben die Metadaten ihres Quelldokuments.

-- Eingabe: Seiten aus einem PDF mit Seitennummern
local pages = {
    {content = "First page content...", metadata = {page = 1}},
    {content = "Second page content...", metadata = {page = 2}}
}

local chunks, err = splitter:split_batch(pages)

-- Ausgabe: Jeder Chunk weiß, von welcher Seite er stammt
for _, chunk in ipairs(chunks) do
    print("Page " .. chunk.metadata.page .. ": " .. chunk.content:sub(1, 50))
end

Gibt zurück: table, error (Array von {content, metadata})

Fehler

Siehe Fehlerbehandlung für die Arbeit mit Fehlern.