Types

JavaScript has eight built-in types, null, undefined, boolean, number, bigint, string, object, and symbol.

Essential:

github.com/getify/You-Dont-Know-JS

Description:

Programming languages all have built-in data structures, but these often differ from one language to another. JavaScript is a dynamic language with dynamic types, and variables in JavaScript are not directly associated with any particular value type, as any variable can be assigned (and re-assigned) values of all types. It is also a weakly typed language, which means it allows implicit type conversion when an operation involves mismatched types, instead of throwing type errors.

Table of Contents

  1. 1. Introduction
  2. 2. Creating a Value
  3. 3. Native Constructors
  4. 4. Boxing
  5. 5. Inspecting
  6. 6. Documentation
  7. 7. Related notes

1. Introduction

Usually, we understood JavaScript types as follows:

JavaScript data types.

Remember, however, that in JavaScript, the Number type cannot safely represent integer values larger than 253. This limitation forced developers to use inefficient workarounds and third-party libraries until they incorporated BigInt as a numeric data type intended to address that problem.

NameDescription
bigintStores integer values that are too big to be represented by a normal JavaScript Number.

Note: Detailed information in the following section:

JavaScript Variables


2. Creating a Value

A value can be created in 2 different ways:

FormExample
Literal formconst strPrimitive = "abc";
Constructor formconst strObject = new String("abc");

Using the constructor form results in an object wrapper around the primitive value. This gives access to the helpful properties and methods such as toUpperCase for a string:

Example:


3. Native Constructors

Each native constructor has its own prototype object. These contain properties and methods unique to their object subtype. For example: String.prototype.toUpperCase. When the constructor form is used, the returned object’s prototype property is set constructor’s prototype object. This is how you get access to the properties and methods.

String native example.

Date

The Date(..) constructor accepts optional arguments to specify the date/time to use. Format used below is ISO 8601 format - YYYY-MM-DDTHH:mm:ss.sssZ (international standard).

Example:

Error

An error object captures the current execution stack context into the returned object. Stored in property stack. This includes the function call-stack and the line-number where the error object was created.

Example:

RegExp

If you require a variable in a regex, it must be created using the constructor form.

Example:

Number

JavaScript uses binary floating-point numbers. This can result in the following bugs:

OutputExample
falseconst result = 0.1 + 0.2 === 0.3; console.log(result)

The representations for 0.1 and 0.2 are not exact. When added, the result isn’t 0.3, it closer to 0.30000000000000004. Number.EPSILON is predefined with this tolerance value that can be used as a workaround:

OutputExample
trueconst result = 0.1 + 0.2 - 0.3 < Number.EPSILON; console.log(result)

Special Values

Honorable mentions:

    ▪ NaN - Not a Number

    ▪ +Infinity

    ▪ -Infinity

    ▪ -0

OutputExample
trueconst result = Number.isNaN(1 / "a") console.log(result);

4. Boxing

A primitive like “abc” is not an object. However, you can call methods on it like "abc".length. This is possible through a technique called boxing. When the interpreter sees a property or method call on a primitive, it calls the constructor form and passes in the primitive value, creating an object. This object has properties and methods linked to it via the prototype chain.

Boxing example.

5. Inspecting

Primitives

The typeof operator inspects the type of the given value and returns one of seven string values (except for null).

Example:

Note: variables don’t have types. Only values do. When using typeof against a variable, it is like asking: “What’s the type of the value in this variable?”

Object Subtypes

Let’s analyze a couple of cases now:

[[Class]]

Objects are tagged with an internal [[Class]] property. A classification (not related to class-oriented coding) corresponding to the built-in native constructor. It can only be accessed through Object.prototype.toString(..):

Example:

instanceof

The instanceof operator tests to see if the prototype property of a constructor appears anywhere in the prototype chain of an object:

Example:


6. Documentation

For a better understanding of types, remember that websites such as:

    ▪ w3schools, or

    ▪ MDN Web Docs

will always be there to offer you some proper insight.


All Notes: