git checkout -b <branchname1> <remote>/<branchname2>

Clone a remote branch and switch to it

git branch

List all branches

git push

Uploads local repository content to a remote repository

git pull <remote>

Fetches and merges remote changes into the current branch

git restore --staged

Move all files from the staging area back to the working directory

git branch <branchname>

Copy current branch as a new branch

git commit -a

Commits any changes to tracked files in the current repository.

git add -A

Add all new and changed files to the staging area

git diff <commitA> --name-only

Show the names of the changed files between the current commit and specific commit

git merge <branchname>

Merge a branch into the current branch

git branch -M <branchname>

Forcefully rename the current branch to <branchname>

git pull

Fetch and merge remote changes

git diff HEAD

Show uncommitted changes

git init

Initialize a Git repository in the current directory

git add <pathname>

Stage changes for the next commit

git fetch

Download remote changes

git status -s

Display a short summary of the working directory's status

git rm --cached <pathname>

Remove files only from the git index

git log -<number>

Display the last <number> commits in the repository

git checkout <branchname>

Switch to a different branch

git branch -v

List all branches including commit information

git commit -m <message>

Commit staged changes with a message

git config pull.rebase false

Configure git to always merge the changes when doing a pull

git diff --staged

Displays changes between the index and the last commit.

git restore .

Reverts all uncommitted changes in the current directory.

git reflog

Show a log of all Git references

git clone <repo_url>

Clone a remote Git repository

git checkout -b <branchname>

Create a new branch and switch to it

git log

Show the commit history

git rm <pathname>

Remove a file or a directory from the file system and from git's index

git branch -m <old_branchname> <new_branchname>

Rename a branch

git restore --staged <pathname>

Unstages the specified file/s

git rm -f <pathname>

Forcefully removes a file from the working directory and stages the deletion.

git branch -d <branchname>

Delete a branch

git status

Show the status of the current repository

git checkout --<pathname>

Discard changes in working directory.

git push -n

Performs a dry run of the `git push` operation

git log --oneline

View git commit history summarized

git diff HEAD~ HEAD

Shows changes between the last and current commit.

git push <remote> <branchname>

Upload local changes to a remote repository

git shortlog

Summarize git commit history by author.

git log --oneline --graph

Displays condensed repository history in a graphical format.

git checkout HEAD <pathname>

Restore a file from the most recent commit

git diff HEAD --stat

View a summary of changes from the last commit

git add -p

Interactively stage file changes

git stash pop

Restores the most recently stashed changes and deletes the stash

git log ..<branchname>

Lists the commits that are available in <branchname> but not in the current branch

git reset HEAD <pathname>

Unstage changes for a specific file or files

git clone <repo_url> <local_repo_name>

Creates a copy of a remote repository with a different name on your local machine

git diff HEAD HEAD^

Displays the differences between the two most recent commits.

git commit --amend -m <message>

Change the commit message in the last commit

git prune

Removes unreachable objects

git cherry-pick <commitA>

Apply the changes introduced by <commitA> on top of the current branch.

git diff <branchname1>..<branchname2>

Show the difference between the contents of two branches

git branch -vv

List all branches with extra verbose information

git log --all --grep=<searchterm>

Search commit messages in all branches

git branch -r

List remote branches

git branch -D <branchname>

Delete a branch forcefully

git rebase <branchname>

reapply commits from the current branch onto <branchname>

git push origin -d <branchname>

Delete a remote branch

git blame <pathname>

identify changes in a file by author and time.

git stash

Temporarily saves changes that are not ready to be committed.

git log --all -- <filepath>

List complete commit history involving a specific file.

git checkout -

Switch to the branch last checked out

git stash push -m <message>

Stashes the changes in the working directory with a custom message.

git diff --stat

View a summary of changes between your working directory and the staging area

git revert <commit>

Revert the changes introduced by a specific commit

git stash save <message>

Stash changes with a custom message

git show <commit>

Displays content changes of a specific commit

git reset <commit>

Reset the repository or a file to a specific commit

git remote add origin <repo_url>

Links a local repository to a remote one.

git reset -- <pathname>

Unstage changes to a specific file or files

git add .

Stage all changes in the current directory

git stash show -p

Shows the content of the last stash

git stash -u

Stash all changes including untracked files

git checkout -m <branchname>

Switch to a different branch and merge changes

git stash clear

Remove all stashed entries

git branch -a --contains <commit>

List all branches that contain commit <commit>, including remote branches.

git config --global user.name <username>

Set the global username for git

git remote set-url origin <url>

Changes the url of the `origin` remote repository.

