JavaScript is a lightweight, interpreted programming language primarily used for web development. Runs in browsers and Node.js. Dynamic typing, supports OOP and functional programming.

Variables store values. Declare with var, let, or const. Example: var x = 5; let y = 10; const z = 15;

var is function-scoped, let/const are block-scoped. var can be redeclared, let cannot. const is immutable (cannot be reassigned).

Primitive: string, number, boolean, null, undefined, symbol. Object: object (includes arrays, functions). Dynamically typed language.

Returns data type: typeof 5 returns "number". typeof "hello" returns "string". typeof {} returns "object".

NaN (Not a Number) is special value. Check: Number.isNaN(value) or isNaN(value). Example: 0/0 returns NaN.

Variables and function declarations moved to top of scope before execution. var initialized as undefined, let/const not initialized (temporal dead zone).

Reusable blocks of code. Declare: function name(params) { } or const name = (params) => { } (arrow function).

Function passed as argument to another function, called later. Example: setTimeout(callback, 1000);

Function with access to variables from outer scope even after outer function returns. Example: function outer() { let x = 1; return function() { return x; } }

Visibility of variables. Global scope (window object), function scope, block scope. Inner scope can access outer scope.

References current object. In functions, refers to window (non-strict) or undefined (strict). In methods, refers to object.

Concise syntax: const sum = (a, b) => a + b; Don't have their own this, inherit from parent scope.

User interactions: click, submit, change, keydown, mouseover. Handle with addEventListener or onclick attribute.

Attaching listener to parent element to handle events from child elements. Improves performance.

Tree representation of HTML. JavaScript accesses/modifies DOM. Root: document object. Example: document.getElementById('id').innerHTML

document.getElementById('id'), document.querySelector('selector'), document.querySelectorAll('selector'), document.getElementsByClassName('class')

element.innerHTML = "text" (parses HTML). element.textContent = "text" (plain text). element.innerText (visible text).

element.setAttribute('attr', 'value'). element.getAttribute('attr'). element.removeAttribute('attr').

element.classList.add('class'), .remove('class'), .toggle('class'), .contains('class').

Handle asynchronous operations. States: pending, resolved, rejected. Example: new Promise((resolve, reject) => {})

Syntactic sugar for Promises. async function returns Promise. await pauses execution until Promise resolves.

JavaScript Object Notation. Text format for data interchange. Parse: JSON.parse(string). Stringify: JSON.stringify(object).

Modern way to make HTTP requests. fetch(url).then(response => response.json()).then(data => {})

Older API for HTTP requests. Create: const xhr = new XMLHttpRequest(); Replaced by fetch API.

Ordered collection of values. Declare: const arr = [1, 2, 3] or new Array(). Dynamic size.

push(), pop(), shift(), unshift(), map(), filter(), reduce(), forEach(), find(), includes(), indexOf(), slice(), splice().

Collection of key-value pairs. Declare: const obj = { name: "John", age: 30 } or new Object(). Access: obj.name or obj["name"].

Extract values from object/array into variables. Example: const { name, age } = obj; or const [a, b] = arr;

... spreads array/object. Example: const arr2 = [...arr1, 4, 5]; or const obj2 = { ...obj1, prop: value }

... collects arguments. Example: function sum(...numbers) { return numbers.reduce((a, b) => a + b); }

Provide default value if argument not passed. Example: function greet(name = "Guest") { }

Backtick strings with interpolation. Example: `Hello ${name}` instead of "Hello " + name

Enforce stricter parsing and error checking. Enable: "use strict"; at top of file or function.

null is intentionally no value. undefined is variable declared but not assigned. typeof null returns "object" (bug).

Falsy: false, 0, "", null, undefined, NaN. Truthy: everything else. Used in conditions: if (value) { }

==, ===, !=, !==, <, >, <=, >=. === checks type and value, == only value.

&&, ||, !. Example: if (a && b) { } or (a || b)

Safely access deeply nested properties. Example: obj?.prop?.subProp returns undefined if null.

Returns right operand if left is null/undefined. Example: value ?? "default" returns "default" if value is null.

Pattern matching. Create: /pattern/flags or new RegExp("pattern", "flags"). Methods: test(), exec(), match(), replace().

length, charAt(), substring(), slice(), indexOf(), split(), toUpperCase(), toLowerCase(), trim(), replace().

Global object in browsers. Contains alert(), setTimeout(), setInterval(), fetch(), document, etc.

Stores data in browser (persistent). localStorage.setItem('key', 'value'), getItem(), removeItem().

Stores data per browser session (cleared on close). Similar API to localStorage.

Store small data in browser. Set: document.cookie = "name=value"; Get: document.cookie returns all cookies.

Debugging tool. Methods: console.log(), console.error(), console.warn(), console.table(), console.time().

try-catch-finally. Example: try { } catch (error) { } finally { }

Create custom error classes: class MyError extends Error { }

isNaN() converts to number first (loose check). Number.isNaN() checks if NaN (strict). Prefer Number.isNaN().

Objects inherit from prototype. Prototype chain: object.__proto__. Every function has prototype property.

Each function has prototype object. Instances inherit from prototype: obj.__proto__ === constructor.prototype

Function called with new keyword to create object. Example: function Person(name) { this.name = name; } const p = new Person("John");

Creates new object, sets prototype, calls constructor, returns object.

Syntactic sugar for constructor functions. Example: class Person { constructor(name) { this.name = name; } }

get/set keywords. Example: get name() { return this._name; } set name(value) { this._name = value; }

