Primitive data types in Javascript

Introduction

Primitive data types are the basic building blocks to store simple values in a program. They help us keep and use small pieces of information like numbers or words.

When you want to store a number like age or price.

When you want to store a short piece of text like a name or a city.

When you want to store true or false answers, like if a light is on or off.

When you want to store a single character or symbol.

When you want to store a special value like 'nothing' or 'unknown'.

Syntax

Javascript

let numberExample = 42;
let stringExample = "hello";
let booleanExample = true;
let undefinedExample;
let nullExample = null;
let symbolExample = Symbol('id');
let bigintExample = 9007199254740991n;

JavaScript has 7 primitive data types: number, string, boolean, undefined, null, symbol, and bigint.

Primitive values are stored directly and are immutable (cannot be changed).

Examples

Basic examples of number, string, and boolean types.

Javascript

let age = 30; // number
let name = "Alice"; // string
let isStudent = false; // boolean

undefined means a variable has no value yet; null means an intentional empty value.

Javascript

let unknownValue; // undefined
let emptyValue = null; // null

Symbol creates a unique identifier, useful for special keys.

Javascript

let uniqueId = Symbol('id');

BigInt stores very large integers beyond normal number limits.

Javascript

let bigNumber = 123456789012345678901234567890n;

Sample Program

This program shows all primitive data types in JavaScript with example values and prints them.

Javascript

console.log("Primitive Data Types Examples:");

let numberExample = 100;
let stringExample = "Hello World";
let booleanExample = true;
let undefinedExample;
let nullExample = null;
let symbolExample = Symbol('unique');
let bigintExample = 9007199254740991n;

console.log("Number:", numberExample);
console.log("String:", stringExample);
console.log("Boolean:", booleanExample);
console.log("Undefined:", undefinedExample);
console.log("Null:", nullExample);
console.log("Symbol:", symbolExample.toString());
console.log("BigInt:", bigintExample);

Important Notes

Time complexity: Accessing primitive values is very fast, constant time O(1).

Space complexity: Each primitive uses a small fixed amount of memory.

Common mistake: Confusing null and undefined; undefined means no value assigned, null means empty value assigned.

Use primitives for simple data. For collections or complex data, use objects or arrays.

Summary

Primitive data types store simple, single values like numbers or text.

JavaScript has 7 primitive types: number, string, boolean, undefined, null, symbol, and bigint.

Primitives are fast and use little memory, perfect for basic data storage.

Practice

1. Which of the following is NOT a primitive data type in JavaScript?

easy

A. object

B. boolean

C. string

D. number

Solution

1. Step 1: Recall JavaScript primitive types

   JavaScript primitive types include string, number, boolean, undefined, null, symbol, and bigint.

2. Step 2: Identify non-primitive types

   Object is not a primitive type; it is a complex data type used to store collections.

3. Final Answer:

   object -> Option A

4. Quick Check:

   Primitive types exclude objects [OK]

Hint: Remember: objects are NOT primitives, others are [OK]

Common Mistakes:

• Confusing object with primitive types
• Thinking null is an object
• Mixing symbol with object

2. Which of the following is the correct way to declare a variable with a string primitive in JavaScript?

easy

A. let name = John;

B. let name = 'John';

C. let name = "John;

D. let name = `John;

Solution

1. Step 1: Check string declaration syntax

   Strings must be enclosed in matching quotes: single ('') or double ("") or backticks (``).

2. Step 2: Validate each option

   let name = 'John'; uses single quotes correctly. let name = John; lacks quotes. Options C and D have unclosed quotes.

3. Final Answer:

   let name = 'John'; -> Option B

4. Quick Check:

   Strings need matching quotes [OK]

Hint: Strings always need matching quotes around text [OK]

Common Mistakes:

• Missing quotes around string
• Using mismatched quotes
• Forgetting semicolon (optional but good)

3. What will be the output of the following code?

console.log(typeof 123);
console.log(typeof 'hello');
console.log(typeof true);

medium

A. "number", "string", "boolean"

B. "Number", "String", "Boolean"

C. "num", "str", "bool"

D. "integer", "text", "bool"

Solution

1. Step 1: Understand typeof operator

   typeof returns the type of a value as a lowercase string like "number", "string", or "boolean".

2. Step 2: Check each console.log output

   typeof 123 is "number", typeof 'hello' is "string", typeof true is "boolean".

3. Final Answer:

   "number", "string", "boolean" -> Option A

4. Quick Check:

   typeof returns lowercase type names [OK]

Hint: typeof returns lowercase type names as strings [OK]

Common Mistakes:

• Capitalizing type names
• Using short forms like 'num'
• Confusing typeof output with values

4. Find the error in this code snippet:

let value = null;
console.log(typeof value);

medium

A. null is not a valid value

B. typeof null returns 'null'

C. typeof null returns 'object' which is confusing

D. No error, code works fine

Solution

1. Step 1: Understand typeof null behavior

   typeof null returns "object" due to a historical JavaScript bug.

2. Step 2: Identify confusion

   This is confusing because null is a primitive but typeof shows "object".

3. Final Answer:

   typeof null returns 'object' which is confusing -> Option C

4. Quick Check:

   typeof null is 'object' (quirk) [OK]

Hint: Remember typeof null is 'object' due to JavaScript quirk [OK]

Common Mistakes:

• Expecting 'null' from typeof
• Thinking null is an object
• Assuming code throws error

5. You want to store a very large integer number beyond the safe integer limit in JavaScript. Which primitive type should you use?

hard

A. number

B. symbol

C. string

D. bigint

Solution

1. Step 1: Understand number limits in JavaScript

   The number type can safely represent integers only up to 2^53 - 1.

2. Step 2: Identify type for large integers

   bigint is designed to store integers larger than the safe limit without losing precision.

3. Final Answer:

   bigint -> Option D

4. Quick Check:

   Use bigint for very large integers [OK]

Hint: Use bigint for integers larger than safe number limit [OK]

Common Mistakes:

• Using number for very large integers
• Using string instead of bigint
• Confusing symbol with number types