JavaScript

How to answer in an interview

JavaScript is a dynamically-typed, interpreted scripting language originally designed to make web pages interactive, running natively in every browser. With the introduction of Node.js, it can also run server-side, enabling full-stack development, and it's widely used for web apps, mobile apps, and even desktop applications.

Explain like I am 5

JavaScript is the language that makes websites do things — like when a button lights up or a menu pops open when you click it.

How to answer in an interview

'var' is function-scoped and hoisted with an initial value of undefined, which can lead to bugs. 'let' is block-scoped and allows reassignment, while 'const' is also block-scoped but prevents reassignment after initialization. Modern JavaScript favors 'let' and 'const' over 'var' for more predictable scoping.

Explain like I am 5

'var' is an old rule that lets a variable wander around the whole house. 'let' keeps it in one room, and 'const' keeps it in one room and glues it to the floor so it can't move.

How to answer in an interview

'==' performs type coercion before comparing values, so different types can be considered equal, e.g. '1 == "1"' is true. '===' checks both value and type without coercion, making it stricter and generally the recommended choice to avoid unexpected bugs.

Explain like I am 5

'==' is lenient and says 'close enough' even if things look different on paper, like a number versus its word form. '===' is strict and only agrees if both the value and the type match exactly.

How to answer in an interview

'undefined' means a variable has been declared but not yet assigned a value, and it's the default value JavaScript assigns automatically. 'null' is an intentional assignment representing 'no value' or emptiness, explicitly set by the developer.

Explain like I am 5

'undefined' is like an empty box nobody has labeled yet. 'null' is a box someone deliberately labeled 'empty' on purpose.

How to answer in an interview

Arrow functions provide a shorter syntax for writing functions and do not bind their own 'this', 'arguments', or 'super', instead inheriting these from the surrounding scope. This makes them especially useful in callbacks where preserving the outer 'this' context matters, but they aren't suitable as object methods that need dynamic 'this' binding.

Explain like I am 5

An arrow function is a shorter way to write a function, and it doesn't change who 'this' is pointing to — it just goes along with whatever was already true outside it.

How to answer in an interview

Synchronous code executes sequentially, blocking further execution until the current operation finishes. Asynchronous code allows the program to continue running other tasks while waiting for an operation like a network request to complete, using mechanisms like callbacks, Promises, or async/await.

Explain like I am 5

Synchronous is like waiting in line and doing nothing else until it's your turn. Asynchronous is like taking a numbered ticket and doing other things until your number is called.

How to answer in an interview

A callback function is a function passed as an argument to another function, to be executed after some operation completes. Callbacks are foundational to JavaScript's asynchronous model, though excessive nesting can lead to 'callback hell', which Promises and async/await help resolve.

Explain like I am 5

A callback is like telling a friend, 'call me back once you're done,' so they know exactly what to do the moment they finish their task.

How to answer in an interview

Scope determines the accessibility of variables. Global scope variables are accessible anywhere in the code, function scope variables declared with 'var' are accessible only within that function, and block scope variables declared with 'let' or 'const' are limited to the enclosing curly braces, such as an if block or loop.

Explain like I am 5

Scope is like rooms in a house — some things (global) are visible from anywhere, but some things are only visible inside one specific room (block or function) and can't be seen from outside it.

How to answer in an interview

JSON, or JavaScript Object Notation, is a lightweight text-based data interchange format. JSON.parse() converts a JSON string into a JavaScript object, while JSON.stringify() converts a JavaScript object into a JSON string, commonly used when sending or receiving data from APIs.

Explain like I am 5

JSON is like a universal recipe card format. JSON.parse turns the written recipe into something you can actually cook with in JavaScript, and JSON.stringify turns your cooking notes back into a written recipe card.

How to answer in an interview

Hoisting is JavaScript's behavior of moving variable and function declarations to the top of their scope during compilation, before code execution. Function declarations are fully hoisted, but 'let' and 'const' variables are hoisted into a 'temporal dead zone' where they exist but cannot be accessed until their declaration line runs.

Explain like I am 5

It's like the JavaScript engine peeking ahead and writing down all the names it's going to see before it actually starts reading the story, even though it hasn't gotten there yet.

How to answer in an interview

