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

Interpreted vs compiled, ECMAScript basics, and JavaScript engines

JavaScript is specified by ECMAScript, and modern engines use parsing, JIT compilation, and optimization rather than pure line-by-line interpretation.

ECMAScript is the language standard
Engines implement the spec
Modern engines optimize hot code paths

#ecmascript #javascript #runtime

JavaScript Medium Theory

Iteration in JavaScript: for, while, do while, for...of, for...in, iterables, iterators, generators, and yield

JavaScript supports several loop forms, plus iterator and generator protocols for custom iteration behavior.

`for...of` iterates values
`for...in` iterates enumerable property keys
Generators pause and resume with `yield`

#generators #iteration #javascript

JavaScript Easy Theory

JavaScript arrays, array methods, and push/pop/shift/unshift operations

Arrays are ordered list-like objects with mutation helpers like `push`, `pop`, `shift`, and `unshift`.

Array methods mix mutation and non-mutation
Front operations are typically costlier than tail operations
Arrays are objects under the hood

#arrays #basics #javascript

JavaScript Easy Theory

JavaScript best practices: readable code, const by default, avoiding globals, preferring ===, immutable patterns, proper error handling, modular code, and meaningful naming

Strong JavaScript code emphasizes readability, safe defaults, modular design, clear errors, and predictable state changes.

Prefer `const` unless reassignment is needed
Avoid accidental globals and hidden mutation
Good names and modules reduce cognitive load

#best-practices #javascript #style

JavaScript Easy Theory

JavaScript data types, primitive vs reference values, typeof, NaN, and truthy/falsy values

JavaScript has primitive values like numbers and strings plus reference types like objects and arrays, and some runtime quirks like `typeof null` and `NaN`.

Primitives copy by value
Objects and arrays compare by reference
`NaN` is a special number value

#basics #data-types #javascript

JavaScript Easy Theory

JavaScript overview, key features, dynamic typing, and weak typing

JavaScript is a high-level language used in browsers and servers, and it is dynamically and weakly typed.

Runs in browsers and Node.js
Types are checked at runtime
Coercion happens more freely than in strongly typed languages

#basics #javascript #typing

JavaScript Medium Theory

JavaScript security basics: XSS, CSRF, safe DOM updates, and avoiding eval

Client-side JavaScript can create security issues when it injects unsafe content, trusts the wrong source, or executes arbitrary code.

Unsafe HTML updates can cause XSS
CSRF abuses trusted browser state
`eval` is dangerous and usually unnecessary

#browser #javascript #security

JavaScript Easy Theory

JavaScript strings, string methods, template literals, and string immutability

Strings are immutable primitive values, and JavaScript offers many helper methods plus template literals for interpolation.

Methods return new strings
Template literals support interpolation
Immutability means characters are not changed in place

#basics #javascript #strings

JavaScript Easy Theory

JSON, JSON.parse, and JSON.stringify in JavaScript

JSON is a text format for structured data, and JavaScript uses `JSON.parse` to read it and `JSON.stringify` to serialize it.

JSON is text, not live objects
Parsing turns text into values
Stringifying is common for APIs and storage

#api #javascript #json

JavaScript Medium Theory

Modules in JavaScript: import/export, default export, named export, and CommonJS vs ES modules

Modern JavaScript uses modules to organize code, with ES modules in the language standard and CommonJS still common in older Node.js code.

Named and default exports behave differently
ES modules use `import` and `export`
CommonJS uses `require` and `module.exports`

#javascript #modules #nodejs

JavaScript Easy Theory

Node.js basics: what Node.js is, common use cases, module.exports, require, npm basics, and package.json basics

Node.js lets JavaScript run outside the browser, especially for servers, tooling, CLIs, and build pipelines.

Node.js is a runtime, not the language
CommonJS uses `require` and `module.exports`
npm and package.json manage dependencies and scripts

#javascript #nodejs #tooling

JavaScript Easy Theory

Object creation, object literals, property access, dot vs bracket notation, and object methods

Objects can be created in several ways, and property access depends on whether the key is static or dynamic.

Object literals are the common default
Dot access needs a valid identifier
Bracket access handles dynamic keys

#basics #javascript #objects