JavaScript reference

Reads an element by index and supports negative positions.

Returns a new array with the inputs appended. Spread syntax is usually clearer.

Overwrites a range with a value in place.

Returns the index of the first match, or -1.

Returns the last matching element, or undefined.

Flattens nested arrays by one level, or by the supplied depth.

Maps and then flattens one level. Great for expanding one item into several.

Runs a callback for each element. It does not return a value and cannot be awaited meaningfully.

Creates an array from any iterable or array-like value, with an optional mapping function.

Tests membership with SameValueZero, which finds NaN but cannot compare objects by value.

Returns the first index of a value, or -1. Fails for NaN.

The reliable way to test for an array. typeof returns "object".

Joins elements into a string. The default separator is a comma.

Iterators over indexes, values and index-value pairs.

The number of elements. Assigning a smaller length truncates the array.

Removes and returns the last element, or undefined when empty.

Adds one or more values to the end and returns the new length.

Reverses the array in place. Use toReversed() for a copy.

Removes and returns the first element, or undefined when empty.

Returns a shallow copy of part of an array without mutating the original.

Sorts in place and returns the same array. The default is lexicographic, which surprises with numbers.

Removes, replaces or inserts elements in place and returns the removed items.

Returns a sorted copy without mutating the original.

Adds one or more values to the start and returns the new length.

Creates a new array with only the elements whose callback returns a truthy value.

Returns the first matching element, or undefined.

Creates a new array by transforming every element. It never mutates the original.

Folds an array into a single value. Always pass an initial value when the type matters.

Tests whether at least one or all elements match. Both short-circuit.

Cancels fetch requests and removable event listeners through its signal.

An async function always returns a promise. await pauses it until another promise settles, then returns its value or throws its error.

Cancels a pending timeout or interval. Clearing an already finished timer is safe.

Synchronous code runs first, then promise callbacks, then timers. Logging the order is the fastest way to remember it.

Starts an HTTP request and resolves with a Response. It rejects only on network failure, not on 404 or 500.

Represents a future value. Resolve with a value or reject with an Error.

Waits for every promise. Resolves with all values, or rejects as soon as one rejects.

Waits for every promise regardless of outcome and returns status and value or reason for each.

Resolves with the first fulfilled promise and rejects only if every promise rejects.

Handles rejection. Put one catch at the end of a chain instead of a handler after every step.

Runs whether the promise settles or rejects, and passes the result through.

Settles with the first promise to fulfil or reject. Useful for timeouts.

Runs when a promise fulfils. Return a value or another promise to chain further.

Schedules work after the current task but before the next render.

Reads and parses the response body as JSON. The body can be read only once.

Repeats a function. Always keep the id so you can stop it.

Runs a function once after a delay. The delay is a minimum, not a guarantee.

Await turns rejection into a thrown error, so the usual try/catch works.

Sets this explicitly. bind returns a new function; call and apply invoke immediately.

A function keeps access to variables from the scope where it was created, even after that scope returns.

Log values to the console. console.table is excellent for arrays of objects.

Generates a cryptographically strong UUID. Available in secure contexts.

Loads a module at runtime and returns a promise. Use it for code splitting.

Produces a sequence lazily. Each yield pauses the function until the next value is requested.

Function declarations are hoisted with their body; let and const are hoisted but uninitialised until the declaration runs.

Locale-aware number, currency and percentage formatting.

Parses JSON text. Wrap it in try/catch because malformed input throws.

Serialises a value to JSON. Functions and undefined disappear from objects.

Stores strings per origin with no expiry. Serialise objects with JSON.

A keyed collection that accepts any key type and remembers insertion order.

Exports a value from a module. Modules are strict and scoped to their own file.

Imports a named or default export. Paths need the file extension in browsers.

Like localStorage but cleared when the tab closes.

A collection of unique values with fast membership tests. Iteration keeps insertion order.

A unique, non-string property key. Use it to avoid accidental collisions.

Inside a normal function, this depends on how it is called. Arrow functions inherit this from their enclosing scope.

Parses and builds URLs. Use it instead of string concatenation for query parameters.

Reads and writes query strings safely, including encoding.

Collections with weak keys that can be garbage-collected. They are not iterable and are used for private metadata.

Dates compare and add through millisecond timestamps. Mutating methods such as setDate exist too.

Reads the local year. getMonth is zero-based, so January is 0.

The current Unix timestamp in milliseconds. Useful for measuring elapsed time.

