Let’s explore them one by one.😊

1. let

The let keyword was introduced in ES6(2015)

• Variables defined with let cannot be Redeclared.
• Variables defined with let must be Declared before use.

• Variables defined with let have Block Scope

➢ let cannot be Redeclared. Variables defined with let cannot be redeclared.

With var, we can be redeclared..

Initialization

2. var

• Variables declared with the var keyword can NOT have block scope.

• Variables declared inside a { } block can be accessed from outside the block.

➢ Redeclaring variables using var.

• Redeclaring a variable using the var keyword can impose problems.

• Redeclaring a variable inside a block will also redeclare the variable outside the block:

➢ Initialization

3. Const

• The const keyword was introduced in ES6 (2015)
• Variables defined with const cannot be Redeclared.
• Variables defined with const cannot be Reassigned.
• Variables defined with const have Block Scope.

➢ Cannot be reassigned.

• A const variable cannot be reassigned.

Initialization

Summarization

So I think now you get a better idea about Variable types in Javascript.😊🤞

They are

• Primitive values
• Reference Values

Let’s see what are they …… 😊🤷‍♂️

First, we take a look at what the primitive values are….🤞

Primitive values

There are six types of primitive values in javascript. Let’s see what they are ….

Number

Numbers represent numeric values, both integers and floating-point numbers.

String

Strings represent text and are enclosed in either single (‘’) or double (“”) quotes. They are used for storing and manipulating textual data.

Boolean

Booleans have only two possible values true and false. They are used to represent logical values and are essential for making decisions.

Undefined

Undefined is a special value that represents the absence of a value. It is often used as the default value of variables or function parameters that have not been assigned a value.

Null

null represents the intentional absence of any object value. It is often used when you want to indicate that a variable should have no value or that an object property is intentionally empty.

Symbol

Symbols are unique and immutable values introduced in ECMAScript 2015 (ES6). They are often used as property keys in objects to avoid naming conflicts.

Keep this mind 😊👀

Primitive values are fundamental values that are immutable, it means you know they cannot be altered once they are created.

Primitive types are stored directly in memory and have a fixed size.

When we assign a variable that stores a primitive value to another, the value stored in the variable is created and copied into the new variable.

Now let’s see what the reference values are…..😊👀

Reference Values

JavaScript provides three types of Reference values. They are as follows.

Array

Arrays are ordered collections of values, indexed by integers.

They are used for storing and manipulating lists of data.

Let’s see an example of arrays 🤔

let fruits = [“apple”, “banana”, “orange”];

console.log(fruits);

// output: [“apple”, “banana”, “orange”]

Object

They are collections of key-value pairs, where keys are strings, and values can be of any data type, including other objects.

They do not have a fixed size.

Objects can represent complex data structures and are used for modeling real-world entities.

Let’s see an example of Objects 🤔

let person = {

name: “John”,

age: 30

};

console.log(person);

// output: {name: “John”, age: 30}

The last reference value is functions.

Function

They are objects that can be invoked and passed around as arguments to other functions.

Functions are used for encapsulating reusable code and implementing logic in JavaScript programs.

Let’s see an example of Functions 🤔

let x = myFunction(4, 3);

function myFunction(a, b) {

// Function returns the product of a and b

return a * b;

}

You know that Unlike primitives, reference data types are mutable, meaning their contents can be changed after they are created.

Thus, variables that are reference values are accessed by reference.

So I think now you get a better understanding of the primitive and reference data types.😊🤞