JavaScript Data Types Explained: A Beginner’s Guide to Number, BigInt, String & Boolean

Published on June 9, 2025 • 5 min read

JavaScript data types form the backbone of programming in JavaScript, enabling you to store and manipulate different kinds of information efficiently. For beginners, understanding data types such as number, string, Boolean, undefined, null, and BigInt is essential as these concepts help manage data effectively inside your code's memory. This foundational knowledge will enhance your coding clarity and pave the way for more advanced JavaScript topics. Let's dive into the essential JavaScript data types, how they operate in memory (RAM), and why grasping these will sharpen your programming skills.

Understanding JavaScript Memory: RAM, Stack, and Heap

Whenever you run any software or JavaScript program on your computer, it operates inside the RAM (Random Access Memory). RAM is fast primary memory where active programs and data reside temporarily. Within RAM, JavaScript distinguishes two main memory partitions:

• Stack: Used for storing primitive data types like numbers, strings, and Booleans, as well as function calls and local variables.
• Heap: For storing objects and complex data structures.

Imagine the stack as a neatly organized shelf holding boxes (variables), each containing a particular piece of data. Each box is labeled with a variable name (identifier) so you can easily find and manipulate it. For beginners, thinking about memory this way helps demystify how variables work and interact in JavaScript. For more on how memory works in programming, the Mozilla Developer Network (MDN) article on memory management is an excellent resource.

JavaScript Number Data Type: Integers, Real Numbers, and Special Numeric Values

In JavaScript, the number data type is versatile — it covers both integer values (whole numbers like 23 or 2000) and floating-point numbers (decimals like 5.9 or 68.2). This looser typing means you don't explicitly declare if a value is an integer or float; JavaScript figures it out automatically.

Here’s a basic example of declaring a number in JavaScript:

let age = 23;
console.log(age); // 23
console.log(typeof age); // number

What's interesting is that JavaScript also supports special numeric values:

• Infinity and -Infinity: The result of dividing a positive or negative number by zero.
• NaN (Not a Number): The result when a numeric operation is invalid, like dividing a string by a number.

console.log(1 / 0); // Infinity
console.log('hello' / 2); // NaN
console.log(typeof NaN); // number

Numbers in JavaScript cover a huge range, from approximately -2^53 + 1 to 2^53 - 1. Attempting to store numbers beyond this range can lead to precision errors. If you need to handle really large integers, JavaScript provides the BigInt data type.

BigInt: Handling Large Integers Beyond Number Range

When working with numbers that exceed the safe integer limit, BigInt steps in as a savior. For example, if you want to store a huge number like 9007199254740991n, you suffix the number with an n to denote it's a BigInt:

let bigNumber = 9007199254740991n;
console.log(typeof bigNumber); // bigint

Key points about BigInt:

• Only works with whole numbers (integers).
• You cannot use decimals or floating-point numbers with BigInt.
• Arithmetic operations are allowed between two BigInts but mixing BigInt with regular numbers causes errors.

For more detailed behavior and restrictions, refer to the official MDN BigInt documentation.

Strings: Working with Series of Characters

Strings in JavaScript are simply a series of characters enclosed in quotes. Whether it's your name, a city, or a password, all these are stored as strings. Here's an example:

let academyName = "Tap Academy";
console.log(academyName); // "Tap Academy"
console.log(typeof academyName); // string

Strings are stored in the stack for easy access. Special characters, escape sequences, and template literals enrich how you manipulate strings, which are topics worth exploring separately.

Booleans: Representing True or False

Boolean data types take only two values: true or false. You can think of this as digital yes/no, pass/fail, or on/off in real-life scenarios. For example, a variable indicating if someone has a passport can be expressed as:

let hasPassport = true;
console.log(hasPassport); // true
console.log(typeof hasPassport); // boolean

Booleans are essential in control flow and decision making in your programs.

Undefined: Variables Without Assigned Values

If you declare a variable but don't assign a value, JavaScript automatically assigns it the value undefined. This indicates that the variable exists but doesn't hold any value yet.

let uninitializedVar;
console.log(uninitializedVar); // undefined
console.log(typeof uninitializedVar); // undefined

Understanding undefined is crucial because it often serves as a default or placeholder state in JavaScript programs.

Looking Forward: Null and Symbol Data Types

While we've covered the main data types you'll frequently encounter, two more important ones are null and symbol. These deserve their own detailed discussions, especially as you delve into object-oriented JavaScript and advanced programming concepts. Stay tuned for future lessons where these will be unpacked comprehensively.

Mastering JavaScript data types helps build a strong foundation for writing clean, efficient, and bug-free code. Remember that in JavaScript, variables are flexible thanks to loose typing, but understanding the range and behaviors of each data type (like number vs. BigInt) prevents potential coding pitfalls.

Start experimenting with these data types right away in your coding environment—try creating variables with numbers, BigInts, strings, and Booleans. Get familiar with how JavaScript automatically infers types and explore edge cases like special numeric values or undefined variables.

For further learning, the JavaScript guide on MDN provides a comprehensive and beginner-friendly explanation.

Happy coding, and I'll catch you in the next lesson where we will explore objects and more advanced JavaScript topics!

This blog post is based on content from a YouTube video. Watch it here. All rights reserved by the original creator.