Methods on class, not instance. Example: class Math { static add(a, b) { return a + b; } } Math.add(1, 2);

Use extends and super. Example: class Dog extends Animal { constructor(name) { super(name); } }

Primitive type representing unique identifier. Example: const sym = Symbol('desc'); Cannot be accessed with for...in.

Creates object with specified prototype. Example: const obj = Object.create(proto);

Define properties precisely: Object.defineProperty(obj, 'prop', { value: 5, writable: false, enumerable: true });

freeze prevents modification. seal allows modification but not adding/removing properties.

Event propagates from target to parent elements. Stop with event.stopPropagation().

Event propagates from parent to target. addEventListener(..., true) enables capturing phase.

Execute function after delay. Useful for search input: function debounce(fn, delay) { let timer; return function() { clearTimeout(timer); timer = setTimeout(fn, delay); } }

Execute function at most once per interval. Useful for scroll/resize: function throttle(fn, delay) { let last = 0; return function() { const now = Date.now(); if (now - last >= delay) { fn(); last = now; } } }

Cache function results. Example: function memoize(fn) { const cache = {}; return function(arg) { if (arg in cache) return cache[arg]; return cache[arg] = fn(arg); } }

Convert function to chain of single-argument functions. Example: const add = (a) => (b) => a + b; add(1)(2)

Fix some arguments of function. Example: const add5 = add.bind(null, 5); add5(3)

Function that takes/returns function. Example: function twice(fn) { return function() { fn(); fn(); } }

Functions that can pause/resume. Use function* and yield. Example: function* gen() { yield 1; yield 2; }

Iterate over async values. Use for await...of. Example: for await (const value of asyncIterable) { }

JavaScript runs synchronously. Callbacks go to task queue. Event loop executes when main thread is empty.

Higher priority than task queue. Promises, async/await use microtask queue. Executes after main code, before task queue.

setTimeout executes once after delay. setInterval executes repeatedly. Example: setTimeout(fn, 1000); setInterval(fn, 1000);

Invoke function with specific this. Example: function.call(thisArg, arg1, arg2);

Similar to call() but takes array of arguments. Example: function.apply(thisArg, [arg1, arg2]);

Creates new function with specified this. Example: const boundFn = function.bind(thisArg);

Key-value collection. Keys can be any type (unlike objects). new Map(); map.set(key, value); map.get(key);

Collection of unique values. new Set(); set.add(value); set.has(value);

Similar to Map/Set but hold weak references. Garbage collected if no other references. Keys must be objects.

Intercept and customize operations on objects. Example: const proxy = new Proxy(target, handler);

Provides methods for interceptable operations. Example: Reflect.get(obj, 'prop'); Reflect.set(obj, 'prop', value);

Organize code into reusable pieces. export const func = () => {}; import { func } from "./module";

Module A depends on B, B depends on A. Causes issues. Avoid by restructuring modules.

Access/modify URL. window.location.href, .pathname, .search, .hash, .reload(), .replace().

Manage browser history. history.back(), .forward(), .go(n).

Detect when elements enter viewport. Useful for lazy loading: new IntersectionObserver(callback);

Watch for DOM changes. Example: new MutationObserver(callback).observe(element, options);

Run JavaScript in background thread. Prevent blocking main thread. new Worker('worker.js');

Superset of JavaScript with static typing. Compiled to JavaScript. Example: const x: number = 5;

Define object structure. Example: interface User { name: string; age: number; }

Define data structure. Example: type User = { name: string; age: number; }

Type parameters for reusable code. Example: function identity<T>(arg: T): T { return arg; }

Assert type explicitly. Example: (value as string).toUpperCase();

Variable can be one of multiple types. Example: type Status = "active" | "inactive";

Combine multiple types. Example: type Admin = User & { adminId: number; }

Make properties immutable. Example: interface User { readonly id: number; }

Define set of constants. Example: enum Color { Red = 0, Green = 1, Blue = 2 }

Narrow type in conditional block. Example: if (typeof value === "string") { ... }

Tree representation of code structure. Used by compilers and linters. Example: ESLint, Babel use AST.

Variable/function declarations moved to scope top. var hoisted as undefined. Function declarations fully hoisted. let/const not hoisted (temporal dead zone).

Interprets/compiles JavaScript. V8 (Chrome), SpiderMonkey (Firefox), JavaScriptCore (Safari). Uses JIT compilation.

Minimize DOM operations, use debouncing/throttling, lazy load, code splitting, caching, use efficient algorithms.

105-150. Advanced Topics (abbreviated)

105-110: Code splitting, tree shaking, bundlers (Webpack, Rollup, Vite), transpilation (Babel), module federation. 111-115: Testing frameworks (Jest, Mocha, Jasmine), mocking, test doubles, coverage analysis, CI/CD integration. 116-120: Design patterns (Observer, Factory, Singleton, Strategy), SOLID principles, OWASP security. 121-125: DOM optimization, virtual DOM (React), rendering engines, layout/paint optimization, memory leaks. 126-130: Frameworks (React, Vue, Angular), state management (Redux, Zustand), reactive programming (RxJS). 131-135: Progressive Web Apps (PWA), Service Workers, Indexed DB, Web APIs, Fetch API advanced. 136-140: Node.js, Express, file system, streams, child processes, worker threads. 141-145: GraphQL clients, REST client libraries, WebSocket implementation, real-time communication. 146-150: Security (XSS prevention, CSRF protection, Content Security Policy), performance monitoring, error tracking, analytics integration.