Functions

Arrow functions give a concise => syntax and, crucially, have no own this, arguments, super, or new.target — they inherit this lexically from the enclosing scope. They also cannot be used as constructors with new and have no prototype, so they suit callbacks but not object methods that need their own this.

A closure is a function bundled with the lexical environment it was created in, so it keeps access to that scope's variables even after the outer function has returned. This lets an inner function read and update outer variables, which is the basis for private state, function factories, and stateful callbacks.

Functions are values like any other: you can assign one to a variable, pass it as an argument, return it from another function, and store it in an array or object. This is what enables callbacks, higher-order functions, and event handlers like addEventListener('click', handler).

All three set a function's this to a given object. call invokes it immediately with arguments listed individually; apply invokes it immediately but takes the arguments as a single array; bind does not invoke — it returns a new function with this (and any leading arguments) permanently fixed, to be called later.

A higher-order function takes one or more functions as arguments, returns a function, or both. It relies on functions being first-class values. Array methods map, filter, and reduce are built-in examples that accept a callback, and a function factory that returns a configured function is the returning case.

this is set by how a function is called, not where it is defined. Called as obj.method(), this is obj (implicit binding). Called standalone, this is the global object in sloppy mode or undefined in strict mode (default binding). An arrow has no own this and takes it lexically from the enclosing scope.

An IIFE (Immediately Invoked Function Expression) is a function that runs the moment it is defined, written as (function () { ... })(). Wrapping code in one creates a private scope: variables declared inside are not visible outside, which avoided polluting the global namespace before block-scoped let/const and ES modules made it largely unnecessary.

bind returns a brand-new function (an exotic bound function) that, when called, invokes the original with this permanently fixed to the bound value plus any pre-set leading arguments. It does not call the original immediately.

Closures power data privacy and the module pattern (an IIFE returning methods over private variables), function factories, and stateful callbacks. The classic pitfall is the loop-capture bug: a var loop shares one binding, so all callbacks see the final value, while let gives each iteration its own. Closures also retain captured variables, risking memory leaks if kept alive.

There is a precedence: new makes this the fresh instance; explicit call/apply/bind (hard binding) sets it to the given object and wins over implicit; obj.method() makes this the receiver; a standalone call defaults to the global object or undefined in strict mode. An arrow ignores all of these — it has no own this and takes it lexically from where it was defined.