# Git for beginners: basics and essential commands

Git is an open-sourced **distributed version control system** (DVCS) to manage the collaborative or personal coding files effectivity. Git installed in the local system and manages from the local with the remote repository. In the server side, modern management system like Github, GitLab manages the coding files and extends to deploy those code in the server destination like CI/CD approaches.

## Why git is used

Git's main ideas include its distributed setup, where developers have the entire project history on their local machines, a repository as the main storage, commits as snapshots of the project, and branching and merging for working separately and then combining changes.

## How git works

![Git Workflow](https://miro.medium.com/v2/resize:fit:1400/1*NQ4244rrGsfMbslP3Fs6Ig.png align="center")

*Git workflow, from* [*https://madewithml.com/courses/mlops/git/*](https://madewithml.com/courses/mlops/git/)

To start working on git, you need to install and configure the git in your local system. To understand the git as how it works and the role of this .git folder. Refer this article: [**Inside Git: How It Works and the Role of the .git Folder**](https://somnathsahu.hashnode.dev/inside-git-how-it-works-and-the-role-of-the-git-folder)

Starting from `git init` to initialize the local repo → `git add .` to stages all the local changes → `git commit` to commit all the local changes with message → `git push` to store all the local changes to server → `git pull` to take other’s committed file in to the local system to keep the system at sync.

## Git basics and core terminologies

* **Repository (Repo):** A project's storage location, containing all files and their complete revision history.
    
* **Commit:** A snapshot of your files at a specific point in time. Each commit has a unique ID (SHA) and a description of changes.
    
* **Branch:** A parallel version of the repository. It allows you to develop features or fix bugs in isolation from the main codebase (usually called `main` or `master` or `dev`).
    
* **Staging Area (Index):** A "buffer" zone where you prepare changes before they are officially committed to the history.
    
* **HEAD:** A pointer to the current branch or specific commit you are currently working on.
    
* **Remote:** A version of your repository hosted on a server (e.g., GitHub, GitLab) that allows for collaboration.
    
* **Merge:** The process of combining changes from one branch into another.
    
* **Clone:** Creating a local copy of a remote repository on your computer.
    
* **Fork:** A personal copy of someone else's project on a remote server, used for contributing to open-source projects. 
    

## **Basic git workflow**

To manage changes effectively, Git follows a specific workflow involving three main trees: the **Working Directory**, the **Staging Area**, and the **Repository**. 

1. **Initialize/Clone:** Start a new repo with `git init` or copy an existing one with `git clone [URL]`.
    
2. **Modify:** Make changes to files in your **Working Directory**.
    
3. **Stage:** Use `git add [file]` to move changes to the **Staging Area**.
    
4. **Commit:** Use `git commit -m "message"` to permanently save staged changes to the **Repository** history.
    
5. **Push/Pull:** Share your work by sending commits to a remote repo using `git push`, or update your local repo with others' changes using `git pull`
    

## Common git commands

`git config --global` [`user.name`](http://user.name) `“[firstname lastname]”` : set a name that is identifiable for credit when review version history

`git config --global` [`user.email`](http://user.email) `“[valid-email]”` : set an email address that will be associated with each history marker

`git init` : initialize an existing directory as a Git repository

`git clone [url]` : retrieve an entire repository from a hosted location via URL

`git remote add [alias] [url]` : add a git URL as an alias

`git fetch [alias]` : fetch down all the branches from that Git remote

`git merge [alias]/[branch]` : merge a remote branch into your current branch to bring it up to date

`git push [alias] [branch]` : Transmit local branch commits to the remote repository branch

`git pull` : fetch and merge any commits from the tracking remote branch

`git status` : show modified files in working directory, staged for your next commit

`git add [file]` : add a file as it looks now to your next commit (stage)

`git reset [file]` : unstage a file while retaining the changes in working directory

`git diff` : difference between file about what is changed but not staged

`git diff --staged` : difference of what is staged but not yet committed

`git commit -m “[message]”` : commit your staged content as a new commit snapshot

`git branch` : list all the branches. a `*` will appear next to the currently active branch

`git branch [branch-name]` : create a new branch at the current commit

`git checkout` : switch to another branch and check it out into current working directory

`git merge [branch]` : merge the specified branch’s history into the current one

`git log` : show all commits in the current branch’s history

`git stash` : Save modified and staged changes

`git stash list` : list stack-order of stashed file changes

`git stash pop` : write working from top of stash stack

`git stash drop` : discard the changes from top of stash stack

`git rebase [branch]` : apply any commits of current branch ahead of specified one

`git reset --hard [commit]` : clear staging area, rewrite working tree from specified commit

`git log branchB..branchA` : show the commits on branchA that are not on branchB

`git log --follow [file]` : show the commits that changed file, even across renames

`git diff branchB...branchA` : show the diff of what is in branchA that is not in branchB

`git show [SHA]` : show any object in Git in human-readable format

`git rm [file]` : delete the file from project and stage the removal for commit

`git mv [existing-path] [new-path]` : change an existing file path and stage the move

`git am <patch_file>` : applies the specified patch to the current branch.

`git am --abort` : cancel the entire operation and revert your branch to its original state before you started the `am` command.