Kenhuang Academy
  • English

      • Git Working Directory, Staging Area, and Repository

      This chapter dives deep into Git's three core concepts: Working Directory, Staging Area, and Repository. Understanding these three areas is key to mastering Git.

      Overview of the Three Areas

      ┌─────────────────────────────────────────────────────────────────┐
│                        Git Project Structure                    │
├─────────────────────────────────────────────────────────────────┤
│  Working Directory                                              │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │  • Actual project files                                 │    │
│  │  • Can edit, create, delete files                       │    │
│  │  • Git monitors but doesn't manage directly             │    │
│  └─────────────────────────────────────────────────────────┘    │
│                              │                                  │
│                         git add                                 │
│                              ↓                                  │
│  Staging Area (Index)                                           │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │  • Temporary snapshot for next commit                   │    │
│  │  • Precise control over commit content                  │    │
│  │  • Located in .git/index file                           │    │
│  └─────────────────────────────────────────────────────────┘    │
│                              │                                  │
│                        git commit                               │
│                              ↓                                  │
│  Repository                                                     │
│  ┌─────────────────────────────────────────────────────────┐    │
│  │  • Stores complete project history                      │    │
│  │  • Contains all commits, branches, tags                 │    │
│  │  • Located in .git directory                            │    │
│  └─────────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────────┘

      Working Directory

      Definition and Characteristics

      The Working Directory is where you actually do your work. It contains all project files and folders (except the .git directory).

      Characteristics:

      • 📁 Contains actual project files
      • ✏️ Freely edit, create, delete files
      • 👀 Git monitors changes but doesn't auto-save
      • 🔄 Can restore to any historical version at any time

      Working Directory Example

      # Create demo project
mkdir git-areas-demo
cd git-areas-demo
git init

# Create files in working directory
echo "# Project Description" > README.md
echo "print('Hello, World!')" > main.py
mkdir src
echo "# Helper functions" > src/utils.py

# Check status
git status

      Output:

      On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        README.md
        main.py
        src/

nothing added to commit but untracked files present (use "git add" to track)

      Working Directory File States

      Files in the working directory can be in the following states:

      1. Untracked: Newly created files
      2. Modified: Tracked files that have been changed
      3. Deleted: Tracked files that have been removed
      # Demo different states
git add README.md main.py src/utils.py
git commit -m "Initial commit"

# Modify tracked file
echo "Update content" >> README.md

# Create new file
echo "New feature" > feature.py

# Delete file
rm main.py

# Check status
git status

      Output:

      On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   README.md
        deleted:    main.py

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        feature.py

no changes added to commit (use "git add" or "git commit -a")

      Staging Area (Index)

      Definition and Characteristics

      The Staging Area (also known as Index) is a buffer between the working directory and the repository, used to prepare content for the next commit.

      Characteristics:

      • 🎯 Precise control over commit content
      • 📦 Can stage partial file changes
      • 🔄 Can modify staged content multiple times
      • 💾 Stored in .git/index file

      Staging Area Operations

      1. Add Files to Staging Area

      # Add single file
git add README.md

# Add multiple files
git add main.py feature.py

# Add directory
git add src/

# Add all changes
git add .

# Add all modifications to tracked files
git add -u

# Interactive add
git add -i

      2. View Staging Area Content

      # Check staging area status
git status

# View diff between staging and working directory
git diff

# View diff between staging and last commit
git diff --staged
# Or
git diff --cached

      3. Remove Files from Staging Area

      # Remove file from staging (keep working dir changes)
git restore --staged README.md

# Or using old syntax
git reset HEAD README.md

# Remove all staged changes
git restore --staged .

      4. Partial Staging

      Git allows you to stage only parts of a file's changes:

      # Create file for demo
cat > example.py << EOF
def function1():
    print("Function 1")

def function2():
    print("Function 2")
EOF
# (Further steps would involve git add -p)