JavaScript is adynamic language withdynamic types. Variables in JavaScript are not directly associated with any particular value type, and any variable can be assigned (and re-assigned) values of all types:

let foo = 42; // foo is now a numberfoo = "bar"; // foo is now a stringfoo = true; // foo is now a boolean

JavaScript is also aweakly typed language, which means it allows implicit type conversion when an operation involves mismatched types, instead of throwing type errors.

const foo = 42; // foo is a numberconst result = foo + "1"; // JavaScript coerces foo to a string, so it can be concatenated with the other operandconsole.log(result); // 421

Implicit coercions are very convenient, but can create subtle bugs when conversions happen where they are not expected, or where they are expected to happen in the other direction (for example, string to number instead of number to string). Forsymbols andBigInts, JavaScript has intentionally disallowed certain implicit type conversions.

All types exceptObject defineimmutable values represented directly at the lowest level of the language. We refer to values of these types asprimitive values.

All primitive types, exceptnull, can be tested by thetypeof operator.typeof null returns"object", so one has to use=== null to test fornull.

All primitive types, exceptnull andundefined, have their corresponding object wrapper types, which provide useful methods for working with the primitive values. For example, theNumber object provides methods liketoExponential(). When a property is accessed on a primitive value, JavaScript automatically wraps the value into the corresponding wrapper object and accesses the property on the object instead. However, accessing a property onnull orundefined throws aTypeError exception, which necessitates the introduction of theoptional chaining operator.

The object wrapper classes' reference pages contain more information about the methods and properties available for each type, as well as detailed descriptions for the semantics of the primitive types themselves.

The Null type is inhabited by exactly one value:null.

The Undefined type is inhabited by exactly one value:undefined.

Conceptually,undefined indicates the absence of avalue, whilenull indicates the absence of anobject (which could also make up an excuse fortypeof null === "object"). The language usually defaults toundefined when something is devoid of a value:

• Areturn statement with no value (return;) implicitly returnsundefined.
• Accessing a nonexistentobject property (obj.iDontExist) returnsundefined.
• A variable declaration without initialization (let x;) implicitly initializes the variable toundefined.
• Many methods, such asArray.prototype.find() andMap.prototype.get(), returnundefined when no element is found.

null is used much less often in the core language. The most important place is the end of theprototype chain — subsequently, methods that interact with prototypes, such asObject.getPrototypeOf(),Object.create(), etc., accept or returnnull instead ofundefined.

null is akeyword, butundefined is a normalidentifier that happens to be a global property. In practice, the difference is minor, sinceundefined should not be redefined or shadowed.

TheBoolean type represents a logical entity and is inhabited by two values:true andfalse.

Boolean values are usually used for conditional operations, includingternary operators,if...else,while, etc.

TheNumber type is adouble-precision 64-bit binary format IEEE 754 value. It is capable of storing positive floating-point numbers between 2^-1074 (Number.MIN_VALUE) and 2¹⁰²³ × (2 - 2^-52) (Number.MAX_VALUE) as well as negative floating-point numbers of the same magnitude, but it can only safely store integers in the range -(2⁵³ − 1) (Number.MIN_SAFE_INTEGER) to 2⁵³ − 1 (Number.MAX_SAFE_INTEGER). Outside this range, JavaScript can no longer safely represent integers; they will instead be represented by a double-precision floating point approximation. You can check if a number is within the range of safe integers usingNumber.isSafeInteger().

Values outside the representable range are automatically converted:

• Positive values greater thanNumber.MAX_VALUE are converted to+Infinity.
• Positive values smaller thanNumber.MIN_VALUE are converted to+0.
• Negative values smaller than -Number.MAX_VALUE are converted to-Infinity.
• Negative values greater than -Number.MIN_VALUE are converted to-0.

+Infinity and-Infinity behave similarly to mathematical infinity, but with some slight differences; seeNumber.POSITIVE_INFINITY andNumber.NEGATIVE_INFINITY for details.

