Errors and Recovery

Errors and Recovery | JavaScript Course | SovranCode

COMPLETE LESSON · ABOUT 30 MIN OF ACTIVE PRACTICE

Learn Errors and Recovery 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

Throw for violated function contracts
Preserve the original cause when adding context
Show users safe messages with recovery actions
Design typed validation errors and an application boundary that maps them to useful, safe messages.

DEEP EXPLANATION

Build the complete mental model

Build the mental model

Throwing interrupts normal control flow and transfers control to the nearest applicable catch. Built-in types communicate broad categories: TypeError for an inappropriate value type or shape, RangeError for a value outside an accepted range, and custom Error subclasses for domain distinctions. Messages should identify the violated contract without leaking secrets. Before writing more syntax, name the values involved in Errors and Recovery, 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

try should wrap only the operation whose expected failure you can handle. Catch receives an unknown thrown value in principle, so narrow it with instanceof Error before reading message. Add higher-level context with the cause option when rethrowing. finally runs regardless of settlement and is appropriate for cleanup, not for silently replacing the result. During implementation, keep the throw 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

Recovery depends on the product: retry a transient request with limits, ask for corrected validation input, use a documented fallback for optional data, or stop and report a defect. Logging and user messaging serve different audiences. Never expose stack traces, query text, tokens, or internal server messages to a visitor. Verification for Errors and Recovery 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 Errors and Recovery example from validated input to returned value or visible effect before editing it.

function parsePositiveInteger(raw) {
  const text = String(raw).trim();
  if (!text) throw new TypeError("A value is required");
  const value = Number(text);
  if (!Number.isInteger(value) || value < 1) throw new RangeError("A positive integer is required");
  return value;
}
try {
  console.log(parsePositiveInteger("0"));
} catch (error) {
  console.error(error instanceof Error ? error.message : "Unknown failure");
}

Example 2: Second worked example

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

class ValidationError extends Error {
  constructor(field, message) {
    super(message);
    this.name = "ValidationError";
    this.field = field;
  }
}
function requireTitle(value) {
  if (typeof value !== "string" || value.trim() === "") throw new ValidationError("title", "Enter a title");
  return value.trim();
}

How to trace this lesson

Write down the exact inputs used by Errors and Recovery.
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

Catching an error and continuing with undefined can move the failure far away from its real cause.: Make the throw 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
Throw for violated function contracts
2
Preserve the original cause when adding context
3
Show users safe messages with recovery actions
4
Design typed validation errors and an application boundary that maps them to useful, safe messages.

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 Errors and Recovery example. Explain every changed result before continuing.

function parsePositiveInteger(raw) {
  const text = String(raw).trim();
  if (!text) throw new TypeError("A value is required");
  const value = Number(text);
  if (!Number.isInteger(value) || value < 1) throw new RangeError("A positive integer is required");
  return value;
}
try {
  console.log(parsePositiveInteger("0"));
} catch (error) {
  console.error(error instanceof Error ? error.message : "Unknown failure");
}

function parsePositiveInteger(raw) {
  const text = String(raw).trim();
  if (!text) throw new TypeError("A value is required");
  const value = Number(text);
  if (!Number.isInteger(value) || value < 1) throw new RangeError("A positive integer is required");
  return value;
}
try {
  console.log(parsePositiveInteger("0"));
} catch (error) {
  console.error(error instanceof Error ? error.message : "Unknown failure");
}

Press Run to execute your code.

DEBUGGING CHALLENGE

Locate the first incorrect value

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

try { return JSON.parse(text); } catch { return undefined; }

Reveal repair and explanation

try { return JSON.parse(text); } catch (error) {
  throw new SyntaxError("Saved data is not valid JSON", { cause: error });
}

The repaired boundary keeps the operation failed while adding context and preserving the original cause.

INDEPENDENT LAB

Build without copying the example

Design typed validation errors and an application boundary that maps them to useful, safe messages.

// Define small functions before composing the complete solution.
// Design typed validation errors and an application boundary that maps them to useful, safe messages.

// Define small functions before composing the complete solution.
// Design typed validation errors and an application boundary that maps them to useful, safe messages.

Press Run to execute your code.

Self-review checklist Throw for violated function contracts Preserve the original cause when adding context Show users safe messages with recovery actionsWhat did you predict, observe, and change?

KNOWLEDGE CHECK

Explain the rule, not only the syntax

1. Where should an error normally be caught? At a layer that can recover or add useful context Immediately after every function call Only inside a CSS rule

2. Which evidence best demonstrates mastery of Errors and Recovery? 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