1. Introduction to Git

Git is a distributed version control system that tracks changes in source code during software development. It allows multiple developers to work on a project simultaneously, managing and tracking changes, and maintaining the history of the entire project. Git is widely used in the software industry due to its efficiency, reliability, and flexibility in handling complex projects.

2. Basic Git Concepts

Understanding the basic concepts of Git is essential for effectively using the tool in software development. These concepts form the foundation of how Git manages and tracks changes in a project.

2.1 Repository

A repository (repo) in Git is a storage space where the project's files and their version history are kept. Repositories can be local (on your machine) or remote (on a server like GitHub or GitLab).

2.1.1 Example: Creating a New Repository

# Initialize a new local Git repository
git init my-project

# Navigate to the project directory
cd my-project

2.2 Commit

A commit is a snapshot of the changes made to the project files. Each commit has a unique identifier (hash) and is accompanied by a commit message that describes the changes. Commits create a history of changes that can be revisited or rolled back if necessary.

2.2.1 Example: Making a Commit

# Stage the changes for commit
git add .

# Commit the changes with a message
git commit -m "Initial commit with project setup"

2.3 Branch

A branch in Git represents a separate line of development. Branches allow developers to work on features or bug fixes independently of the main codebase (usually the master or main branch). Once the work on a branch is complete, it can be merged back into the main branch.

2.3.1 Example: Creating and Switching to a New Branch

# Create a new branch named "feature-branch"
git branch feature-branch

# Switch to the newly created branch
git checkout feature-branch

3. Advanced Git Operations

After mastering the basics, it's important to understand some of the more advanced operations in Git, which are crucial for managing large and complex projects.

3.1 Merging

Merging is the process of integrating changes from one branch into another. This operation is commonly used to bring feature branches back into the main branch. Git automatically handles merging most of the time, but conflicts can arise when changes in different branches affect the same part of a file.

3.1.1 Example: Merging a Branch

# Switch to the branch you want to merge into (usually main)
git checkout main

# Merge the feature branch into main
git merge feature-branch

3.2 Resolving Merge Conflicts

Merge conflicts occur when Git is unable to automatically resolve differences between branches. When this happens, Git marks the conflicting areas in the affected files, and the developer must manually resolve the conflicts.

3.2.1 Example: Resolving a Merge Conflict

# After attempting a merge, open the conflicting file
# Git will mark the conflicts with <<<<<<<, =======, and >>>>>>>

# Edit the file to resolve the conflict, then stage and commit the changes
git add conflicted-file.txt
git commit -m "Resolved merge conflict in conflicted-file.txt"

3.3 Rebasing

Rebasing is another way to integrate changes from one branch into another. Unlike merging, which creates a new commit to represent the merge, rebasing re-applies commits from one branch onto another, creating a cleaner, linear history.

3.3.1 Example: Rebasing a Branch

# Switch to the branch you want to rebase onto (e.g., main)
git checkout feature-branch

# Rebase the feature branch onto the main branch
git rebase main

3.4 Stashing

Stashing is a way to temporarily save changes that are not ready to be committed. This is useful when you need to switch branches or perform other tasks without committing incomplete work.

3.4.1 Example: Stashing Changes

# Save the current changes to the stash
git stash save "WIP - working on new feature"

# List all stashes
git stash list

# Apply the most recent stash
git stash apply

4. Working with Remote Repositories

Remote repositories are hosted on servers and can be accessed by multiple developers. Working with remote repositories involves pushing and pulling changes, as well as managing collaboration among team members.

4.1 Cloning a Repository

Cloning creates a local copy of a remote repository. This is often the first step when you want to start working on an existing project.

4.1.1 Example: Cloning a Repository

# Clone a repository from GitHub
git clone https://github.com/username/repository.git

4.2 Pulling Changes

Pulling changes from a remote repository updates your local repository with the latest changes from the remote. This operation is a combination of fetching the changes and merging them into your local branch.

4.2.1 Example: Pulling Changes from a Remote Repository

# Pull the latest changes from the remote repository
git pull origin main

4.3 Pushing Changes

Pushing changes sends your commits from your local repository to the remote repository. This is how you share your work with others and update the remote repository with your changes.

4.3.1 Example: Pushing Changes to a Remote Repository

# Push your local changes to the remote repository
git push origin feature-branch

4.4 Forking and Pull Requests

Forking a repository creates a copy of it under your own GitHub account, allowing you to make changes without affecting the original repository. After making changes, you can create a pull request to propose your changes to the original repository.

4.4.1 Example: Creating a Pull Request on GitHub

# After pushing your changes to your forked repository, navigate to GitHub
# Go to the original repository and click on "New pull request"
# Compare changes and submit the pull request for review

5. Git Tags

Tags in Git are used to mark specific points in a repository's history as important. Typically, tags are used to mark release points (e.g., v1.0.0). Tags are like branches but do not change over time, making them a useful reference point.

5.1 Creating a Tag

Tags can be lightweight (just a name) or annotated (a full Git object with a message, date, and author information).

5.1.1 Example: Creating an Annotated Tag

# Create an annotated tag
git tag -a v1.0.0 -m "Initial release"

# Push the tag to the remote repository
git push origin v1.0.0

5.2 Listing and Deleting Tags

You can list all tags in a repository, and if necessary, delete them. Tags can also be pushed to or deleted from a remote repository.

5.2.1 Example: Listing and Deleting Tags

# List all tags
git tag

# Delete a tag locally
git tag -d v1.0.0

# Delete a tag from the remote repository
git push origin --delete v1.0.0

6. Git Hooks

Git hooks are scripts that are automatically triggered by certain events in the Git lifecycle, such as committing or merging code. Hooks can be used to enforce policies, automate tasks, and improve the development workflow.

6.1 Client-Side Hooks

Client-side hooks are triggered by operations on the local repository, such as committing code or preparing a commit message. Common examples include < code>pre-commit, prepare-commit-msg, and post-commit hooks.

6.1.1 Example: A Simple Pre-Commit Hook

#!/bin/sh
# A pre-commit hook that prevents commits with empty messages

if git diff --cached --quiet; then
  echo "Nothing to commit. Aborting."
  exit 1
fi

msg=$(git log -1 --pretty=%B)
if [ -z "$msg" ]; then
  echo "Empty commit message. Aborting."
  exit 1
fi

6.2 Server-Side Hooks

Server-side hooks are triggered by operations on the remote repository, such as receiving pushed commits. Common examples include pre-receive, update, and post-receive hooks.

6.2.1 Example: A Post-Receive Hook for Deploying Code

#!/bin/sh
# A post-receive hook that deploys code to a production server

while read oldrev newrev refname
do
  if [ "$refname" = "refs/heads/main" ]; then
    GIT_WORK_TREE=/var/www/yourproject git checkout -f main
    systemctl restart yourproject
  fi
done

7. Git Submodules

Git submodules allow you to include and manage a repository within another repository. This is useful for integrating external projects into your own without merging their history into your main repository.

7.1 Adding a Submodule

To add a submodule, specify the repository URL and the directory where it should be included in your project.

7.1.1 Example: Adding a Submodule

# Add a submodule to your repository
git submodule add https://github.com/username/other-project.git other-project

# Initialize the submodule
git submodule update --init --recursive

7.2 Updating Submodules

Submodules can be updated to the latest commit from their respective repositories. This is useful when the external project has new changes that you want to integrate into your project.

7.2.1 Example: Updating Submodules

# Pull the latest changes for all submodules
git submodule update --remote