std.json

JSON auf Textebene: Sonderzeichen maskieren, Wohlgeformtheit grob prüfen, einen Einzelwert einlesen und flache Arrays über ein Pipe-getrenntes Zwischenformat verarbeiten. Ein Dokumentmodell mit Objektzugriff gibt es nicht.

→ std.string · Guide: Daten & Serialisierung · Standard Library

Alle Beispiele dieser Seite sind mit lyxc 1.0.21A übersetzt und ausgeführt; die gezeigten Ausgaben sind echte Programmausgaben.

Einsatz: einfache REST-Antworten auswerten, Zahlenlisten übergeben, Werte für die Ausgabe maskieren.

Die JSON_*-Werte liefert parseValue als Typ, die ERR_JSON_*-Werte liefert parseArray als Fehlercode. Von den fünf Fehlercodes verwendet die Unit nur ERR_JSON_OK und ERR_JSON_INVALID.

import std.json;
import std.alloc;
import std.string;

fn J(b: bool): pchar { if (b) { return "gueltig"; } return "ungueltig"; }

fn main(): int64 {
    var d: pchar := alloc(1024) as pchar;

    // Pruefen: Skalare und Arrays/Objekte werden inhaltlich geprueft (#1434)
    PrintLn(StrConcat("'{\"a\":1}'  ", J(isValidJSON("{\"a\":1}"c))));
    PrintLn(StrConcat("'[1,2,3]'   ", J(isValidJSON("[1,2,3]"c))));
    PrintLn(StrConcat("'nonsense'  ", J(isValidJSON("nonsense"c))));
    PrintLn(StrConcat("'12.5'      ", J(isValidJSON("12.5"c))));
    PrintLn(StrConcat("'12.5.7'    ", J(isValidJSON("12.5.7"c))));
    PrintLn(StrConcat("'[abc]'     ", J(isValidJSON("[abc]"c))));

    // Array einlesen: der Rueckgabewert ist ein Fehlercode, das Ergebnis steht in dest
    var rc: int64 := parseArray(d, "[1,2,3]"c);
    PrintLn(StrConcat(StrConcat("parseArray rc=", IntToStr(rc)), StrConcat("  Pipe-Form: ", d)));

    // Einzelwert einlesen: der Rueckgabewert ist der Typ
    var typ: int64 := parseValue(d, "\"Hallo\""c);
    PrintLn(StrConcat(StrConcat("parseValue Typ=", IntToStr(typ)), StrConcat("  Inhalt: ", d)));

    // Maskieren fuer die Ausgabe
    JSONEscape(d, "Er sagte \"Hallo\"\nund ging"c);
    PrintLn(StrConcat("JSONEscape: ", d));
    return 0;
}

'{"a":1}'  gueltig
'[1,2,3]'   gueltig
'nonsense'  ungueltig
'12.5'      gueltig
'12.5.7'    ungueltig
'[abc]'     ungueltig
parseArray rc=0  Pipe-Form: 1|2|3
parseValue Typ=3  Inhalt: Hallo
JSONEscape: "Er sagte \"Hallo\"\nund ging"

Die Skalarprüfung ist seit #1269 belastbar: nonsense und 12.5.7 werden abgewiesen, true/false/null namentlich verglichen. Nur der Inhalt von Arrays und Objekten bleibt ungeprüft — dort zählt allein, ob sich zur öffnenden Klammer eine schließende findet.

Arrays werden nicht als Struktur geführt, sondern als eine Zeichenkette, in der die Elemente durch | getrennt sind. parseArray erzeugt sie, stringify macht daraus wieder JSON.

import std.json;
import std.alloc;
import std.string;

fn Zeig(json: pchar): void {
    var pipe: pchar := alloc(1024) as pchar;
    var back: pchar := alloc(1024) as pchar;
    toArray(pipe, json);
    stringify(back, pipe);
    PrintLn(StrConcat(StrConcat(json, "  ->  "), StrConcat(pipe, StrConcat("  ->  ", back))));
}