The Number type has only one value with multiple representations:0 is represented as both-0 and+0 (where0 is an alias for+0). In practice, there is almost no difference between the different representations; for example,+0 === -0 istrue. However, you are able to notice this when you divide by zero:

console.log(42 / +0); // Infinityconsole.log(42 / -0); // -Infinity

NaN ("NotaNumber") is a special kind of number value that's typically encountered when the result of an arithmetic operation cannot be expressed as a number. It is also the only value in JavaScript that is not equal to itself.

Although a number is conceptually a "mathematical value" and is always implicitly floating-point-encoded, JavaScript providesbitwise operators. When applying bitwise operators, the number is first converted to a 32-bit integer.

It may be necessary to use such techniques in very constrained environments, like when trying to cope with the limitations of local storage, or in extreme cases (such as when each bit over the network counts). This technique should only be considered when it is the last measure that can be taken to optimize size.

TheBigInt type is a numeric primitive in JavaScript that can represent integers with arbitrary magnitude. With BigInts, you can safely store and operate on large integers even beyond the safe integer limit (Number.MAX_SAFE_INTEGER) for Numbers.

A BigInt is created by appendingn to the end of an integer or by calling theBigInt() function.

This example demonstrates where incrementing theNumber.MAX_SAFE_INTEGER returns the expected result:

// BigIntconst x = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991nx + 1n === x + 2n; // false because 9007199254740992n and 9007199254740993n are unequal// NumberNumber.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true because both are 9007199254740992

You can use most operators to work with BigInts, including+,*,-,**, and% — the only forbidden one is>>>. A BigInt is notstrictly equal to a Number with the same mathematical value, but it isloosely so.

BigInt values are neither always more precise nor always less precise than numbers, since BigInts cannot represent fractional numbers, but can represent big integers more accurately. Neither type entails the other, and they are not mutually substitutable. ATypeError is thrown if BigInt values are mixed with regular numbers in arithmetic expressions, or if they areimplicitly converted to each other.

TheString type represents textual data and is encoded as a sequence of 16-bit unsigned integer values representingUTF-16 code units. Each element in the string occupies a position in the string. The first element is at index0, the next at index1, and so on. Thelength of a string is the number of UTF-16 code units in it, which may not correspond to the actual number of Unicode characters; see theString reference page for more details.

JavaScript strings are immutable. This means that once a string is created, it is not possible to modify it. String methods create new strings based on the content of the current string — for example:

• A substring of the original usingsubstring().
• A concatenation of two strings using the concatenation operator (+) orconcat().

Beware of "stringly-typing" your code!

It can be tempting to use strings to represent complex data. Doing this comes with short-term benefits:

• It is easy to build complex strings with concatenation.
• Strings are easy to debug (what you see printed is always what is in the string).
• Strings are the common denominator of a lot of APIs (input fields,local storage values,fetch() responses when usingResponse.text(), etc.) and it can be tempting to only work with strings.

With conventions, it is possible to represent any data structure in a string. This does not make it a good idea. For instance, with a separator, one could emulate a list (while a JavaScript array would be more suitable). Unfortunately, when the separator is used in one of the "list" elements, then, the list is broken. An escape character can be chosen, etc. All of this requires conventions and creates an unnecessary maintenance burden.

Use strings for textual data. When representing complex data,parse strings, and use the appropriate abstraction.

ASymbol is aunique andimmutable primitive value and may be used as the key of an Object property (see below). In some programming languages, Symbols are called "atoms". The purpose of symbols is to create unique property keys that are guaranteed not to clash with keys from other code.

In computer science, an object is a value in memory which is possibly referenced by anidentifier. In JavaScript, objects are the onlymutable values.Functions are, in fact, also objects with the additional capability of beingcallable.

