Skip to main content

Data Types

JavaScript is a dynamically typed language, which means variables are not bound to specific data types. However, it still categorizes values into distinct data types, broadly divided into primitive and non-primitive types.

Primitive Data Types​

Primitive data types are immutable and represent a single value. There are seven primitive data types in JavaScript:

Number​

Represents numeric values, both integer and floating-point numbers. JavaScript uses double-precision 64-bit format (IEEE 754) for numbers.

  • Examples:

    let integer = 42;
    let float = 3.14;
    let negative = -10;

  • Special numeric values:

    • Infinity and -Infinity

      console.log(1 / 0); // Infinity

    • NaN (Not-a-Number)

      console.log(Math.sqrt(-1)); // NaN

BigInt​

Used to represent integers of arbitrary length.

  • Syntax:

    let bigInt = 1234567890123456789012345678901234567890n;

  • Operations with BigInt and Number are not allowed:

    let sum = bigInt + 10n; // Works
    let invalid = bigInt + 10; // TypeError

String​

Represents textual data enclosed within single ('), double ("), or template literals (`).

  • Examples:

    let single = "Hello";
    let double = "World";
    let template = `Sum: ${5 + 10}`; // Template literal

Boolean​

Represents logical values: true or false.

  • Examples:

    let isTrue = true;
    let isFalse = false;

Undefined​

Indicates a variable has been declared but not assigned a value.

  • Example:

    let unassigned;
    console.log(unassigned); // undefined

Null​

Represents the intentional absence of any object value.

  • Example:

    let empty = null;
    console.log(empty); // null

Symbol​

Introduced in ES6, used to create unique and immutable identifiers.

  • Example:

    let sym1 = Symbol("description");
    let sym2 = Symbol("description");
    console.log(sym1 === sym2); // false

Non-Primitive Data Types​

Non-primitive types are mutable and include objects, arrays, and functions.

Object​

An object is a collection of key-value pairs, where keys are strings (or Symbols) and values can be of any type.

  • Example:

    let person = {
      name: "John",
      age: 30,
      greet: function () {
        console.log("Hello");
      },
    };

Array​

A type of object used to store ordered lists of values. Arrays are zero-indexed.

  • Example:

    let fruits = ["Apple", "Banana", "Cherry"];

Function​

Functions are first-class objects, meaning they can be assigned to variables, passed as arguments, and returned from other functions.

  • Example:

    function add(a, b) {
      return a + b;
    }
    let subtract = (a, b) => a - b;

Date, Set, Map, WeakSet, WeakMap​

JavaScript includes several built-in objects for more specialized purposes:

  • Date: For handling dates and times.

    let now = new Date();

  • Set: For storing unique values.

    let unique = new Set([1, 2, 2, 3]);

  • Map: For key-value pairs with any data type as keys.

    let map = new Map();
    map.set("key", "value");

  • WeakSet and WeakMap: Similar to Set and Map but allow garbage collection of unused entries.

Type Coercion​

JavaScript performs implicit type conversion (coercion) in certain operations:

  • Example:

    console.log("5" - 3); // 2 (string '5' is coerced to number)
    console.log("5" + 3); // '53' (number 3 is coerced to string)

Checking Data Types​

To determine the type of a value, use:

typeof Operator​

Returns the type of a value as a string.

  • Examples:

    console.log(typeof 42); // "number"
    console.log(typeof null); // "object" (quirk in JavaScript)
    console.log(typeof undefined); // "undefined"

instanceof Operator​

Checks if an object is an instance of a specific class or constructor.

  • Example:

    console.log([] instanceof Array); // true
    console.log({} instanceof Object); // true

Array.isArray Method​

Used to check if a value is an array.

  • Example:

    console.log(Array.isArray([])); // true

Summary​

  • Primitive types: Immutable, single values like Number, String, and Boolean.
  • Non-primitive types: Mutable, complex types like Object, Array, and Function.
  • Use typeof, instanceof, and Array.isArray for type checking.
  • JavaScript's type system supports flexibility but requires careful handling to avoid bugs due to coercion or type mismatches.