fn main(): int64 {
    Zeig("[1,2,3]"c);
    Zeig("[\"a\",\"b\"]"c);
    Zeig("[1,[2,3]]"c);
    Zeig("[\"a|b\",\"c\"]"c);
    return 0;
}

[1,2,3]  ->  1|2|3  ->  [1,2,3]
["a","b"]  ->  "a"|"b"  ->  ["a","b"]
[1,[2,3]]  ->  1|[2,3]  ->  [1,[2,3]]
["a|b","c"]  ->  "a\|b"|"c"  ->  ["a|b","c"]

Die Pipe-Form lässt sich mit StrSplit aus std.string weiterverarbeiten — das ist der vorgesehene Weg, an die einzelnen Werte zu kommen.

parseValue erkennt den Typ am ersten Zeichen und legt den Wert in dest ab:

• Zielpuffer gehören dem Aufrufer und werden nicht auf Größe geprüft. Für JSONEscape sind zwei Byte je Eingabezeichen plus zwei für die Anführungszeichen sicher.
• JSONEscape setzt die Anführungszeichen selbst — wer sie zusätzlich schreibt, bekommt doppelte.
• isValidJSON ist keine Eingangsprüfung für fremde Daten.
• Kein Objektzugriff, keine Pfadausdrücke, keine Zahlen-Umwandlung — was aus parseValue kommt, ist Text; für int64 anschließend StrToInt aus std.string.
• Kein Whitespace-Handling zwischen Elementen: [1, 2] ergibt im Pipe-Format 1| 2 — mit führendem Leerzeichen im zweiten Element.
• serializeValue maskiert nur bei JSON_STRING. Für alle anderen Typen kopiert es die Eingabe wörtlich — auch dann, wenn dort etwas steht, das kein gültiges JSON ist.

Weiterführend: Guide: Daten & Serialisierung · std.string · std.xml · std.net.http · Standard Library

Quelle: std/json.lyx (480 Zeilen) · Autor: Andreas Röne · Copyright: 2024–2025 Andreas Röne

Letzte Aktualisierung: 2026-09-05 (#1433, nachgemessen mit lyxc 1.2.2B) — JSONEscape-Kasten auf den behobenen Stand gezogen.

Vorherige letzte Aktualisierung: 2026-08-30 — Beispielausgaben gegen lyxc 1.1.14A nachgezogen: isValidJSON(„[abc]“) ist jetzt ungueltig (#1434) und der Pipe-Durchlauf ist verlustfrei (#1432). Text, Tabellenzeile und Kasten entsprachen dem noch nicht.

Vorherige Aktualisierung: 2026-08-27 — die vier Fallstricke gegen lyxc 1.1.11B nachgemessen: #1432, #1433 und #1434 sind behoben, #1435 (Objektzugriff) besteht fort.

Vorherige Letzte Aktualisierung: 2026-08-13 — Seite gegen std/json.lyx überarbeitet: zwei lauffähige Beispiele mit echter Ausgabe, Rückgabewert-Bedeutungen je Funktion, Verhaltenstabelle für parseValue, Grenzen des Pipe-Formats, Fallstricke. Belegt und als Issue erfasst: Pipe-Durchlauf verliert Typen (#1432), JSONEscape maskiert keine Steuerzeichen (#1433), isValidJSON prüft […]/{…} nur auf Klammerpaare (#1434), parseValue lässt dest bei Objekten unberührt (#1435). Geprüft mit lyxc 1.0.21A.

Codebeispiele geprüft: gegen lyxc 1.2.5C übersetzt (Prüflauf 2026-09-08 über die gesamte Doku: 574 Vollprogramme, 0 echte Fehler; zusätzlich 5159 Aufrufe gegen die pub fn-Signaturen in aurum/std gehalten, 0 Abweichungen).