Scribd
Upload
3 views

Variables

The document explains the concept of variables in JavaScript, detailing the use of var, let, and const keywords for declaring variables. It highlights the differences in scope and reassignment rules for each keyword, along with examples of primitive and non-primitive data types. Additionally, it clarifies the behavior of constant objects and arrays, emphasizing that while their references cannot be reassigned, their properties or elements can be modified.

Uploaded by

Maya Lee
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
3 views

Variables

The document explains the concept of variables in JavaScript, detailing the use of var, let, and const keywords for declaring variables. It highlights the differences in scope and reassignment rules for each keyword, along with examples of primitive and non-primitive data types. Additionally, it clarifies the behavior of constant objects and arrays, emphasizing that while their references cannot be reassigned, their properties or elements can be modified.

Uploaded by

Maya Lee
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 7

Variables

A variable is like a container that holds data that can be reused or


updated later in the program. In JavaScript, variables are declared
using the keywords var, let, or const.

1. var Keyword
The var keyword is used to declare a variable. It has a function-scoped
or globally-scoped behaviour.
var n = 5;

console.log(n);

var n = 20; // reassigning is allowed

console.log(n);

Output
5

20

JavaScript Let
The let keyword was introduced in ES6 (2015)

Variables declared with let have Block Scope

Variables declared with let must be Declared before use

Variables declared with let cannot be Redeclared in the same scope

The let keyword is introduced in ES6, has block scope and cannot be
re-declared in the same scope.
let n= 10;
n = 20; // Value can be updated

// let n = 15; //can not redeclare

console.log(n)

Output
20

JavaScript Const
The let keyword was introduced in ES6 (2015)

Variables declared with let have Block Scope

Variables declared with let must be Declared before use

Variables declared with let cannot be Redeclared in the same scope

const Keyword
The const keyword declares variables that cannot be reassigned. It’s
block-scoped as well.
const n = 100;

// n = 200; This will throw an error

console.log(n)

Output
100

Cannot be Reassigned
A variable defined with the const keyword cannot be reassigned:

Example
const PI = 3.141592653589793;
PI = 3.14; // This will give an error
PI = PI + 10; // This will also give an error

Must be Assigned
JavaScript const variables must be assigned a value when they are
declared:

Correct
const PI = 3.14159265359;

Incorrect
const PI;
PI = 3.14159265359;

When to use JavaScript const?


Always declare a variable with const when you know that the value
should not be changed.

Use const when you declare:

 A new Array
 A new Object
 A new Function
 A new RegExp

When to Use var, let, or const?


1. Always declare variables

2. Always use const if the value should not be changed

3. Always use const if the type should not be changed (Arrays and Objects)

4. Only use let if you can't use const

5. Only use var if you MUST support old browsers.


Constant Objects and Arrays
The keyword const is a little misleading.

It does not define a constant value. It defines a constant reference to a


value.

Because of this you can NOT:

 Reassign a constant value


 Reassign a constant array
 Reassign a constant object

But you CAN:

 Change the elements of constant array


 Change the properties of constant object

Constant Arrays
You can change the elements of a constant array:

Example
// You can create a constant array:
const cars = ["Saab", "Volvo", "BMW"];

// You can change an element:


cars[0] = "Toyota";

// You can add an element:


cars.push("Audi");

But you can NOT reassign the array:

Example
const cars = ["Saab", "Volvo", "BMW"];

cars = ["Toyota", "Volvo", "Audi"]; // ERROR


Constant Objects
You can change the properties of a constant object:

Example
// You can create a const object:
const car = {type:"Fiat", model:"500", color:"white"};

// You can change a property:


car.color = "red";

// You can add a property:


car.owner = "Johnson";

But you can NOT reassign the object:

Example
const car = {type:"Fiat", model:"500", color:"white"};

car = {type:"Volvo", model:"EX60", color:"red"}; // ERROR

Data Types
JavaScript supports various datatypes, which can be broadly
categorized into primitive and non-primitive types.

Primitive Datatypes
Primitive datatypes represent single values and are immutable.
1. Number: Represents numeric values (integers and decimals).
let n = 42;
let pi = 3.14;

2. String: Represents text enclosed in single or double quotes.


let s = "Hello, World!";

3. Boolean: Represents a logical value (true or false).


let bool= true;

4. Undefined: A variable that has been declared but not assigned a


value.
let notAssigned;

console.log(notAssigned);

Output
undefined

5. Null: Represents an intentional absence of any value.


let empty = null;

6. Symbol: Represents unique and immutable values, often used as


object keys.
let sym = Symbol('unique');

7. BigInt: Represents integers larger than


Number.MAX_SAFE_INTEGER.
let bigNumber = 123456789012345678901234567890n;

Non-Primitive Datatypes
Non-primitive types are objects and can store collections of data or
more complex entities.
1. Object: Represents key-value pairs.
let obj = {
name: "Amit",
age: 25
};

2. Array: Represents an ordered list of values.


let a = ["red", "green", "blue"];

3. Function: Represents reusable blocks of code.


function fun() {
console.log("GeeksforGeeks");
}

You might also like