1. Introduction
JavaScript is a dynamically typed language: variables do not have fixed types, but the values they hold do. JavaScript values fall into two categories — primitive types, which are immutable and copied by value, and reference types (objects), which are mutable and accessed by reference.
Cricket analogy: A batting slot in the lineup doesn't have a fixed type of player assigned forever — today it holds an opener, tomorrow it might hold a middle-order batsman — just as a JavaScript variable has no fixed type, only the value currently placed in it does; and handing a teammate a photocopy of your training plan (copied by value) is different from handing them the shared team locker key that opens the same locker for everyone (accessed by reference).
2. Syntax
let num = 42; // number
let str = "hello"; // string
let bool = true; // boolean
let notAssigned; // undefined
let empty = null; // null
let id = Symbol("id"); // symbol
let big = 10n; // bigint
let person = { name: "Al" }; // object (reference type)
let list = [1, 2, 3]; // array (also an object)2.1 Primitive Types
JavaScript has seven primitive types: number, string, boolean, undefined, null, symbol, and bigint. Primitives are compared and copied by value — assigning a primitive to a new variable copies the actual value.
Cricket analogy: The seven primitives are like seven fixed, indivisible facts about a delivery — the speed (number), the bowler's name (string), whether it was a wicket (boolean), a not-yet-recorded review outcome (undefined), a deliberately blank 'no review requested' field (null), a unique internal ball-tracking ID (symbol), and a massive career run-total too big for normal counters (bigint) — and copying any of these facts onto a second scorecard gives an independent value.
2.2 Reference Types
Everything that is not a primitive is an object, including plain objects, arrays, functions, dates, and maps. Reference types are compared and copied by reference — assigning an object to a new variable copies the reference to the same underlying data, so mutating it through one variable is visible through the other.
Cricket analogy: A shared team kit bag is like an object — arrays of players, functions like 'select XI,' dates of matches, and squad maps are all objects too — and if two selectors both hold the same kit bag reference and one adds a bat, the other sees it too, unlike a personal photocopy.
3. Explanation
The typeof operator returns a string describing a value's type, and it is the most common way to inspect a value's type at runtime. Arrays and functions both report as related but distinct results: typeof [] is 'object' (arrays are a specialized kind of object), while typeof (a function) is the special value 'function'.
Cricket analogy: The typeof operator is like asking an official scorer 'what category is this entry?' — a run total reports as 'number,' and while a bowling figures table (an array-like list) still technically reports as belonging to the broader 'match data' category, a specific action like 'appeal for LBW' (a function-like decision trigger) gets its own distinct 'decision' category.
Gotcha: typeof null returns 'object', not 'null'. This is a long-standing bug from JavaScript's first implementation in 1995 that can never be fixed without breaking existing code on the web. To reliably check for null, compare directly with === null instead of relying on typeof.
4. Example
console.log(typeof 42);
console.log(typeof "hello");
console.log(typeof true);
console.log(typeof undefined);
console.log(typeof null);
console.log(typeof Symbol("id"));
console.log(typeof 10n);
console.log(typeof { a: 1 });
console.log(typeof [1, 2, 3]);
console.log(typeof function () {});5. Output
number
string
boolean
undefined
object
symbol
bigint
object
object
function6. Key Takeaways
- JavaScript has 7 primitive types: number, string, boolean, undefined, null, symbol, and bigint.
- Objects, arrays, and functions are all reference types built on top of the object type.
- typeof null incorrectly returns 'object' — a historical bug you must remember.
- Arrays report typeof 'object'; use Array.isArray() to distinguish arrays from plain objects.
- Primitives are copied by value; objects are copied by reference.
Practice what you learned
1. What does typeof null return?
2. Which of the following is NOT a primitive type in JavaScript?
3. What does typeof [1, 2, 3] return?
4. How are primitive values copied when assigned to a new variable?
5. What does typeof (function () {}) return?
Was this page helpful?
You May Also Like
Type Conversion and Coercion in JavaScript
Learn the difference between explicit type conversion and implicit coercion, and the common pitfalls each creates.
Variables in JavaScript (var, let, const)
Learn how var, let, and const differ in scope, hoisting, and reassignment when declaring variables in JavaScript.
Arrays in JavaScript
Understand how JavaScript arrays store ordered lists of values, how indexing and length work, and why `typeof` alone can't identify an array.
Objects in JavaScript
Learn how to create, access, and modify JavaScript objects, and understand why objects behave as reference types.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics