JavaScript

In JavaScript, data types determine the type of value stored in a variable.

JavaScript has both primitive data types (which include String, Number, Boolean, Undefined, Null, Symbol, and BigInt) and non-primitive data types (Object, Array, Function).

1. Primitive Data Types

1.1. String

A string is a sequence of characters used to represent text. Strings are enclosed in single (‘ ‘), double (” “), or backticks (` `) quotes.

let singleQuote = 'Hello, World!';
let doubleQuote = "JavaScript is fun!";
let templateString = `This is a template literal, and you can include variables like ${singleQuote}`;

console.log(singleQuote); // Output: Hello, World!
console.log(doubleQuote); // Output: JavaScript is fun!
console.log(templateString); // Output: This is a template literal, and you can include variables like Hello, World!

1.2. Number

The Number data type is used to represent both integers and floating-point numbers. JavaScript also supports special numeric values like Infinity and NaN (Not-a-Number).

let integer = 42;
let float = 3.14;
let negative = -7;
let infinityValue = Infinity;
let notANumber = NaN;

console.log(integer); // Output: 42
console.log(float); // Output: 3.14
console.log(negative); // Output: -7
console.log(infinityValue); // Output: Infinity
console.log(notANumber); // Output: NaN

1.3. Boolean

A boolean can only have two values: true or false. Booleans are often used in conditional statements to control the flow of the program.

let isJavaScriptFun = true;
let isPythonFun = false;

console.log(isJavaScriptFun); // Output: true
console.log(isPythonFun); // Output: false

1.4. Undefined

A variable that has been declared but not assigned a value has the value undefined.

let undefinedVar;
console.log(undefinedVar); // Output: undefined

// Declaring a variable explicitly as undefined
let explicitlyUndefined = undefined;
console.log(explicitlyUndefined); // Output: undefined

1.5. Null

The null value represents an intentional absence of any object value. It is explicitly set by the programmer to indicate “no value.”

let emptyValue = null;
console.log(emptyValue); // Output: null

1.6. Symbol

Symbol is a unique and immutable data type that is often used as unique property keys in objects. Each Symbol is unique.

let sym1 = Symbol('description');
let sym2 = Symbol('description');

console.log(sym1 === sym2); // Output: false
console.log(sym1); // Output: Symbol(description)
console.log(sym2); // Output: Symbol(description)

1.7. BigInt

BigInt is a data type introduced in ES2020 that allows you to represent integers larger than the Number type's limit (2^53 – 1).

let bigIntNumber = 123456789012345678901234567890n; // Notice the 'n' at the end
console.log(bigIntNumber); // Output: 123456789012345678901234567890n

// Operations with BigInt
let bigIntSum = bigIntNumber + 10n;
console.log(bigIntSum); // Output: 123456789012345678901234567900n

2. Non-Primitive Data Types

2.1. Object

An Object is a collection of key-value pairs. Objects can store various data types and complex entities.

let person = {
  firstName: 'John',
  lastName: 'Doe',
  age: 30,
  isEmployed: true
};

console.log(person.firstName); // Output: John
console.log(person['lastName']); // Output: Doe

// Adding a new property
person.country = 'USA';
console.log(person.country); // Output: USA

2.2. Array

Arrays are special types of objects used to store multiple values in a single variable. Array elements are ordered and indexed starting from 0.

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

console.log(fruits[0]); // Output: Apple
console.log(fruits.length); // Output: 3

// Adding an element to the array
fruits.push('Orange');
console.log(fruits); // Output: ['Apple', 'Banana', 'Cherry', 'Orange']

2.3. Function

A function is an object in JavaScript that performs a task or calculates a value. Functions can be assigned to variables, passed as arguments, and returned from other functions.

// Function declaration
function greet(name) {
  return `Hello, ${name}!`;
}

console.log(greet('Alice')); // Output: Hello, Alice!

// Function expression
let add = function(a, b) {
  return a + b;
};

console.log(add(5, 3)); // Output: 8

3. Dynamic Typing in JavaScript

In JavaScript, a variable can change its type as new values are assigned to it.

let variable = 'I am a string';
console.log(typeof variable); // Output: string

variable = 42; // Now the variable is a number
console.log(typeof variable); // Output: number

variable = true; // Now the variable is a boolean
console.log(typeof variable); // Output: boolean

4. Checking Data Types

JavaScript provides the typeof operator to check the data type of a variable.

console.log(typeof 'Hello'); // Output: string
console.log(typeof 123); // Output: number
console.log(typeof true); // Output: boolean
console.log(typeof undefined); // Output: undefined
console.log(typeof null); // Output: object (this is a quirk in JavaScript)
console.log(typeof Symbol('id')); // Output: symbol
console.log(typeof 123n); // Output: bigint
console.log(typeof {}); // Output: object
console.log(typeof []); // Output: object (arrays are objects in JavaScript)
console.log(typeof function(){}); // Output: function

Summary

Primitive data types include: String, Number, Boolean, Undefined, Null, Symbol, and BigInt.
Non-primitive data types include: Object, Array, and Function.

Use typeof to determine the data type of a variable.

JavaScript is dynamically typed, meaning variables can change types during runtime.

This guide provides a comprehensive overview of JavaScript data types with practical code examples to help you understand how to use them effectively in your programming.