Everyday Git commands

This chapter follows How Git works.

These commands assume a repository already exists. To connect a new project to GitHub, see Working with remotes.

Identity and configuration

Commits record name and email. Set them once globally or per repository:

1
git config --global user.name "Your Name"
2
git config --global user.email "you@example.com"

On GitHub you can hide your address with a noreply email from profile settings. If GitHub rejects pushes because the email is private, configure that noreply address locally:

1
git config --global user.email "12345678+noreply@users.noreply.github.com"
2
git config --global user.email

Omit --global to set values only for the current repo. View settings with git config --list or git config user.email.

Starting a repository and the daily loop

1
git init
2
git status
3
git add .
4
git commit -m "Initial commit"

git status shows untracked files, staged changes, and branch state. git add path or git add . stages changes into the index. git commit -m "message" creates a snapshot on the current branch.

Commit messages should explain why, not only what changed. Small, frequent commits are easier to review and revert than one giant commit at the end of the week.

Removing and renaming files

1
git rm obsolete.txt
2
git rm --cached secret.local.env
3
git mv old-name.ts new-name.ts

git rm deletes from the working tree and stages the deletion. --cached removes from the index only (keeps the file on disk). Prefer git mv over manual rename plus add so history and renames stay clearer.

Inspecting history and diffs

1
git log --oneline
2
git log --graph --decorate --oneline
3
git show HEAD
4
git diff
5
git diff --cached
6
git diff HEAD

git log lists commits on the current branch. git show displays one commit, including its patch. git diff compares working tree to index; --cached compares index to last commit; git diff HEAD is everything that would go into a commit if you staged it all.

Compare branches or paths:

1
git diff main feature -- src/app.ts

Committing part of a file

Not every hunk in a file must land in the same commit:

1
git add --patch file.txt

Git walks hunks interactively: y stage, n skip, s split further. Useful when one file mixes a bugfix and an unrelated refactor.

Branches

List, create, switch, delete, and rename:

1
git branch
2
git branch -a
3
git branch -v
4
git branch feature/login
5
git checkout feature/login
6
git checkout -b feature/login
7
git branch -d feature/login
8
git branch -D feature/login
9
git branch -m old-name new-name

-a includes remote-tracking branches; -v shows the latest commit on each branch. -d refuses to delete unmerged work; -D forces deletion. You cannot delete the branch you are on—switch first.

Modern commands split checkout’s jobs:

1
git switch feature/login
2
git switch -c feature/login
3
git restore --staged file.txt
4
git restore file.txt

git switch moves HEAD to another branch. git restore copies from the repository to the index and/or working tree (for example to unstage or discard local edits).

Use short branch names with a team convention, such as feat/115/email-login or bug/123/menu-null.

Tags

Lightweight tags are branch-like refs; annotated tags store a message and signer metadata:

1
git tag v1.0.0
2
git tag -a v1.0.0 -m "First production release"
3
git push origin v1.0.0
4
git push origin --tags

Release workflows often require annotated tags on main.

Ignoring files

Git tracks tracked, untracked, and ignored paths. Place .gitignore at the repo root (or in subfolders) with patterns:

Ignored files never appear in git add unless you force-add them. Typical ignores: build output, dependencies, IDE metadata, local env files.

Next: Working with remotes.