JavaScript · Beginner interview

There are seven primitives: string, number, boolean, null, undefined, bigint, and symbol. Everything else (objects, arrays, functions) is an object. Primitives are immutable and compared by value, while objects are compared by reference. typeof tells you the type, with the well-known quirk that typeof null returns 'object'.

=== is strict equality: it compares value and type with no conversion. == is loose equality: it coerces the operands to a common type first, which leads to surprises like 0 == '' or null == undefined being true. The rule is to use === by default to avoid hidden coercion bugs.

undefined means a variable has been declared but not assigned, or a missing property/return — it's JavaScript's default 'nothing'. null is an intentional 'no value' you assign yourself. They're loosely equal (==) but not strictly (===), and you typically check for both with == null.

var is function-scoped and hoisted (initialized as undefined), which causes leaks and confusing bugs. let and const are block-scoped and live in a 'temporal dead zone' until declared, so using them early throws. const can't be reassigned (though objects it points to can still be mutated). Modern code uses const by default and let when reassignment is needed, avoiding var.

Hoisting is JavaScript moving declarations to the top of their scope before execution. Function declarations are fully hoisted (callable before their definition); var declarations are hoisted but initialized as undefined; let/const are hoisted but unusable until their line (the temporal dead zone). Understanding it explains why some code runs and some throws ReferenceError.

Arrow functions are shorter and, crucially, don't have their own this — they inherit it from the enclosing scope, which makes them great for callbacks where you want the outer this. They also lack their own arguments object and can't be used as constructors. Regular functions get their this from how they're called.

const obj = { items: [1], show() { this.items.forEach(i => console.log(this)); } };

Primitives are copied by value — assigning one variable to another duplicates the value, and they're independent. Objects (and arrays) are copied by reference — the variable holds a pointer, so two variables can point to the same object and mutating through one is visible through the other. To get an independent copy you spread or use a copy function.

const a = { n: 1 }; const b = a; b.n = 2; // a.n is now 2
const c = { ...a }; // independent shallow copy

map transforms each element and returns a new array of the same length; filter returns a new array with only the elements that pass a test; reduce boils an array down to a single value by accumulating. They're non-mutating and composable, which is why they're preferred over manual for-loops for transforming data.

[1,2,3].map(n => n*2);        // [2,4,6]
[1,2,3].filter(n => n>1);     // [2,3]
[1,2,3].reduce((a,b) => a+b); // 6

JSON.stringify converts a JavaScript value to a JSON string (for storage or sending over the network); JSON.parse turns a JSON string back into a value. Note that stringify drops functions and undefined and turns Dates into strings, so a stringify→parse round trip is also a quick (but lossy) way to deep-copy plain data.

A callback is a function passed to another function to be called later — when an event fires or an async operation finishes. They're the original async mechanism in JS (setTimeout, event listeners), but nesting many of them for dependent steps creates hard-to-read 'callback hell', which promises and async/await solve.

A promise represents a value that will be available later — it's pending, then either fulfilled with a value or rejected with an error. You handle the outcome with .then and .catch, and you can chain them so each step runs after the previous resolves. Promises flatten the nesting of callbacks and standardize error handling.

async/await is syntax over promises that lets you write asynchronous code that reads like synchronous code. An async function returns a promise, and await pauses it until a promise settles, with errors handled by ordinary try/catch. It's the same machinery as .then chains, just easier to read.

async function load() {
  try { const r = await fetch(url); return await r.json(); }
  catch (e) { console.error(e); }
}