1. What variables are and why they are needed

2. How to declare variables using var, let and const

3. Primitive data types (string, number, boolean, null, undefined)

4. Basic difference between var, let, and const

5. What is scope (very beginner-friendly explanation)

When we begin learning JavaScript, the very first building block we encounter is variables.

Every program needs to store information — names, numbers, user inputs, or even true/false values.
In JavaScript, we store this information using variables.

Let’s understand this clearly and step by step

What is a Variable?

A variable is a named container used to store data in memory.

Imagine you are moving into a new house. You have a lot of items—books, clothes, and kitchenware. To keep things organized, you put them into boxes and put a label on each box.

Think of it like a labeled box:

1. The label is the variable name.

2. The box is the variable.

3. The content inside the box is the value.

4. JavaScript stores this inside memory while the program runs.

Without variables, we would not be able to store or reuse information in our programs.

How to Declare Variables in JavaScript

JavaScript provides three keywords to declare variables:

• var

• let

• const

Var

var is the older way of declaring variables.

var age = 25;
age = 30; // value can be changed

Key Points:

• Value can be reassigned.

• Variable can be redeclared.

• It does not follow block scope properly.

Because of scope-related issues, var is generally avoided in modern JavaScript.

Let

let is used when the value may change later.

let city = "Delhi";
city = "Bangalore"; // allowed 

Key Points:

• Value can be reassigned.

• Cannot be redeclared in the same scope.

• Follows block scope.

Most modern JavaScript code prefers let.

Const

const is used when the value should not change(like your birth date). Short for "constant."

Key Points:

• Cannot be reassigned.

• Cannot be redeclared.

• Follows block scope.

Best practice:

Use const by default. Use let only when the value needs to change.

Types of Data in JavaScript

In JavaScript, data types are broadly divided into two categories:

1. Primitive Data Types

2. Non-Primitive Data Types

JavaScript supports different kinds of data. In this article, we will focus on the most basic and commonly used types.

Primitive Data Types

Variables can store different kinds of values. These basic types are known as primitive data types.

1. String(Text)

Anything inside quotes ("" or '') is a String.

Real-world use: Storing a username, a street address, or a tweet.

Important Characteristics

• Strings are primitive and immutable — once created, their content cannot be changed.

• Methods like toUpperCase() return a new string instead of modifying the original.

• JavaScript does not have a separate character type; a single character is simply a string of length 1.

• Strings are indexable (read-only).

2. Number

The number type represents both integers and decimal values.

let age = 25;
let price = 99.99;

JavaScript does not differentiate between integers and floating-point numbers — both are simply numbers.

3. Boolean.

A boolean represents logical values: True or False (Think of it like a light switch-only two states).It is mostly used in decision-making.

let isLoggedIn = true;
let hasPermission = false;

console.log(isLoggedIn);   // true
console.log(hasPermission); // false

let age = 20;
let isAdult = age >= 18;

console.log(isAdult); // true

Boolean values are often the result of comparisons.

4. Undefined.

A variable has been declared, but no value has been assigned yet. When we declare a variable without initializing it, JavaScript automatically stores undefined in it.

( Imagine reserving a box but not putting anything inside it yet. The box exists but it is empty.)

let score;

console.log(score); // undefined

• Memory is created for score. Since no value is assigned, JavaScript sets it to. Undefined is real value.

5. Null.

The variable intentionally has no value.

Unlike undefined, null is explicitly assigned by the developer.

let selectedUser = null;

console.log(selectedUser); // null

console.log(typeof null); // "object"

• Memory is created for selectedUser but We deliberately store null inside it. It represents an intentional absence of value.

Understanding Scope

+----------------------------------+
|        Global Scope              |
|                                  |
|   +--------------------------+   |
|   |       Block Scope        |   |
|   |                          |   |
|   |   let / const → inside   |   |
|   +--------------------------+   |
|                                  |
|   var → accessible outside block |
+----------------------------------+

After declaring variables, an important concept to understand is scope. It determines where a variable can be accessed in the program.

Not every variable is accessible everywhere.

Global Scope

If a variable is declared outside any block or function, it becomes globally accessible.

greeting is declared outside the function. So it can be used anywhere in the program.

Block Scope

If a variable is declared inside { },it can only be used inside that block.

{
  let age = 25;
  console.log(age); // 25
}

console.log(age); // Error

age exists only inside the block Outside the block, it does not exist

Important Note

• let and const follow block scope.

• var does not properly respect block boundaries.

That’s why in modern JavaScript, we prefer let and const.

Conclusion

In this article, we explored one of the most fundamental concepts in JavaScript — variables.

