Start learning free

LESSON 10 OF 410 · VARIABLES

Data Types in JavaScript

Lesson Read the full explanation

TL ; DR:

In JavaScript, not all data is treated the same. There are different data types, such as:

  • number - represents numbers like 3 and 3.14

  • string - represents a string (sequence of characters) like "John Doe"

  • boolean - represents data that can have one of two values: true or false

  • null - represents a null value, or no value at all


Full lesson:

We've talked about data and variables, which are containers to store that data. But not all data is treated the same.

For example, JavaScript distinguishes between numbers, such as 12, and strings, such as "12" or "dog", which are collections of characters.

The most basic and used data types in JavaScript are:

  • number - represents integer numbers like 3 and -7 and floating point numbers like 3.14
  • string - represents a string (sequence of characters) like "John Doe" or 'dog'
  • boolean - represents a Boolean, data that can have one of two values: True or False
  • None - represents a null value, or no value at all

typeof operator

JavaScript knows what type everything is. We can ask JavaScript what type something is by using the typeof operator:

let x = 1;
console.log(typeof x); // Output: number

let y = 3.14;
console.log(typeof y); // Output: number

console.log(typeof "butter"); // Output: string

let z = true;
console.log(typeof z); // Output: boolean

Choosing what operation to perform:

One instruction can have several distinct meanings depending on the data types it's working with.

For example, suppose you see this line of code somewhere in a program:

console.log(a + b);

Can you tell for sure what it does without knowing anything about the variables a and b?

It might add two numbers, if a and b are both numbers:

let a = 10, b = -5;

console.log(a + b); // Output: 5

But it also might concatenate two strings, if a and b are both strings:

let a = "Hello ", b = "world!";

console.log(a + b); // Output: Hello world!

Of course, addition and string concatenation are two completely different operations and JavaScript needs to figure out which one to do.

And this is exactly why JavaScript assesses the data type of every value you use in your program. In order to be able to make these decisions when needed.

In our example, when it reads a + b, JavaScript checks the data type of a and b. If both are string, it performs string concatenation. If both are numbers, it performs addition.

Invalid operations:

Asessing data types is also helpful for JavaScript to make sure that what you do with the data actually makes sense.

For example, computers can perform mathematical operations on numbers, but not on strings. Of course, nobody can stop you from writing a program like this:

let a = "peanut";
let b = "butter";

console.log(a * b); // Output: NaN

But when you try to run this program, it will output NaN.

This is the way of JavaScript telling you: "Hey, I'm a little confused. How do you multiply two strings? I've never heard of that."

Some languages like Python wouldn't even let this code run, but throw a TypeError: can't multiply sequence by non-int of type 'str'. JavaScript is more permissive, which is not necessary a good thing.

As a programmer, I'd rather be told when I made a mistake early on so I can fix it, instead of running into problems later on and not knowing what the root of those problems is.

Assignment
Follow the Coding Tutorial and let's practice with data types!

Hint
Look at the examples above if you get stuck.

STEP 1 OF 4
    Ctrl + Enter to check

    JAVASCRIPT · VARIABLES

    Data Types in JavaScript, explained

    Introduction

    In this lesson, we will explore the different data types in JavaScript. Understanding data types is crucial because it helps us write more efficient and error-free code. Data types define the kind of data a variable can hold, and knowing them allows us to perform appropriate operations on the data.

    Data types are fundamental in programming and are used in various scenarios, such as mathematical calculations, string manipulations, and logical operations. By mastering data types, you can avoid common pitfalls and write more robust programs.

    Understanding the Basics

    Before diving into the main concepts, let's understand the basic data types in JavaScript:

    • number: Represents both integer and floating-point numbers. Examples: 3, 3.14.
    • string: Represents a sequence of characters. Examples: "John Doe", 'dog'.
    • boolean: Represents a logical entity and can have one of two values: true or false.
    • null: Represents the intentional absence of any object value.

    Understanding these basics is essential before moving on to more complex aspects of data types.

    Main Concepts

    Let's delve deeper into the key concepts and techniques related to data types in JavaScript:

    Using the typeof Operator

    The typeof operator is used to determine the type of a variable. Here are some examples:

    let x = 1;
