Strategien zum sicheren Parsen von JSON

Warum sicheres Parsen?

safeParse-Hilfsfunktion

// safeParse: never throws, returns { ok, value, error }
function safeParse(text) {
  try {
    const value = JSON.parse(text);
    return { ok: true, value: value, error: null };
  } catch (e) {
    return { ok: false, value: null, error: String(e.message) };
  }
}

// Demo
const good = safeParse("{\"name\":\"Ayla\",\"age\":20}");
const bad  = safeParse("{broken}");

console.log("good.ok:", good.ok, "name:", good.value && good.value.name);
console.log("bad.ok:", bad.ok, "error:", bad.error);

Strukturprüfungen

// Validate required fields and simple types
function isNonEmptyString(x) {
  return typeof x === "string" && x.trim().length > 0;
}

function isNonNegativeInt(x) {
  return Number.isInteger(x) && x >= 0;
}

function validateUser(u) {
  if (u == null || typeof u !== "object") {
    return { ok: false, reason: "not an object" };
  }
  if (!isNonEmptyString(u.name)) {
    return { ok: false, reason: "name required" };
  }
  if (!isNonNegativeInt(u.age)) {
    return { ok: false, reason: "age must be a non-negative integer" };
  }
  return { ok: true };
}

// Demo
const rawUser = "{\"name\":\"Mina\",\"age\":22}";
const parsed = safeParse(rawUser);

if (parsed.ok) {
  console.log("valid?", validateUser(parsed.value));
}

Standardwerte für optionale Werte

// Apply defaults using nullish coalescing and spread
function normalizeUser(u) {
  const theme = (u.theme ?? "light");        // default theme
  const tags  = Array.isArray(u.tags) ? u.tags : [];
  return { ...u, theme: theme, tags: tags };
}

// Demo
const raw = "{\"name\":\"Lena\",\"age\":19}";
const p = safeParse(raw);
if (p.ok) {
  const v = normalizeUser(p.value);
  console.log("theme:", v.theme, "tags:", v.tags);
}

Bereiche und Begrenzungen

// Guard numbers and arrays with tiny limits
function clampNumber(x, min, max) {
  if (typeof x !== "number" || !Number.isFinite(x)) return min;
  return Math.min(max, Math.max(min, x));
}

function toStringArray(a) {
  if (!Array.isArray(a)) return [];
  return a.map(function (x) { return String(x); }).slice(0, 5); // cap length
}

// Demo
const cfgText = "{\"limit\":200,\"labels\":[\"a\",\"b\",\"c\",\"d\",\"e\",\"f\"]}";
const cfg = safeParse(cfgText);
if (cfg.ok) {
  const limit = clampNumber(cfg.value.limit, 1, 100);
  const labels = toStringArray(cfg.value.labels);
  console.log("limit:", limit, "labels:", labels);
}

Parsen → validieren → normalisieren

// Putting it together: parse → validate → normalize
function readUser(jsonText) {
  const p = safeParse(jsonText);
  if (!p.ok) return { ok: false, reason: "parse: " + p.error };

  const check = validateUser(p.value);
  if (!check.ok) return { ok: false, reason: "shape: " + check.reason };

  const normalized = normalizeUser(p.value);
  return { ok: true, value: normalized };
}

// Demo
const text = "{\"name\":\"Ayla\",\"age\":21,\"tags\":[\"new\"],\"theme\":\"dark\"}";
console.log(readUser(text));

Quiz zum sicheren Parsen

Zusammenfassung