Data Types in Programming

From Bee: JavaScript will silently convert types behind your back. Always use === instead of ==. Always parse form input with Number() before doing math.

What Is a Data Type?

A data type is a category that describes a value. 42 is a number; "hello" is a string; true is a boolean. The type determines which operations make sense — adding two numbers works, but adding two booleans usually doesn't.

Languages handle types in two main ways. Statically typed languages (Java, C++) require you to declare the type up-front — the compiler checks types before running. Dynamically typed languages (Python, JavaScript) figure types out at runtime — more flexible but easier to slip a wrong-type bug past your eyes.

The Core Types You'll See Everywhere

• Number — whole numbers (42) and decimals (3.14). Some languages split them into int and float.
• String — text in quotes: "hello".
• Boolean — true or false.
• Array / List — an ordered sequence of values.
• Object / Dictionary — a collection of named fields.
• Null / None — explicit "no value."
• Undefined (JavaScript) — variable declared but not assigned.

Code Examples in Three Languages

// JavaScript types
let n = 42;              // number
let s = "hi";            // string
let b = true;            // boolean
let arr = [1, 2, 3];     // array
let obj = { x: 1 };      // object
let nothing = null;      // null
let maybe;               // undefined

console.log(typeof n);   // "number"
console.log(typeof s);   // "string"

# Python types
n = 42                   # int
x = 3.14                 # float
s = "hi"                 # str
b = True                 # bool (capitalized!)
lst = [1, 2, 3]          # list
d = {"x": 1}             # dict
nothing = None           # None

print(type(n))           # <class 'int'>
print(type(s))           # <class 'str'>

// Java types — must be declared
int n = 42;
double x = 3.14;
String s = "hi";
boolean b = true;
int[] arr = {1, 2, 3};
// Java has no built-in dict;
// use HashMap<String,Object>
String nothing = null;

Best Practices

1. Pick the most specific type — int over double if you only need whole numbers.
2. Don't mix types accidentally: "5" + 3 is "53" in JS, an error in Python.
3. Convert types explicitly: Number(s) in JS, int(s) in Python.
4. Prefer null/None over a "magic" sentinel value like -1.

Common Mistakes

• Treating a string number as a number. Form inputs are always strings — convert them first.
• Comparing different types with ==. JavaScript's "5" == 5 returns true (use ===). Most languages refuse this comparison.
• Forgetting that floats aren't exact. 0.1 + 0.2 === 0.3 is false — floating-point arithmetic is approximate.
• Reading typeof null in JS. Returns "object" — a famous quirk. Use === null for null checks.

How It Works Under the Hood

Behind the scenes, every value in your program is stored as bits in memory. The type is metadata that tells the language how to read those bits and which operations are valid. A 4-byte chunk of memory representing the integer 42 looks identical to the same 4 bytes representing a different float — the type is what disambiguates them.

This explains why some languages (Java, Rust) require you to declare types up-front: the compiler needs to allocate the right amount of memory and emit the correct CPU instructions. Dynamic languages (Python, JavaScript) defer that decision to runtime, which is why they can be slower but more flexible.

JavaScript actually uses a single Number type for all numerics — internally, every number is a 64-bit IEEE 754 float. Python automatically promotes integers beyond 64 bits into arbitrary-precision BigInt values. Java keeps a strict separation: int, long, float, double are all distinct.

From Beginner to Pro

The same concept gets deeper as you grow. Here's what mastery looks like at three levels:

Performance & Gotchas

• Float arithmetic is approximate. Use a tolerance for equality, or use a Decimal library for money.
• JS's typeof null === "object" is a 25-year-old quirk. Use === null.
• Java boxed types (Integer vs int) compare with .equals(), not ==.
• NaN never equals itself. NaN === NaN is false. Use Number.isNaN().

Quick Quiz

Real-World Uses (Production Code, Today)

Frequently Asked Questions

Related Concepts