Git Aliases and Configuration

Why Git Configuration Matters

Git works immediately, but a small amount of configuration makes daily work much smoother. Good defaults reduce mistakes, remove repeated typing, and help keep your environment consistent across projects.

In this lesson, you will cover:

• config scopes
• identity settings
• editor and default branch setup
• useful aliases
• a global ignore file

Tip: Start with a few settings you use every day. You do not need a giant .gitconfig to get real value.

Understanding .gitconfig Scopes

Git reads settings from three main levels:

• system: for all users on the machine
• global: for your user account
• local: for one repository only

Most personal preferences belong in global config, while project-specific exceptions belong in local config.

Useful commands:

git config --list
git config --list --show-origin

Typical files are:

• /etc/gitconfig
• ~/.gitconfig
• .git/config

Local settings override global ones, and global settings override system ones.

Setting Name and Email

Git writes author information into each commit, so configure identity first.

git config --global user.name "Vishvesh Patel"
git config --global user.email "vishvesh@example.com"

Verify the values:

git config --global user.name
git config --global user.email

If one repository needs a different email, set it locally:

cd company-project
git config user.email "vishvesh@company.com"

Default Editor and Default Branch

Git may open an editor for commit messages, rebases, or merge messages. Pick one you already use.

git config --global core.editor "code --wait"

Or:

git config --global core.editor "vim"

To make new repositories start on main:

git config --global init.defaultBranch main

Note: This affects only future git init repositories. Existing repositories keep their current branch names until you rename them.

Reading a .gitconfig File

A .gitconfig file is a simple INI-style file.

[user]
  name = Vishvesh Patel
  email = vishvesh@example.com
[core]
  editor = code --wait
[init]
  defaultBranch = main

You can edit it directly or let git config write the entries for you.

Useful Git Aliases

Aliases turn longer commands into shorter ones.

Basic examples:

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit

That lets you run:

git st
git co main
git br

Pretty Log Alias

A compact history view is one of the most useful aliases you can add.

git config --global alias.lg "log --oneline --graph --decorate --all"

Then run:

git lg

Workflow Aliases

A few more practical shortcuts:

git config --global alias.last "log -1 HEAD"
git config --global alias.unstage "restore --staged"
git config --global alias.amend "commit --amend"

Aliases should make common work faster, not hide commands you do not understand.

Using a Global Ignore File

Some files should stay out of git status in every repository, such as:

• .DS_Store
• editor folders like .vscode/
• swap files
• local-only secret files

Create a personal ignore file:

touch ~/.gitignore_global

Example contents:

.DS_Store
.vscode/
*.swp
.env.local

Tell Git to use it:

git config --global core.excludesfile ~/.gitignore_global

This keeps machine-specific clutter out of all repositories without editing each project's .gitignore.

A Simple Starter Setup

git config --global user.name "Vishvesh Patel"
git config --global user.email "vishvesh@example.com"
git config --global core.editor "code --wait"
git config --global init.defaultBranch main
git config --global core.excludesfile ~/.gitignore_global
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.lg "log --oneline --graph --decorate --all"

What You Should Remember

Git configuration lives at system, global, and local levels. Set your identity, choose a comfortable editor, define main as the default branch for new repositories, add a few aliases, and use a global ignore file for OS and editor clutter. Small config improvements make Git easier every day.

Test Your Understanding

<MCQExercise exercise={{ id: 'git-aliases-config-q1', title: 'Exercise 1: Picking the right config scope', description: 'Which Git configuration scope should you use for a custom email address that only applies to one specific repository?', options: [ { id: 'a', text: 'system' }, { id: 'b', text: 'global' }, { id: 'c', text: 'local' }, { id: 'd', text: 'remote' }, ], correctId: 'c', explanation: 'Local configuration lives in .git/config inside the repository and overrides broader settings for that one project. That is the right place for repo-specific identity changes such as a different work email.', wrongExplanations: { a: 'System configuration affects all users on the machine and is too broad for one repository-specific email.', b: 'Global configuration applies to your whole user account, so it would affect all repositories unless overridden.', d: 'A remote is a repository endpoint, not a Git config scope.', }, }} />

<MCQExercise exercise={{ id: 'git-aliases-config-q2', title: 'Exercise 2: Understanding aliases', description: 'After running git config --global alias.st status, what does git st do?', options: [ { id: 'a', text: 'It opens the stash list' }, { id: 'b', text: 'It runs git status' }, { id: 'c', text: 'It stages all files automatically' }, { id: 'd', text: 'It starts a new Git repository' }, ], correctId: 'b', explanation: 'Aliases are shortcuts for longer commands. In this case, st becomes another way to run git status.', wrongExplanations: { a: 'That would only happen if you explicitly created a stash-related alias.', c: 'Staging files is a different operation such as git add.', d: 'Initializing a repository is done with git init, not git status.', }, }} />

<MCQExercise exercise={{ id: 'git-aliases-config-q3', title: 'Exercise 3: Global ignore behavior', description: 'Why would you use ~/.gitignore_global with core.excludesfile?', options: [ { id: 'a', text: 'To ignore machine-specific files like .DS_Store across all repositories' }, { id: 'b', text: 'To delete ignored files from disk automatically' }, { id: 'c', text: 'To replace every project's .gitignore file permanently' }, { id: 'd', text: 'To stop Git from tracking source code in the current branch' }, ], correctId: 'a', explanation: 'A global ignore file is useful for patterns that are personal or machine-specific, such as OS artifacts and editor files. It keeps those items out of git status without forcing every repository to duplicate the same rules.', wrongExplanations: { b: 'Ignore rules affect tracking and status behavior, not physical deletion of files.', c: 'Global ignore complements project-specific .gitignore files rather than replacing them.', d: 'It filters specific file patterns, not all source code or whole branches.', }, }} />