Command of the Day: Sunday, December 21, 2025

git pull --squash

Fetches and merges remote updates into your current branch as a single squashed commit.
204 results

git rm <pathname>

Remove a file from the working directory and staging area.

git add <pathname>

Stage changes for the next commit

git branch -m <old_branchname> <new_branchname>

Rename a branch

git fetch

Download new commits, branches, and tags from the remote without changing your current files.

git init

Initialize a Git repository in the current directory

git rm --cached <pathname>

Remove files only from the git index

git commit -m <message>

Commit staged changes with a message

git restore .

Reverts all uncommitted changes in the current directory.

git pull

Fetch and merge remote changes

git clone <repo_url>

Clone a remote Git repository

git log

Show the commit history

git rm -f <pathname>

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

git commit -a

Commits any changes to tracked files in the current repository.

git diff --staged

Displays changes between the index and the last commit.

git reflog

Show a log of all Git references

git checkout -b <branchname>

Create a new branch and switch to it

git status -s

Display a short summary of the working directory's status

git branch -M <branchname>

Forcefully rename the current branch to <branchname>

git add -A

Add all new and changed files to the staging area

git branch <branchname>

Creates a new branch with the specified name.

git branch -d <branchname>

Delete a branch

git merge <branchname>

Merge the specified branch into the current branch, combining their histories.

git push

Upload local commits from your current branch to its configured remote branch.

git restore --staged <pathname>

Unstages the specified file/s

git diff HEAD

Show uncommitted changes

git restore --staged

Removes files from the staging area without altering their content in the working directory.

git pull <remote>

Fetches and merges remote changes into the current branch

git switch -c <branchname>

Creates a new branch and switches to it.

git branch

List all branches

git checkout <branchname>

Switch to a different branch

git switch <branchname>

Switch to the specified branch

git branch -v

List all branches including commit information

git show-ref --tags

Show each tag name and its commit hash in the local repository.

git diff <commitA> --name-only

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

git tag -a <version_number>

Creates an annotated Git tag named `<version_number>` pointing at the current commit.

git status

Show the status of the current repository

git log -<number>

Shows the last `<number>` commits in the log.

git log ..<branchname>

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

git clone <repo_url> <local_repo_name>

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

git count-objects -v

Prints counts and disk usage of loose and packed objects in the repository.

git push origin -d <branchname>

Delete a remote branch

git shortlog

Summarize git commit history by author.

git add -p

Interactively stage file changes

git push --force origin

Forcefully updates the `origin` remote with your local commits, overwriting any conflicting history.

git log --oneline --graph

Displays condensed repository history in a graphical format.

git stash save <message>

Stash changes with a custom message

git pull --squash

Fetches and merges remote updates into your current branch as a single squashed commit.

git diff HEAD~ HEAD

Shows changes between the last and current commit.

git rebase <branchname>

reapply commits from the current branch onto <branchname>

git push <remote> <branchname>

Upload local changes to a remote repository

git branch --no-merged

List local branches that haven’t been merged into the current branch.

git reset -- <pathname>

Unstage changes to a specific file or files

git stash pop

Applies the latest stashed changes to your working directory and removes that stash entry.

git diff --name-status

Lists changed files with codes indicating added, modified, or deleted status.

git branch -r

Lists all remote branches in the repository.

git remote add origin <repo_url>

Links a local repository to a remote one.

git log --oneline

View git commit history summarized

git log --all -- <filepath>

List complete commit history involving a specific file.

git diff HEAD HEAD^

Displays the differences between the two most recent commits.

git diff HEAD --stat

View a summary of changes from the last commit

git push -n

Show what would be pushed to the remote without actually pushing anything.

git log --follow -- <pathname>

Show the commit history for a single file, including before it was renamed or moved.

git show <commit>

Displays content changes of a specific commit

git commit --amend -m <message>

Change the commit message in the last commit

git prune

Removes unreachable objects

git stash push -m <message>

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

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

Display all commits across branches whose message contains a specified keyword.

git cherry-pick <commitA>

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

git checkout --<pathname>

Restore a file in the working directory to the version from the current branch or index.

git diff <branchname1>..<branchname2>

Show the difference between the contents of two branches

git branch -vv

List all branches with extra verbose information

git blame <pathname>

Annotate each line in `<pathname>` with the commit SHA, author, and timestamp of its last modification.

git branch -D <branchname>

Delete a branch forcefully

git stash drop

Delete the most recent stash entry

git reset <commit>

Reset the repository or a file to a specific commit

git branch --merged

List local branches fully merged into the current branch.

git checkout -

Switch back to the previously checked-out branch

git checkout HEAD <pathname>

Restore a file from the most recent commit

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

Clone a remote branch and switch to it

git stash

Temporarily saves changes that are not ready to be committed.

git notes add -m <note-text>

Add a note to the current commit without altering its history

git branch --contains <commit>

List local branches that include the specified commit.

git add .

Stage all changes in the current directory

git revert <commit>

Revert the changes introduced by a specific commit

git diff --stat

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

git reset HEAD <pathname>

Unstage changes for a specific file or files

git checkout -m <branchname>

Switch to a different branch and merge changes

git show <commit>:<pathname>

Display the contents of a file as it existed in a specified commit.

git checkout <commit> -- <pathname>

Restores a file or directory to its state from a specific commit.

git stash -u

Stash all changes including untracked files

git reset --hard HEAD~1