Formats the date as UTC ISO 8601. This is the format to store and transmit.

Formats a date for a locale. Pass options to control the parts shown.

A reusable, locale-aware date formatter. Create it once and call format many times.

Creates a date for the current moment or from an ISO string or timestamp.

Attaches an event handler. Pass { once: true } for one-shot listeners or an AbortSignal to remove later.

Inserts nodes or strings at the end of an element. Unlike appendChild it accepts several values.

Manages classes without touching the class attribute string. Supports add, remove, toggle and contains.

Walks up the ancestor chain and returns the nearest matching element. Ideal for event delegation.

Creates a detached element that you can configure and then insert.

Reads data-* attributes as camel-cased properties.

Sets inline styles. Prefer classes because inline styles win specificity and are hard to theme.

Attach one listener to a container and read event.target to handle clicks on its children. Works for dynamic content.

The event passed to a handler. target is where it started; currentTarget is the element with the listener.

Cancels the browser’s default action, such as following a link or submitting a form.

Moves keyboard focus to an element. Use it deliberately, for example when opening a dialog.

Reads or writes HTML markup. Dangerous with untrusted input because scripts and event handlers can execute.

Returns the first element matching a CSS selector, or null.

Returns a static NodeList of all matches. Convert with Array.from to use array methods.

Removes a handler. It must be the same function reference that was added.

Sets any attribute, including ARIA attributes. Use the property when one exists.

Reads or writes text safely. The browser escapes it, so it cannot inject markup.

A lightweight container for building DOM subtrees before a single insertion.

Finds one element by its id. Prefer querySelector for consistency.

Adds a node as the last child and returns it. append() is the modern multi-node alternative.

Copies an element. Pass true to include descendants.

Returns the element’s size and position relative to the viewport.

Inserts HTML at beforebegin, afterbegin, beforeend or afterend. Dangerous with untrusted input.

Tests whether an element would be selected by a CSS selector.

Removes the element from the DOM.

Replaces all children with a new set of nodes in one operation.

Scrolls an element into view, optionally smoothly and aligned to start or center.

Adds or removes a boolean attribute and returns the new state.

Changes the URL without a reload. Listen for popstate to support back and forward.

Reports when elements enter or leave the viewport. Ideal for lazy loading.

Navigates to a URL, adding a history entry. replace() navigates without one.

Tests a CSS media query from JavaScript and lets you subscribe to changes.

Watches DOM changes and batches them into callback records.

Schedules a callback before the next repaint. The basis of smooth animation.

Reports size changes of an element, not just the window.

Bundles several errors, used by Promise.any when every promise rejects.

A non-standard but widely supported stack trace string. Log it, but do not parse it in production.

Creates a general error with a message and optional cause.

Signals a value outside the allowed range, such as an invalid array length.

Signals malformed code or data, including invalid JSON.

Signals that a value is not of the expected type.

Compares strings with locale-aware sorting rules.

Returns the formatted date as labelled parts, useful for custom layouts.

Joins lists with the correct conjunctions for a locale.

Formats money with the right symbol, separators and decimal places.

Formats a fraction as a percentage.

Selects the plural category for a number, which is essential for translations.

Formats relative times such as “3 days ago” for a locale.

Splits text into graphemes, words or sentences using locale rules.

A concise function expression. It does not bind its own this or arguments.

JavaScript has no chained comparison. Combine two comparisons explicitly.

Evaluates each expression and returns the last value. Rarely worth the confusion.

Supplies a value when the argument is undefined.

Unpacks arrays into positional names and objects into property names. Use a colon to rename and = for defaults.

Iterates enumerable property names, including inherited ones. Use Object.keys for own keys only.

Iterates values of arrays, strings, maps and sets. Prefer it over for…in for data.

A named function hoisted to the top of its scope. Good for top-level utilities.

Runs a block when a condition is truthy, with optional else branches.

Tests whether an object was created by a constructor and is therefore on its prototype chain.

Block-scoped declarations. Use const by default and let only when reassigning. Neither is hoisted to a usable value.

Assigns only when the operator’s condition passes. Useful for filling defaults.

Uses the fallback only when the left side is null or undefined, unlike || which also replaces 0 and "".

Omits the error variable when the handler does not need it.

Stops evaluating and returns undefined when the value before ?. is null or undefined.

Copies an object while omitting named keys. Handy for updating immutable state.