A closure is a function that retains access to variables from its enclosing lexical scope even after that outer function has finished executing. Closures are commonly used to create private variables, implement data encapsulation, and build factory functions or memoization patterns.

Explain like I am 5

A closure is like a backpack a function carries around — it remembers and keeps the things from where it was made, even after it leaves that place.

How to answer in an interview

A Promise represents the eventual result of an asynchronous operation and can be in one of three states: pending, fulfilled, or rejected. You attach handlers using .then() for success and .catch() for errors, allowing cleaner asynchronous code than deeply nested callbacks.

Explain like I am 5

A promise is like an order receipt at a restaurant — you don't have your food yet, but the receipt promises you'll either get your food later or be told something went wrong.

How to answer in an interview

async/await is syntactic sugar built on top of Promises that lets asynchronous code be written in a more synchronous, readable style. Marking a function 'async' means it always returns a Promise, and 'await' pauses execution within that function until the awaited Promise resolves, without blocking the main thread.

Explain like I am 5

Instead of chaining lots of '.then()' steps, async/await lets you write 'wait here until this is done' in a way that reads like a normal to-do list.

How to answer in an interview

'this' refers to the object that is currently executing the function, and its value depends on how the function is called rather than where it's defined. In a regular function, 'this' can change based on the caller, while arrow functions don't have their own 'this' and instead inherit it from the enclosing lexical scope. Methods like call(), apply(), and bind() let you explicitly set 'this'.

Explain like I am 5

'this' is like asking 'who's talking right now?' The answer changes depending on who's speaking (calling the function), except arrow functions always just point back to whoever was speaking before them.

How to answer in an interview

Event bubbling means an event triggered on a nested element propagates upward through its ancestors in the DOM, while event capturing propagates downward from the root to the target element first. By default, most event listeners use the bubbling phase, but you can opt into capturing by passing a third argument to addEventListener.

Explain like I am 5

If you shout inside a small room inside a house, bubbling means the sound travels outward to the hallway and then the whole house. Capturing is the opposite — sound would travel inward from the house to the room first.

How to answer in an interview

Debouncing delays a function's execution until a certain period of inactivity has passed, so rapid repeated triggers only fire the function once at the end. Throttling ensures a function runs at most once within a specified time interval, regardless of how many times the event fires. Both are used to optimize performance for frequent events like scrolling or typing.

Explain like I am 5

Debouncing waits until you stop typing before doing something. Throttling lets something happen only once every few seconds, no matter how fast you keep clicking.

How to answer in an interview

A higher-order function is a function that takes another function as an argument, returns a function, or both. Common examples in JavaScript include map(), filter(), and reduce(), which allow declarative and reusable data transformations rather than manual loops.

Explain like I am 5

A higher-order function is like a manager who hands out instructions (other functions) to workers, rather than doing every task itself.

How to answer in an interview

JavaScript runs on a single thread with a call stack that executes synchronous code. Asynchronous operations like timers or network requests are handled by the browser or Node APIs, and their callbacks are pushed to a task queue or microtask queue. The event loop continuously checks if the call stack is empty and then pushes queued callbacks onto it, with microtasks like Promises resolved before macrotasks like setTimeout.

Explain like I am 5

Imagine one waiter serving one table at a time. When something takes a while, like cooking food, the waiter puts it aside and keeps serving others, then comes back to deliver the food once it's ready.

How to answer in an interview

JavaScript objects can inherit properties and methods from other objects via a prototype chain, rather than classical class-based inheritance. When a property isn't found on an object, JavaScript looks up the chain through its prototype until it finds the property or reaches null. ES6 classes are essentially syntactic sugar over this prototype-based system.

Explain like I am 5

If an object doesn't know how to do something, it asks its 'parent' object, and if that parent doesn't know either, it asks its own parent, all the way up the family line.

How to answer in an interview

A memory leak occurs when memory that's no longer needed isn't released, often because references are unintentionally kept alive, such as forgotten event listeners, uncleared timers, or closures holding onto large objects. To avoid leaks, developers should remove event listeners when no longer needed, clear intervals/timeouts, and avoid unnecessary global variable references.

Explain like I am 5

A memory leak is like forgetting to return borrowed items — if you keep holding onto things you don't need anymore, eventually there's no room left for new things.