# Understanding Variables and Data Types in JavaScript

When writing programs, we often need a place to **store information** so we can use it later. Whether it's a user's name, their age, or the status of a task, programs rely on stored values to work effectively. In JavaScript, this stored information lives inside **variables**.

To understand variables easily, it helps to imagine a simple real-life example.

## A Real-Life Analogy: Variables as Boxes

Think of a **variable as a labeled box** where you store information.

For example:

*   A box labeled **name** might store `"Rahul"`
    
*   A box labeled **age** might store `22`
    
*   A box labeled **isStudent** might store `true`
    

In JavaScript, it looks like this:

```javascript
let name = "Rahul";
let age = 22;
let isStudent = true;
```

Each variable stores a value that the program can use whenever needed.

# Declaring Variables in JavaScript

JavaScript provides three keywords to declare variables:

*   `var`
    
*   `let`
    
*   `const`
    

Each of them creates a variable, but they behave slightly differently.

## Using `var`

`var` is the older way of declaring variables in JavaScript.

Example:

```javascript
var city = "Delhi";
console.log(city);
```

Output:

```plaintext
Delhi
```

The value stored in a `var` variable can be changed later.

```javascript
var city = "Delhi";
city = "Mumbai";

console.log(city);
```

Output:

```plaintext
Mumbai
```

## Using `let`

`let` is the modern and commonly used way to declare variables whose values might change.

Example:

```javascript
let score = 50;
console.log(score);
```

Output:

```plaintext
50
```

You can update the value later.

```javascript
let score = 50;

score = 80;

console.log(score);
```

Output:

```plaintext
80
```

This makes `let` useful for values that may change during program execution.

## Using `const`

`const` is used when a variable **should not change** after it is created.

Example:

```javascript
const country = "India";

console.log(country);
```

Output:

```plaintext
India
```

If you try to change it later, JavaScript will show an error.

```javascript
const country = "India";

country = "USA";
```

Because `const` variables are meant to remain constant.

# Primitive Data Types in JavaScript

The values stored inside variables belong to **data types**. JavaScript has several primitive data types that represent basic values.

## String

A **string** represents text.

Examples include names, messages, or addresses.

```javascript
let name = "Amit";
let message = "Welcome to the website";

console.log(name);
console.log(message);
```

Strings are always written inside **quotes**.

## Number

A **number** represents numeric values.

Examples include age, price, or quantity.

```javascript
let age = 25;
let price = 199;

console.log(age);
console.log(price);
```

Numbers can be integers or decimals.

## Boolean

A **boolean** represents one of two values:

*   `true`
    
*   `false`
    

These are often used in decision-making.

```javascript
let isLoggedIn = true;
let hasPermission = false;

console.log(isLoggedIn);
console.log(hasPermission);
```

## Null

`null` represents **an intentional empty value**.

It means the variable exists but currently has no value assigned.

```javascript
let selectedProduct = null;
```

This might happen when a user hasn’t selected anything yet.

## Undefined

`undefined` means a variable has been declared but **no value has been assigned yet**.

Example:

```javascript
let username;

console.log(username);
```

Output:

```plaintext
undefined
```

Here the variable exists, but it doesn’t hold a value yet.

# Difference Between `var`, `let`, and `const`

These three keywords behave differently when it comes to updating values.

| Keyword | Can Reassign Value? | Modern Usage |
| --- | --- | --- |
| var | Yes | Older JavaScript |
| let | Yes | Commonly used |
| const | No | Used for fixed values |

Example:

```javascript
let age = 20;
age = 21;   // allowed

const birthYear = 2003;
birthYear = 2004; // error
```

Because `const` is meant for values that should remain unchanged.

# What Is Scope?

**Scope** refers to **where a variable can be used in a program**.

In simple terms, scope determines **which parts of the code can access a variable**.

Imagine you are working in a company.

*   Some documents are **private to your team**
    
*   Some documents are **accessible to the whole company**
    

Variables behave similarly in programming.

## Simple Scope Example

```javascript
let message = "Hello World";

function showMessage() {
  console.log(message);
}

showMessage();
```

In this example, the function can access the `message` variable because it is available in that scope.

But sometimes variables are limited to a specific block of code.

```javascript
{
  let city = "Delhi";
  console.log(city);
}
```

Inside the block, the variable works normally.

Outside the block, it cannot be accessed.

here is an another example of scope:

![](https://cdn.hashnode.com/uploads/covers/695680309f0bfb2529cfff0f/e4390b90-d09f-4b38-9546-66e5fe3cb90b.png align="center")