Git - Basic Commands

Basic Commands of Git

Repository Initialization

git init

The git init command initializes a new Git repository in the current directory. It creates a .git folder containing all the necessary metadata for version control.

# Initialize a new Git repository
git init

After running this command, the current directory becomes a Git-managed project.

Cloning a Repository

git clone

The git clone command is used to create a copy of an existing Git repository, usually from a remote source like GitHub or GitLab.

# Clone a remote repository
git clone https://github.com/username/repo-name.git

This command creates a new directory with the repository contents and complete commit history.

Tracking File Changes

git status

The git status command displays the current state of the working directory and staging area. It shows which files are staged, unstaged, or untracked.

# Check the status of the working directory
git status

git add

The git add command is used to stage changes for the next commit. You can add specific files or all files using a dot.

# Stage a specific file
git add index.html

# Stage all changes
git add .

git rm

The git rm command removes files from the working directory and staging area.

# Remove a file and stage the deletion
git rm old_file.txt

Committing Changes

git commit

The git commit command captures a snapshot of the staged changes. Each commit includes a message that describes the changes.

# Commit with a message
git commit -m "Add header section to homepage"

git commit --amend

You can use --amend to modify the last commit, either to change the commit message or include additional changes.

# Amend the previous commit
git commit --amend -m "Updated homepage header section"

Viewing History

git log

The git log command shows the commit history for the current branch.

# View commit history
git log

git log --oneline

To see a condensed version of the commit history:

git log --oneline

git diff

The git diff command shows the differences between files in the working directory and the staging area, or between commits.

# View changes not staged for commit
git diff

# View changes staged for the next commit
git diff --cached

Branching and Merging

git branch

The git branch command lists all branches and can also be used to create new branches.

# List all branches
git branch

# Create a new branch
git branch feature-login

git checkout

The git checkout command is used to switch branches or restore files.

# Switch to an existing branch
git checkout feature-login

git switch

A newer alternative to git checkout for switching branches:

# Switch to another branch
git switch feature-login

git merge

The git merge command combines changes from one branch into another.

# Merge feature-login into main
git checkout main
git merge feature-login

git rebase

The git rebase command is another way to integrate changes. It rewrites the commit history to create a linear sequence.

# Rebase the current branch onto main
git rebase main

Remote Repositories

git remote

The git remote command manages remote connections.

# View configured remotes
git remote -v

# Add a new remote
git remote add origin https://github.com/user/project.git

git push

The git push command sends local changes to the remote repository.

# Push changes to remote repository
git push origin main

git pull

The git pull command fetches and merges changes from a remote repository into the current branch.

# Pull changes from the remote repository
git pull origin main

git fetch

The git fetch command downloads updates from a remote repository but does not merge them.

# Fetch changes from remote
git fetch origin

Undoing Changes

git restore

The git restore command restores working directory files to their last committed state.

# Restore a modified file
git restore index.html

git reset

The git reset command un-stages files or resets commits.

# Unstage a file
git reset HEAD index.html

# Reset to a previous commit
git reset --hard 123abc

Stashing Changes

git stash

The git stash command temporarily shelves changes that are not ready to commit.

# Save local changes
git stash

# List stashes
git stash list

# Apply the most recent stash
git stash apply

# Drop the applied stash
git stash drop

Tagging

git tag

The git tag command is used to mark specific commits as versions or releases.

# Create a lightweight tag
git tag v1.0

# Create an annotated tag
git tag -a v1.1 -m "Version 1.1 release"

git show

The git show command displays information about a commit or tag.

# Show tag details
git show v1.0

Configuration

git config

The git config command sets configuration values such as username and editor.

# Set username and email
git config --global user.name "John Doe"
git config --global user.email "john@example.com"

# Set default editor
git config --global core.editor "code --wait"

# View all configuration settings
git config --list

Mastering Git’s basic commands is crucial for effective version control in any software project. These commands enable you to initialize repositories, track changes, commit updates, manage branches, interact with remotes, and undo mistakes. They form the foundation of everyday Git workflows and collaborative development.

As you become more familiar with Git, you will naturally progress to advanced commands and workflows, such as cherry-picking, bisecting, interactive rebasing, and using hooks. However, the commands covered in this document will remain essential in all stages of Git usage.

By practicing these commands regularly and understanding their purpose, you will become proficient in using Git, resulting in cleaner workflows, better collaboration, and more reliable code management.