Undo last commit and discard changes.

git apply <pathname>

Apply a patch file’s changes directly to the working directory

git show-ref

List all references (branches and tags) and their commit hashes.

git describe --tags

Shows the nearest tag name reachable from the current commit.

git describe --always --dirty

Show a short identifier for the current commit, marking it 'dirty' if there are uncommitted changes.

git branch --unset-upstream

Remove the upstream tracking branch from the current branch.

git diff --name-only --diff-filter=U

List filenames of files with merge conflicts

git fetch --dry-run

Preview remote changes without actually downloading them.

git stash clear

Remove all stashed entries

git blame -w file.txt

Shows who last modified each line in file.txt, ignoring whitespace-only changes.

git diff @{push}

Compare your working directory to the commit recorded at your last push

git checkout --theirs <pathname>

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

git check-ignore -v <filepath>

Show why a specific file is ignored by `.gitignore` and which rule causes it.

git cat-file -p <commit>

Display a commit’s raw metadata and message in a readable form.

git worktree list

Show all worktrees linked to the current Git repository and their paths.

git bisect stop

Stops the bisect session and restores the repository to its original state.

git log -S <string>

Show commits that add or remove a specific string.

git filter-branch --subdirectory-filter <dir_folder>

Rewrite history so only the contents and history of a specific subdirectory remain in the repository.

git branch -a --contains <commit>

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

git bundle create <filename> <branchname>

Bundles the commit history of <branchname> into a single file named <filename>.

git notes show <commit>

Displays the note text attached to a specific commit.

git instaweb

Launches a temporary local web server and opens your Git repository in a browser for quick browsing.

git stash show -p

Shows the content of the last stash

git fsck

Checks the integrity and connectivity of objects in a Git repository.

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 bisect visualize

Show commits between the known good and bad revisions during a bisect session.

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

Cherry-pick several commits

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 show-ref --heads

Show commit hashes and reference names for all local branches.

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 config pull.rebase false

Configures Git to merge instead of rebasing when pulling changes.

git pull --rebase

Rebase the remote branch into the local one

git rebase <branchname> -i

Interactively rebase current branch onto `<branchname>`.

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 blame -C -C <filepath>

Annotate each line of a file with its last commit and author, tracking code copies across files.

git reset --merge

Abort a merge and reset files to the previous HEAD while preserving unrelated local changes.

git archive --remote=<repo> <commit>

Create a tar archive of a remote repository at a specific commit without cloning it.

git revert --no-commit <commit>

Prepare a revert of a specific commit without creating the commit automatically.

git remote get-url <remote>

Show the URL used by a given Git remote (like `origin`).

git log <commitA>..<commitB>

Show commit logs between commitA and commitB

git pull --no-commit

Fetch and merge remote changes without auto-committing the merge

git rev-list --all --objects

Lists all objects in all commits.

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

Lists commit hashes containing changes to a file.

git commit --no-verify

Commit changes without running pre-commit hooks

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 add --edit

Interactive staging of changes

git log --show-signature

Displays the git log with GPG signatures.

git add -i

Interactively add files to the git index

git blame -C

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

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 pull --rebase --autostash

Fetch and rebase remote updates onto your branch while auto-stashing local changes

git for-each-ref --sort=-committerdate

List all refs (branches, tags, etc.) ordered by most recent commit first.

git diff <commitA> --name-status

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

git name-rev <commit>

Shows a friendly reference name for a commit hash

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

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

git merge-base <branchname1> <branchname2>

Finds common ancestor(s) between two branches

git config --global pager.branch false

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

git cherry-pick -n <commitA>

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

git log --merge --oneline

Displays commits relevant to the current merge in a concise one-line format.

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 log -p

Show the commit log with its diff

git rev-parse

Resolve Git refs or paths into object names and directory info

git config --global push.default current

Set default tracking for new branches

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

Create an annotated tag with a specific version number and message

git push --tags

Pushes tags to the remote repository

git checkout --orphan <branchname>

Create a new orphan branch

git log --pretty=format:<format_string>

View the commit history in a custom format

git fetch --tags

Downloads all remote tags without merging any branch changes.

git am

Apply one or more patch files from email-style mbox input as local commits.

git bisect run <filepath>

Automatically runs a script at each step of `git bisect` to find the commit that introduced a bug.

git add --patch

Interactively select hunks of changes to stage for the next 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 cat-file -t <hash>

Display the type of a Git object specified by `<hash>`.

git config --global --list

List the global configuration settings for Git

git config --local --list

Show the local configuration settings for Git repository

git remote set-head origin --auto

Automatically sets the default branch of a remote repository

git reset --mixed HEAD~1

Undo last commit, keep changes staged

git fsck --lost-found

Recovers unreachable Git objects and places them in .git/lost-found for inspection

git diff --histogram

Show file changes using a histogram algorithm that groups similar changes more intelligently.

git stash apply

Apply the most recent stash to the working directory

git rebase --rebase-merges <branchname>

Rebase a branch incorporating merge commits.

git log -G<regexp>

Searches commit diffs for changes matching a regex pattern.

git maintenance start

Starts Git's background maintenance tasks to optimize the repository.

git bisect log

Displays the recorded steps of a Git bisect session

git fast-import

Stream bulk history data into a Git repository at high speed using a specialized import format.

git bundle list-heads <filepath>

Show the branch and tag heads stored in a Git bundle file.

Welcome to GitExamples!

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