Textverarbeitung

Das Modul text stellt reguläre Ausdrücke, Textvergleiche und Patches sowie das Aufteilen von Dokumenten bereit. Diese Seite ist eine API-Referenz. Die kurzen Blöcke sind einzelne Aufrufe; längere Blöcke zum Aufteilen sind Teilrezepte, deren Dokumente, konfigurierte Dateisystemressourcen und nachgelagerte Verarbeitung von der umgebenden Anwendung bereitgestellt werden.

Laden

local text = require("text")

Reguläre Ausdrücke

text.regexp.compile

local re, err = text.regexp.compile("[0-9]+")
if err then
    return nil, err
end

Gibt zurück: Regexp, error

re:match_string

local ok = re:match_string("abc123")

Gibt zurück: boolean

re:find_string

local match = re:find_string("abc123def")

Gibt zurück: string | nil

In dieser Runtime-Version wird auch ein Treffer auf die leere Zeichenkette als nil dargestellt. Verwenden Sie ein Muster, das mindestens ein Zeichen verbraucht, wenn Sie einen leeren Treffer von keinem Treffer unterscheiden müssen.

re:find_all_string

local matches = re:find_all_string("a1b2c3")

Gibt zurück: string[]

re:find_string_submatch

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

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

re:find_all_string_submatch

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

Gibt zurück: string[][]

re:find_string_index

local pos = re:find_string_index("abc123")

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

re:find_all_string_index

local positions = re:find_all_string_index("a1b2c3")

Gibt zurück: table[] | nil (nil, wenn es keine Treffer gibt)

re:replace_all_string

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

Gibt zurück: string

re:split

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

Gibt zurück: string[]

re:num_subexp

local count = re:num_subexp()

Gibt zurück: number

re:subexp_names

local names = re:subexp_names()

Gibt zurück: string[]

re:string

local pattern = re:string()

Gibt zurück: string

Text-Diffing

Vergleichen Sie Textversionen und erzeugen Sie Patches mit go-diff, einer Implementierung von Googles diff-match-patch-Algorithmus.

text.diff.new

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

Gibt zurück: Differ, error

Optionen {id="diff-options"}

diff:compare

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

local diff, diff_err = text.diff.new()
if diff_err then
    return nil, diff_err
end
local diffs, err = diff:compare("hello world", "hello there")
if err then
    return nil, err
end

-- diffs contains:
-- {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"

diff:summarize

Zählen Sie unveränderte, eingefügte und gelöschte UTF-8-Bytes. Bei Nicht-ASCII-Text entsprechen diese Summen weder Unicode-Codepoints noch Graphemclustern.

-- `diffs` is the checked result from diff:compare.
local summary = diff:summarize(diffs)

-- summary.equals = 6 (bytes unchanged)
-- summary.deletions = 5 (bytes removed)
-- summary.insertions = 5 (bytes added)

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

diff:pretty_text

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

local formatted, err = diff:pretty_text(diffs)
if err then
    return nil, err
end
print(formatted)

Gibt zurück: string, error

diff:pretty_html

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

local html, err = diff:pretty_html(diffs)
if err then
    return nil, err
end
-- `html` is an HTML fragment with equal, deleted, and inserted spans.

Gibt zurück: string, error

diff:patch_make

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)
if err then
    return nil, err
end

Gibt zurück: table, error

diff:patch_apply

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

Prüfen Sie success, bevor Sie result als die angeforderte Transformation behandeln. Übergeben Sie Patch-Tabellen, die von patch_make erzeugt wurden. In dieser Runtime-Version kann fehlerhafter serialisierter Patch-Text in einer manuell erstellten Tabelle übersprungen werden, ohne dass dies separat gemeldet wird.

Text-Splitting

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

text.splitter.recursive

Der rekursive Splitter versucht nacheinander doppelte Zeilenumbrüche, einzelne Zeilenumbrüche, Leerzeichen und schließlich einzelne Zeichen. Er wechselt zum nächsten Trennzeichen, wenn ein Abschnitt die Größenbegrenzung überschreitet.

local splitter, err = text.splitter.recursive({
    chunk_size = 1000,
    chunk_overlap = 100
})
if err then
    return nil, err
end

local long_text = "This is a long text that needs splitting..."
local chunks, split_err = splitter:split_text(long_text)
if split_err then
    return nil, split_err
end

Gibt zurück: Splitter, error

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

text.splitter.markdown

Der Markdown-Splitter kann Überschriften mit ihrem Inhalt zusammenhalten, Codeblöcke bewahren und Tabellenzeilen gruppieren.

local splitter, err = text.splitter.markdown({
    chunk_size = 2000,
    code_blocks = true,
    heading_hierarchy = true
})
if err then
    return nil, err
end

local readme = fs.get("app:docs"):readfile("README.md")
local chunks, err = splitter:split_text(readme)

Dieses Teilrezept setzt voraus, dass der Eintrag sowohl text als auch fs aktiviert, eine Dateisystemressource app:docs konfiguriert ist und darin eine lesbare README.md vorhanden ist.

Gibt zurück: Splitter, error

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

splitter:split_text

Einzelnes Dokument in Array von Chunks aufteilen.

local chunks, err = splitter:split_text(document)
if err then
    return nil, err
end

for i, chunk in ipairs(chunks) do
    -- Process each chunk (e.g., create embedding, send to LLM)
    process(chunk)
end

Hier ist splitter ein erfolgreich erstellter Splitter; document und process werden von der Anwendung bereitgestellt.

Gibt zurück: string[], error

splitter:split_batch

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

-- Input: pages from a PDF with page numbers
local pages = {
    {content = "First page content...", metadata = {page = 1}},
    {content = "Second page content...", metadata = {page = 2}}
}

local chunks, err = splitter:split_batch(pages)
if err then
    return nil, err
end

-- Output: each chunk knows which page it came from
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})

split_batch überspringt ein Element stillschweigend, wenn es keine Tabelle ist, sein Feld content fehlt, leer oder keine Zeichenkette ist oder das Aufteilen dieses Elements fehlschlägt. Die Methode gibt die verbleibenden Abschnitte dennoch mit einem nil-Fehler zurück. Validieren Sie jedes Eingabeelement vor dem Aufruf und prüfen Sie Anforderungen an die Anzahl der Ergebnisse im Anwendungscode; ein erfolgreicher Aufruf belegt nicht, dass jede Eingabe vertreten ist.

Fehler

Informationen zum Umgang mit Fehlern finden Sie unter Fehlerbehandlung.