Estrategias para analizar JSON de forma segura
Analice JSON no confiable de forma segura con try/catch, comprobaciones pequeñas de estructura, valores predeterminados y utilidades auxiliares sencillas.
Estrategias para analizar JSON de forma segura es una lección gratuita de JavaScript Academy en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de JavaScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de JavaScript Academy incluye 3 lecciones en total.
¿Por qué analizar de forma segura?
Objetivo: leer JSON sin sorpresas.
- try/catch alrededor de parse
- Pequeña función auxiliar safeParse
- Comprobaciones de estructura para los campos obligatorios
- Valores predeterminados para los valores opcionales
Función auxiliar safeParse
Use una pequeña función safeParse para evitar errores y mostrar los problemas con claridad.
// 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);
Comprobaciones de estructura
Añada validadores pequeños para los campos obligatorios (name, age) y rangos sencillos.
// 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));
}
Valores predeterminados para valores opcionales
Use ?? y comprobaciones sencillas para establecer valores predeterminados seguros en los campos opcionales.
// 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);
}
Rangos y límites
Limite los rangos numéricos y el tamaño de los arrays para mantener los datos seguros y predecibles.
// 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);
}
Analizar → validar → normalizar
Flujo: analizar → validar → normalizar. Mantenga las funciones pequeñas y legibles.
// 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));
Cuestionario sobre análisis seguro
Comprobación rápida: patrón seguro.
Repaso
Repaso: cree un safeParse pequeño, compruebe los campos obligatorios y sus tipos, limite los números y los arrays, y aplique valores predeterminados para que su aplicación gestione los datos incorrectos con tranquilidad.
Preguntas frecuentes
¿La lección «Estrategias para analizar JSON de forma segura» es gratis?
Sí — el texto completo de «Estrategias para analizar JSON de forma segura» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de JavaScript Academy, actualiza a CoddyKit PRO. El curso de JavaScript Academy incluye 3 lecciones en total.
¿Qué aprenderé en «Estrategias para analizar JSON de forma segura»?
Analice JSON no confiable de forma segura con try/catch, comprobaciones pequeñas de estructura, valores predeterminados y utilidades auxiliares sencillas. Practicas JavaScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar JavaScript Academy?
No se requiere experiencia previa. JavaScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.
¿Cuánto tiempo toma la lección «Estrategias para analizar JSON de forma segura»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de JavaScript Academy?
Sí. Cada lección de JavaScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Fundamentos de JSON.parse y JSON.stringify
- Clonación estructurada y URLSearchParams
- Estrategias para analizar JSON de forma segura