The typeof operator returns 'object' for null due to a historical bug in JavaScript. This behavior is widely recognized and important when performing type checks.

Closures allow an inner function to access variables from its outer (enclosing) function even after the outer function has finished executing. This is a fundamental concept in JavaScript that enables private data and state retention.

The 'use strict' directive enables strict mode in JavaScript, which turns previously accepted bad practices into errors. This helps developers catch mistakes and write safer, more secure code.

The map() method creates a new array by calling a provided function on every element of the original array. It is a fundamental tool for transforming arrays in JavaScript.

In JavaScript, when a number and a string are added together using the '+' operator, type coercion occurs and the number is converted to a string. The two strings are concatenated, resulting in '22'.

In non-strict mode, when a function is invoked without an explicit context, the 'this' keyword defaults to the global object (window in browsers). This behavior is essential to understand when dealing with function calls in JavaScript.

Using Number('123') explicitly converts the string '123' into a number. This approach is clear and reliable for converting valid numeric strings, in contrast to methods that may return partial results or remain as strings.

The event loop continuously checks if the call stack is empty and then processes tasks from the callback queue. This mechanism allows JavaScript to handle asynchronous operations without blocking the main execution thread.

Due to floating point imprecision, the sum of 0.1 and 0.2 does not exactly equal 0.3, resulting in a false comparison. This is a well-known issue in many programming languages that use binary floating point arithmetic.

Hoisting is the JavaScript mechanism where variable and function declarations are moved to the top of their corresponding scope during the compile phase. This means that they can be referenced before their actual declaration in the code, though only the declaration is hoisted, not the initialization.

The push() method appends one or more elements to the end of an array and returns the new length of the array. It is one of the most commonly used methods for modifying arrays in JavaScript.

Let, introduced in ES6, is block scoped, meaning it is only accessible within the nearest set of curly braces. In contrast, var is function scoped, which can lead to unexpected behavior when used in loops and conditional statements.

JSON.stringify converts a JavaScript object or value to a JSON string, making it useful for data transmission and storage. This method is a key tool when working with APIs and local storage.

The finally block is executed after the try and catch blocks regardless of whether an exception has occurred. It is typically used for cleanup tasks that must always be performed, such as releasing resources.

A promise acts as a placeholder for a value that may be available in the future as the result of an asynchronous operation. It allows developers to handle asynchronous events more cleanly compared to traditional callback-based approaches.

Prototypal inheritance in JavaScript lets objects inherit properties and methods from other objects by linking to them via a prototype chain. This system is distinct from classical inheritance and is a core feature of JavaScript's object model.

Memoization involves caching the results of expensive function calls so that repeated calls with the same input can return the cached result immediately. This optimization technique can greatly enhance performance, especially in recursive and computationally intensive operations.

An IIFE is executed immediately after its definition, which creates a private scope for variables and functions. This pattern helps prevent global namespace pollution and potential naming conflicts in larger codebases.

Currying transforms a function that takes multiple arguments into a series of functions that each take a single argument. This approach allows for partial application of functions and can simplify complex function calls by breaking them into simpler steps.

Synchronous code runs line by line, meaning each operation must complete before the next one begins, which can block further execution. In contrast, asynchronous code initiates operations and then moves on, allowing the main thread to remain unblocked and handle other tasks concurrently.