Getting Started with Git Repositories

By /

Okay, here’s a comprehensive article on getting started with Git repositories, aiming for approximately 5000 words. I’ve structured it to be easily digestible, with clear headings and subheadings, practical examples, and explanations of core concepts.

Getting Started with Git Repositories: A Comprehensive Guide

This guide provides a detailed introduction to Git repositories, covering everything from basic setup to everyday workflows. Whether you’re a complete beginner or have some limited experience, this article will equip you with the knowledge and skills to confidently use Git for version control.

Table of Contents

  1. What is Git and Why Should You Use It?

    • 1.1 Version Control Explained
    • 1.2 Benefits of Using Git
    • 1.3 Git vs. Other Version Control Systems (Brief Overview)
    • 1.4 Centralized vs. Distributed Version Control (Git is Distributed)

  2. Installing Git

    • 2.1 Installation on Windows
    • 2.2 Installation on macOS
    • 2.3 Installation on Linux
    • 2.4 Verifying the Installation
    • 2.5 Initial Git Configuration (User Name and Email)

  3. Creating Your First Git Repository

    • 3.1 Initializing a New Repository (git init)
    • 3.2 Understanding the .git Directory
    • 3.3 Cloning an Existing Repository (git clone)
    • 3.4 Choosing a Remote Repository Hosting Service (GitHub, GitLab, Bitbucket)

  4. The Basic Git Workflow: Tracking Changes

    • 4.1 The Working Directory, Staging Area, and Repository
    • 4.2 Checking the Status of Your Files (git status)
    • 4.3 Adding Files to the Staging Area (git add)
    • 4.4 Committing Changes to the Repository (git commit)
    • 4.5 Understanding Commit Messages (Best Practices)
    • 4.6 Viewing the Commit History (git log)
    • 4.7 Ignoring Files (.gitignore)

  5. Branching and Merging: Managing Parallel Development

    • 5.1 What is a Branch?
    • 5.2 Creating a New Branch (git branch, git checkout -b)
    • 5.3 Switching Between Branches (git checkout)
    • 5.4 Merging Branches (git merge)
    • 5.5 Resolving Merge Conflicts
    • 5.6 Deleting Branches (git branch -d, git branch -D)

  6. Working with Remote Repositories

    • 6.1 Adding a Remote Repository (git remote add)
    • 6.2 Fetching Changes from a Remote (git fetch)
    • 6.3 Pulling Changes from a Remote (git pull)
    • 6.4 Pushing Changes to a Remote (git push)
    • 6.5 Understanding origin and main/master
    • 6.6 Working with remotes (git remote -v)

  7. Undoing Changes

    • 7.1 Amending the Last Commit (git commit --amend)
    • 7.2 Unstaging Files (git reset HEAD <file>)
    • 7.3 Discarding Changes in the Working Directory (git checkout -- <file>)
    • 7.4 Reverting Commits (git revert)
    • 7.5 Resetting to a Previous Commit (git reset) – Use with Caution!
      • 7.5.1 --soft
      • 7.5.2 --mixed
      • 7.5.3 --hard

  8. Inspecting and Comparing Changes

    • 8.1 Viewing Differences (git diff)
    • 8.2 Comparing Branches (git diff branch1 branch2)
    • 8.3 Viewing File History (git log -p <file>)
    • 8.4 Blaming (Annotating) Files (git blame <file>)

  9. Tagging: Marking Specific Points in History

    • 9.1 Creating Lightweight Tags (git tag)
    • 9.2 Creating Annotated Tags (git tag -a)
    • 9.3 Listing Tags (git tag)
    • 9.4 Checking Out Tags (git checkout <tag_name>)
    • 9.5 Pushing Tags to a Remote (git push origin <tag_name>, git push origin --tags)

  10. Stashing: Temporarily Shelving Changes

    • 10.1 Stashing Changes (git stash)
    • 10.2 Listing Stashes (git stash list)
    • 10.3 Applying Stashes (git stash apply, git stash pop)
    • 10.4 Dropping Stashes (git stash drop)
    • 10.5 Creating a Branch from a Stash (git stash branch)

  11. Advanced Topics (Brief Overview)

    • 11.1 Rebasing (git rebase)
    • 11.2 Interactive Rebasing (git rebase -i)
    • 11.3 Cherry-Picking (git cherry-pick)
    • 11.4 Git Hooks
    • 11.5 Submodules and Subtrees
    • 11.6 .gitattributes file

  12. Best Practices and Tips

    • 12.1 Commit Frequently and with Meaningful Messages
    • 12.2 Use Branches Liberally
    • 12.3 Keep Your Repository Clean
    • 12.4 Understand the Difference Between git pull and git fetch
    • 12.5 Learn to Resolve Merge Conflicts Effectively
    • 12.6 Use a .gitignore File
    • 12.7 Back Up Your Remote Repository
    • 12.8 Learn to love the command line

  13. Conclusion

1. What is Git and Why Should You Use It?

1.1 Version Control Explained

Version control, also known as source control, is a system that records changes to a file or set of files over time so that you can recall specific versions later. Imagine working on a document and saving multiple versions (e.g., “Document_v1.docx”, “Document_v2.docx”, “Document_Final.docx”). Version control automates and improves this process, providing a history of changes, the ability to revert to previous states, and facilitating collaboration among multiple people.

1.2 Benefits of Using Git

Git offers numerous advantages for developers and anyone working with files that change over time:

  • Track Changes: See exactly what changed, when it changed, and who made the change.
  • Revert to Previous Versions: Easily go back to an earlier state if something goes wrong or you need to retrieve an older version.
  • Collaboration: Multiple people can work on the same project simultaneously without overwriting each other’s changes.
  • Branching and Merging: Work on new features or experiments in isolation without affecting the main codebase.
  • Backup and Recovery: Your code is stored not only on your local machine but also (typically) on a remote server, providing a backup.
  • Experimentation: Safely try out new ideas without fear of ruining your project.
  • Open Source and Widely Adopted: Git is free, open-source, and the industry-standard version control system.

1.3 Git vs. Other Version Control Systems (Brief Overview)

While Git is the dominant version control system, others exist, such as Subversion (SVN), Mercurial (Hg), and Perforce. SVN is a centralized system, meaning there’s a single central server that holds the main repository. Mercurial is similar to Git in that it’s distributed. Perforce is often used in game development and large enterprise environments.

1.4 Centralized vs. Distributed Version Control (Git is Distributed)

  • Centralized (e.g., SVN): A single central server holds the “official” repository. Users “check out” files to work on them and then “commit” changes back to the central server. If the server goes down, collaboration is impossible.
  • Distributed (e.g., Git): Every user has a complete copy of the repository, including the entire history. This allows for offline work, faster operations, and greater resilience. Collaboration happens by exchanging changes between repositories.

2. Installing Git