We learned how to declare variables using let, const and var, and understood when to use each of them. We also explored primitive data types like string , number, boolean , undefined and null along with how they behave in memory.

Understanding variables is not just about syntax. It’s about knowing:

• How data is stored

• How values can change

• Where variables can be accessed (scope)

• And how JavaScript handles uninitialized or empty values

These concepts may seem simple at first, but they form the backbone of every JavaScript program — whether it's a small script or a large application.

When we begin learning JavaScript, the very first building block we encounter is variables.

Every program needs to store information — names, numbers, user inputs, or even true/false values.
In JavaScript, we store this information using variables.

Let’s understand this clearly and step by step.

What is a Variable?

A variable is a named container used to store data in memory.

Imagine you are moving into a new house. You have a lot of items—books, clothes, and kitchenware. To keep things organized, you put them into boxes and put a label on each box.

Think of it like a labeled box:

1. The label is the variable name.

2. The box is the variable.

3. The content inside the box is the value.

4. JavaScript stores this inside memory while the program runs.

Without variables, we would not be able to store or reuse information in our programs.

How to Declare Variables in JavaScript

JavaScript provides three keywords to declare variables:

• var

• let

• const

Var

var is the older way of declaring variables.

var age = 25;
age = 30; // value can be changed

Key Points:

• Value can be reassigned.

• Variable can be redeclared.

• It does not follow block scope properly.

Because of scope-related issues, var is generally avoided in modern JavaScript.

Let

let is used when the value may change later.

let city = "Delhi";
city = "Bangalore"; // allowed 

Key Points:

• Value can be reassigned.

• Cannot be redeclared in the same scope.

• Follows block scope.

Most modern JavaScript code prefers let.

Const

const is used when the value should not change(like your birth date). Short for "constant."

Key Points:

• Cannot be reassigned.

• Cannot be redeclared.

• Follows block scope.

Best practice:

Use const by default. Use let only when the value needs to change.

Types of Data in JavaScript

In JavaScript, data types are broadly divided into two categories:

1. Primitive Data Types

2. Non-Primitive Data Types

JavaScript supports different kinds of data. In this article, we will focus on the most basic and commonly used types.

Primitive Data Types

Variables can store different kinds of values. These basic types are known as primitive data types.

1. String(Text)

Anything inside quotes ("" or '') is a String.

Real-world use: Storing a username, a street address, or a tweet.

Important Characteristics

• Strings are primitive and immutable — once created, their content cannot be changed.

• Methods like toUpperCase() return a new string instead of modifying the original.

• JavaScript does not have a separate character type; a single character is simply a string of length 1.

• Strings are indexable (read-only).

• 

2. Number

The number type represents both integers and decimal values.

let age = 25;
let price = 99.99;

JavaScript does not differentiate between integers and floating-point numbers — both are simply numbers.

3. Boolean.

A boolean represents logical values: True or False (Think of it like a light switch-only two states).It is mostly used in decision-making.

let isLoggedIn = true;
let hasPermission = false;

console.log(isLoggedIn);   // true
console.log(hasPermission); // false

let age = 20;
let isAdult = age >= 18;

console.log(isAdult); // true

Boolean values are often the result of comparisons.

4. Undefined.

A variable has been declared, but no value has been assigned yet. When we declare a variable without initializing it, JavaScript automatically stores undefined in it.

( Imagine reserving a box but not putting anything inside it yet. The box exists but it is empty.)

let score;

console.log(score); // undefined

• Memory is created for score. Since no value is assigned, JavaScript sets it to. Undefined is real value.

5. Null.

The variable intentionally has no value.

Unlike undefined, null is explicitly assigned by the developer.

let selectedUser = null;

console.log(selectedUser); // null

console.log(typeof null); // "object"

• Memory is created for selectedUser but We deliberately store null inside it. It represents an intentional absence of value.

Understanding Scope

+----------------------------------+
|        Global Scope              |
|                                  |
|   +--------------------------+   |
|   |       Block Scope        |   |
|   |                          |   |
|   |   let / const → inside   |   |
|   +--------------------------+   |
|                                  |
|   var → accessible outside block |
+----------------------------------+

After declaring variables, an important concept to understand is scope. It determines where a variable can be accessed in the program.

Not every variable is accessible everywhere.

Global Scope

If a variable is declared outside any block or function, it becomes globally accessible.

greeting is declared outside the function. So it can be used anywhere in the program.

Block Scope

If a variable is declared inside { },it can only be used inside that block.

{
  let age = 25;
  console.log(age); // 25
}

console.log(age); // Error

age exists only inside the block Outside the block, it does not exist

Important Note

• let and const follow block scope.

