There are majorly two types of languages.
- Statically typed language
- Dynamically typed languages
Statically typed language: Where each variable and expression type is already known at compile time. Once a variable is declared to be of a certain data type, it cannot hold values of other data types.
Example: C, C++, Java.
Dynamically typed languages: These languages can receive different data types over time.
The latest ECMAScript(ES6) standard defines the following data types: Out of which six data types are Primitive(predefined).
- Numbers: Represent both integer and floating-point numbers. Example: 5, 6.5, 7 etc.
- Boolean: Represent a logical entity and can have two values: true or false.
- Null: This type has only one value: null. It is left intentionally so that it shows something that does not exist.
- Undefined: A variable that has not been assigned a value is undefined.
- Symbol: Unlike other primitive data types, it does not have any literal form. It is a built-in object whose constructor returns a symbol-that is unique.
- bigint: The bigint type represents the whole numbers that are larger than 253-1. To form a bigint literal number, you append the letter n at the end of the number.
- The value stored in a variable can be changed during program execution.
- A variable is only a name given to a memory location, all the operations done on the variable effects that memory location.
var var_name; var x;
Notice in the above code sample, we didn’t assign any values to the variables. We are only saying they exist. If you were to look at the value of each variable in the above code sample, it would be undefined.
We can initialize the variables either at the time of declaration or also later when we want to use them.
// Declaring single variable var name; // Declaring multiple variables var name, title, num; // Initializing variables var name = "Harsh"; name = "Rakesh";
Below is an example for this:
// Creating variable to store a number var num = 5; // Store string in the variable num num = "GeeksforGeeks";
// Storing a mathematical expression var x = 5 + 10 + 1; console.log(x); // 16
After ES2015, we now have two new variable containers: let and const. Now we shall look at both of them one by one. The variable type Let shares lots of similarities with var but unlike var, it has scope constraints. To know more about them visit let vs var. Let’s make use of the let variable:
// let variable let x; // undefined let name = 'Mukul'; // Can also declare multiple values let a=1,b=2,c=3; // Assignment let a = 3; a = 4; // works same as var.
Const is another variable type assigned to data whose value cannot and will not change throughout the script.
// const variable const name = 'Mukul'; name = 'Mayank'; // will give Assignment to constant variable error.
- Global Scope – Scope outside the outermost function attached to the window.
- Local Scope – Inside the function being executed.
Let’s look at the code below. We have a global variable defined in the first line in the global scope. Then we have a local variable defined inside the function fun().
This is a global variable This is a local variable
When we execute the function fun(), the output shows that both global, and local variables, are accessible inside the function as we are able to console.log them. This shows that inside the function we have access to both global variables (declared outside the function) and local variables (declared inside the function). Let’s move the console.log statements outside the function and put them just after calling the function.
We are still able to see the value of the global variable, but for the local variable, console.log throws an error. This is because now the console.log statements are present in the global scope where they have access to global variables but cannot access the local variables.