Collects the remaining arguments into a real array.

Expands an iterable into a new array, object or argument list without mutating the original.

Compares without type coercion. Use it instead of == so 0, "", false and null stay distinct.

Opts into stricter parsing and error rules. Modules are strict by default.

Branches on strict equality. Every case needs a break or a deliberate fallthrough comment.

A string with interpolation and multi-line support. Use backticks, not quotes.

Chooses between two values. Keep it short; a full if statement is clearer for side effects.

Stops execution and raises an exception. Throw Error objects, not strings.

Handles thrown errors. finally always runs, including when an error is thrown.

Returns a string describing the type. Arrays and null need their own checks.

Function-scoped and hoisted. Kept for legacy code; use let or const instead.

Removes every entry.

Removes a key and returns whether it existed.

Iterates entries in insertion order.

Reads a value by key, or undefined when the key is absent.

Tests whether a key exists, including keys mapped to undefined.

Iterators over keys, values or [key, value] pairs.

Adds or replaces a value and returns the map for chaining.

The number of entries. It is a property, not a method.

Removes every value.

Removes a value and returns whether it existed.

Returns values in the first set that are not in the second.

Iterates values in insertion order.

Tests membership in constant time on average.

Returns a new set with values present in both sets.

Tests whether the sets share no values.

Tests whether every value in a is also in b.

Tests whether a contains every value in b.

The number of values.

Returns values that appear in exactly one set.

Returns a new set with values from both sets.

Copies a slice to another position inside the same array.

Returns the last index of a value, or -1.

Like reduce but processes from the end to the start.

Returns a reversed copy without mutating the original array.

Returns a spliced copy instead of mutating the original.

Returns a copy with one index replaced. Negative indexes count from the end.

Groups items into a Map, so keys can be any value.

Creates an object with a chosen prototype and optional property descriptors.

Defines a property with precise control over value, writability, enumerability and getters.

Turns a Map or entry list into a plain object.

Reads the full descriptor of one property.

Lists own string keys, including non-enumerable ones.

Returns the prototype of an object.

Groups items into an object keyed by the callback result.

Compares values like === but treats NaN as equal and +0 as different from -0.

Prevents new properties but allows editing and deleting existing ones.

Prevents adding or removing properties while still allowing values to change.

Replaces an object’s prototype. Slow; prefer Object.create for new objects.

The day of the month from 1 to 31.

The weekday from 0 (Sunday) to 6 (Saturday).

The local hour from 0 to 23. Use getUTCHours for UTC.

The local minutes from 0 to 59.

The month from 0 (January) to 11 (December).

Milliseconds since the Unix epoch. Dates compare through this value.

Parses a date string and returns milliseconds, or NaN when invalid.

Changes the day of the month and returns the new timestamp.

Changes the year, optionally alongside month and day.

A readable local date without the time.

Formats both date and time for a locale.

Formats the time for a locale.

Builds a timestamp from UTC parts without creating a Date.

Returns the numeric timestamp. It is what Date comparisons use.

An integer type for values beyond Number.MAX_SAFE_INTEGER. BigInt and Number cannot be mixed in arithmetic.

Wraps a BigInt into a signed integer of the given bit width.

Wraps a BigInt into an unsigned integer of the given bit width.

Raises a number to a power. It has higher precedence than multiplication.

Returns the absolute value.

Returns the angle of a vector, handling all quadrants.

Returns the cube root.

Returns e raised to a power.

Rounds down or up to the nearest integer.

Rounds a number to the nearest 32-bit float. Useful when interoperating with Float32Array.

Returns the square root of the sum of squares, without intermediate overflow.

Returns the base-10 logarithm.

Returns the base-2 logarithm.

Returns the smallest or largest of the arguments.

The constants pi and Euler’s number.

Raises a number to a power. The ** operator is the modern equivalent.

Returns a float from 0 up to but not including 1. Not cryptographically secure.

Rounds to the nearest integer. Ties go towards positive infinity.

Returns -1, 0 or 1 depending on the sign.

Trigonometric functions that take radians, not degrees.

Returns the square root.

Removes the fractional part without rounding.

The smallest difference between 1 and the next representable number. Useful for float comparisons.

True for finite numbers and false for Infinity, NaN and numeric strings.

True only for finite whole numbers, not for numeric strings.

True only when the value is the NaN number. The global isNaN coerces strings first.

True when an integer can be represented exactly without precision loss.

