Variables are the first building block you will be introduced to when learning most languages. Variables are values in your code that can represent different values each time the code runs. Here is an example of two variables in a script:

firstname = "Maaike";
x = 2;

And they can be assigned a new value while the code is running:

firstname = "Edward";
x = 7;

Without variables, a piece of code would do the exact same thing every single time it was run. Even though that could still be helpful in some cases, it can be made much more powerful by working with variables to allow our code to do something different every time we run it.

Declaring variables

The first time you create a variable, you declare it. And you need a special word for that: let, var, or const. We'll discuss the use of these three arguments shortly. The second time you call a variable, you only use the name of the existing variable to assign it a new value...

Now you know what variables are and why we need them in our code, it is time to look at the different types of values we can store in variables. Variables get a value assigned. And these values can be of different types. JavaScript is a loosely typed language. This means that JavaScript determines the type based on the value. The type does not need to be named explicitly. For example, if you declared a value of 5, JavaScript will automatically define it as a number type.

A distinction exists between primitive data types and other, more complex data types. In this chapter, we will cover the primitive type, which is a relatively simple data structure. Let's say for now that they just contain a value and have a type. JavaScript has seven primitives: String, Number, BigInt, Boolean, Symbol, undefined, and null. We'll discuss each of them in more detail below.

String

A string is used to store a text value. It is a sequence of characters. There...

We have seen the primitive data types. There are some built-in JavaScript methods that will help us deal with common problems related to primitives. Built-in methods are pieces of logic that can be used without having to write JavaScript logic yourself.

There are many of these built-in methods, and the ones you will be meeting in this chapter are just the first few you will encounter.

Working out the type of a variable

Especially with null and undefined, it can be hard to determine what kind of data type you are dealing with. Let's have a look at typeof. This returns the type of the variable. You can check the type of a variable by entering typeof, then either a space followed by the variable in question, or the variable in question in brackets:

testVariable = 1;
variableTypeTest1 = typeof testVariable;
variableTypeTest2 = typeof(testVariable);
console...

After seeing quite a few data types and some ways to convert them, it is time for the next major building block: operators. These come in handy whenever we want to work with the variables, modify them, perform calculations on them, and compare them. They are called operators because we use them to operate on our variables.

Arithmetic operators

Arithmetic operators can be used to perform operations with numbers. Most of these operations will feel very natural to you because they are the basic mathematics you will have come across earlier in life already.

Addition

Addition in JavaScript is very simple, we have seen it already. We use + for this operation:

let nr1 = 12;
let nr2 = 14;
let result1 = nr1 + nr2;

However, this operator can also come in very handy for concatenating strings. Note the added space after "Hello" to ensure the end result contains space characters:

let str1 = "Hello ";
let str2 = "addition";
let...

Miles-to-kilometers converter

Create a variable that contains a value in miles, convert it to kilometers, and log the value in kilometers in the following format:

The distance of 130 kms is equal to 209.2142 miles

For reference, 1 mile equals 1.60934 kilometers.

BMI calculator

Set values for height in inches and weight in pounds, then convert the values to centimeters and kilos, outputting the results to the console:

• 1 inch is equal to 2.54 cm
• 2.2046 pounds is equal to 1 kilo

Output the results. Then, calculate and log the BMI: this is equal to weight (in kilos) divided by squared height (in meters). Output the results to the console.

1. What data type is the following variable?

   const c = "5";
   

2. What data type is the following variable?

   const c = 91;
   

3. Which one is generally better, line 1 or line 2?

   let empty1 = undefined; //line 1
   let empty2 = null; //line 2
   

4. What is the console output for the following?

   let a = "Hello";
   a = "world";
   console.log(a);
   

5. What will be logged to the console?

   let a = "world";
   let b = `Hello ${a}!`;
   console.log(b);
   

6. What is the value of a?

   let a = "Hello";
   a = prompt("world");
   console.log(a);
   

7. What is the value of b output to the console?

   let a = 5;
   let b = 70;
   let c = "5";
   b++;
   console.log(b);
   

8. What is the value of result?

   let result = 3 + 4 * 2 / 8; 
   

9. What is the value of total and total2?

   let firstNum = 5;
   let secondNum ...

In this chapter, we dealt with the first two programming building blocks: variables and operators. Variables are special fields that have a name and contain values. We declare a variable by using one of the special variable-defining words: let, var, or const. Variables enable us to make our scripts dynamic, store values, access them later, and change them later. We discussed some primitive data types, including strings, numbers, Booleans, and Symbols, as well as more abstract types such as undefined and null. You learned how to determine the type of a variable using the typeof word. And you saw how you can convert the data type by using the built-in JavaScript methods Number(), String(), and Boolean().

Then we moved on and discussed operators. Operators enable us to work with our variables. They can be used to perform calculations, compare variables, and more. The operators we discussed included arithmetic operators, assignment operators, comparison operators, and logical...