Guest Contributor

What Are Javascript Data Types?

By | Adelaide Ferrano

Are you ready to unlock the secrets of JavaScript? This dynamic, weakly typed language holds the key to effective programming. But beware! Without a solid understanding of its data types, you’re navigating a minefield. Dive into this article to master the essentials and avoid common pitfalls.

What are JavaScript data types? JavaScript data types are the building blocks of the language, categorizing values into primitive types like string, number, and boolean, and non-primitive types like object. Understanding these types is crucial for manipulating data and creating robust programs.

Embark on this journey to demystify JavaScript data types. Grasp the nuances of dynamic typing, conquer the complexities of type coercion, and wield the power of the typeof operator. Your code’s success hinges on this knowledge!

Overview Of JavaScript Data Types 

JavaScript is a language full of surprises, thanks to its dynamic typing. What does this mean? Variables in JavaScript can hold different data types at different times. You can start with a number, then switch to a string, no questions asked. It’s like a chameleon, changing its colors to fit the situation.

But there’s a catch. JavaScript is also weakly typed. This isn’t about strength, but flexibility. The language doesn’t force you to declare the type of your variable upfront. Plus, it’s pretty lenient with type conversion. You can mix and match types in your operations, and JavaScript will try its best to make sense of it.

For example, adding a number to a string turns everything into a string. “Hello” + 5 becomes “Hello5”. But be careful! This flexibility can lead to unexpected results. Imagine subtracting a string from a number. What’s 10 – “5”? You might expect 5, but JavaScript gives you 5. It’s like a magic trick, but not always the one you want.

In a nutshell, understanding dynamic and weak typing in JavaScript is crucial. It’s the foundation for working with data types and avoiding surprises in your code. Keep this in mind as we dive deeper into the world of JavaScript data types.

What Are Primitive Data Types?

In the world of JavaScript, primitive data types are the building blocks of your code. Let’s dive into each one and see what they’re all about.


Strings are like sentences. They’re a series of characters wrapped in quotes, whether single (‘ ‘), double (” “), or backticks ( ). You can put anything inside those quotes: letters, numbers, symbols, you name it. Strings are great for text, like names or messages. Want to combine strings? Use concatenation with the ‘+’ operator, like “Hello” + “World” = “HelloWorld”. Or, get fancy with template literals using backticks: Hello ${name}!.


Numbers in JavaScript can be integers or floating-point (decimals). But there’s more! You’ve got special numbers like Infinity (bigger than any number) and NaN (Not-a-Number, when things go wrong in calculations). You can do all sorts of operations with numbers: add, subtract, multiply, divide, and even find remainders with the modulus operator (%).


Sometimes, numbers are just too big for the regular Number type. That’s where BigInt comes in. It handles integers larger than 2^53 – 1. Create a BigInt by adding ‘n’ to the end of an integer, like 12345678901234567890n. Now you can do math with massive numbers without losing precision.


Booleans are the simplest type, with just two values: true or false. They’re the backbone of decision-making in your code, used in conditional statements like if-else. For example, if (isHappy) { smile(); } else { frown(); }.


Undefined is a bit mysterious. It’s the value of a variable that hasn’t been assigned yet. If you declare a variable but don’t give it a value, it’s undefined. It’s like a placeholder waiting for its true purpose.


Null is the intentional absence of value. It’s like saying, “This variable exists, but it holds nothing.” It’s different from undefined because it’s a deliberate choice. Use null to clear a variable or indicate that it should be empty.


Symbols are unique and unchangeable. They’re used as identifiers for object properties, ensuring that each property is one of a kind. Create a symbol with Symbol(), and even if you create another with the same description, they won’t be the same. It’s like having a secret code for your properties.

Each of these primitive data types has its role in the grand scheme of your JavaScript code. Understanding them is key to mastering the language and writing efficient, bug-free programs.

What Are Non-Primitive Data Types?

In JavaScript, there’s more to data types than just the basics. Enter the realm of non-primitive data types, where things get a bit more complex and a lot more interesting. The star of this show is the Object.


Think of an object as a treasure chest. Inside, you can store a collection of key-value pairs. The keys are like labels, and the values can be anything: numbers, strings, even other objects or functions. Here’s a simple object:

let person = {

 name: “John”,

 age: 30,

 greet: function() {

 console.log(“Hello, ” +;



In this example, name and age are properties of the person object, and greet is a method, a function associated with an object. You can access properties using dot notation ( or bracket notation (person[“age”]), and call methods like person.greet().

Objects are the backbone of object-oriented programming (OOP) in JavaScript. They help you organize your code into reusable, modular pieces. You can create instances of objects, inherit properties and methods from other objects, and encapsulate data and behavior.

But objects aren’t just standalone entities. They come in various flavors, like Arrays and Functions:

  • Arrays are special objects for storing ordered collections. You can access elements by their index, like myArray[0].
  • Functions are also objects, but with the superpower of being callable. They can take inputs, process data, and return outputs.

Understanding non-primitive data types, especially objects, is crucial for diving deeper into JavaScript and unlocking its full potential, including exploring the vast landscape of JavaScript frameworks. They’re the building blocks for more complex structures and concepts you’ll encounter on your coding journey, providing the foundation for integrating and leveraging various JavaScript frameworks effectively.

Type Coercion in JavaScript

In the quirky world of JavaScript, things aren’t always what they seem, especially when it comes to type coercion. This is JavaScript’s way of converting values from one type to another, often behind the scenes, and it can lead to some unexpected results.

For instance, when you mix different data types in arithmetic operations, JavaScript tries to make sense of it by converting types implicitly. Here’s a classic example:

let result = “5” + 2; // “52”

You might expect the result to be 7, but surprise! JavaScript concatenates the string “5” and the number 2, resulting in the string “52”. This is because the + operator is also used for string concatenation, and JavaScript prioritizes strings in mixed operations.

But it’s not just about strings and numbers. Even logical operations can involve type coercion:

let truthyCheck = “hello” && 0; // 0

In this case, JavaScript evaluates the truthiness of each operand. Since non-empty strings are truthy and 0 is falsy, the result of the && operation is 0.

Understanding type coercion is crucial for debugging and writing predictable code. It’s one of those JavaScript idiosyncrasies that can trip up even experienced programmers, so keep an eye out for it in your coding adventures.

Detecting Data Types with typeof Operator

In the ever-changing world of JavaScript, keeping track of data types is crucial. Enter the typeof operator, your trusty tool for identifying the type of a variable. It’s like a detective, uncovering the secrets of your data with a simple syntax:

let myVar = “Hello, world!”;

console.log(typeof myVar); // “string”

The typeof operator returns a string indicating the type of the operand. It’s straightforward for most data types:

  • “string” for strings
  • “number” for numbers
  • “boolean” for booleans
  • “undefined” for undefined values
  • “object” for objects, null, and arrays
  • “function” for functions
  • “bigint” for BigInts
  • “symbol” for symbols

However, there are some special cases to watch out for:

  • typeof null returns “object”, which is a historical bug in JavaScript.
  • Arrays are considered objects, so typeof [1, 2, 3] will return “object”.

Using typeof is a quick and easy way to check data types, especially when dealing with dynamic values or debugging your code. It’s a handy tool to have in your JavaScript toolbox.


JavaScript’s dynamic nature makes understanding its data types essential. From primitive types like strings, numbers, and booleans to non-primitive types like objects and arrays, each serves a unique purpose in programming. Be aware of special cases, like the typeof null quirk and type coercion, which can lead to unexpected results. Embrace the flexibility of JavaScript, but remember that with great power comes great responsibility. Keep a close eye on your data types to prevent common bugs and write more robust, predictable code.


What are the 5 data types in JavaScript?

  • JavaScript has more than 5 data types, but the main primitive ones are string, number, boolean, undefined, and null. Non-primitive types include object, which covers arrays and functions.

Is array a data type in JavaScript?

  • In JavaScript, an array is not a primitive data type but falls under the object category. It’s a collection of elements that can hold multiple values.

What data type is NaN in JavaScript?

  • NaN stands for “Not-a-Number” and is a special value in JavaScript. It’s considered a number data type, even though it represents a value that’s not a valid number.

Is JavaScript statically or dynamically typed?

  • JavaScript is a dynamically typed language. This means variables in JavaScript can hold different data types and their types can change during runtime.

What is type coercion in JavaScript?

  • Type coercion is the automatic or implicit conversion of values from one data type to another, such as converting a string to a number. It’s a common behavior in JavaScript due to its dynamic and weakly typed nature.
Show More

Related Articles

Back to top button