In JavaScript, objects can be seen as a collection of properties. With theobject literal syntax, a limited set of properties are initialized; then properties can be added and removed. Object properties are equivalent to key-value pairs. Property keys are eitherstrings orsymbols. When other types (such as numbers) are used to index objects, the values are implicitly converted to strings. Property values can be values of any type, including other objects, which enables building complex data structures.

There are two types of object properties: Thedata property and theaccessor property. Each property has correspondingattributes. Each attribute is accessed internally by the JavaScript engine, but you can set them throughObject.defineProperty(), or read them throughObject.getOwnPropertyDescriptor(). You can read more about the various nuances on theObject.defineProperty() page.

Data property

Data properties associate a key with a value. It can be described by the following attributes:

value

The value retrieved by a get access of the property. Can be any JavaScript value.

writable

A boolean value indicating if the property can be changed with an assignment.

enumerable

A boolean value indicating if the property can be enumerated by afor...in loop. See alsoEnumerability and ownership of properties for how enumerability interacts with other functions and syntaxes.

configurable

A boolean value indicating if the property can be deleted, can be changed to an accessor property, and can have its attributes changed.

Accessor property

Associates a key with one of two accessor functions (get andset) to retrieve or store a value.

An accessor property has the following attributes:

get

A function called with an empty argument list to retrieve the property value whenever a get access to the value is performed. See alsogetters. May beundefined.

set

A function called with an argument that contains the assigned value. Executed whenever a specified property is attempted to be changed. See alsosetters. May beundefined.

enumerable

A boolean value indicating if the property can be enumerated by afor...in loop. See alsoEnumerability and ownership of properties for how enumerability interacts with other functions and syntaxes.

configurable

A boolean value indicating if the property can be deleted, can be changed to a data property, and can have its attributes changed.

Theprototype of an object points to another object or tonull — it's conceptually a hidden property of the object, commonly represented as[[Prototype]]. Properties of the object's[[Prototype]] can also be accessed on the object itself.

Objects are ad-hoc key-value pairs, so they are often used as maps. However, there can be ergonomics, security, and performance issues. Use aMap for storing arbitrary data instead. TheMap reference contains a more detailed discussion of the pros & cons between plain objects and maps for storing key-value associations.

JavaScript provides two sets of APIs for representing dates: the legacyDate object and the modernTemporal object.Date has many undesirable design choices and should be avoided in new code if possible.

Arrays are regular objects for which there is a particular relationship between integer-keyed properties and thelength property.

Additionally, arrays inherit fromArray.prototype, which provides a handful of convenient methods to manipulate arrays. For example,indexOf() searches a value in the array andpush() appends an element to the array. This makes Arrays a perfect candidate to represent ordered lists.

Typed Arrays present an array-like view of an underlying binary data buffer, and offer many methods that have similar semantics to the array counterparts. "Typed array" is an umbrella term for a range of data structures, includingInt8Array,Float32Array, etc. Check thetyped array page for more information. Typed arrays are often used in conjunction withArrayBuffer andDataView.

These data structures take object references as keys.Set andWeakSet represent a collection of unique values, whileMap andWeakMap represent a collection of key-value associations.

You could implementMaps andSets yourself. However, since objects cannot be compared (in the sense of< "less than", for instance), neither does the engine expose its hash function for objects, look-up performance would necessarily be linear. Native implementations of them (includingWeakMaps) can have look-up performance that is approximately logarithmic to constant time.

Usually, to bind data to a DOM node, one could set properties directly on the object, or usedata-* attributes. This has the downside that the data is available to any script running in the same context.Maps andWeakMaps make it easy toprivately bind data to an object.

WeakMap andWeakSet only allow garbage-collectable values as keys, which are either objects ornon-registered symbols, and the keys may be collected even when they remain in the collection. They are specifically used formemory usage optimization.

JSON (JavaScriptObjectNotation) is a lightweight data-interchange format, derived from JavaScript, but used by many programming languages. JSON builds universal data structures that can be transferred between different environments and even across languages. SeeJSON for more details.

