Strategie bezpiecznego parsowania JSON
Bezpieczne parsowanie niezaufanego JSON za pomocą try/catch, prostych kontroli struktury, wartości domyślnych i niewielkich funkcji pomocniczych
Strategie bezpiecznego parsowania JSON to bezpłatna lekcja JavaScript Academy na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej JavaScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs JavaScript Academy zawiera 3 lekcji w sumie.
Po co bezpiecznie analizować dane?
Cel: odczytywać JSON bez niespodzianek.
- try/catch wokół parse
- Niewielka funkcja pomocnicza safeParse
- Sprawdzanie struktury wymaganych pól
- Wartości domyślne dla pól opcjonalnych
Funkcja pomocnicza safeParse
Niewielka funkcja safeParse pomaga uniknąć awarii i jasno sygnalizować błędy.
// 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);
Sprawdzanie struktury
Należy dodać niewielkie walidatory wymaganych pól (name, age) oraz prostych zakresów wartości.
// 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));
}
Wartości domyślne dla pól opcjonalnych
Za pomocą ?? i prostych sprawdzeń można ustawiać bezpieczne wartości domyślne dla pól opcjonalnych.
// 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);
}
Zakresy i limity
Ograniczaj zakresy liczbowe i rozmiary tablic, aby dane były bezpieczne i przewidywalne.
// 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);
}
Parsowanie → walidacja → normalizacja
Potok: parsowanie → walidacja → normalizacja. Należy pisać małe i czytelne funkcje.
// 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: bezpieczne parsowanie
Szybkie sprawdzenie: bezpieczny wzorzec.
Podsumowanie
Podsumowanie: Należy utworzyć niewielką funkcję safeParse, sprawdzać wymagane pola i typy, ograniczać liczby oraz rozmiary tablic i stosować wartości domyślne, aby aplikacja spokojnie radziła sobie z nieprawidłowymi danymi wejściowymi.
Często zadawane pytania
Czy lekcja „Strategie bezpiecznego parsowania JSON” jest bezpłatna?
Tak — pełny tekst „Strategie bezpiecznego parsowania JSON” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu JavaScript Academy, przejdź na CoddyKit PRO. Kurs JavaScript Academy zawiera 3 lekcji w sumie.
Co nauczysz się w „Strategie bezpiecznego parsowania JSON”?
Bezpieczne parsowanie niezaufanego JSON za pomocą try/catch, prostych kontroli struktury, wartości domyślnych i niewielkich funkcji pomocniczych Ćwiczysz JavaScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć JavaScript Academy?
Nie wymagamy żadnego doświadczenia. JavaScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.
Ile czasu zajmuje lekcja „Strategie bezpiecznego parsowania JSON”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji JavaScript Academy?
Tak. Każda lekcja JavaScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Podstawy JSON.parse i JSON.stringify
- Klonowanie strukturalne i URLSearchParams
- Strategie bezpiecznego parsowania JSON