• var does not properly respect block boundaries.

That’s why in modern JavaScript, we prefer let and const.

Conclusion

In this article, we explored one of the most fundamental concepts in JavaScript — variables.

We learned how to declare variables using let, const and var, and understood when to use each of them. We also explored primitive data types like string , number, boolean , undefined and null along with how they behave in memory.

Understanding variables is not just about syntax. It’s about knowing:

• How data is stored

• How values can change

• Where variables can be accessed (scope)

• And how JavaScript handles uninitialized or empty values

These concepts may seem simple at first, but they form the backbone of every JavaScript program — whether it's a small script or a large application.

Table Of Contents

1. What is Git

2. Why Git is Used

3. Git Basics and Core Terminologies

4. Common Git Commands

Have you ever edited a file Google Docs, saved it, and then wished you could go back to the previous version?

Or maybe you tried something new in your project and suddenly everything broke—and you didn’t remember what the “working” version looked like?

In tools like Google Docs we have Version History. You can see the different editing there like what time and which day the page is edited and the data also.

That is exactly the kind of problem Git solves for developers.

It remembers what your project looked like yesterday, last week, or even months ago. You can experiment freely, make mistakes, and always come back.

What is GIT?

Git is a “Distributed Version Control system” .

• Version Control means it keeps track of the changes we made to the code and tracking who made the changes.

• Distributed means it is distributed in the group like every developer has a full copy of project history in their computer.

Now let’s understand a bit about “GitHub”

Git works locally on your computer—it tracks changes, saves versions, and lets you experiment safely. But GitHub(online service) is a cloud-based platform where you can store your Git projects online. GitHub allows developers to collaborate, share code, review changes, and back up their work. It also makes teamwork easy by letting multiple people work on the same project from different places.

Why GIT is used?

• It helps to track every change in your project, so we always know what changed and when .

• It lets you undo mistakes safely. If something breaks, you can go back to a previous working version.

• It makes teamwork easy to manage . Multiple people can work on the same project without overwriting each other’s work.

Git is used because projects requirements will keep on changing. Code is written, edited, deleted, and improved every day. So system like GIT helps to manage.

Git Basics and Core Terminologies

Lets understand some of the Core Terminologies in GIT.

1. Repository(Repo) : A repository is a storage space where your project's files and their history are kept. It can be local (on your computer) or remote (on a server like GitHub).

2. Commit : A commit represents a snapshot of your repository — like a version of your project at a particular time . Each commit has:

   • A unique identifier

   • A commit message

   • A record of changes

3. Clone : Cloning is the process of creating a copy of a remote repository on your local machine.

4. Branch : Branch is like a seperate copy of the repository where we work on feature development, bug fixes etc. Branches allow you to work on different parts of a project without affecting the main branch.

5. Head : Head points to the current commit you are working on.

6. Working Directory: The directory that contains all the files that are tracked by Git.

7. Staging Area (Index): A place where you can see changes before committing them.

8. Repository (HEAD): The Git repository is the place where the files are stored. Git Repository has a directory structure

The diagram below shows how your files move from your computer to Git’s history.

GIT Basic Commands

1. git init : Creates a new .git folder in your current directory. This turns any folder into a Git repository

Below I have attached screenshots of how to create a new repository and clone it and then Initialize the empty repository.

2. git clone : git clone is the command used to download a copy of the repository on to the local machine. I have shown above how to create a repo and then cloning the empty repository. Likewise you can clone any repository on the internet onto your local machine. This will create an exact copy of the existing Git repository with a complete history

3. git status : This command is used to display the state of the working directory and the staging area. This shows which files are being tracked by git.

4. git add : This command we use in the staging area. In this stage you can select the files we would like to commit. In the below diagram I have used “git add .” means to stage the changed files to commit.

5. git commit : Commit command is used to save the files in the staging area with the message , all saved history can be found with the given message name.

6. git push: Push command is used to add the commits from local repository to the remote repository. Once pushed others will be able to see those changes in the GitHub.

7. git pull : Pull command is used to get the changes which are present in the remote repo, It helps to have all the latest code from remote repo on to your local repo.

8. git log : This command is used to view the history of the commits in the local repo.

9. git branch : A branch creates a separate workspace from the main repository so you can work safely.
   It is a copy of the current code where you can make design changes, fix bugs, or add new features without affecting the main branch.
   Once your work is complete and tested, you can merge it back into the main branch.

In the below screenshot I have created a new branch and checked out into that new branch. You can find out in the bottom left .

you can see a complete Git flow in action — a file is staged, committed with a message, pushed to GitHub, and finally a new branch is created for future work.

This is how you use Git in projects every day.