In the previous section, we have seen that there are seven primitive data types in javascript, but there is another fundamental thing to know about types. Which is the fact that javascript has a feature called Dynamic Typing
. This article contains a lot of abstraction, so I would suggest you read slowly and carefully; skimming is not the best way for this article.
Dynamic Typing means that whenever we create a new variable, you do not have to manually define the data type of the value that it contains.
In many other programming languages, you actually have to define the datatype of a variable manually, but not in javascript. Instead, javascript automatically determines the data type of the value when it is stored into a variable. And this distinction between a value and variable is crucial in javascript because, in javascript, it's the value that has a type, not the variable.
So variables
simply store values
that has a type
. Many people don't know about this detail or just don't care, but this is how it works.
Another important application of Dynamic Typing is that later in our code, we can assign a new value with a different data type to the same variable without any issue.
let x = 20; // Varible x is intially is of type "number"
let x = 'Hello' // Now Variable x is a type of "string"
And this can be of course be very useful but it can also be the source of some difficulty to find bugs which means errors in our code.
Dynamic Typing in Action
typeof
is an operator used to find the type of value holding within a variable? Let's check it in action.
let hero = 'Naruto';
let myAge = 24;
let javascriptIsFun = true;
console.log(typeof hero); // string
console.log(typeof myAge); // number
console.log(typeof javascriptIsFun); // boolean
// Let's see what will happen if we change the type of data
// Dynamic Typing in action
javascriptIsFun = 'yes it is';
console.log(typeof javascriptIsFun); // string
In the above code example, initially, the variable javascriptIsFun
contains the value true
which is a boolean, so even the variable type is boolean. As javascript supports Dynamic Typing, we can change the value of the variable dynamically. This means that if the new value is of a different type, the type of the variable will also vary accordingly. This can also be seen when the value of javascriptIsFun
became a string yes it is
.

automatically
according to the value
it is holding.// Let's create a variable year
let year;
console.log(year); // undefined
console.log(typeof year); // undefined
// Let's assign a value to the variable year
// year is a defined variable, so no need to use let
// we use let to create a variable
year = 2021;
console.log(year); // 2021
console.log(typeof year); // number
In the above code example, initially, the variable year
was defined but doesn't hold any value; which means it is a defined variable with an undefined
value. As the value is undefined
the type of the variable is also undefined
I'm reiterating it again, undefined
is different from not defined
. In the above code example initially, the variable year
is defined but it has no value; so it is undefined
. Later as we assigned a value 2021
to the variable year
, it now has a value and type.
// Let's create a variable year
let year; // variable year is defined, but its value is undefined
console.log(year) // undefined
year = 2021; // variable year is defined and its value is 2021
console.log(year) // 2021
console.log(month) // variable month is not defined
// we can both create and assign a value to a variable in one line
let month = 'October'; // now we defined the variable month
console.log(month); // October
console.log(typeof month) // string