💡
To check if Git is installed on a local machine, type the command git --version in the terminal.
## **What is GitHub?**
Github is a product that is a cloud based hosting service for Git repositories. GitHub is not Git, it just provides hosting but for your codebase. There are other hosting platforms like GitLab and Bitbucket.
## Git Basics and Core Terminologies
Before we take a dive into Git commands, lets understand some important terminologies so that we don’t scratch our heads later.
1. **Repository or Repo**
It is a directory that contains your project files and all the track records of your changes. It includes a hidden `.git` folder that stores all version control information.
* **Local Repository**: The project version on your local machine
* **Remote Repository**: The project version hosted on a server like GitHub
![](https://cdn.hashnode.com/res/hashnode/image/upload/v1769705277909/77957be1-b168-4463-ae66-d388c5de271e.png align="left")
2. **Working Directory**
The folder on your local machine where you actively edit your files. It contains the current state of your project that you can track and edit.
3. **Index or Staging Area**
It is a platform between your machine i.e. the working directory and the repository. They will hold the file before you commit them, allowing you to choose the the files and the changes you want to commit.
4. **Commit**
This is the snapshot of your project. The commit holds a unique ID called `hash`**,** author information, a commit message to describe the changes, timestamp, and reference to your previous commit. One commit at a time builds your project.
5. **Branch**
It is an independent path of development. Git branch is similar to a Tree branch, like a tree trunk the default branch is called `main`. You create new brach to work on a new feature or bugs without affecting the stable codebase.
6. **HEAD**
It is a pointer that indicates your current position in the repository. When you switch branches, HEAD moves to point to that branch.
7. **Merge**
The process to combine one branch to another is called merging.
8. **Clone**
As the name signifies, it makes a copy of a remote repository on the local machine.
9. **Pull**
It helps to fetch all the changes made by other on the remote repository and update the local repository with the changes.
10. **Push**
It is a process to commit your changes to the remote repository, making the changes available to others
### Git's Three-Stage Architecture
**Workflow:**
* Edit files in your working directory
* Select the changes to commit by adding them to staging area
* Commit the changes to your local repository
* Share your changes with others by committing the changes to remote repository
![](https://cdn.hashnode.com/res/hashnode/image/upload/v1769705938565/6fcee213-643b-4066-8a25-f16cfe38337b.png align="center")
## Git Commands
Here comes the better part, the Git commands. Lets dive into them one by one.
1. **Configuration Commands**
Before you start using Git, you have to configure your identity.
```bash
#Set your name
git config --global user.name "your_name"
#Set your email
git config --global user.email "your.email@example.com"
#Check your configuration
git config --list
#Set default branch name to 'main'
git config --global init.defaultBranch main
```
2. **Creating and Cloning Repositories**
`git init`: To initialise git repository. `.git` subdirectory contains all the repository metadata.
```bash
#Create a new directory and initialize Git
mkdir new-project
cd new-project
git init
```
`git clone`: Copy an existing remote repository
```bash
#Clone a remote repository
git clone https://github.com/username/repository.git
#Clone into a specific folder
git clone https://github.com/username/repository.git my-folder
```
3. **Checking Status and Changes**
`git status`: Check the state of your working directory, the files that were modified, files staged for commits, and the untracked files.
```bash
#Check status
git status
```
`git diff`: Get detailed view of change logs
```bash
#Check unstaged changes
git diff
#Check staged changes
git diff --staged
#Compare two branches
git diff branch1..branch2
```
4. **Adding and Committing Changes**
`git add`: Stage files for commit
```bash
#add specific file
git add filename.txt
#add multiple files
git add file1.txt file2.txt
#add all changed files
git add .
```
`git commit`: Save staged changes to repository
```bash
#Commit with inline message
git commit -m "Add user authentication feature"
#Commit with detailed message (opens editor)
git commit
```
5. **Track History**
`git log`: View commit history
```bash
#Standard log
git log
#Condensed one-line format
git log --oneline
#Show last 5 commits
git log -5
#Show commits with file changes
git log --stat
#Graphical representation
git log --oneline --graph --all
#Search commits
git log --grep="bug fix"
```
6. **Branch management**
`git branch`: List, create, or delete branches
```bash
#List all branches
git branch
#Create a new branch
git branch new-feature
#Delete a branch
git branch -d added-feature
#Force delete (even if not merged)
git branch -D added-feature
#Rename current branch
git branch -m new-branch-name
```
`git checkout`: Switch branches or restore files
```bash
#Switch to existing branch
git checkout new-feature
#Create and switch to new branch
git checkout -b new-feature
#Restore a file to last committed state
git checkout -- filename.txt
```
7. **Merging Changes**
`git merge`: Combine branches
```bash
#switch to the branch you want to merge into
git checkout main
#then merge the feature branch
git merge new-feature
```
8. **Repository Commands**
`git remote`: Manage remote repositories
```bash
#List remote repositories
git remote -v
#Add a remote
git remote add origin https://github.com/username/repo.git
#Remove a remote
git remote remove origin
#Rename a remote
git remote rename origin upstream
```
`git fetch`: Download changes without merging
```bash
#Fetch from default remote
git fetch
#Fetch from specific remote
git fetch origin
```
`git pull`: Fetch and merge changes
```bash
#Pull from current branch remote
git pull
#Pull from specific branch
git pull origin main
```
`git push`: Upload local commits to remote
```bash
#Push to remote repository
git push origin main
#Push and set upstream
git push -u origin main
#Push all branches
git push --all
#Force push (use with caution!)
git push --force
```
`git stash`: Temporarily save changes
```bash
#Stash current changes
git stash
#List stashes
git stash list
#Apply most recent stash
git stash apply
#Apply and remove stash
git stash pop
#Stash with description
git stash save "Working on feature"
```
9. **Undo Changes (or Life Saviour)**
`git restore`: Discard changes
```bash
#Discard changes in working directory
git restore filename.txt
#Unstage a file
git restore --staged filename.txt
```
`git revert`: Create a new commit that undoes changes
```bash
#Revert the last commit
git revert HEAD
#Revert a specific commit
git revert commit-ID
```
### Best Practice for Git Newbies
* **Commit Often**: Make small changes frequently instead of huge changes. This helps to keep track and it is easy to revert changes.
* **Write Meaningful Commit Messages**: It is easy to track the changes introduced when you or the collaborators visit the codebase.
* **Pull Before Push**: Always pull the latest changes before pushing to avoid conflicts.
* **Use Branches**: Commit new features in a branch and not directly in `main`.
* **Review Before Committing**: Use `git diff` and `git status` to review changes before staging.
* **Don't Commit Sensitive Data**: Never commit passwords, API keys, or personal information.
* **Use** `.gitignore`: Create a `.gitignore` file to exclude files you don't want public to access (like `node_modules/`, `.env`, etc.)
Example:
```plaintext
#Dependencies
node_modules/
#Environment variables
.env
#OS files
.DS_Store
Thumbs.db
#IDE files
.vscode/
```
## The Ultimate Cheat Sheet
```plaintext
#Setup
git config --global user.name "Name"
git config --global user.email "email@example.com"
#Creating repositories
git init
git clone