Academy — Sanjib Sikder

Values Have Kinds

In the previous lesson you stored values in boxes. But not all values are the same kind of thing.

The number 42 and the text "42" look similar to a human eye. To a computer, they are completely different objects stored differently in memory, with different operations permitted on them. Trying to use one where the other is expected is one of the most common sources of bugs in all of programming.

JavaScript has 7 primitive types. You will use 5 of them constantly. Let's meet them one by one.

Number

In JavaScript, there is only one type for all numbers. Integers, decimals, negative — they are all just number.

JavaScript

Ctrl+Enter to run

console.log(42);          // integer
console.log(3.14159);     // decimal
console.log(-273.15);     // negative (absolute zero in Celsius)
console.log(1.5e6);       // scientific notation: 1,500,000

// Arithmetic
console.log(10 + 3); // 13
console.log(10 - 3); // 7
console.log(10 * 3); // 30
console.log(10 / 3); // 3.3333...
console.log(10 % 3); // 1 ← remainder (modulo)
console.log(10 ** 3); // 1000 ← exponentiation

The % operator — modulo — deserves special attention. It gives you the remainder after division. 10 % 3 is 1 because 10 divided by 3 is 3 with a remainder of 1. You will use modulo constantly: to check if a number is even or odd, to wrap values around a range, to build cycles.

The Strange Number: NaN

JavaScript

Ctrl+Enter to run

const result = "hello" / 2;
console.log(result);
console.log(typeof result);

NaN stands for Not a Number. It is JavaScript's way of saying: "You asked me to do arithmetic on something that isn't a number, so the result is meaningless."

The bizarre thing: typeof NaN returns "number". NaN is a number-type value that represents an invalid number. It is the only value in JavaScript that is not equal to itself — NaN === NaN is false. This surprises everyone the first time.

String

A string is a sequence of characters — any text at all, wrapped in quotes.

JavaScript

Ctrl+Enter to run

const name = "Sanjib";
const greeting = 'Hello';          // single quotes work too
const message = `${greeting}, ${name}!`;  // template literal

console.log(message);
console.log(name.length); // number of characters
console.log(name.toUpperCase());
console.log(name[0]); // first character: "S"
console.log(name[0] + name[1]); // "Sa"

The backtick syntax `${greeting}, ${name}!` is called a template literal. It lets you embed variables directly inside a string using ${}. This is almost always cleaner than using + to join strings together.

name[0] accesses the first character. Strings in JavaScript are zero-indexed — the first character is at position 0, not 1. This confuses beginners exactly once, after which it becomes second nature.

Strings Are Immutable

Once a string exists, it cannot be changed. You can create a new string based on an old one, but you cannot modify the original.

JavaScript

Ctrl+Enter to run

const word = "hello";
const louder = word.toUpperCase();

console.log(word); // still "hello" — unchanged
console.log(louder); // "HELLO" — a brand new string

Boolean

A boolean has exactly two possible values: true or false. Nothing else.

JavaScript

Ctrl+Enter to run

const isRaining = false;
const hasUmbrella = true;

console.log(isRaining);
console.log(10 > 3); // true
console.log(10 < 3); // false
console.log(10 === 10); // true ← strict equality
console.log(10 === "10"); // false ← number vs string
console.log(10 !== 5); // true ← not equal

Notice === — three equals signs. This is strict equality: the values must be the same and the same type. 10 === "10" is false because one is a number and the other is a string.

There is also == (two equals signs), which does type coercion before comparing. 10 == "10" returns true. Avoid ==. It produces surprises. Always use ===. The extra = costs nothing and saves hours of debugging.

Undefined

undefined means: a variable exists, but has never been given a value.

JavaScript

Ctrl+Enter to run

let temperature;
console.log(temperature);          // undefined
console.log(typeof temperature);   // "undefined"

function greet(name) {
console.log("Hello,", name);
}

greet("Sanjib"); // Hello, Sanjib
greet(); // Hello, undefined ← no argument passed