The largest integer that can be represented exactly in a double.

Parses a decimal number from the start of a string.

Parses an integer with an explicit radix.

Formats a number in exponential notation.

Formats a number to a number of significant digits.

Converts a value to a number. Empty strings become 0, which is often a trap.

Parses a floating-point number from the start of a string.

Parses an integer from the start of a string. Always pass radix 10.

Formats a number with fixed decimal places and returns a string.

Formats numbers, currency and percentages for a locale.

Uses an expression as the property name.

Removes a property. Deleting array elements leaves holes; use splice or filter instead.

The clearest way to iterate own object properties with keys and values.

Tests whether a property exists in an object or its prototype chain.

Copies own enumerable properties into a target. Later sources win.

Returns an array of [key, value] pairs.

Prevents adding, removing or changing properties. It is shallow.

Builds an object from key-value pairs, the inverse of Object.entries.

Safely checks for an own property, even when the object has a null prototype.

Returns an array of own enumerable string keys.

Returns an array of own enumerable values.

Reads a property only when the object exists.

When the variable name matches the key, write it once.

Deep-copies objects, arrays, maps, sets and dates. Functions and DOM nodes cannot be cloned.

Turns a multi-argument function into a chain of single-argument functions.

Delays a function until calls stop, which is ideal for search inputs and resize handlers.

Decodes an encoded URL component. Wrap it in try/catch for malformed input.

Encodes a complete URL while leaving reserved characters such as / and ? intact.

Encodes a string for use inside a URL component such as a query value.

Coerces the value before testing. Prefer Number.isFinite.

Coerces the value to a number before testing. Prefer Number.isNaN.

Wraps an object to intercept reads, writes and other operations.

Performs the default property read, useful inside Proxy traps.

The functional form of the in operator.

A function receives the template strings and interpolated values separately, which enables safe HTML and CSS helpers.

Runs a function at most once per interval, which is ideal for scroll handlers.

Evaluates an expression and returns undefined. Sometimes used to trigger a function without a return value.

A regular expression literal compiles once and is the fastest way to write a pattern.

Parenthesised groups capture parts of a match by number.

Matches x only when it is followed by y, without consuming y.

Matches x only when it is preceded by y.

Names a capture so you can read it from match.groups instead of by position.

Returns the next match with groups and index, or null. Global patterns remember lastIndex.

The flags enabled on a pattern, such as g, i, m, s, u and y.

Tests whether a pattern appears. It returns a boolean and advances lastIndex for global patterns.

A replacement function receives the match and captures, which makes conditional rewrites easy.

The y flag anchors each match at lastIndex, which suits tokenisers.

Returns an iterator of every match, including capture groups. The pattern must be global.

The u flag enables Unicode-aware escapes and code-point matching.

Returns the character at an index and supports negative positions.

Returns the character at an index, or an empty string when out of range.

Tests whether a substring exists. Case-sensitive unless you normalise both sides.

Returns the first position of a substring, or -1. Use includes when you only need a boolean.

Compares strings using language-aware rules. Pass a locale for deterministic output.

Returns the matches of a regular expression, including groups.

Normalises Unicode so visually identical characters compare equal.

Format a number with leading zeros for timers and dates.

Pads a string to a length. Useful for aligned numbers and codes.

Repeats a string. The count must be a non-negative integer.

Replaces the first match of a string or regular expression.

Replaces every match. With a regexp, the global flag is still required.

Returns the index of the first match, or -1.

Extracts a substring. Negative indexes count from the end.

Splits a string into an array. Use an empty separator for characters or a regexp for patterns.

Tests the beginning or end of a string. An optional position changes where the test starts.

Like slice but swaps arguments when start is greater than end and does not accept negatives.

Changes case. Be careful where case changes the meaning of identifiers.

Removes whitespace from both ends. trimStart and trimEnd remove one side.

Counts UTF-16 code units. Emoji outside the basic plane count as two.

Converts a value to a string. Handles objects, null and undefined predictably.

A fixed-length block of raw bytes. Views such as Uint8Array read and write it.

Encodes and decodes Base64 for ASCII text. Use TextEncoder for Unicode.

Reads and writes numbers of various widths and endianness from an ArrayBuffer.

A view of 32-bit floating point numbers.

Copies values from another array or typed array into a typed array.

Copies part of a typed array into a new buffer.

Returns a view over part of the same buffer without copying.

A view of bytes as unsigned 8-bit integers.