JavaScript Data Types

Data Types in JavaScript

Data Types in JavaScript define how data is stored and manipulated in your programs. JavaScript provides two main categories of data types: primitive types that store simple values (String, Number, Boolean, undefined, null, BigInt, Symbol) and reference types that store complex data (Object, Array, Function).

JavaScript data types are divided into two categories: Primitive Types and Reference Types. Primitive types are immutable and stored directly in memory by value, making them efficient for simple data. Modern JavaScript (ES6+) supports 7 primitive types, an expansion from the 5 types available in ES5. Reference types store addresses (references) to values in memory, making them ideal for complex data structures and functions.

As JavaScript and all scripting languages are loosely typed, there is no typecast in javascript. JS supports dynamic typing. Means We can create any type of data using a single variable.

Declaring variable means creating a new variable in memory with variable name and value. Assignment Operator (=) means assigning value to variable declared..

Types of Data Types in JavaScript

1. Primitive Data Types
2. Reference Data Types

Primitive data types

Primitive data types are the fundamental building blocks of JavaScript. They represent simple values that are immutable (cannot be changed). All primitive types except null and undefined have corresponding object wrapper types (like String, Number) that provide useful methods and properties for working with these values. JavaScript originally had five primitive types (string, number, boolean, undefined, null), but ES6 added BigInt and Symbol, bringing the total to seven.

A key characteristic of primitive data types is that they are passed by value, not by reference. This means when you assign a primitive value to a new variable or pass it to a function, a copy of the value is created. For example, if x = 3 and y = x, changing y to 5 won't affect the value of x.

In modern JavaScript, we declare variables using const (for values that won't be reassigned), let (for values that will change), and rarely var (older syntax, generally avoided in modern code). The choice of declaration doesn't affect the data type itself but rather how the variable can be used.

How to declare Primitive Data Types

        const name="js string";
        

        const num=20;
        

        const t=true;
        const f=false;
        

        let u;
        const t=undefined;   
        

    const u=null;
        

      const u=2n;
      const v=9007199254740992n;
          

        const a=Symbol("a");
        const b=Symbol("a");
        console.log(a===b);     // false
            

Reference Data Type in JAVASCRIPT

Reference data types like Array, Object and Functions are advance data types, based which pass by reference, not value. They are stored on heap memory. Everything is JavaScript is either a primitive datatype or Object. Even Arrays and Functions are objects, but they are build-in objects.

All reference datatypes are Constructor Objects, that means they are created using new keyword. new means, a new instance of Function Object or class.

typeof Operator

typeof operator in javascript is used to check data type of a variable. It can return string, number, boolean and undefined. For reference type and null, typeof operator will return object.

let x;                 // undefined
const y=9;               // number
const z="Tech Altum";    // string
					
typeof(x) and typeof x will return undefined,
typeof(y) and typeof y will return number,
typeof(z) and typeof z will return string.

Video