undefined is not something you typically assign on purpose. It is the computer's way of saying: "This box exists but no one has put anything in it yet."

When you call a function without providing an expected argument, that argument is undefined inside the function. This is JavaScript being permissive — it does not crash, it just proceeds with undefined. Whether that is helpful or dangerous depends entirely on the situation.

Null

null means: this variable intentionally has no value.

JavaScript

Ctrl+Enter to run

let selectedUser = null;   // no user selected yet
console.log(selectedUser);
console.log(typeof selectedUser);  // watch this carefully

Run it. typeof null returns "object". This is a bug in JavaScript that has existed since 1995 and cannot be fixed without breaking the internet. Every JavaScript programmer knows it. Accept it and move on.

Null vs Undefined — The Real Distinction

This is the thing most tutorials explain poorly. Here it is clearly:

	Meaning	Who sets it
`undefined`	Value was never assigned	JavaScript itself
`null`	Value is intentionally absent	You, the programmer

undefined is JavaScript talking. null is you talking.

When you retrieve a user from a database and no user exists, you return null — because you are deliberately communicating "there is no user here." When you declare let x without assigning it, JavaScript sets it to undefined — because you said nothing about its value.

JavaScript

Ctrl+Enter to run

// undefined: JavaScript saying "nothing was put here"
let x;
console.log(x);

// null: you saying "I deliberately put nothing here"
let currentUser = null;
console.log(currentUser);

// They are loosely equal but not strictly equal
console.log(null == undefined); // true ← both mean "nothing"
console.log(null === undefined); // false ← different kinds of nothing

Checking Types with typeof

The typeof operator tells you what type a value is:

JavaScript

Ctrl+Enter to run

console.log(typeof 42);           // "number"
console.log(typeof "hello");      // "string"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof null);         // "object" ← the famous bug
console.log(typeof {});           // "object"
console.log(typeof []);           // "object" ← arrays too!
console.log(typeof function(){}); // "function"

Notice that arrays and objects both return "object". typeof is useful for distinguishing primitives, but not detailed enough for complex values. You will learn better tools for that later.

Type Coercion — The Full Picture

In Lesson 1 you saw that 10 + "20" gives "1020". Now you understand why: JavaScript sees a number and a string, decides to convert the number to a string, and concatenates them. This automatic conversion is type coercion.

JavaScript

Ctrl+Enter to run

// + with a string: coerces to string (concatenation)
console.log(10 + "20");    // "1020"
console.log("3" + "4");    // "34"

// Other operators: coerce to number
console.log("10" - 5); // 5
console.log("6" * "2"); // 12
console.log("10" / "2"); // 5

// The trap
console.log("5" + 1); // "51" ← string wins with +
console.log("5" - 1); // 4 ← number wins with -

+ is the dangerous one because it serves double duty: addition for numbers, concatenation for strings. When in doubt, use explicit conversion:

JavaScript

Ctrl+Enter to run

const input = "42";   // imagine this came from a form field

// Wrong: "42" + 8 = "428"
console.log(input + 8);

// Right: convert first
console.log(Number(input) + 8); // 50
console.log(parseInt(input) + 8); // 50

What You Have Learned

Every value in JavaScript has a type. The five you will use daily:

Number — all numeric values; NaN is its strange edge case
String — text; zero-indexed; immutable; use template literals
Boolean — true or false; always use === not ==
Undefined — JavaScript's signal that a value was never assigned
Null — your signal that a value is intentionally absent

Type coercion happens automatically and silently. Knowing when and why it happens is the difference between a programmer who writes reliable code and one who spends hours chasing phantom bugs.

In the next lesson, we meet conditionals — how a program makes decisions. This is where code stops being a sequence of instructions and starts feeling like it can think.

Data Types

Values Have Kinds

Number

The Strange Number: NaN

String

Strings Are Immutable

Boolean

Undefined

Null

Null vs Undefined — The Real Distinction

Checking Types with typeof

Type Coercion — The Full Picture

What You Have Learned