Basic Git Operation Tutorial Using the Terminal

What is Git?

Git is a distributed version control system that allows developers to track every change in their code, collaborate with teams, and revert to any previous version when needed. Whether it is a personal project or a large team effort, Git is an indispensable tool in modern software development.

Why Use Git?

Version Tracking: Records every modification, allowing you to view or revert to previous versions at any time
Team Collaboration: Multiple people can work on different branches simultaneously without interfering with each other
Backup Safety: Code is stored in remote repositories, protecting against local data loss
Code Review: Pull Request mechanisms enable code reviews, improving code quality

Installation and Setup

Installing Git

macOS: Install using Homebrew
```
brew install git
Loading...
```

Ubuntu / Debian:

sudo apt-get install git
Loading...

Windows: Download the installer from git-scm.com

Setting Your Information

When using Git for the first time, you need to set your username and email. This information will be recorded in every commit.

Set information

git config --global user.name "Your Name"
Loading...

git config --global user.email "Your Email"
Loading...

View current settings
```
git config --list
Loading...
```

Remove information

git config --global --unset user.name
Loading...

git config --global --unset user.email
Loading...

Git Workflow

git flow

The Git workflow consists of three main areas:

Working Directory: Where the files you are editing are located
Staging Area: Files that are ready to be committed
Repository: The committed history records

The basic flow is: Edit files → Add to staging area → Commit to repository

Basic Commands

Initialize and Clone

Create a new Git repository:

git init
Loading...

Clone an existing Git repository from a remote server to your local machine:

URL method:

git clone <https://url/owner/repo.git>
Loading...

SSH method:

git clone <[email protected]:username/projectname.git>
Loading...

Clone and rename the folder:

git clone <https://url/owner/repo.git> <new-folder-name>
Loading...

Check Status and Differences

View the current file status:

git status
Loading...

View file modification differences:

git diff                 # View unstaged changes
git diff --staged        # View staged changes
git diff <file>          # View changes for a specific file
Loading...

Staging and Committing

Add files to the staging area (avoid adding confidential information like API keys, database passwords, etc.):

git add <file1> <file2>  # Add specific files
git add .                # Add all changed files
Loading...

Commit staged files:

git commit -m "Your commit message"
Loading...

Amend the last commit message (use only when not yet pushed to remote):

git commit --amend -m "Corrected message"
Loading...

Remote Repository Operations

Add a remote repository:

git remote add origin <https://url/owner/repo.git>
Loading...

View remote repository information:

git remote -v
Loading...

Push local code to remote:

git push -u origin <branch>   # First push, set upstream branch
git push                       # Subsequent pushes
Loading...

Pull the latest code from remote:

git pull                       # Pull and merge
git fetch                      # Fetch only, do not merge
Loading...

Set remote upstream URL:

git remote set-url origin <https://url/owner/repo.git>
Loading...

Branch Operations

Branching is one of Git's most powerful features, allowing you to develop new features or fix bugs without affecting the main branch.

Basic Branch Commands

git branch                     # List all local branches
git branch -a                  # List all branches (including remote)
git branch <branch-name>       # Create a new branch
git checkout <branch-name>     # Switch to a specific branch
git checkout -b <branch-name>  # Create and switch to a new branch
git branch -d <branch-name>    # Delete a merged branch
git branch -D <branch-name>    # Force delete a branch
Loading...

Merging Branches

Merge changes from another branch into the current branch:

git checkout main              # First switch to the target branch
git merge <branch-name>        # Merge the specified branch
Loading...

Resolving Merge Conflicts

When two branches modify the same part of the same file, Git cannot automatically merge them and a conflict occurs. Conflicting files will contain the following markers:

<<<<<<< HEAD
Your changes in the current branch
=======
Changes from the branch being merged
>>>>>>> branch-name

Resolution steps:

Open the conflicting file
Manually choose which content to keep and remove the conflict markers
Add the resolved file to the staging area
Commit the merge result

git add <resolved-file>
git commit -m "resolve merge conflict"
Loading...

Viewing History

git log                        # View full commit history
git log --oneline              # Compact mode, one line per commit
git log --graph                # Display branch and merge history graphically
git log --oneline --graph      # Compact graphical mode
git log -n 5                   # Show only the last 5 commits
git log --author="Name"        # View commits by a specific author
Loading...

View the modification history of a specific file:

git log --follow <file>
Loading...

View the details of a specific commit:

git show <commit-hash>
Loading...

Undoing and Reverting

Unstage Files

git restore --staged <file>    # Remove file from staging area (keep changes)
Loading...

Discard Working Directory Changes

git restore <file>             # Discard changes to a specific file
Loading...

Revert to a Previous Commit

git revert <commit-hash>       # Create a new commit that undoes the specified commit (safe)
git reset --soft <commit-hash> # Reset to a commit, keep changes in staging area
git reset --hard <commit-hash> # Reset to a commit, discard all changes (dangerous)
Loading...

Warning: git reset --hard will permanently discard changes. Make sure before using it.

Git Stash (Temporarily Save Changes)

When you are working on a feature but need to switch to another branch to handle an urgent issue, you can use stash to temporarily save your current changes.

git stash                      # Stash current changes
git stash list                 # List all stashed changes
git stash pop                  # Restore the most recent stash and remove it from the list
git stash apply                # Restore the most recent stash but keep it in the list
git stash drop                 # Delete the most recent stash
Loading...

The .gitignore File

.gitignore tells Git which files or folders should not be tracked. Create a .gitignore file in your project root:

# Dependencies
node_modules/

# Environment variables
.env
.env.local

# Build output
.next/
dist/
build/

# System files
.DS_Store
Thumbs.db

# IDE settings
.vscode/
.idea/

# Log files
*.log

Common Workflow Examples

Personal Development Workflow

# 1. Create a new feature branch
git checkout -b feature/new-feature

# 2. Develop and commit
git add .
git commit -m "add new feature"

# 3. Switch back to main branch and merge
git checkout main
git merge feature/new-feature

# 4. Push to remote
git push origin main

# 5. Delete the feature branch
git branch -d feature/new-feature
Loading...

Team Collaboration Workflow

# 1. Pull the latest code from remote
git pull origin main

# 2. Create a feature branch
git checkout -b feature/my-feature

# 3. Develop and commit
git add .
git commit -m "implement my feature"

# 4. Push the feature branch to remote
git push -u origin feature/my-feature

# 5. Create a Pull Request on GitHub / GitLab for code review

# 6. Merge into the main branch after review is approved
Loading...

Useful Tips

Use meaningful commit messages that clearly describe what was changed
Commit frequently, keeping each commit small and focused
Run git pull before pushing to stay in sync with the remote
Use .gitignore to avoid committing unnecessary files
Use branches for development, avoid modifying the main branch directly
Use git stash to temporarily save unfinished work