JavaScript Crash Course

Lesson 1 • Code Style and Basic Syntax Rules

Covers semicolons, whitespace, comments, and naming conventions. Establishes clean-code habits that prevent common beginner errors throughout the course.

Lesson 2 • Setting Up Your Dev Environment

Installs and configures a code editor, browser dev tools, and Node.js. Ensures every student has a consistent, functional workspace from day one.

Lesson 3 • Writing and Running Your First Script

Introduces script tags, external JS files, and the browser console. Students produce and debug their first working output immediately.

Lesson 1 • Primitive Data Types

Covers string, number, boolean, null, undefined, symbol, and BigInt. Students identify and use each type correctly in expressions.

Lesson 2 • Arithmetic, Comparison, and Logical Operators

Covers all core operator groups and operator precedence. Students write correct expressions and understand how JS evaluates compound conditions.

Lesson 3 • Type Coercion and the typeof Operator

Explains implicit and explicit type conversion and how typeof inspects values. Students avoid coercion bugs by understanding JS's dynamic typing.

Lesson 1 • Loop Control with break and continue

Introduces break and continue to alter loop execution flow. Students write efficient loops that skip unnecessary iterations or exit early.

Lesson 2 • Truthy, Falsy, and Short-Circuit Evaluation

Explains which values JS treats as false in boolean contexts and how short-circuit logic works. Students write concise, safe conditional expressions.

Lesson 3 • for, while, and do-while Loops

Covers the three primary loop constructs and their appropriate use cases. Students select the right loop type and control iteration precisely.

Lesson 4 • Conditional Statements

Teaches if, else if, else, and switch statements for branching logic. Students translate real-world rules into executable decision trees.

Lesson 1 • Arrow Functions and Lexical this

Introduces arrow function syntax and explains how they differ from regular functions regarding this. Students use arrow functions correctly in callbacks and methods.

Lesson 2 • Scope, Closures, and the Scope Chain

Explains global, function, and block scope, then builds to closures. Students leverage closures for data encapsulation and factory patterns.

Lesson 3 • Parameters, Arguments, and Return Values

Covers default parameters, rest parameters, and explicit return. Students write flexible functions that handle variable input gracefully.

Lesson 4 • Function Declarations and Expressions

Compares function declarations, expressions, and named function expressions. Students understand hoisting differences and choose the right form.

Lesson 1 • Creating and Accessing Arrays

Covers array literals, indexing, length, and nested arrays. Students create and read arrays of any shape confidently.

Lesson 2 • Searching and Testing Arrays

Introduces find, findIndex, indexOf, includes, some, and every. Students query arrays efficiently without manual loops.

Lesson 3 • Destructuring and Spread with Arrays

Covers array destructuring assignment and the spread operator. Students write concise code for unpacking and combining arrays.

Lesson 4 • Mutating Array Methods

Teaches push, pop, shift, unshift, splice, and sort. Students add, remove, and reorder elements while understanding mutation side effects.

Lesson 1 • Prototypes and Prototype Chain

Explains prototype-based inheritance and property lookup. Students understand how JS objects share behavior without duplication.

Lesson 2 • Object Destructuring, Spread, and Utility Methods

Covers destructuring assignment, spread/rest for objects, and Object utility methods. Students write concise object manipulation code.

Lesson 3 • Object Literals and Property Access

Covers object creation, dot notation, bracket notation, and shorthand properties. Students build and read objects as the primary data structure in JS.

Lesson 4 • ES6 Classes and Inheritance

Introduces class syntax, constructors, and extends for inheritance. Students model hierarchies using modern, readable class-based patterns.

Lesson 1 • The Event Loop and Call Stack

Explains the single-threaded model, call stack, and event loop. Students understand why async patterns exist and how JS schedules work.

Lesson 2 • async and await Syntax

Introduces async functions and await expressions as syntactic sugar over Promises. Students write async code that reads like synchronous logic.

Lesson 3 • Promise Combinators and Fetch API

Covers Promise.all, Promise.race, Promise.allSettled, and the Fetch API. Students coordinate multiple async operations and retrieve remote data.

Lesson 4 • Callbacks and Callback Hell

Covers async callbacks and the nesting problem they create. Students recognize callback hell and understand why Promises were introduced.

Lesson 1 • Creating and Removing DOM Elements

Covers createElement, appendChild, insertBefore, and remove. Students build and tear down page elements programmatically.

Lesson 2 • Event Handling and Delegation

Introduces addEventListener, event objects, and delegation via bubbling. Students attach efficient listeners that work on dynamic content.

Lesson 3 • Selecting DOM Elements

Covers getElementById, querySelector, querySelectorAll, and related selectors. Students retrieve single and multiple elements reliably.

Lesson 4 • Understanding the DOM Tree

Explains the document object model as a tree of nodes. Students navigate parent, child, and sibling relationships to locate any element.