GIT Cheat Sheet

Git Cheat Sheet (All Commands)

Git is the open source distributed version control system that facilitates GitHub activities on your laptop or desktop. This cheat sheet summarizes commonly used Git command line instructions for quick reference.

INSTALL GIT

GitHub provides desktop clients that include a graphical user

interface for the most common repository actions and an automatically

updating command line edition of Git for advanced scenarios.

GitHub for Windows

https://windows.github.com

GitHub for Mac

https://mac.github.com

Git distributions for Linux and POSIX systems are available on the

official Git SCM web site.

Git for All Platforms

http://git-scm.com

Git Configuration

Git Config

Get and set configuration variables that control all facets of how Git looks and operates.

Set the name:

$ git config --global user.name "User Name"

Set the email:

$ git config --global user.email "rootuser@gmail.com"

Set the default editor

$ git config --global core.editor vim

check the setting

$ git config -list

Git Alias

Set up an alias for each command:

$ git config --global alias.co checkout

$ git config --global alias.br branch

$ git config --global alias.ci commit

$ git config --global alias.st status

Starting a Project

Git init

Crate a repo

$ git init <repo name>

$ git clone <remote url>

Local Changes

Git add

Add a file to staging (index) area

$ git add filename

Add all files of a repo to staging (index) area

$ git add *

Git Commit

Record or snapshot the file permanently in the version history with a message.

$ git commit -m "msg"

Track Changes

Git diff

Track the changes that have not been changed:

$ git diff

Track the changes that have staged but not committed:

$ git diff --staged

Track the changes after commiting a file

$ git diff HEAD

Track the changes between two commit

$ git diff <commit1-sha> <commit2-sha>

Git diff branches:

$ git diff <branch1> <branch2>

Git Status

Display the state of the working directory and the staging are.

$ git status

Git show

show objects:

$ git show <option> <obj>

Commit History

Git log

Display the most recent commits and the status of the head:

$ git log

Display the output as one commit per line:

$ git log --oneline

Display the files that have been modified:

$ git log -stat

Display the modified files with location:

$ git log -p

Git Blame

Display the modification on each line of a file:

$ git blame <file name>

Ignoring files

.gitingore

specify intentionally untracked files that Git should ignore.

Create .gitignore:

$ touch .gitignore

List the ignores files:

$ git ls-files -i --exclude-standard

Branching

Git branch

Create branch

$ git branch <branch name>

List Branch: 

$ git branch --list

Delete Branch: 

$ git branch -d<branch name>

Delete a remote Branch:

 $ git push origin -delete <branch name>

Rename Branch: 

$ git branch -m <old branch name><new branch name>

Git checkout

Switch between branches in a repository.

Switch to a particular branch: 

$ git checkout <branch name>

Create a new branch and switch to it:

 $ git checkout -b <branchname>

Checkout a Remote branch: 

$ git checkout <remotebranch>

Git stash

Switch branches without committing the current branch.

Stash current work:

$ git stash

Saving stashes with a message: 

$ git stash save "<Stashing Message>"

Check the stored stashes: 

$ git stash list

Re-apply the changes that you just stashed 

$ git stash apply

Track the stashes and their changes: 

$ git stash show

Re-apply the previous commits:

 $ git stash pop

Delete a most recent stash from the queue: 

$ git stash drop

Delete all the available stashes at once: 

$ git stash clear

Stash work on a separate branch: 

$ git stash branch <branch name>

Merging

Git merge

Merge the branches: 

$ git merge <branch name>

Merge the specified commit to currently active branch:

 $ git merge <commit>

Git rebase

Apply a sequence of commits from distinct branches into a final commit. 

$ git rebase <branch name>

Continue the rebasing process: 

$ git rebase –continue

Abort the rebasing process:

 $ git rebase --skip

Git interactive rebase

Allow various operations like edit, rewrite, reorder, and more on existing commits.

 $ git rebase -i

Remote

Git remote

Check the configuration of the remote server: 

$ git remote -v

Add a remote for the repository: 

$ git remote add <short name><remote URL>

Fetch the data from remote server 

$ git fetch <Remote>

Remove a remote connection from the repository:

 $ git remote rm <destination>

Rename remote server: 

$ git remote rename <old name><new name>

Show additional information about a particular remote:

 $ git remote show <remote>

Change remote: 

$ git remote set-url <remote name><newURL>

Git origin master

Push data to remote server:

 $ git push origin master

Pull data from remote server: 

$ git pull origin master

Pushing Updates

Git push

Transfer the commits from your local repository to a remote server.

Push data to remote server: 

$ git push origin master

Force push data: 

$ git push <remote><branch> -f

Delete a remote branch by push command: 

$ git push origin -delete edited

Pulling updates

Git pull

Pull the data from the server: 

$ git pull origin master

Pull a remote branch: 

$ git pull <remote branch URL>

Git fetch

Downloads branches and tags from one or more repositories.

Fetch the remote repository:

 $ git fetch< repository Url>

Fetch a specific branch:

 $ git fetch <branch URL><branch name>

Fetch all the branches simultaneously: 

$ git fetch –all

Synchronize the local repository:

 $ git fetch origin

Undo changes

Git revert

Undo the changes 

$ git revert

Revert a particular commit: 

$ git revert <commit-ish>

Git reset

Reset the changes: $ git reset –hard $ git reset –soft $ git reset --mixed

Removing files

Git rm

Remove the files from the working tree and from the index:

$ git rm <file Name>

Remove files from the Git But keep the files in your local repository: $ git rm --cached