Quick recall mode

Keywords first, details second.

Use this mode when you want memory triggers only: title, summary, tags, and bullet anchors without long answers getting in the way.

Results update as you type. Press / to jump straight into search.

Type Category Tag Difficulty Keywords only

Quick recall

374 cards

JavaScript Medium Theory

Constructor functions, prototypes, and the prototype chain in JavaScript

Before class syntax, constructor functions and prototypes were the main way to share behavior, and that model still exists underneath modern classes.

Functions can act as constructors
Shared methods usually live on the prototype
Property lookup follows the prototype chain

#javascript #oop #prototypes

JavaScript Easy Theory

Date and time basics in JavaScript: Date object and common date methods

JavaScript's `Date` object represents points in time and exposes local or UTC getters, setters, and formatting helpers.

Dates are stored as timestamps
Timezone handling can surprise people
Common methods expose year, month, day, and time parts

#basics #date #javascript

JavaScript Medium Theory

DOM basics: DOM selection, querySelector, querySelectorAll, getElementById, traversal, manipulation, createElement, appendChild, removeChild, and innerHTML vs textContent

The DOM is the browser's tree representation of the page, and JavaScript can select, traverse, and update nodes through several APIs.

Selectors return elements or node lists
DOM manipulation changes the page tree
`textContent` is safer than arbitrary `innerHTML`

#browser #dom #javascript

JavaScript Easy Theory

Equality and identity in JavaScript: == vs ===, != vs !==, and object reference equality

Loose equality performs coercion, strict equality compares without coercion, and objects are equal only when they reference the same object.

Prefer `===` and `!==`
`==` follows coercion rules
Object equality is reference-based

#comparison #equality #javascript

JavaScript Easy Theory

Error handling in JavaScript: try, catch, finally, throw, and custom errors

JavaScript handles recoverable runtime failures with exceptions, and you can throw your own error objects when needed.

`finally` runs regardless of success or failure
Throw meaningful error types
Custom errors improve clarity

#errors #javascript #runtime

JavaScript Hard Theory

Event loop, Web APIs, callback queue, microtask queue, macrotask queue, promise queue, and setTimeout behavior

JavaScript's event loop decides when queued async work can return to the call stack, with microtasks running before the next macrotask.

The stack must be empty before queued work runs
Promise callbacks go to the microtask queue
`setTimeout` is a minimum delay, not an exact execution time

#async #event-loop #javascript

JavaScript Medium Theory

Events in JavaScript: event handling, addEventListener, bubbling, capturing, delegation, preventDefault, and stopPropagation

Browser events travel through capture and bubble phases, and good event handling often relies on delegation and controlled propagation.

`addEventListener` can listen in capture or bubble phase
Delegation reduces many per-node listeners
`preventDefault` and `stopPropagation` solve different problems

#dom #events #javascript

JavaScript Medium Theory

Execution context, call stack, scope chain, and memory heap in JavaScript

JavaScript creates execution contexts for code execution, uses a call stack for active functions, resolves variables through the scope chain, and stores objects in memory.

Contexts track variables and `this`
The call stack orders active frames
Heap memory holds reference values

#execution-context #javascript #runtime

JavaScript Medium Theory

Function declarations, function expressions, arrow functions, default parameters, rest parameters, callbacks, higher-order functions, first-class functions, IIFE, and pure functions

JavaScript functions are first-class values, which is why callbacks, higher-order utilities, and different function forms all matter.

Declarations and expressions behave differently
Arrow functions change `this` behavior
Pure functions avoid hidden side effects

#basics #functions #javascript

JavaScript Medium Theory

Functional programming topics in JavaScript: immutability, map/filter/reduce, and composition basics

JavaScript supports functional patterns through immutable updates, transformation helpers, and composing small functions into larger pipelines.

Immutability reduces accidental shared-state bugs
`map`, `filter`, and `reduce` support declarative transforms
Composition connects small reusable functions

#functional #immutability #javascript

JavaScript Hard Theory

Garbage collection, memory leaks, deep copy vs shallow copy, and performance pitfalls in loops and DOM updates

JavaScript uses garbage collection, but leaks still happen when references stay alive unexpectedly or when code creates unnecessary work.

Leaked references block collection
Shallow copies can share nested state
Repeated DOM writes and bad loops can hurt performance

#javascript #memory #performance

JavaScript Medium Theory

Implicit coercion, explicit conversion, Number/String/Boolean, parseInt vs Number, and common coercion pitfalls

JavaScript can convert values automatically or explicitly, and interview questions often focus on where that behavior becomes surprising.

Explicit conversion is easier to reason about
`parseInt` and `Number` do different jobs
Coercion can hide bugs

#coercion #javascript #type-conversion