Skip to content
academia.sh
tr
Log in

Course Beginner

JavaScript Fundamentals

By the end of this course

Start course

01

Language Structure

The distinction between language, runtime, and standard; ways to run code; the scope difference between declaration kinds and hoisting.

  1. 01 What Is JavaScript The distinction between language, engine, runtime, and standard; the boundary between what ECMAScript defines and what the host environment adds.
  2. 02 Ways to Run Code Running from a file, the interactive shell, the browser console, and the script tag; the script–module distinction and reading an error message.
  3. 03 Language Versions and Standardization How ECMAScript editions are versioned, proposal stages, the traces backward compatibility leaves in the language, and feature detection.
  4. 04 Variable Declarations The difference between function-scoped and block-scoped declarations, redeclaration rules, the scope of constant binding, and the binding of the loop variable.
  5. 05 Naming and Scope Rules Naming rules and reserved words, the resolution of lexical scope, shadowing, hoisting, and the temporal dead zone.

02

Values and Types

Primitive types, arbitrary-precision integers, the type coercion algorithm, the three equality comparisons, and truthy and falsy values.

  1. 01 Primitive Types The seven primitive types and the distinction from objects; the single number type's floating-point representation, special number values, string, boolean, the two absence values, and symbol.
  2. 02 BigInt Cases where the safe integer range is crossed, the arbitrary-precision integer type, operator behavior, the ban on mixing types, and the serialization limit.
  3. 03 Type Conversion and Coercion The distinction between explicit conversion and implicit coercion; the procedures for converting to number, to string, and to primitive value; the two faces of the addition operator, and reading measurement values from text.
  4. 04 Equality Comparisons Strict equality, the step-by-step algorithm of loose equality, same-value equality, and identity comparison for objects.
  5. 05 Truthy and Falsy Values The to-boolean conversion procedure, the eight values counted as false, logical operators returning a value, nullish coalescing, and optional chaining.

03

Control Flow and Functions

Conditional selection, loop forms, the behavioral difference between function definition forms, parameter rules, arrow functions, and error handling.

  1. 01 Conditions and Selection `if` chains and guard clauses, the ternary operator, the `switch` statement's strict equality, fall-through behavior, and scope in case blocks.
  2. 02 Loops Counted, conditional, and collection loops; the `for...in` versus `for...of` distinction, loop control, labeled exit, and traversing objects.
  3. 03 Function Declaration and Expression The hoisting difference between the two definition forms, named function expressions, using functions as values, return rules, and the automatic semicolon insertion trap.
  4. 04 Parameters Missing and extra arguments, the condition under which default values kick in, rest parameters and spread, the arguments object, and destructured parameters.
  5. 05 Arrow Functions The forms of the short syntax, the implicit return and object-return trap, the absence of the arguments object, and context coming from the enclosing scope.
  6. 06 Error Handling The flow of `try`/`catch`/`finally`, the `throw` statement, built-in error types, the error object's fields, the cause chain, and the choice between an error and a return value.

04

Built-in Data Structures

Array and object operations, string formatting, serialization and parsing with JSON, and date–time representation.

  1. 01 Arrays Ways to create an array and holes, index access, the distinction between mutating and non-mutating methods, the sorting trap, and transformation chains.
  2. 02 Objects The two forms of property access, key stringification, shorthand and computed syntax, existence checks, destructuring, spread, and reference semantics.
  3. 03 Strings Template literals, slicing and search methods, locale-dependent case conversion, the code-unit/grapheme distinction, and number formatting.
  4. 04 JSON Serialization and parsing, values the format does not support, circular references, callbacks that adapt the conversion, and the limit of number precision.
  5. 05 Date and Time The timestamp model, the distinction between local time and coordinated universal time, parsing traps, date arithmetic, and locale-aware formatting.

Start typing to search.

↑↓ ↵ Esc navigate · open · close