High-Frequency Git Operations for Everyday Development

Here are some of the most frequent Git operations you may need in day-to-day development.

Connect Your Local Folder to a GitHub Repository

Scenario

You have an existing local folder with files and want to connect it to an already existing GitHub repository.

Steps

Initialize Git in your folder:

git init

Add your GitHub repository (replace URL with your repo):

git remote add origin https://github.com/username/repo.git

Fetch remote history:

git fetch origin

Merge remote and local files, allowing unrelated histories (change main to your repo's default branch if necessary):

git pull origin main --allow-unrelated-histories

If you see an error like:

The following untracked working tree files would be overwritten by merge...

We recommend:

# 1. Move local conflicting files to a temporary directory
# For example, back them up to a non-conflicting `backup` folder in the current directory
mkdir backup
mv conflicting-file-1 conflicting-file-2 backup/

# 2. Try pulling the remote repository content again
git pull origin main --allow-unrelated-histories

# 3. Manually merge the backed up files into the pulled files

Commit after resolving all conflicts:

git add .
git commit -m "Merge local files with remote repository"

Push to the remote repository (if needed):

git push --set-upstream origin main

The --set-upstream origin main option is only needed for the first push; you don't need it afterward.

List What Files git add . Would Stage

git status --short

Example Output:

M file1.txt       # modified file
?? newfile.txt     # untracked file

Breakdown:

• M = Modified (but not staged)
• ?? = Untracked (new files)

Remove Previously Committed Files Now in .gitignore

Scenario

You added rules to .gitignore but some files were already committed.

Steps

Stage removal of all currently tracked files (but not delete locally):

git rm -r --cached .

Add everything back to the repo ("add" skips gitignored files):

git add .

Commit the change:

git commit -m "Remove ignored files from the repository"

At this point, the files are only removed from the repository from this commit onward (they'll still exist in older commits/history). If you want them removed from previous commits as well, consider squashing multiple commits into a single commit, as explained below.

List Files Added, Removed, or Changed Relative to Another Commit

Run git status and ensure you have no unstaged changes or staged but uncommitted changes. Then, to compare the current state (HEAD) against commit abcdef1:

git diff --name-status --no-renames abcdef1

Output looks like:

A  src/new_file.py
D  src/old_file.py
M  src/changed_file.py

• Added (A): File is present in HEAD but not in abcdef1.
• Deleted (D): File is present in abcdef1, but not in HEAD.
• Modified (M): File exists in both, but contents changed.

Squash Multiple Commits into a Single Commit

Scenario

You have made several small commits (some of which may be faulty or embarassing) and want to clean up history by squashing them into one.

Steps

Review commit history:

git log

Decide how many previous commits you want to squash.

Start an interactive rebase, e.g. with the last 3 commits:

git rebase -i HEAD~3

In the opened editor:

• Leave pick for the first commit.
• For the others, change pick to squash (or just s).
• Save and close.

You will then enter a second editor session. Edit the combined commit message. Save and close.

Force-push the branch to rewrite history on GitHub:

git push --force

Note

• Use squashing carefully if collaborating, as force push overwrites history.

List Branches

List local branches:

git branch

List remote branches:

git branch -r

List local and remote branches:

git branch -a

List Commits in Branches

To list commits in the branch feature:

git log feature

Get Files and Folders from Another Branch or Commit

Copy files and folders from the tip of branch feature into your current working directory:

git checkout feature -- path/to/file path/to/folder

Copy files and folders from commit abcdef1 into your current working directory:

git checkout abcdef1 -- path/to/file path/to/folder

Print a file from the tip of branch feature to STDOUT:

git show feature:path/to/file

Print a file from commit abcdef1 to STDOUT:

git show abcdef1:path/to/file

Push a New Branch in Your Local Repo to the upstream Remote (not your own origin)

Checkout the new branch:

git checkout -b my-feature

Add and commit files as usual, for example:

git add .
git commit -m "Describe your changes"

Use the following command to push:

git push upstream my-feature

Delete a Local Branch

git branch -d branch_name

This will refuse if the branch contains undeleted/unmerged changes.

Overwriting Branch History to Match Upstream

Fetch the latest changes:

git fetch upstream

Make backups of your files outside of the repository. See "Get Files and Folders from Another Branch or Commit" for how.

Reset your branch to upstream. WARNING: This will override your branch. Local changes/commits not in upstream will be lost.

git checkout main
git reset --hard upstream/main

Push the changes to your fork. This will overwrite your fork's main branch on GitHub/etc to match upstream, removing commit B:

git push -f origin main

Create a New Commit Merging with Another Commit on Another Branch

Assumptions:

• You are on the latest commit C on branch B.
• You want to merge in the content from commit C' on branch B' and create a new commit CC on B.

Fetch the latest info:

git fetch --all

Ensure you're on branch B:

git checkout B  

Manually assess the differences between C and C' by listing files added, removed, or changed relative to C'.

Scenario 1: CC should be a complete clone of C

Here, you want to do a merge, but content stays as in C; only history merges. CC is a merge commit, with parents C and C', tree is identical to C.

git merge -s ours <hash of C'> -m "Merge C', keep only B's content"

Scenario 2: CC should be a complete clone of C'

You want a merge commit on branch B (so CC has parents C and C'), but override all files so they match C' (even if that discards local changes).

# Start the merge, do not commit yet
git merge --no-commit <hash of C'>

# Overwrite working tree with C's tree
git checkout <hash of C'> -- .

# Add everything
git add -A

# Commit
git commit -m "Merge C' into B, taking all content from C'"

Scenario 3: CC mixes content from C and C'

git merge --no-commit <hash of C'>

# Overwrite or merge specific files manually
git checkout <hash of C'> -- path/to/file1 path/to/file2

# Add everything
git add -A

# Commit
git commit -m "Manually merge selected files from C'"

List Remotes

git remote -v

This will display a list of remotes with their URLs, e.g.:

origin  https://github.com/example/repo.git (fetch)
origin  https://github.com/example/repo.git (push)

Push to a Specific Remote

git push --force <remote-name> <branch-name>

• <remote-name> is the name of the remote you want to push to (e.g., origin, upstream, etc).
• <branch-name> is the branch you want to push (e.g., main, master, etc).

Keep a Fork Updated with an Original Repository

If you've forked a repository on GitHub, your fork won't automatically stay up to date as the original repository changes. By default, your fork links only to itself (as origin), and not to the original repository. To pull in updates from the source, you'll want to add the original repository as a new remote, commonly named upstream.

Here's a quick guide to achieve this:

1. Find the Original Repository URL

First, go to the original repository (not your fork) on GitHub. Copy the repository's clone URL (use either HTTPS or SSH, depending on your setup).

2. Add the Original Repository as a Remote Called upstream

Open your terminal and navigate to your local copy of the forked repository. Then add the original as a new remote called upstream:

git remote add upstream https://github.com/original-owner/original-repo.git

(Replace the URL above with the actual URL of the original repository.)

3. Confirm Your Remotes

To make sure everything is set up correctly, run:

git remote -v

You should see output similar to:

origin    https://github.com/your-username/your-fork.git (fetch)
origin    https://github.com/your-username/your-fork.git (push)
upstream  https://github.com/original-owner/original-repo.git (fetch)
upstream  https://github.com/original-owner/original-repo.git (push)

4. Fetch Updates from the Original Repository

You can now fetch all the latest branches and updates from the original repository using:

git fetch upstream