Git Cheatsheet

Setting up Git for the first time requires configuring your identity, preferred editor, and other basic settings. These configurations can be set at system, global, or repository level.

Core Git commands for initializing repositories, checking status, staging files, committing changes, and viewing history. These commands form the foundation of everyday Git usage.

Branches in Git allow you to diverge from the main line of development and work independently without affecting the main codebase. They are lightweight, easy to create and switch between, making them ideal for feature development, bug fixes, and experimentation.

Merging combines changes from different branches. Git offers various merge strategies to handle different scenarios, from simple fast-forwards to complex conflict resolutions.

Git rebase is a command that allows you to reapply commits on top of another base branch. Unlike merging, which creates a new commit that combines changes, rebasing moves the entire branch to begin on the tip of another branch, creating a linear history. This can make the project history cleaner but requires careful use, especially with shared branches.

Remote operations allow you to interact with repositories hosted on servers like GitHub, GitLab, or Bitbucket. These commands enable collaboration by synchronizing your local repository with remote repositories.

Git stash temporarily shelves changes you've made to your working directory so you can work on something else, and then come back and re-apply them later. Stashing is useful when you need to quickly switch context but aren't ready to commit.

Git history commands allow you to view, search, and analyze the commit history of a repository. These commands help you understand how a project has evolved, who made specific changes, and when they were made.

Git provides multiple ways to undo changes depending on where they are in the workflow: working directory, staging area, or committed. Understanding these options helps you recover from mistakes without losing work.

Tags are references that point to specific points in Git history, typically used to mark release points (v1.0, v2.0, etc.). Unlike branches, tags don't change once created. There are two types: lightweight (simple pointer) and annotated (stored as full objects with message, tagger, and date).

Git workflows are structured approaches to development and collaboration in Git. Each workflow has its strengths and is suitable for different team sizes and project types.

Git hooks are scripts that Git executes before or after events such as commit, push, and receive. They allow you to customize Git's behavior and automate workflows like code linting, testing, and deployment.

Git submodules allow you to keep a Git repository as a subdirectory of another Git repository. This lets you clone another repository into your project and keep your commits separate.

Git aliases are custom shortcuts for Git commands that can save time and reduce typing. They allow you to create simple abbreviations for complex or frequently used commands, making your Git workflow more efficient.

Git bisect is a powerful debugging tool that uses binary search to find the commit that introduced a bug. It helps you efficiently narrow down the problematic commit by testing the middle point between a known good commit and a known bad commit.

Cherry-picking allows you to apply specific commits from one branch to another. It's useful when you want to selectively apply changes rather than merging entire branches. Each cherry-picked commit creates a new commit with the same changes but a different commit hash.

Git reflog (reference log) records updates to branches and other references, providing a safety net for recovering lost commits, branches, or accidentally reset changes. Unlike git log, reflog includes all reference updates, even those that aren't part of the current branch history.

Git Large File Storage (LFS) is an extension that replaces large files with text pointers inside Git, while storing the file contents on a remote server. This helps maintain repository performance when working with large binary files like images, videos, and datasets.

Git's internal structure is built around a simple key-value store and a content-addressable filesystem. Understanding how Git stores and references data helps demystify its operations and enables advanced troubleshooting and workflows.

Common Git issues and their solutions. When Git operations don't work as expected, these troubleshooting steps can help identify and resolve problems.

Git patches allow you to create and apply changes in a structured format. This is useful for sharing changes with others, applying changes from others, or creating a series of changes to apply later.