2.1 Installation on Windows

  1. Download: Go to the official Git website (https://git-scm.com/) and download the Windows installer.
  2. Run the Installer: Double-click the downloaded .exe file.
  3. Follow the Prompts: The installer will guide you through the process. You can generally accept the default options, but pay attention to these:
    • Choosing the default editor: You can select your preferred text editor (e.g., Notepad++, VS Code, Vim).
    • Adjusting your PATH environment: Select the option to use Git from the Windows Command Prompt and from third-party software. This is usually recommended.
    • Choosing the line ending conversion: On Windows, it’s generally recommended to choose “Checkout Windows-style, commit Unix-style line endings.”
  4. Complete installation

2.2 Installation on macOS

There are several ways to install Git on macOS:

  • Homebrew (Recommended): If you have Homebrew installed, open Terminal and run:
    bash
    brew install git
  • Xcode Command Line Tools: Git is often included with Xcode’s command-line tools. Try running git --version in Terminal. If it’s not installed, you’ll be prompted to install the tools.
  • Installer: Download the macOS installer from the official Git website (https://git-scm.com/).

2.3 Installation on Linux

Most Linux distributions have Git available in their package managers.

  • Debian/Ubuntu:
    bash
    sudo apt update
    sudo apt install git
  • Fedora/CentOS/RHEL:
    bash
    sudo dnf install git # Or sudo yum install git (older versions)
  • Other Distributions: Use your distribution’s package manager (e.g., pacman on Arch Linux).

2.4 Verifying the Installation

Open a terminal (Command Prompt on Windows, Terminal on macOS/Linux) and run:

bash
git --version

This should display the installed Git version, confirming that the installation was successful.

2.5 Initial Git Configuration (User Name and Email)

Git uses your name and email address to identify who made each commit. Configure these globally using:

bash
git config --global user.name "Your Name"
git config --global user.email "[email protected]"

Replace "Your Name" and "[email protected]" with your actual name and email address. This information will be associated with all your commits. You can check your config with
bash
git config --list
You can also set these values on a per-repository basis by omitting the --global flag. This is useful if you use different identities for different projects.

3. Creating Your First Git Repository

You have two main ways to start a Git repository:

3.1 Initializing a New Repository (git init)

This creates a new, empty Git repository in an existing directory.

  1. Navigate to your project directory: Use the cd command in your terminal to go to the folder where your project files are located (or where you want to create them).
  2. Initialize the repository:
    bash
    git init
    This command creates a hidden .git subdirectory within your project directory. This subdirectory is where Git stores all the version control data.

3.2 Understanding the .git Directory

The .git directory is the heart of your Git repository. It contains:

  • Objects: Store the actual content of your files and commits.
  • Refs: Pointers to commits (branches, tags).
  • HEAD: A pointer to the currently checked-out branch or commit.
  • config: Repository-specific configuration settings.
  • hooks: Scripts that can be executed at various points in the Git workflow.

You generally don’t need to interact directly with the contents of the .git directory. Git manages it for you.

3.3 Cloning an Existing Repository (git clone)

This creates a local copy of a repository that already exists (usually on a remote server like GitHub, GitLab, or Bitbucket).

bash
git clone <repository_url>

For example, to clone a repository from GitHub:

bash
git clone https://github.com/username/repository-name.git

Replace https://github.com/username/repository-name.git with the actual URL of the repository you want to clone. This will create a new directory (with the same name as the repository) containing a full copy of the repository, including its history.

3.4 Choosing a Remote Repository Hosting Service (GitHub, GitLab, Bitbucket)

Remote repository hosting services provide a central place to store your Git repositories, facilitate collaboration, and offer additional features like issue tracking, pull requests, and wikis. Popular choices include:

  • GitHub: The most popular platform, widely used for open-source projects.
  • GitLab: Offers similar features to GitHub, with a strong focus on DevOps and CI/CD. Can be self-hosted.
  • Bitbucket: Integrates well with Atlassian tools like Jira and Confluence. Often used by teams using those tools.

The choice of service depends on your needs and preferences. GitHub is a good starting point for most users.

4. The Basic Git Workflow: Tracking Changes

4.1 The Working Directory, Staging Area, and Repository

Understanding these three areas is crucial for using Git effectively:

  • Working Directory: This is the directory where you edit your files. It’s your “live” version of the project.
  • Staging Area (Index): A temporary holding area where you prepare changes before committing them. Think of it as a “draft” of your next commit. You selectively add files or changes to the staging area.
  • Repository: The .git directory, where Git stores the complete history of your project, including all commits and branches.

4.2 Checking the Status of Your Files (git status)

The git status command is your primary tool for understanding the current state of your repository. It shows:

  • Untracked files: Files in your working directory that Git is not yet tracking.
  • Modified files: Files that have been changed since the last commit.
  • Staged files: Files that have been added to the staging area and are ready to be committed.
  • The current branch

bash
git status

Run this command frequently to keep track of your changes.

4.3 Adding Files to the Staging Area (git add)

The git add command adds changes from your working directory to the staging area.

  • Add a specific file:
    bash
    git add filename.txt
  • Add all modified and new files:
    bash
    git add .
    (The . represents the current directory.)
  • Add all files in a directory
    bash
    git add directory/
  • Add files with a specific pattern:
    bash
    git add *.txt # Adds all .txt files
  • Add interactively
    bash
    git add -p
    This command allows you to review each change (hunk) and decide whether to stage it, skip it, or edit it. It’s very useful for creating clean, focused commits.

4.4 Committing Changes to the Repository (git commit)

The git commit command creates a snapshot of the staged changes and adds it to the repository’s history.

bash
git commit -m "Your commit message here"

The -m flag allows you to provide a commit message directly on the command line. If you omit -m, Git will open your configured text editor, prompting you to enter a commit message.

4.5 Understanding Commit Messages (Best Practices)

Commit messages are essential for documenting your changes. Good commit messages make it easier to understand the history of your project.

  • Be descriptive: Explain what was changed and why.
  • Use the imperative mood: Write as if you’re giving a command (e.g., “Fix bug in login form,” not “Fixed bug in login form”).
  • Keep it concise (ideally under 50 characters for the subject line): The first line should be a short summary.
  • Use the body for details (optional): If needed, add a blank line after the subject line and then provide more details in the body. Wrap lines at around 72 characters.

Example of a good commit message:

“`
Fix: Correctly handle edge case in user authentication

The previous implementation failed to handle cases where the
username was empty. This commit adds a check for empty usernames
and returns an appropriate error message.
“`

4.6 Viewing the Commit History (git log)

The git log command displays the commit history of your repository.

bash
git log

By default, git log shows the commit hash, author, date, and commit message for each commit. There are many options to customize the output:

  • git log --oneline: Shows a concise, one-line summary of each commit.
  • git log -p: Shows the changes (diff) introduced by each commit.
  • git log --graph: Displays a text-based graph of the branch structure.
  • git log --author="Your Name": Shows only commits by a specific author.
  • git log --since="2 weeks ago": Shows commits within a specific time range.
  • git log -- <filename>: Show history for one file
  • git log --pretty=format:"%h %s": Create a custom log, using placeholders like %h for the abbreviated commit hash and %s for the subject.

Experiment with these options to find the most useful views for your needs.

4.7 Ignoring Files (.gitignore)

The .gitignore file tells Git which files or directories to intentionally ignore. These files won’t be tracked, and they won’t appear in git status. This is useful for:

  • Build artifacts: Compiled code, temporary files.
  • Dependencies: Packages managed by a package manager (e.g., node_modules).
  • Sensitive information: API keys, passwords (never commit these!).
  • Operating system files: e.g., .DS_Store on macOS.
  • Editor/IDE-specific files: e.g., .idea (IntelliJ IDEA).

Create a file named .gitignore in the root of your repository. Each line in the file specifies a pattern to ignore.

Example .gitignore:

“`

Ignore compiled Python files

*.pyc

Ignore the node_modules directory

node_modules/

Ignore a specific file

secret.txt

Ignore a directory

/my_secret_directory

Ignore files with .log at the end of their names

*.log
“`

You can find comprehensive .gitignore templates for various project types online (e.g., on GitHub’s gitignore repository).

5. Branching and Merging: Managing Parallel Development

5.1 What is a Branch?

A branch is a lightweight, movable pointer to a commit. It allows you to diverge from the main line of development and work on a new feature, bug fix, or experiment without affecting the main codebase. The default branch is usually named main (or master in older repositories).

5.2 Creating a New Branch (git branch, git checkout -b)

  • git branch <branch_name>: Creates a new branch, but doesn’t switch to it.
  • git checkout -b <branch_name>: Creates a new branch and switches to it in one step (this is the most common way).

bash
git checkout -b feature/add-login
This creates a new branch named feature/add-login and switches your working directory to that branch.

5.3 Switching Between Branches (git checkout)

The git checkout command is used to switch between branches.

bash
git checkout main # Switch back to the main branch
git checkout feature/add-login # Switch to the feature branch

When you switch branches, Git updates your working directory to match the state of the files on that branch.

5.4 Merging Branches (git merge)

Once you’ve finished working on a branch, you’ll typically want to merge its changes back into the main branch (or another branch).

  1. Switch to the target branch: The branch you want to merge into (e.g., main).
    bash
    git checkout main
  2. Merge the source branch:
    bash
    git merge feature/add-login
    This integrates the changes from feature/add-login into main.

Git performs a “fast-forward” merge if possible (if the target branch hasn’t diverged from the source branch). Otherwise, it creates a “merge commit” to combine the changes.

5.5 Resolving Merge Conflicts

A merge conflict occurs when Git cannot automatically merge changes because the same lines in a file have been modified differently on both branches. Git will mark the conflicting areas in the affected files.

Example of a conflict:

“`
<<<<<<< HEAD
This is the content on the main branch.
=======
This is the content on the feature branch.

feature/add-login
“`

To resolve a conflict:

  1. Open the conflicting file(s) in a text editor.
  2. Edit the file to choose the correct version of the code. Remove the <<<<<<<, =======, and >>>>>>> markers.
  3. Save the file.
  4. git add the resolved file.
  5. git commit to complete the merge.

5.6 Deleting Branches (git branch -d, git branch -D)

Once a branch has been merged, you can delete it.

  • git branch -d <branch_name>: Deletes the branch if it has been fully merged. This is a safe operation.
  • git branch -D <branch_name>: Force-deletes the branch, even if it hasn’t been merged. Use this with caution!

bash
git branch -d feature/add-login

6. Working with Remote Repositories

6.1 Adding a Remote Repository (git remote add)

A remote repository is a version of your project that is hosted on the internet or a network. To connect your local repository to a remote, use git remote add.

bash
git remote add origin <repository_url>

  • origin is a conventional name for the primary remote repository (you can use other names, but origin is standard).
  • <repository_url> is the URL of the remote repository (e.g., from GitHub, GitLab, or Bitbucket).

Example:

bash
git remote add origin https://github.com/yourusername/your-repository.git

6.2 Fetching Changes from a Remote (git fetch)

git fetch downloads the latest changes from a remote repository without merging them into your local branches. It updates your local “remote-tracking branches” (e.g., origin/main).

bash
git fetch origin

6.3 Pulling Changes from a Remote (git pull)

git pull combines git fetch and git merge. It downloads the latest changes from a remote and immediately merges them into your current branch.

bash
git pull origin main

This is equivalent to:

bash
git fetch origin
git merge origin/main

6.4 Pushing Changes to a Remote (git push)

git push uploads your local commits to a remote repository.

bash
git push origin main
This pushes the commits from your local main branch to the main branch on the origin remote.

The first time you push a new branch, you may need to use:

bash
git push -u origin <branch_name>

The -u flag sets up “upstream tracking,” so that future git pull and git push commands for that branch will automatically use the corresponding remote branch.

6.5 Understanding origin and main/master

  • origin: The default name for the remote repository you cloned from or added.
  • main (or master): The default name for the primary branch. main is becoming the preferred name, replacing master.

6.6 Working with remotes (git remote -v)

bash
git remote -v
Shows the URLs for your remotes (fetch and push). Useful for verifying your remote configuration.

7. Undoing Changes

Git provides several ways to undo changes, depending on what you want to undo and whether the changes have been committed or pushed.

7.1 Amending the Last Commit (git commit --amend)

If you made a mistake in your last commit (e.g., forgot to add a file, typo in the commit message), you can amend it.

bash
git commit --amend

This opens your editor, allowing you to modify the commit message. You can also add staged changes to the amended commit. Important: Only amend commits that haven’t been pushed to a remote repository. Amending a pushed commit rewrites history, which can cause problems for collaborators.

7.2 Unstaging Files (git reset HEAD <file>)

If you’ve added a file to the staging area but don’t want to include it in the next commit, you can unstage it.

bash
git reset HEAD <file>

This removes the file from the staging area but doesn’t discard the changes in your working directory.

7.3 Discarding Changes in the Working Directory (git checkout -- <file>)

If you’ve made changes to a file in your working directory but want to revert to the last committed version, use:

bash
git checkout -- <file>

Warning: This is a destructive operation. The changes you discard are lost.

7.4 Reverting Commits (git revert)

git revert creates a new commit that undoes the changes introduced by a specific commit. It’s a safe way to undo changes, even if they’ve been pushed, because it doesn’t rewrite history.

bash
git revert <commit_hash>

Replace <commit_hash> with the hash of the commit you want to revert. Git will create a new commit with the opposite changes.

7.5 Resetting to a Previous Commit (git reset) – Use with Caution!

git reset moves the HEAD pointer (and optionally the branch pointer) to a specified commit. It can be used to unstage files, discard changes, or even remove commits from your local history. Use git reset with extreme caution, especially with the --hard option, as it can lead to data loss.

There are three main modes of git reset:

  • 7.5.1 --soft: Moves the HEAD pointer, but leaves the staging area and working directory unchanged. This is the least destructive option.
  • 7.5.2 --mixed (Default): Moves the HEAD pointer and resets the staging area to match the specified commit, but leaves the working directory unchanged.
  • 7.5.3 --hard: Moves the HEAD pointer, resets the staging area, and resets the working directory to match the specified commit. This discards any uncommitted changes and unstaged changes.

bash
git reset --soft <commit_hash> # Move HEAD, keep staging area and working directory
git reset --mixed <commit_hash> # Move HEAD, reset staging area (default)
git reset --hard <commit_hash> # Move HEAD, reset staging area and working directory (DANGEROUS)

Never use git reset --hard on commits that have been pushed to a shared remote repository. This will rewrite history and cause problems for anyone else working on the project.

8. Inspecting and Comparing Changes

8.1 Viewing Differences (git diff)

The git diff command shows the differences between:

  • Your working directory and the staging area:
    bash
    git diff
  • The staging area and the last commit:
    bash
    git diff --staged
  • Two specific commits:
    bash
    git diff <commit_hash1> <commit_hash2>
  • A specific file between two commits
    bash
    git diff <commit_hash1> <commit_hash2> -- <file>

8.2 Comparing Branches (git diff branch1 branch2)

bash
git diff main feature/add-login

This shows the differences between the main branch and the feature/add-login branch. It shows what changes are present on feature/add-login that are not on main.

8.3 Viewing File History (git log -p <file>)

bash
git log -p <file>
This shows the commit history for a specific file, including the changes (diffs) made to that file in each commit.

8.4 Blaming (Annotating) Files (git blame <file>)

bash
git blame <file>

This shows, for each line in a file, who last modified that line and in which commit. It’s useful for understanding the history of specific lines of code.

9. Tagging: Marking Specific Points in History

Tags are used to mark specific commits, typically releases or important milestones.

9.1 Creating Lightweight Tags (git tag)

A lightweight tag is simply a pointer to a commit.

bash
git tag v1.0.0

This creates a tag named v1.0.0 pointing to the current commit.

9.2 Creating Annotated Tags (git tag -a)

An annotated tag is a more complete object in Git. It includes the tagger’s name, email, date, and a tagging message. It can also be signed and verified with GPG.

bash
git tag -a v1.0.0 -m "Release version 1.0.0"

9.3 Listing Tags (git tag)

bash
git tag

This lists all tags in the repository.

9.4 Checking Out Tags (git checkout <tag_name>)

You can check out a tag to view the state of the repository at that point in time.

bash
git checkout v1.0.0

This puts you in a “detached HEAD” state. You can make changes and commit them, but you’ll need to create a new branch if you want to save those changes.

9.5 Pushing Tags to a Remote (git push origin <tag_name>, git push origin --tags)

Tags are not automatically pushed to a remote repository.

  • Push a specific tag:
    bash
    git push origin v1.0.0
  • Push all tags:
    bash
    git push origin --tags

10. Stashing: Temporarily Shelving Changes

10.1 Stashing Changes (git stash)

git stash temporarily saves changes that you don’t want to commit yet. This is useful if you need to switch branches but have uncommitted work.

bash
git stash

This saves your modified and staged files to a “stash” and reverts your working directory to the state of the last commit.

10.2 Listing Stashes (git stash list)

bash
git stash list

This shows a list of your stashes.

10.3 Applying Stashes (git stash apply, git stash pop)

  • git stash apply: Applies the most recent stash (or a specific stash) to your working directory without removing it from the stash list.
    bash
    git stash apply # Apply the most recent stash
    git stash apply stash@{2} # Apply a specific stash
  • git stash pop: Applies the most recent stash and removes it from the stash list.
    bash
    git stash pop

10.4 Dropping Stashes (git stash drop)

bash
git stash drop # Drop the most recent stash
git stash drop stash@{2} # Drop a specific stash

10.5 Creating a Branch from a Stash (git stash branch)

bash
git stash branch <branch_name> <stash>
This creates a new branch, checks it out, and applies the specified stash (or the most recent stash if none is specified). This is a good way to recover a stash if applying it to your current branch results in conflicts.

11. Advanced Topics (Brief Overview)

This section provides a very brief overview of some more advanced Git topics. Each of these could be a full article in itself.

11.1 Rebasing (git rebase)

git rebase is an alternative to git merge for integrating changes from one branch into another. It rewrites the commit history by moving a branch’s commits onto the tip of another branch. This can create a cleaner, more linear history, but it should be used with caution, especially on shared branches. Never rebase commits that have been pushed to a public repository.

11.2 Interactive Rebasing (git rebase -i)

Interactive rebasing (git rebase -i) allows you to modify the commit history in more detail. You can reorder, edit, squash (combine), or even delete commits. This is a powerful tool for cleaning up your commit history before sharing it.

11.3 Cherry-Picking (git cherry-pick)

git cherry-pick allows you to apply a specific commit from one branch to another, without merging the entire branch.

11.4 Git Hooks

Git hooks are scripts that Git executes before or after certain events, such as commits, pushes, or merges. They can be used to enforce commit message policies, run tests, or perform other automated tasks.

11.5 Submodules and Subtrees

Git submodules and subtrees allow you to include other Git repositories within your main repository. This is useful for managing dependencies or incorporating external projects.

11.6 .gitattributes File
The .gitattributes file allows you to specify attributes for paths within your

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top