JavaScript Academy · Lezione

Strategie per un parsing sicuro del JSON

Analizzi in modo sicuro JSON non attendibile con try/catch, piccoli controlli della struttura, valori predefiniti e minuscole utility di supporto.

Strategie per un parsing sicuro del JSON è una lezione JavaScript Academy gratuita su CoddyKit. Questa è la lezione 3 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento JavaScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso JavaScript Academy include 3 lezioni in totale.

Perché fare il parsing in sicurezza?

Obiettivo: leggere JSON senza sorprese.

try/catch intorno a parse
Piccolo helper safeParse
Controlli della struttura per i campi obbligatori
Valori predefiniti per i campi facoltativi

Strategie per un parsing sicuro del JSON — illustrazione 1

Helper safeParse

Utilizzi un piccolo safeParse per evitare arresti anomali e rendere chiari gli errori.

// 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);

Strategie per un parsing sicuro del JSON — illustrazione 2

Controlli della struttura

Aggiunga piccoli validatori per i campi obbligatori (name, age) e per semplici intervalli di valori.

// 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));
}

Strategie per un parsing sicuro del JSON — illustrazione 3

Valori predefiniti per i campi facoltativi

Utilizzi ?? e semplici controlli per impostare valori predefiniti sicuri per i campi facoltativi.

// 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);
}

Strategie per un parsing sicuro del JSON — illustrazione 4

Intervalli e limiti

Limiti i valori numerici a intervalli definiti e le dimensioni degli array, per mantenere i dati sicuri e prevedibili.

// 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);
}

Strategie per un parsing sicuro del JSON — illustrazione 5

Analizzare → validare → normalizzare

Pipeline: analizzare → validare → normalizzare. Mantenga le funzioni piccole e leggibili.

// 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));

Strategie per un parsing sicuro del JSON — illustrazione 6

Quiz sull'analisi sicura

Controllo rapido: schema sicuro.

Strategie per un parsing sicuro del JSON — illustrazione 7

Riepilogo

Riepilogo: costruisca un piccolo safeParse, controlli i campi obbligatori e i tipi, limiti i numeri, imponga un limite agli array e applichi valori predefiniti, così l'applicazione gestirà con calma gli input non validi.

Strategie per un parsing sicuro del JSON — illustrazione 8

Domande Frequenti

La lezione «Strategie per un parsing sicuro del JSON» è gratuita?

Sì — il testo completo di «Strategie per un parsing sicuro del JSON» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso JavaScript Academy, passa a CoddyKit PRO. Il corso JavaScript Academy include 3 lezioni in totale.

Cosa imparerò in «Strategie per un parsing sicuro del JSON»?

Analizzi in modo sicuro JSON non attendibile con try/catch, piccoli controlli della struttura, valori predefiniti e minuscole utility di supporto. Eserciti JavaScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare JavaScript Academy?

Non è richiesta alcuna esperienza precedente. JavaScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.

Quanto tempo richiede la lezione «Strategie per un parsing sicuro del JSON»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione JavaScript Academy?

Sì. Ogni lezione JavaScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Basi di JSON.parse / JSON.stringify
Clonazione strutturata e URLSearchParams
Strategie per un parsing sicuro del JSON

← Torna a JavaScript Academy