# Variables and Data Types in JavaScript: A Beginner's Guide

Think of a variable as a box. You write a label on it, put something inside, and refer to it by that label whenever you need it. That's what variables do in JavaScript. They hold information your program can use, change, or pass around.

Without variables, you'd have to repeat the same values everywhere. Want to show a user's name in three different places? You'd hard-code it three times. Change it once, and you've broken the other two. Variables solve that.

* * *

## Declaring Variables

JavaScript gives you three ways to create a variable: `var`, `let`, and `const`.

**var** is the original way, around since JavaScript's early days:

```javascript
var name = "Alice";
```

**let** was introduced later and is now the standard choice for variables whose values might change:

```javascript
let age = 25;
```

**const** is for values that won't change after you set them:

```javascript
const country = "India";
```

You'll mostly use `let` and `const` in modern code. `var` still works, but it has some quirky behavior that trips up beginners, so there's little reason to reach for it.

* * *

## Primitive Data Types

Every value you store has a type. JavaScript has five primitive types worth knowing as a beginner.

### String

A string is text. Wrap it in single or double quotes (both work):

```javascript
let firstName = "Riya";
let greeting = 'Hello, world!';
```

### Number

Numbers don't need quotes, whether whole or decimal:

```javascript
let age = 22;
let price = 199.99;
```

### Boolean

A boolean is either `true` or `false`. Nothing else:

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

These are useful when your code needs to make a decision. Is the user logged in? Show the dashboard. If not, show the login page.

### Null

`null` means "intentionally empty." You set a variable to null when you want to say it exists, but has no value right now:

```javascript
let selectedItem = null;
```

### Undefined

`undefined` means a variable was declared but never given a value:

```javascript
let score;
console.log(score); // undefined
```

The difference is subtle but real. `null` is an intentional absence. `undefined` is just... nothing was set yet.

* * *

## How Values Can Change

With `let`, you can update a variable after it's been set:

```javascript
let mood = "tired";
mood = "awake";
console.log(mood); // "awake"
```

With `const`, that's not allowed. Try it and JavaScript will throw an error:

```javascript
const city = "Mumbai";
city = "Delhi"; // Error: Assignment to constant variable.
```

This is actually useful. When you use `const`, you're making a small promise to yourself and anyone reading your code: this value won't change. That makes code easier to follow.

* * *

## A Quick Word on Scope

Scope is the question "where in my code can I actually use this variable?"

Imagine the box analogy again. If you put a box inside a room, you can use it inside that room. But you can't take it outside and expect it to still be there.

```javascript
function greetUser() {
    let message = "Hello!";
    console.log(message); // works fine
}

console.log(message); // Error: message is not defined
```

`message` was declared inside the function. Outside of it, JavaScript has no idea it exists.

This is called *block scope*, and it's how `let` and `const` work. `var` behaves differently here, which is one reason it's fallen out of favor. With `var`, values can "leak" outside the block they were declared in, and that causes bugs that are genuinely annoying to track down.

* * *

## Putting It Together

Here's a simple example using everything covered:

```javascript
const userName = "Arjun";
let userAge = 20;
let isPremiumMember = false;

console.log(userName);        // "Arjun"
console.log(userAge);         // 20
console.log(isPremiumMember); // false

userAge = 21; // birthday
console.log(userAge);         // 21
```

`userName` uses `const` because names don't change. `userAge` uses `let` because it will. `isPremiumMember` is a boolean, sitting at `false` until the user upgrades.

* * *

## Conclusion

*   Variables store values your code can use later
    
*   Use `const` by default; switch to `let` if the value needs to change; avoid `var`
    
*   Strings hold text, numbers hold numeric values, booleans hold true/false
    
*   `null` is an empty value you set on purpose; `undefined` means you just didn't set anything yet
    
*   Scope controls where a variable is visible in your code
    

These concepts show up constantly in JavaScript. Once they click, the rest of the language gets a lot easier to follow.