13. What are the different data types in JavaScript?

Basic

13. What are the different data types in JavaScript?

Overview

Understanding the different data types in JavaScript is fundamental for any developer working with the language. JavaScript is a dynamically typed language, meaning variables do not need to be declared as specific data types beforehand. Knowing the available data types and their characteristics is crucial for effective programming and debugging in JavaScript.

Key Concepts

  1. Primitive vs. Reference Types: Understanding the difference between these two categories of data types is essential.
  2. Type Coercion: Knowing how JavaScript converts values from one type to another during runtime is important for avoiding unexpected bugs.
  3. Immutability of Primitive Types: Primitive values are immutable, meaning their values cannot be changed once they're set.

Common Interview Questions

Basic Level

  1. What are the different types of data in JavaScript?
  2. How does JavaScript handle type coercion between different data types?

Intermediate Level

  1. Explain the difference between primitive and reference data types in JavaScript.

Advanced Level

  1. Can you explain how immutability works in JavaScript with respect to strings and objects?

Detailed Answers

1. What are the different types of data in JavaScript?

Answer: JavaScript has two categories of data types: Primitive and Reference types. Primitive types include undefined, null, boolean, number, string, symbol, and bigint. Reference types include object and function.

Key Points:
- Primitive types are data that are not objects and have no methods. They are immutable.
- Reference types are objects which may contain multiple values and can be altered.
- typeof operator can be used to find the type of a variable, except for null, which will return "object".

Example:

let name = "John"; // Primitive type string
let age = 30; // Primitive type number
let user = { name: "John", age: 30 }; // Reference type object

console.log(typeof name); // "string"
console.log(typeof age); // "number"
console.log(typeof user); // "object"

2. How does JavaScript handle type coercion between different data types?

Answer: JavaScript performs automatic type coercion in certain situations, such as in arithmetic operations, logical operations, or when using the equality operator. This means JavaScript will automatically convert values from one type to another when necessary.

Key Points:
- Implicit coercion occurs automatically when the operators used in the statement require values of a specific type.
- Explicit coercion involves manually converting values from one type to another using functions such as Number(), String(), or Boolean().

Example:

let result = "5" + 2; // Implicit coercion of 2 to a string, result is "52"
let sum = Number("5") + 2; // Explicit coercion of "5" to a number, sum is 7

console.log(result); // "52"
console.log(sum); // 7

3. Explain the difference between primitive and reference data types in JavaScript.

Answer: The key difference between primitive and reference data types is how they are stored and manipulated in memory. Primitive types are stored directly in the location the variable accesses, and they represent a single value. Reference types, however, store a reference to a memory location where the object is stored, allowing them to represent complex structures like arrays and objects.

Key Points:
- Storage: Primitive types are stored on the stack, making their access faster. Reference types are stored in the heap, which is used for storing dynamically allocated objects.
- Immutability: Primitive types are immutable, meaning their value cannot be changed after they are created. For reference types, the reference itself is immutable, but the content can be changed.
- Copying values: Copying a primitive type variable duplicates the actual value, while copying a reference type variable duplicates the reference, not the object itself.

Example:

let num1 = 10; // Primitive type
let num2 = num1; // Copies value of num1
num2 = 20; // Changes in num2 do not affect num1

let obj1 = { value: 10 }; // Reference type
let obj2 = obj1; // Copies reference of obj1
obj2.value = 20; // Changes in obj2 also reflect in obj1

console.log(num1); // 10
console.log(obj1.value); // 20

4. Can you explain how immutability works in JavaScript with respect to strings and objects?

Answer: In JavaScript, primitive types such as strings are immutable, which means that once a string is created, it cannot be modified. Any operation that appears to change a string actually creates a new string. On the other hand, objects are mutable, meaning their properties or contents can be changed after creation.

Key Points:
- String Immutability: Attempting to change a character directly in a string will not have any effect because strings cannot be altered once created.
- Object Mutability: Objects, including arrays and functions, can have their properties or elements updated or changed after they are created.

Example:

let greeting = "Hello";
greeting[0] = "J"; // Trying to change 'H' to 'J'
console.log(greeting); // "Hello", string is immutable

let user = { name: "John" };
user.name = "Jane"; // Changing the name property of the object
console.log(user.name); // "Jane", object is mutable
logo