Introduction to Version Control Systems

Version control systems are indispensable tools in software development, helping teams collaborate efficiently, track code changes, and manage historical records. Git is currently the most popular distributed version control system, widely used in various project developments.

Basic Concepts of Version Control Systems

A version control system (VCS) is used to record file changes, making it easier to backtrack to historical versions and collaborate on development. It is mainly divided into two categories: centralized (e.g., SVN) and distributed (e.g., Git). Centralized version control systems rely on a central server to store all version information, while distributed version control systems allow each developer to have a complete copy of the repository.

For example, in a centralized system, committing code requires an online operation:

svn commit -m "Update feature"

In a distributed system, commits can be performed offline:

git commit -m "Update feature"

Core Working Principles of Git

Git manages file changes through three main areas: the working directory, the staging area (stage), and the local repository. The working directory contains the actual files, the staging area prepares the content for the next commit, and the local repository stores all commit records.

Here is a typical Git workflow example:

// After modifying files, add them to the staging area
git add index.html

// Check the current status
git status

// Commit to the local repository
git commit -m "Update homepage layout"

Branching and Merging

Git's branching mechanism is one of its most powerful features. Branches allow developers to conduct experimental development without affecting the main code. The commands to create and switch branches are as follows:

git branch new-feature
git checkout new-feature

Modern Git versions also support more concise syntax:

git switch new-feature

Conflicts may arise when merging branches, for example:

/* Styles on the main branch */
.header { color: blue; }

/* Modifications on the feature branch */
.header { color: red; }

Resolving conflicts requires manually editing the file and then marking it as resolved:

git add style.css
git commit

Remote Repository Collaboration

Git supports interaction with remote repositories. Commonly used commands include:

git clone https://github.com/user/repo.git
git push origin main
git pull origin main

During team collaboration, branching strategies are often adopted. For example, GitHub Flow:

1. Create a new branch from the main branch
2. After development is complete, create a Pull Request
3. After code review, merge into the main branch

Advanced Git Techniques

Interactive rebasing can tidy up commit history:

git rebase -i HEAD~3

Stashing changes is useful for temporarily switching tasks:

git stash
git stash pop

Git hooks can automate workflows, such as running tests before committing:

#!/bin/sh
npm test

Git Integration with Other Tools

In modern development, Git is often integrated with CI/CD tools. For example, a GitHub Actions configuration:

name: Node.js CI
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - run: npm install
    - run: npm test

Solutions to Common Problems

When committing to the wrong branch, you can use:

git reset --soft HEAD~1
git stash
git checkout correct-branch
git stash pop

Recovering accidentally deleted files:

git checkout HEAD -- deleted-file.js