JSON and Data Validation

JSON and Data Validation | JavaScript Course | SovranCode

COMPLETE LESSON · ABOUT 30 MIN OF ACTIVE PRACTICE

Learn JSON and Data Validation step by step

Follow the lesson in order: understand the model, trace worked examples, run a controlled experiment, debug a faulty assumption, build independently, and verify your reasoning.

LESSON MAP

What you will understand and apply

Catch JSON syntax failure at the boundary
Validate the parsed shape before property use
Know which JavaScript values JSON cannot preserve
Write a parser that distinguishes invalid JSON from a syntactically valid but invalid lesson record.

DEEP EXPLANATION

Build the complete mental model

Build the mental model

JSON supports objects with string keys, arrays, strings, finite numbers, booleans, and null. It has no representation for undefined, functions, symbols, Map, Set, BigInt, or object identity. stringify omits unsupported object properties and converts some array entries to null. A replacer or reviver can customize transformation, but both need an explicit data contract. Before writing more syntax, name the values involved in JSON and Data Validation, who creates them, and which result or effect the program promises. Trace the smallest example by hand and identify any browser or runtime API separately from the language feature. A useful mental model should predict a changed input, not merely describe the demonstration after it runs.

Use the API deliberately

JSON.parse can throw a SyntaxError, so parse within the boundary that can report malformed input. A parsed value has type unknown conceptually: it might be null, a primitive, an array, or an object of the wrong shape. Validate containers before reading their fields, then check every required field and normalize only according to the domain. During implementation, keep the JSON.parse rule in a focused function or event boundary with explicit inputs. Choose names that reveal the domain, keep calculation separate from document, console, storage, or network effects, and prefer the narrowest API that expresses the problem. Compare this design with one reasonable alternative and explain why the selected construct makes ownership or control flow clearer.

Handle boundaries and tradeoffs

Serialization is not sanitization or authorization. A client can edit stored or submitted JSON, so a server must validate it again and enforce permissions independently. Version persistent shapes when they may evolve. Reject or migrate old data deliberately instead of letting new code make assumptions about yesterday's representation. Verification for JSON and Data Validation must cover an ordinary case, an empty or missing case, invalid input, and the most important threshold. Predict each result before running it, then locate the first value that violates the contract when reality differs. Record the corrected case as a repeatable check and explain which product behavior should occur instead of allowing undefined, NaN, stale data, or silent failure to spread.

WORKED EXAMPLES

Read the decision before the syntax

Example 1: Primary worked example

Trace this JSON and Data Validation example from validated input to returned value or visible effect before editing it.

function parseLesson(json) {
  const value = JSON.parse(json);
  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Object required");
  if (typeof value.title !== "string" || !Number.isFinite(value.minutes)) throw new TypeError("Invalid lesson");
  return { title: value.title.trim(), minutes: value.minutes };
}
console.log(parseLesson('{"title":"DOM","minutes":35}'));

Example 2: Second worked example

This variation changes the shape of the problem so you can compare the underlying JSON.parse contract instead of copying one solution.

function safeParse(text) {
  try {
    return { ok: true, value: JSON.parse(text) };
  } catch (error) {
    return { ok: false, message: error instanceof SyntaxError ? "Malformed JSON" : "Unable to read data" };
  }
}
console.log(safeParse('{"done":true}'));

How to trace this lesson

Write down the exact inputs used by JSON and Data Validation.
Predict each returned value and observable effect before running the example.
Mark the first boundary where invalid or missing data could enter.
Verify the ordinary, empty, invalid, and threshold cases independently.

Common mistakes and corrections

Successful JSON.parse does not mean the result contains the fields or types your application expects.: Make the JSON.parse rule explicit and cover it with a focused example.
Changing several parts of the example before explaining the original result.: Make one change at a time and compare it with a written prediction.
Testing only the demonstration's happy path.: Add missing, invalid, empty, and boundary inputs that exercise the stated contract.

PRACTICE LADDER

Move from recognition to independent work

1
Catch JSON syntax failure at the boundary
2
Validate the parsed shape before property use
3
Know which JavaScript values JSON cannot preserve
4
Write a parser that distinguishes invalid JSON from a syntactically valid but invalid lesson record.

Complete these in order. The final step should work without copying the lesson example; use the runner and lab below to test it.

Core rule

Applied boundary

RUNNABLE EXAMPLE

Change one assumption at a time

Predict the output, run the example, then change one input and one boundary in the JSON and Data Validation example. Explain every changed result before continuing.

function parseLesson(json) {
  const value = JSON.parse(json);
  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Object required");
  if (typeof value.title !== "string" || !Number.isFinite(value.minutes)) throw new TypeError("Invalid lesson");
  return { title: value.title.trim(), minutes: value.minutes };
}
console.log(parseLesson('{"title":"DOM","minutes":35}'));

function parseLesson(json) {
  const value = JSON.parse(json);
  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Object required");
  if (typeof value.title !== "string" || !Number.isFinite(value.minutes)) throw new TypeError("Invalid lesson");
  return { title: value.title.trim(), minutes: value.minutes };
}
console.log(parseLesson('{"title":"DOM","minutes":35}'));

Press Run to execute your code.

DEBUGGING CHALLENGE

Locate the first incorrect value

Predict the failure and write your repair before revealing the explanation.

const lesson = JSON.parse(input);
console.log(lesson.title.toUpperCase());

Reveal repair and explanation

const lesson = JSON.parse(input);
if (!lesson || typeof lesson !== "object" || typeof lesson.title !== "string") throw new TypeError("Lesson title required");
console.log(lesson.title.toUpperCase());

Parsing validates JSON grammar; the repaired code separately validates the application shape.

INDEPENDENT LAB

Build without copying the example

Write a parser that distinguishes invalid JSON from a syntactically valid but invalid lesson record.

// Define small functions before composing the complete solution.
// Write a parser that distinguishes invalid JSON from a syntactically valid but invalid lesson record.

// Define small functions before composing the complete solution.
// Write a parser that distinguishes invalid JSON from a syntactically valid but invalid lesson record.

Press Run to execute your code.

Self-review checklist Catch JSON syntax failure at the boundary Validate the parsed shape before property use Know which JavaScript values JSON cannot preserveWhat did you predict, observe, and change?

KNOWLEDGE CHECK

Explain the rule, not only the syntax

1. What does successful JSON.parse guarantee? Valid JSON syntax only A trusted application record Correct authorization

2. Which evidence best demonstrates mastery of JSON and Data Validation? A prediction, boundary tests, and an explained result A copied snippet with no changes One successful happy-path run

Loading saved work…

Code and answers save automatically. Guest work stays on this device; signed-in work syncs to your account. The runner is isolated, blocks network access, and stops long-running console programs.

1. JavaScript Foundations

2. Functions and Collections

3. Objects and Structured Data

4. Browser Interfaces

5. Async and Reliable Applications

6. Application Engineering