git_commands.md

GitHub Flow

---

Configure tooling

Show current configuration

$ git config --list

Show repository configuration

$ git config --local --list

Show global configuration

$ git config --global --list

Show system configuration

$ git config --system --list

Set automatic command line coloring for Git for easy reviewing

$ git config --global color.ui auto

Set global editor for commit

$ git config --global core.editor vi

---

Create

Turn an existing directory into a git repository:

$ git init

Create a new local repository in a specific directory

$ git init <directory>

Clone (download) a repository that already exists on GitHub, including all of the files, branches, and commits:

$ git clone [url]

---

Local Changes

Changes in working directory

$ git status

Changes to tracked files

$ git diff

See changes/difference of a specific file

$ git diff <file>

Add all current changes

$ git add .

Add some changes

$ git add -p <file>

Commit all local changes in tracked files

$ git commit -a

Commit previously staged changes

$ git commit

Commit with message

$ git commit -m 'message here'

Commit skipping the staging area and adding message

$ git commit -am 'message here'

Commit to some previous date

$ git commit --date="`date --date='n day ago'`" -am "<Commit Message Here>"

Change last commit

$ git commit -a --amend

Amend with last commit but use the previous commit log message

$ git commit --amend --no-edit

Change Author date of last commit

$ git commit --amend --date="date"

Show list of all saved stashes

$ git stash list

Move uncommitted changes from current branch to some other branch

$ git stash
$ git checkout branch2
$ git stash pop

Restore stashed changes back to current branch

$ git stash apply

Restore particular stash back to current branch

$ git stash apply stash@{stash_number}

Remove the last set of stashed changes

$ git stash drop

---

Commit History

Show all commits, starting with newest

$ git log

Show all the commits in one line format

$ git log --oneline

Show all commits of a specific user

$ git log --author="username"

Show changes over time for a specific file

$ git log -p <file>

Display commits that are present only in remote/branch in right side

$ git log --oneline <origin/master>..<remote/master> --left-right

Who changed

$ git blame <file>

Show Reference log

$ git reflog show

Delete Reference log

$ git reflog delete

---

Branches & Tags

List all local branches

$ git branch

List local/remote branches

$ git branch -a

List all remote branches

$ git branch -r

Switch HEAD branch

$ git checkout <branch>

Checkout single file from different branch

$ git checkout <branch> -- <filename>

Create and switch new branch

$ git checkout -b <branch>

Create a new branch from an exiting branch and switch to new branch

$ git checkout -b <new_branch> <existing_branch>

Checkout and create a new branch from existing commit

$ git checkout <commit-hash> -b <new_branch_name>

Create a new branch based on your current HEAD

$ git branch <new-branch>

Create a new tracking branch based on a remote branch

$ git branch --track <new-branch> <remote-branch>

Delete a local branch

$ git branch -d <branch>

Rename current branch to new branch name

$ git branch -m <new_branch_name>

Force delete a local branch

_{You will lose unmerged changes!}

$ git branch -D <branch>

List all tags

$ git tag

List all tags with their messages (tag message or commit message if tag has no message)

$ git tag -n

---

Update & Publish

List all current configured remotes

$ git remote -v

Show information about a remote

$ git remote show <remote>

Add new remote repository, named <remote>

$ git remote add <remote> <url>

Rename a remote repository, from <remote> to <new_remote>

$ git remote rename <remote> <new_remote>

Remove a remote

$ git remote rm <remote>

_{Note git remote rm does not delete the remote repository from the server. It simply removes the remote and its references from your local repository.}

Download all changes from <remote>, but don't integrate into HEAD

$ git fetch <remote>

Updates your current local working branch with all new commits from the corresponding remote branch on GitHub:

$ git pull

_{git pull is a combination of git fetch and git merge}

Download changes and directly merge/integrate into HEAD

$ git remote pull <remote> <url>

Get all changes from HEAD to local repository

$ git pull origin master

Get all changes from HEAD to local repository without a merge

$ git pull --rebase <remote> <branch>

Publish local changes on a remote

$ git push remote <remote> <branch>

Delete a branch on the remote

$ git push <remote> --delete <branch> (since Git v1.7.0)

Publish your tags

$ git push --tags

---

Merge & Rebase

Merge branch into your current HEAD

$ git merge <branch>

List all branches that are already merged into master

git branch --merged master

Remove branches that have already been merged with master

$ git branch --merged master | grep -v '^\*' | xargs -n 1 git branch -d

Rebase your current HEAD onto <branch>

_{Don't rebase published commit!}

$ git rebase <branch>

Abort a rebase

$ git rebase --abort

Continue a rebase after resolving conflicts

$ git rebase --continue

---

Undo

_{CAUTION! Changing history can have nasty side effects. If you need to change commits that exist on GitHub (the remote), proceed with caution.}

Discard all local changes in your working directory

$ git reset --hard HEAD

Get all the files out of the staging area(i.e. undo the last git add)

$ git reset HEAD

Discard local changes in a specific file

$ git checkout HEAD <file>

Revert a commit (by producing a new commit)

$ git revert <commit>

Reset your HEAD pointer to a previous commit and discard all changes since then

$ git reset --hard <commit>

Reset your HEAD pointer to a remote branch current state.

$ git reset --hard <remote/branch> e.g., upstream/master, origin/my-feature

Reset your HEAD pointer to a previous commit and preserve all changes as unstaged changes

$ git reset <commit>

Reset your HEAD pointer to a previous commit and preserve uncommitted local changes

$ git reset --keep <commit>

Remove files that were accidentally committed before they were added to .gitignore

$ git rm -r --cached .
$ git add .
$ git commit -m "remove xyz file"