console.log(typeof x); // Output: number

let y = 3.14;
console.log(typeof y); // Output: number

console.log(typeof "butter"); // Output: string

let z = true;
console.log(typeof z); // Output: boolean

    The typeof operator helps us understand the type of data we are working with, which is crucial for performing the correct operations.

    Choosing the Right Operation

    One instruction can have different meanings depending on the data types involved. For example:

    console.log(a + b);

    If a and b are numbers, the operation will add them:

    let a = 10, b = -5;
console.log(a + b); // Output: 5

    If a and b are strings, the operation will concatenate them:

    let a = "Hello ", b = "world!";
console.log(a + b); // Output: Hello world!

    JavaScript determines the operation to perform based on the data types of the variables involved.

    Examples and Use Cases

    Let's look at some examples to see how data types are used in various contexts:

    Example 1: Mathematical Operations

    let num1 = 5;
let num2 = 10;
let sum = num1 + num2;
console.log(sum); // Output: 15

    In this example, we perform an addition operation on two numbers.

    Example 2: String Concatenation

    let firstName = "John";
let lastName = "Doe";
let fullName = firstName + " " + lastName;
console.log(fullName); // Output: John Doe

    Here, we concatenate two strings to form a full name.

    Example 3: Boolean Logic

    let isAdult = true;
if (isAdult) {
    console.log("You are an adult.");
} else {
    console.log("You are not an adult.");
}

    In this example, we use a boolean value to determine if a person is an adult.

    Common Pitfalls and Best Practices

    When working with data types, it's important to avoid common mistakes and follow best practices:

    • Avoid mixing data types in operations. For example, adding a number and a string can lead to unexpected results.
    • Use the typeof operator to check the data type before performing operations.
    • Be mindful of null and undefined values, as they can cause errors if not handled properly.

    Advanced Techniques

    Once you are comfortable with the basics, you can explore advanced techniques related to data types:

    Type Coercion

    JavaScript can automatically convert data from one type to another. This is known as type coercion. For example:

    let result = "5" - 2;
console.log(result); // Output: 3

    In this example, JavaScript converts the string "5" to a number before performing the subtraction.

    Strict Equality

    Use strict equality (===) to avoid type coercion and ensure that both the value and type are the same:

    console.log(5 === "5"); // Output: false

    Code Implementation

    Here are some well-commented code snippets demonstrating the correct use of data types:

    // Example of using typeof operator
let age = 25;
console.log(typeof age); // Output: number

// Example of string concatenation
let greeting = "Hello, " + "world!";
console.log(greeting); // Output: Hello, world!

// Example of boolean logic
let isLoggedIn = false;
if (isLoggedIn) {
    console.log("Welcome back!");
} else {
    console.log("Please log in.");
}

    Debugging and Testing

    Debugging and testing are crucial for ensuring your code works as expected:

    • Use console.log() to print variable values and check their types.
    • Write test cases to verify the behavior of your functions with different data types.

    Example of a test case:

    function add(a, b) {
    return a + b;
}

// Test cases
console.log(add(2, 3)); // Output: 5
console.log(add("Hello, ", "world!")); // Output: Hello, world!

    Thinking and Problem-Solving Tips

    Here are some strategies for approaching problems related to data types:

    • Break down complex problems into smaller, manageable parts.
    • Use pseudocode to outline your logic before writing actual code.
    • Practice with coding exercises and projects to reinforce your understanding.

    Conclusion

    In this lesson, we covered the fundamental data types in JavaScript, their significance, and how to use them effectively. Mastering data types is essential for writing efficient and error-free code. Keep practicing and exploring further applications to deepen your understanding.

    Additional Resources

    Here are some additional resources for further reading and practice:

    Keep going with JavaScriptAbout 340 step-by-step lessons, from your first line of code to coding interviews. Free to start.
    Start learning free