JavaScript has a standard library of built-in objects. Read thereference to find out more about the built-in objects.

As mentioned above, JavaScript is aweakly typed language. This means that you can often use a value of one type where another type is expected, and the language will convert it to the right type for you. To do so, JavaScript defines a handful of coercion rules.

Theprimitive coercion process is used where a primitive value is expected, but there's no strong preference for what the actual type should be. This is usually when astring, anumber, or aBigInt are equally acceptable. For example:

• TheDate() constructor, when it receives one argument that's not aDate instance — strings represent date strings, while numbers represent timestamps.
• The+ operator — if one operand is a string, string concatenation is performed; otherwise, numeric addition is performed.
• The== operator — if one operand is a primitive while the other is an object, the object is converted to a primitive value with no preferred type.

This operation does not do any conversion if the value is already a primitive. Objects are converted to primitives by calling its[Symbol.toPrimitive]() (with"default" as hint),valueOf(), andtoString() methods, in that order. Note that primitive conversion callsvalueOf() beforetoString(), which is similar to the behavior ofnumber coercion but different fromstring coercion.

The[Symbol.toPrimitive]() method, if present, must return a primitive — returning an object results in aTypeError. ForvalueOf() andtoString(), if one returns an object, the return value is ignored and the other's return value is used instead; if neither is present, or neither returns a primitive, aTypeError is thrown. For example, in the following code:

console.log({} + []); // "[object Object]"

Neither{} nor[] have a[Symbol.toPrimitive]() method. Both{} and[] inheritvalueOf() fromObject.prototype.valueOf, which returns the object itself. Since the return value is an object, it is ignored. Therefore,toString() is called instead.{}.toString() returns"[object Object]", while[].toString() returns"", so the result is their concatenation:"[object Object]".

The[Symbol.toPrimitive]() method always takes precedence when doing conversion to any primitive type. Primitive conversion generally behaves like number conversion, becausevalueOf() is called in priority; however, objects with custom[Symbol.toPrimitive]() methods can choose to return any primitive.Date andSymbol objects are the only built-in objects that override the[Symbol.toPrimitive]() method.Date.prototype[Symbol.toPrimitive]() treats the"default" hint as if it's"string", whileSymbol.prototype[Symbol.toPrimitive]() ignores the hint and always returns a symbol.

There are two numeric types:Number andBigInt. Sometimes the language specifically expects a number or a BigInt (such asArray.prototype.slice(), where the index must be a number); other times, it may tolerate either and perform different operations depending on the operand's type. For strict coercion processes that do not allow implicit conversion from the other type, seenumber coercion andBigInt coercion.

Numeric coercion is nearly the same asnumber coercion, except that BigInts are returned as-is instead of causing aTypeError. Numeric coercion is used by all arithmetic operators, since they are overloaded for both numbers and BigInts. The only exception isunary plus, which always does number coercion.

All data types, except Null, Undefined, and Symbol, have their respective coercion process. Seestring coercion,boolean coercion, andobject coercion for more details.

As you may have noticed, there are three distinct paths through which objects may be converted to primitives:

• Primitive coercion:[Symbol.toPrimitive]("default") →valueOf() →toString()
• Numeric coercion,number coercion,BigInt coercion:[Symbol.toPrimitive]("number") →valueOf() →toString()
• String coercion:[Symbol.toPrimitive]("string") →toString() →valueOf()

In all cases,[Symbol.toPrimitive](), if present, must be callable and return a primitive, whilevalueOf ortoString will be ignored if they are not callable or return an object. At the end of the process, if successful, the result is guaranteed to be a primitive. The resulting primitive is then subject to further coercions depending on the context.

• JavaScript Data Structures and Algorithms by Oleksii Trekhleb
• Computer Science in JavaScript by Nicholas C. Zakas