MDN may have intermittent access issues April 18 13:00 - April 19 01:00 UTC. See whistlepig.mozilla.org for all notifications.

mozilla
Your Search Results

    JavaScript data types and data structures

    Programming languages all have built-in data structures, but these often differ from one language to another. This article attempts to list the built-in data structures available in JavaScript and what properties they have; these can be used to build other data structures. When possible, comparisons with other languages are drawn.

    Dynamic typing

    JavaScript is a loosely typed or a dynamic language. That means you don't have to declare the type of a variable ahead of time. The type will get determined automatically while the program is being processed. That also means that you can have the same variable as different types:

    var foo = 42;    // foo is a Number now
    var foo = "bar"; // foo is a String now
    var foo = true;  // foo is a Boolean now
    

    Data types

    The latest ECMAScript standard defines seven data types:

    Primitive values

    All types except objects define immutable values (values, which are incapable of being changed). For example and unlike to C, Strings are immutable. We refer to values of these types as "primitive values".

    Boolean type

    Boolean represents a logical entity and can have two values: true, and false.

    Null type

    The Null type has exactly one value: null. See null and Null for more details.

    Undefined type

    A variable that has not been assigned a value has the value undefined. See undefined and Undefined for more details.

    Number type

    According to the ECMAScript standard, there is only one number type: the double-precision 64-bit binary format IEEE 754 value (number between -(253 -1) and 253 -1). There is no specific type for integers. In addition to being able to represent floating-point numbers, the number type has three symbolic values: +Infinity, -Infinity, and NaN (not-a-number).

    To check for larger or smaller values than +/-Infinity, you can use the constants Number.MAX_VALUE or Number.MIN_VALUE and starting with ECMAScript 6, you are also able to check if a number is in the double-precision floating-point number range using Number.isSafeInteger() as well as Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER. Beyond this range, numbers in JavaScript are not safe anymore.

    The number type has only one integer that has two representations: 0 is represented as -0 and +0. ("0" is an alias for +0). In the praxis, this has almost no impact. For example +0 === -0 is true. However, you are able to notice this when you divide by zero:

    > 42 / +0
    Infinity
    > 42 / -0
    -Infinity
    

    Although a number often represents only its value, JavaScript provides some binary operators. These can be used to represent several Boolean values within a single number using bit masking. This is usually considered a bad practice, however, JavaScript offers no other means to represent a set of Booleans (like an array of Booleans or an object with Boolean values assigned to named properties). Bit masking also tends to make code more difficult to read, understand, and maintain. It may be necessary to use such techniques in very constrained environments, like when trying to cope with the storage limitation of local storage or in extreme cases 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.

    String type

    JavaScript's String type is used to represent textual data. It is a set of "elements" of 16-bit unsigned integer values. Each element in the String occupies a position in the String. The first element is at index 0, the next at index 1, and so on. The length of a String is the number of elements in it.

    Unlike in languages like C, JavaScript strings are immutable. This means that once a string is created, it is not possible to modify it. However, it is still possible to create another string based on an operation on the original string. For example:

    • A substring of the original by picking individual letters or using String.substr().
    • A concatenation of two strings using the concatenation operator (+) or String.concat().

    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, XMLHttpRequest responses when using responseText, 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.

    Symbol type

    Symbols are new to JavaScript in ECMAScript Edition 6. A Symbol is a unique and immutable primitive value and may be used as the key of an Object property (see below). In some programming languages, Symbols are called atoms. You can also compare them to named enumerations (enum) in C. For more details see Symbol and the Symbol object wrapper in JavaScript.

    Objects

    In computer science, an object is a value in memory which is possibly referenced by an identifier.

    Properties

    In JavaScript, objects can be seen as a collection of properties. With the object literal syntax, a limited set of properties are initialized; then properties can be added and removed. Property values can be values of any type, including other objects, which enables building complex data structures. Properties are identified using key values. A key value is either a String or a Symbol value.

    There are two types of object properties which have certain attributes: The data property and the accessor property.

    Data property

    Associates a key with a value and has the following attributes:

    Attributes of a data property
    Attribute Type Description Default value
    [[Value]] Any JavaScript type The value retrieved by a get access of the property. undefined
    [[Writable]] Boolean If false, the property's [[Value]] can't be changed. false
    [[Enumerable]] Boolean If true, the property will be enumerated in for...in loops. false
    [[Configurable]] Boolean If false, the property can't be deleted and attributes other than [[Value]] and [[Writable]] can't be changed. false

    Accessor property

    Associates a key with one or two accessor functions (get and set) to retrieve or store a value and has the following attributes:

    Attributes of an accessor property
    Attribute Type Description Default value
    [[Get]] Function object or undefined The function is called with an empty argument list and retrieves the property value whenever a get access to the value is performed. See also get. undefined
    [[Set]] Function object or undefined The function is called with an argument that contains the assigned value and is executed whenever a specified property is attempted to be changed. See also set. undefined
    [[Enumerable]] Boolean If true, the property will be enumerated in for...in loops. false
    [[Configurable]] Boolean If false, the property can't be deleted and can't be changed to a data property. false

    "Normal" objects, and functions

    A JavaScript object is a mapping between keys and values. Keys are strings and values can be anything. This makes objects a natural fit for hashmaps.

    Functions are regular objects with the additional capability of being callable.

    Dates

    When representing dates, the best choice is to use the built-in Date utility in JavaScript.

    Indexed collections: Arrays and typed Arrays

    Arrays are regular objects for which there is a particular relationship between integer-key-ed properties and the 'length' property. Additionally, arrays inherit from Array.prototype which provides to them a handful of convenient methods to manipulate arrays. For example, indexOf (searching a value in the array) or push (adding an element to the array), etc. This makes Arrays a perfect candidate to represent lists or sets.

    Typed Arrays are new to JavaScript with ECMAScript Edition 6 and present an array-like view of an underlying binary data buffer. The following table helps you to find the equivalent C data types:

    TypedArray objects

    Type Size Description Web IDL type Equivalent C type
    Int8Array 1 8-bit twos complement signed integer byte int8_t
    Uint8Array 1 8-bit unsigned integer octet uint8_t
    Uint8ClampedArray 1 8-bit unsigned integer (clamped) octet uint8_t
    Int16Array 2 16-bit twos complement signed integer short int16_t
    Uint16Array 2 16-bit unsigned integer unsigned short uint16_t
    Int32Array 4 32-bit twos complement signed integer long int32_t
    Uint32Array 4 32-bit unsigned integer unsigned long uint32_t
    Float32Array 4 32-bit IEEE floating point number unrestricted float float
    Float64Array 8 64-bit IEEE floating point number unrestricted double double

    Keyed collections: Maps, Sets, WeakMaps, WeakSets

    These data structures take object references as keys and are introduced in ECMAScript Edition 6. Set and WeakSet represent a set of objects, while Map and WeakMap associate a value to an object. The difference between Maps and WeakMaps is that in the former, object keys can be enumerated over. This allows garbage collection optimizations in the latter case.

    One could implement Maps and Sets in pure ECMAScript 5. However, since objects cannot be compared (in the sense of "less than" for instance), look-up performance would necessarily be linear. Native implementations of them (including WeakMaps) 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 use data-* attributes. This has the downside that the data is available to any script running in the same context. Maps and WeakMaps make easy to privately bind data to an object.

    Structured data: JSON

    JSON (JavaScript Object Notation) is a lightweight data-interchange format, derived from JavaScript but used by many programming languages. JSON builds universal data structures. See JSON and JSON for more details.

    More objects in the standard library

    JavaScript has a standard library of built-in objects. Please have a look at the reference to find out about more objects.

    Determining types using the typeof operator

    The typeof operator can help you to find the type of your variable. Please read the reference page for more details and edge cases.

    Specifications

    Specification Status Comment
    ECMAScript 1st Edition. Standard Initial definition.
    ECMAScript 5.1 (ECMA-262)
    The definition of 'Types' in that specification.
    Standard  
    ECMAScript 6 (ECMA-262)
    The definition of 'ECMAScript Data Types and Values' in that specification.
    Release Candidate  

    See also

    Document Tags and Contributors

    Last updated by: fscholz,
    Hide Sidebar