Day 10 :- Advance Git & GitHub.

Content :-

Git Branching.
Git Revert and Reset.
Git Rebase and Merge.

Git Branching :-

Git branching is a powerful feature in the Git version control system that allows developers to work on multiple aspects of a project simultaneously without interfering with each other's work. Here's an overview of how branching works in Git:

Master Branch: The default branch in a Git repository is typically called master. This branch represents the stable, production-ready version of the project.
Creating Branches: Developers can create new branches to work on specific features, fixes, or experiments. Branches are lightweight and easy to create.
```
 git checkout -b my-feature
```
This command creates a new branch named my-feature and switches to it (-b option is short for --create and --checkout).
Switching Branches: Developers can switch between branches using the git checkout command.
```
 git checkout master
```
This command switches to the master branch.
Committing Changes: Developers make changes to the files in their working directory and stage them for commit using git add. They then commit the changes to the current branch using git commit.
```
 git add .
 git commit -m "Implemented feature X"
```
Merging Branches: Once work on a branch is complete, changes can be integrated back into the master branch (or any other branch) using the git merge command.
```
 git checkout master
 git merge my-feature
```
This command merges the changes from the my-feature branch into the master branch.
Resolving Conflicts: Sometimes, when merging branches, conflicts may arise if changes in the branches overlap. Developers need to resolve these conflicts manually by editing the affected files and then committing the changes.
Branch Management: Developers can list, rename, delete, and otherwise manage branches using various Git commands.
- git branch: Lists all branches in the repository.
- git branch -d my-feature: Deletes the my-feature branch.
- git branch -m new-name: Renames the current branch to new-name.
Remote Branches: Git also supports remote branches, which are branches stored on a remote repository (like GitHub or Bitbucket). Developers can push and pull changes to and from remote branches using commands like git push and git pull.
```
 git push origin my-feature
```
This command pushes the my-feature branch to the remote repository.

By effectively utilizing branching, developers can collaborate more efficiently, isolate changes, and maintain a clean project history.

Git Revert and Reset :-

In Git, revert and reset are both commands used to undo changes in a repository, but they operate differently and are used in different scenarios.

Git Revert:

The git revert command is used to create a new commit that undoes the changes made by a previous commit. It's a safe way to undo commits because it preserves the commit history and doesn't alter the existing commits.
```
 git revert <commit-hash>
```
This command creates a new commit that undoes the changes introduced by the specified commit.
- <commit-hash>: The SHA-1 hash of the commit to be reverted.

For example:

    git revert abcdef123456

This command will create a new commit that undoes the changes introduced by the commit with the hash abcdef123456.

The git revert command is useful when you want to undo changes in a way that preserves the commit history and allows you to track when and why changes were reverted.

Git Reset:

The git reset command is used to reset the current HEAD to a specified state. It's a more powerful and potentially dangerous command compared to git revert because it can alter the commit history.

There are three main modes of git reset:
- Soft Reset: Moves the HEAD to a specified commit without modifying the working directory or staging area.
```
  git reset --soft <commit-hash>
```
- Mixed Reset: Moves the HEAD to a specified commit and resets the staging area, but keeps the changes in the working directory.
```
  git reset --mixed <commit-hash>
```
- Hard Reset: Moves the HEAD to a specified commit and resets both the staging area and the working directory to match that commit, discarding all changes since then.
```
  git reset --hard <commit-hash>
```
- <commit-hash>: The commit to which you want to reset the HEAD.

For example:

    git reset --hard abcdef123456

This command will move the HEAD to the commit with the hash abcdef123456 and discard all changes made after that commit.

Use caution when using git reset --hard as it can permanently delete uncommitted changes.

In summary, git revert is used to create a new commit that undoes the changes of a previous commit without altering the commit history, while git reset is used to move the HEAD to a specified state, potentially altering the commit history and discarding changes.

Git Rebase and Merge :-

git rebase and git merge are two different Git commands used to integrate changes from one branch into another. Each has its own advantages and use cases.

Git Merge:
- Merge is a non-destructive operation.
- It creates a merge commit to combine the changes from one branch into another.
- It's suitable for integrating feature branches into a main branch, such as merging a feature branch into master.
- Merge commits preserve the commit history of both branches, which can make the history easier to understand but may also result in a more cluttered history.
- Merge conflicts may occur if changes in the branches being merged conflict with each other, and they need to be resolved manually.

Basic merge workflow:

    git checkout master
    git merge feature-branch

This merges the changes from feature-branch into master and creates a merge commit.

Git Rebase:
- Rebase rewrites the commit history by moving or reapplying commits from one branch onto another.
- It results in a linear history without merge commits, which can make the project history cleaner and easier to follow.
- It's useful for keeping feature branches up-to-date with changes in the main branch (master), as it allows you to incorporate changes from master into your feature branch before merging it back.
- Rebase can be used to squash or reorganize commits, making the commit history more coherent.
- It can lead to a cleaner history but may cause conflicts that need to be resolved for each commit that is rebased.

Basic rebase workflow:

    git checkout feature-branch
    git rebase master

This rebases feature-branch onto master, applying the changes from master onto feature-branch one by one. If there are conflicts, they need to be resolved for each commit.

In summary, git merge is used to integrate changes from one branch into another while preserving the commit history, whereas git rebase is used to reapply commits on top of another branch, resulting in a linear history without merge commits. The choice between merge and rebase depends on the project's workflow, team preferences, and the desired structure of the commit history.

Day 10 :- Advance Git & GitHub.

Content :-

Git Branching.

Git Revert and Reset.

Git Rebase and Merge.

Git Branching :-

Git Revert and Reset :-

Git Rebase and Merge :-