JS Data Types

Imagine sorting a junk drawer into labeled containers, coins in one, paperclips in another, notes in a third, each container holds a different kind of thing, and you naturally know what to expect inside each one. JavaScript organizes every value into a small set of data types, strings for text, numbers for math, booleans for true/false, and a few more specialized types, each behaving differently when you work with it. Recognizing which type you're dealing with, whether reading a tutorial on cookiescursor.com or debugging your own code, explains a huge portion of JavaScript's everyday behavior.

In this page:

String, Number, and Boolean
undefined and null
bigint and symbol
The object Type
Dynamic Typing

Syntax

javascript

let text = "string";
let number = 10;
let flag = true;
let list = [item1, item2];
let object = { key: value };

String, Number, and Boolean

string represents text wrapped in quotes, number represents both whole and decimal numbers using a single type, and boolean represents only true or false, the three most commonly used data types in everyday JavaScript.

Note: Unlike many languages, JavaScript uses one number type for both integers and decimals, there's no separate int vs float.

Warning: Numbers written without quotes and text written with quotes look similar but behave very differently in arithmetic and comparisons.

Example: String, Number, and Boolean

javascript

// Declare the variable `name`, set to "Alice"
// Declare the variable `name`, set to "Alice"
let name = "Alice";
// Declare the variable `age`, set to `30`
// Declare the variable `age`, set to `30`
let age = 30;
// Declare the variable `isActive`, set to `true`
// Declare the variable `isActive`, set to `true`
let isActive = true;
// Print `typeof name, typeof age, typeof isActive` to the console
// Print `typeof name, typeof age, typeof isActive` to the console
console.log(typeof name, typeof age, typeof isActive);

undefined and null

undefined means a variable has been declared but never given a value, while null is an intentional value developers assign to represent nothing or 'empty on purpose', they represent different concepts despite both meaning an absence of a real value.

Note: A helpful mental model, undefined usually means the language did this automatically, null usually means a developer set this on purpose.

Warning: typeof null returns object, a famous historical bug in JavaScript that's been kept for compatibility rather than fixed.

Example: undefined and null

javascript

let notSet;
let empty = null;
console.log(notSet); // undefined
console.log(empty);  // null

bigint and symbol

bigint represents whole numbers larger than the regular number type can safely handle, written with an n suffix, while symbol creates a guaranteed unique value, often used as a special, collision-free property key.

Note: bigint is only needed for extremely large integers, calculations involving very large IDs or precise large-number math are common use cases.

Warning: You cannot mix a regular number and a bigint directly with arithmetic operators, doing so throws a TypeError.

Example: bigint and symbol

javascript

// Declare the variable `big`, set to `12345678901234567890n`
// Declare the variable `big`, set to `12345678901234567890n`
let big = 12345678901234567890n;
// Declare the variable `id`, set to `Symbol("id")`
// Declare the variable `id`, set to `Symbol("id")`
let id = Symbol("id");
// Print `typeof big, typeof id` to the console
// Print `typeof big, typeof id` to the console
console.log(typeof big, typeof id);

The object Type

object is the only non-primitive type, used to group related data and functionality together, and it covers not just plain objects but also arrays, functions, and dates, all of which report as object or function with typeof.

Note: When you need to store multiple related pieces of information together, like a user's name and email, an object is usually the right type.

Warning: Arrays report typeof as object, not array, use Array.isArray() specifically when you need to confirm something is an array.

Example: The object Type

javascript

// Declare the variable `user`, set to `{ name: "Sam" }`
// Declare the variable `user`, set to `{ name: "Sam" }`
let user = { name: "Sam" };
// Declare the variable `list`, set to `[1, 2, 3]`
// Declare the variable `list`, set to `[1, 2, 3]`
let list = [1, 2, 3];
// Print `typeof user, typeof list` to the console
// Print `typeof user, typeof list` to the console
console.log(typeof user, typeof list);

Dynamic Typing

JavaScript is dynamically typed, meaning a variable's type is not fixed when declared, it's determined by whatever value currently sits inside it, and that value, along with its type, can change if the variable is reassigned.

Note: Dynamic typing offers flexibility, but writing consistent code, keeping a variable's intended type stable over its lifetime, reduces confusing bugs.

Warning: Accidentally reassigning a variable to an unexpected type, like changing a number to a string mid-script, can cause subtle downstream errors.

Example: Dynamic Typing

javascript

let value = 5;
console.log(typeof value); // "number"
value = "now a string";
console.log(typeof value); // "string"

Live Example

Chapter Quiz — Complete all 10 topics to unlock

0/10 topics done

Complete these topics first:

← Previous Lesson JS Assignment Next Lesson → JS Functions

JS Data Types

String, Number, and Boolean

undefined and null

bigint and symbol

The object Type

Dynamic Typing

Chapter Quiz — Complete all 10 topics to unlock

Login to run this code