- Joined
- Mar 22, 2026
- Messages
- 224
- Reaction score
- 0
Windows 10
Google Chrome 147
Git has become an indispensable tool for developers, enabling efficient collaboration and robust version control for projects of all sizes. Understanding its core concepts and commands is crucial for anyone working with code. This guide will walk you through the fundamental Git commands you'll use daily.
What is Git?
Git is a distributed version control system (DVCS). This means that every developer working on a project has a complete copy of the repository, including its full history. This decentralized approach offers resilience, speed, and flexibility compared to centralized systems.
Key Concepts
Before diving into commands, let's clarify some core Git terms:
Setting Up Git
First, ensure Git is installed on your system. You can download it from the official Git website (git-scm.com). After installation, configure your user name and email:
Starting a New Repository
To initialize a new Git repository in an existing project directory:
This command creates a hidden
The Git Workflow: Add, Commit, Push
1. Checking Status (
This command shows the current state of your working directory and staging area. It tells you which files are untracked, modified, or staged for commit.
2. Staging Changes (
Before committing, you need to "stage" your changes. The staging area (also known as the index) is a temporary snapshot of the changes you want to include in your next commit.
* To stage a specific file:
* To stage all changes in the current directory:
* To stage all deleted files as well:
3. Committing Changes (
Once changes are staged, you can commit them. A commit creates a permanent snapshot of your staged files in the repository history. Always write a clear and concise commit message.
If you omit
4. Viewing History (
To see the commit history of your repository:
This displays commits in reverse chronological order, showing the commit hash, author, date, and commit message.
*
*
Working with Remote Repositories
Most projects involve collaborating with others using a remote repository (e.g., on GitHub, GitLab, Bitbucket).
1. Cloning a Repository (
To get a copy of an existing remote repository onto your local machine:
This command creates a new directory with the repository's name and initializes a Git repo inside it, linking it to the remote.
2. Adding a Remote (
If you initialized a local repo and now want to link it to an empty remote repository:
3. Pushing Changes (
To upload your local commits to the remote repository:
This pushes the
4. Pulling Changes (
To download changes from the remote repository and merge them into your current local branch:
It's good practice to
Branching and Merging
Branches are fundamental for non-linear development.
1. Listing Branches (
To see all local branches:
The current branch will be marked with an asterisk.
2. Creating a New Branch (
This creates a new branch but doesn't switch to it.
3. Switching Branches (
To switch to an existing branch:
To create and switch to a new branch in one command:
4. Merging Branches (
After developing on a feature branch, you'll want to integrate those changes back into a main branch (e.g.,
First, switch to the branch you want to merge *into*:
Then, merge the feature branch:
Git will attempt to merge automatically. If conflicts arise, you'll need to resolve them manually before committing the merge.
5. Deleting Branches (
Once a feature branch is merged, you can delete it:
Use
Undoing Changes (Carefully!)
Git offers several ways to undo changes, but some are destructive.
1. Unstaging Files (
If you've staged a file but decide not to include it in the next commit:
This moves the file from the staging area back to the working directory, keeping your modifications.
2. Discarding Local Changes (
To discard all uncommitted changes in a specific file and revert it to its last committed state:
Warning: This is destructive and will lose any unsaved changes in that file.
3. Rewriting History (
*
*
*
4. Undoing a Commit (
Conclusion
This covers the most frequently used Git commands. Consistent practice is key to mastering Git. Start small, experiment on throwaway repositories, and remember that Git's power lies in its ability to track changes and facilitate collaboration. Happy coding!
What is Git?
Git is a distributed version control system (DVCS). This means that every developer working on a project has a complete copy of the repository, including its full history. This decentralized approach offers resilience, speed, and flexibility compared to centralized systems.
Key Concepts
Before diving into commands, let's clarify some core Git terms:
- Repository (Repo): The project folder that Git tracks. It contains all your files and the complete history of changes.
- Commit: A snapshot of your repository at a specific point in time. Each commit has a unique ID, a message describing the changes, and points to its parent commit(s).
- Branch: A parallel line of development. Branches allow you to work on new features or bug fixes without affecting the main codebase.
- Merge: The process of combining changes from one branch into another.
- HEAD: A pointer to the tip of the current branch, which is the latest commit on that branch.
Setting Up Git
First, ensure Git is installed on your system. You can download it from the official Git website (git-scm.com). After installation, configure your user name and email:
Bash:
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"
Starting a New Repository
To initialize a new Git repository in an existing project directory:
Bash:
cd /path/to/your/project
git init
.git directory, which contains all the necessary Git files for your repository.The Git Workflow: Add, Commit, Push
1. Checking Status (
git status)This command shows the current state of your working directory and staging area. It tells you which files are untracked, modified, or staged for commit.
Code:
bash
git status
2. Staging Changes (
git add)Before committing, you need to "stage" your changes. The staging area (also known as the index) is a temporary snapshot of the changes you want to include in your next commit.
* To stage a specific file:
Code:
bash
git add my_new_feature.py
Code:
bash
git add .
Code:
bash
git add -A
3. Committing Changes (
git commit)Once changes are staged, you can commit them. A commit creates a permanent snapshot of your staged files in the repository history. Always write a clear and concise commit message.
Code:
bash
git commit -m "Add initial structure for user authentication"
-m, Git will open your default text editor for you to write a longer message.4. Viewing History (
git log)To see the commit history of your repository:
Code:
bash
git log
*
git log --oneline: A condensed view.*
git log --graph --oneline --all: Visualize branches and merges.Working with Remote Repositories
Most projects involve collaborating with others using a remote repository (e.g., on GitHub, GitLab, Bitbucket).
1. Cloning a Repository (
git clone)To get a copy of an existing remote repository onto your local machine:
Code:
bash
git clone https://github.com/user/repo.git
2. Adding a Remote (
git remote add)If you initialized a local repo and now want to link it to an empty remote repository:
Code:
bash
git remote add origin https://github.com/user/new-repo.git
origin is the conventional name for the primary remote.3. Pushing Changes (
git push)To upload your local commits to the remote repository:
Code:
bash
git push origin main
main branch from your local origin remote. The first time you push a new branch, you might need to set the upstream:
Code:
bash
git push -u origin main
4. Pulling Changes (
git pull)To download changes from the remote repository and merge them into your current local branch:
Code:
bash
git pull origin main
git pull before starting work and before pushing your own changes to avoid merge conflicts.Branching and Merging
Branches are fundamental for non-linear development.
1. Listing Branches (
git branch)To see all local branches:
Code:
bash
git branch
2. Creating a New Branch (
git branch <branch-name>)
Code:
bash
git branch feature/new-login
3. Switching Branches (
git checkout <branch-name> or git switch <branch-name>)To switch to an existing branch:
Code:
bash
git checkout feature/new-login
# Or using the newer Git 2.23+ command
git switch feature/new-login
Code:
bash
git checkout -b feature/new-login
# Or using git switch
git switch -c feature/new-login
4. Merging Branches (
git merge)After developing on a feature branch, you'll want to integrate those changes back into a main branch (e.g.,
main or develop).First, switch to the branch you want to merge *into*:
Code:
bash
git checkout main
Code:
bash
git merge feature/new-login
5. Deleting Branches (
git branch -d)Once a feature branch is merged, you can delete it:
Code:
bash
git branch -d feature/new-login
-D (force delete) if the branch has unmerged changes.Undoing Changes (Carefully!)
Git offers several ways to undo changes, but some are destructive.
1. Unstaging Files (
git restore --staged <file>)If you've staged a file but decide not to include it in the next commit:
Code:
bash
git restore --staged my_file.txt
2. Discarding Local Changes (
git restore <file>)To discard all uncommitted changes in a specific file and revert it to its last committed state:
Code:
bash
git restore my_file.txt
3. Rewriting History (
git reset)git reset is powerful and can be used to move the HEAD pointer.*
git reset --soft <commit-hash>: Moves HEAD to the specified commit, but keeps all changes staged.*
git reset --mixed <commit-hash> (default): Moves HEAD, unstages changes, but keeps them in your working directory.*
git reset --hard <commit-hash>: Moves HEAD, and *discards all changes* in the working directory and staging area back to the specified commit. This is highly destructive! Use with extreme caution.
Code:
bash
git reset --hard HEAD~1 # Go back one commit, discarding all changes
4. Undoing a Commit (
git revert)git revert creates a *new* commit that undoes the changes of a previous commit. This is safer for shared repositories as it doesn't rewrite history.
Code:
bash
git revert <commit-hash>
Conclusion
This covers the most frequently used Git commands. Consistent practice is key to mastering Git. Start small, experiment on throwaway repositories, and remember that Git's power lies in its ability to track changes and facilitate collaboration. Happy coding!
