JavaScript Variables (let, const, var) and Data Types

These are the notes for JavaScript episode 2. You will learn why programs need variables, how let, const and var differ, JavaScript's naming rules, the seven primitive data types with typeof, the difference between undefined and null, and the silent bugs that catch beginners: big numbers, decimals and dynamic typing. Every example runs as-is in the SyntaxPilot compiler (language: JavaScript, Node.js).

The problem: one value typed everywhere

Ramesh bhaiya runs a chai stall in Pune. One chai costs ₹15, and his program prints a bill per table:

// Ramesh bhaiya's bills
console.log("Table 1: 2 chai = " + 15 * 2);
console.log("Table 2: 1 chai = " + 15 * 1);
console.log("Table 3: 3 chai = " + 15 * 3);

Table 1: 2 chai = 30
Table 2: 1 chai = 15
Table 3: 3 chai = 45

Chai goes up to ₹20. We change tables 1 and 2, and forget table 3:

Table 1: 2 chai = 40
Table 2: 1 chai = 20
Table 3: 3 chai = 45

No error, wrong bill. One value (the price) lived in three places, and every change meant finding every copy.

The fix: store the value once, give it a name, and use the name everywhere. That named box is a variable.

Variables: a labelled jar

// Ramesh bhaiya's bills
let price = 20;
console.log("Table 1: 2 chai = " + price * 2);
console.log("Table 2: 1 chai = " + price * 1);
console.log("Table 3: 3 chai = " + price * 3);

Table 1: 2 chai = 40
Table 2: 1 chai = 20
Table 3: 3 chai = 60

Anatomy

Changing a variable: reassign, don't redeclare

let price = 15;
console.log("Morning: " + price);
price = 20;
console.log("Evening: " + price);

Morning: 15
Evening: 20

Use let once. Declaring the same name again is an error:

let price = 15;
let price = 20;
console.log(price);

SyntaxError: Identifier 'price' has already been declared

const: values that must never change

GST on chai is 5%. Two hundred lines later, a helper writes gst = 12 by mistake:

let gst = 5;
let bill = 100;
// ...200 lines later, a helper writes:
gst = 12;
console.log("Bill: " + (bill + bill * gst / 100));

Bill: 112

The customer should pay 105. With const (a constant: assigned once, never reassigned), the stray line fails loudly:

const gst = 5;
let bill = 100;
// ...200 lines later, a helper writes:
gst = 12;
console.log("Bill: " + (bill + bill * gst / 100));

main.js:4
gst = 12;
    ^

TypeError: Assignment to constant variable.

A const must get its value immediately:

const x;

SyntaxError: Missing initializer in const declaration

A loud error is better than a silent wrong answer.

var: the old way (avoid it)

Before 2015, var was the only keyword. let and const (2015, ES6) fixed its problems.

Declared twice, no error:

var price = 15;
// ...much later, by mistake:
var price = 20;
console.log(price);

20

Used before it exists, no error:

console.log(total);
var total = 100;

undefined

JavaScript prepares var variables before running the code (hoisting, covered in the scope episode), so you get undefined instead of an error. With let:

console.log(total);
let total = 100;

ReferenceError: Cannot access 'total' before initialization

Initialization means giving a variable its first value.

Which one to use

1. const by default: most values never change.
2. let when the value must change (a total, a counter).
3. var: never in new code; just recognise it in old code.

Naming rules

Names may use letters, digits (not first), _ and $. Use camelCase for multi-word names: firstName, chaiPrice, isOpen. Fixed settings are often written in capitals: const GST = 5;.

let firstName = "Aarav";
let chaiPrice = 15;
let isOpen = true;
console.log(firstName, chaiPrice, isOpen);

Aarav 15 true

Data types and typeof

A data type is the kind of value. typeof tells you a value's type.

console.log(typeof 15);
console.log(typeof 15.5);
console.log(typeof "chai");
console.log(typeof true);

number
number
string
boolean

undefined vs null

let seat;
console.log(seat, typeof seat);
let preference = null;
console.log(preference, typeof preference);

undefined undefined
null object

typeof null is "object": a bug from JavaScript's first version (1995), kept so old websites don't break. null is still its own type.

BigInt: huge whole numbers

A number holds whole numbers exactly only up to 9007199254740991 (Number.MAX_SAFE_INTEGER). Beyond that it rounds, silently:

console.log(9007199254740993);
console.log(9007199254740993n);
console.log(typeof 10n);

9007199254740992
9007199254740993n
bigint

Add n to make a BigInt: exact whole numbers of any size.

The seven primitive types

number, string, boolean, undefined, null, bigint, symbol (unique labels; rarely needed early). Everything else (arrays, objects, functions) is an object, covered later.

A decimal surprise

console.log(0.1 + 0.2);
console.log((10 + 20) / 100);

0.30000000000000004
0.3

Computers store decimals in binary, and 0.1 can't be stored exactly (true in almost every language). For money, count in whole paise and divide by 100 only when printing.

Dynamic typing

let box = 5;
console.log(box, typeof box);
box = "five";
console.log(box, typeof box);

5 number
five string

The type belongs to the value, not the variable (dynamic typing). Flexible, but nothing stops a wrong kind of value. TypeScript (later in the course) adds that check.

Common mistakes (and the real error messages)

Mini project: a chai stall bill

// Mini project: a chai stall bill
const CHAI = 15;
const SAMOSA = 20;
const GST = 5;
let customer = "Neha";
let chais = 2;
let samosas = 3;
let subtotal = CHAI * chais + SAMOSA * samosas;
let total = subtotal + subtotal * GST / 100;
console.log("Customer: " + customer);
console.log("Subtotal: " + subtotal);
console.log("Total with GST: " + total);

Customer: Neha
Subtotal: 90
Total with GST: 94.5

Practice

1. Store your name, age, city and whether you're a student in four variables (choose const or let), and print them on one line.
2. Write a bill for your favourite snack shop with const prices and a const tax rate.
3. Predict the output: let a; console.log(a); a = null; console.log(a, typeof a);
4. Why does const PI = 3.14; PI = 3; fail, and what's the exact error?

Quick quiz

What does this print?

let seat;
console.log(typeof seat, typeof null);

• A. undefined null
• B. undefined object
• C. null object
• D. Error

Interview questions

• What are the differences between var, let and const?
• Does const make a value immutable? (It stops reassignment of the variable; objects inside can still change, as you'll see in the objects episode.)
• What is the difference between undefined and null?
• Why is typeof null equal to "object"?
• Why is 0.1 + 0.2 !== 0.3? How do you handle money?
• What is the maximum safe integer, and what is BigInt for?
• What does "dynamically typed" mean?

Glossary

Summary

• A variable is a named box: let price = 15;. Change it in one place.
• const by default, let when it must change, never var in new code.
• Names: no digit first, no spaces, no keywords, case sensitive, camelCase.
• Seven primitive types: number, string, boolean, undefined, null, bigint, symbol. Check with typeof.
• undefined = not filled in yet; null = empty on purpose; typeof null is "object".
• Big whole numbers → BigInt (n); money → whole paise.

Next episode: operators and type coercion. A form says the age is 18, and 18 + 1 comes out as 181.