git reset <commit> --merge

Undo commits without touching the working tree.

git mv -f <oldfilepath> <newfilepath>

Rename or move a file even if destination (i.e. <newfilepath>) exists

git cherry-pick <commitA>^..<commitB>

Cherry-pick several commits

git checkout --theirs <pathname>

Resolve a merge conflict by accepting the "incoming" branch changes

git log --author=<author>

List all commits from a given author

git checkout --ours <pathname>

During a merge request choose the version of a file that existed in the current branch

git pull --ff-only upstream <branchname>

Fast-forward merge from `upstream` into current branch.

git reset --hard

Discard all changes and revert to the commit specified

git grep -i "search pattern"

Search for patterns in the repository, ignoring the case of the search pattern

git merge <branchname1> <branchname2>

Merge a branch into a target branch

git diff @{upstream}

Show differences between local branch and upstream branch

git log --since=<date_or_time>

Show commits since a specific date/time.

git tag <version_number>

Create a new tag with the specified version number

git show --name-status <commit>

Displays the names and status of files modified in a specific commit.

git push -u <remote> <branchname>

Push commits to a remote repository

git ls-files

Lists all the files tracked by git

git rev-parse --symbolic-full-name --abbrev-ref HEAD

Obtain the name of the current branch

git bisect start

Start a binary search for a specific commit.

git pull --rebase

Rebase the remote branch into the local one

git rebase <branchname> -i

Interactively rebase current branch onto `<branchname>`.

git reset --hard HEAD~1

Undo last commit and discard changes.

git --no-pager diff

Displays `git diff` output without pagination.

git stash -k

Stashes changes in the working directory, but keeps the untracked files

git clean -fd

Remove untracked files and directories from your git repository

git rebase -i HEAD~<number>

Interactively rebase the last <number> commits.

git gc

Clean up unnecessary files and optimize the local repository

git remote prune origin

Remove stale remote-tracking branches.

git stash apply stash@{<number>}

Apply a specific stash to the working directory

git rebase -i --autosquash HEAD~n

Interactively rebase with autosquash for last n commits.

git reset --soft HEAD~1

Undo last commit, keep changes staged.

git log -p

Show the commit log with its diff

git config --global pager.branch false

Disables the use of a pager for the output of the `git branch` command globally.

git checkout --orphan <branchname>

Create a new orphan branch

git checkout -t <remote>/<branchname>

Create and switch to a new branch tracking a remote branch

git checkout -b <branchname> <commit>

Creates and switches to a new branch from a specific commit

git rev-list --all -- <pathname>

Lists commit hashes containing changes to a file.

git stash --keep-index

Stashes changes, keeping index intact

git config --global user.name <username> --replace-all

Sets the global username for git, replacing any existing username

git config --global push.default current

Set default tracking for new branches

git add --patch

Interactively select hunks of changes to stage for the next commit.

git cherry-pick -n <commitA>

Apply the changes in `<commitA>` without making a new commit.

git stash push -p -m <message>

Stash changes interactively with a custom commit message

git fetch --prune

Fetches new branches and removes deleted branches

git revert HEAD

Reverts the most recent commit

git remote set-head origin --auto

Automatically sets the default branch of a remote repository

git log --show-signature

Displays the git log with GPG signatures.

git blame -C

Display author's modifications per line in a file while copying or moving across files

git rev-list --all --objects

Lists all objects in all commits.

git blame -w

Displays who last modified each line of a file, ignoring whitespace.

git merge --no-ff <branchname>

Merge branch without fast-forwarding

git diff <commitA> --name-status

Show the file names and status changes between commitA and the current branch

git commit --no-verify

Commit changes without running pre-commit hooks

git push --tags

Pushes tags to the remote repository

git blame -L <start,end> <filepath>

Displays the author and revision details for specific lines in a file.

git add --edit

Interactive staging of changes

git log <commitA>..<commitB>

Show commit logs between commitA and commitB

git add -i

Interactively add files to the git index

git merge-base <branchname1> <branchname2>

Finds common ancestor(s) between two branches

git rebase --rebase-merges <branchname>

Rebase a branch incorporating merge commits.

git stash apply

Apply the most recent stash to the working directory

git reset --mixed HEAD~1

Undo last commit, keep changes staged

git config --local --list

Show the local configuration settings for Git repository

git config --global --list

List the global configuration settings for Git

git log --pretty=format:<format_string>

View the commit history in a custom format

git tag -a <version_number> -m <message>

Create an annotated tag with a specific version number and message

Sign in to enable bookmarking, reminders, progress-tracking and more...