Gain insights into Git version control, delving into commits, branches, and remote collaboration. Learn about resolving conflicts and handling erroneous changes to manage software projects efficiently.

MBE-  Beginning Git Version Control by Thomas Makzan.png

DockerGit.tar.gz

email

name

Grouping 

Git is one of the most widely used version control tools in the software industry. Whether working on frontend or backend, native or server-side applications, every software developer should be comfortable with Git version control.

In this course, you’ll learn how Git is used in software projects and the basics of version control. Moreover, you’ll learn commits, pushing code, branches, and Git Stash. Finally, you’ll learn to use Git for remote collaboration, including reconciling conflicts and correcting erroneous changes with fetch, pull, reversion, and cherry-picking. At each step, you’ll solve quizzes to test your knowledge.

By the end of this course, you’ll have a working knowledge of Git and its use in version control. You’ll be able to proficiently and efficiently manage your future software projects.

Getting Started with Git Version Control

In Git, we have different undo approaches for different scenarios. It depends on what we need to do.The following is a list of scenarios in which an undo action is required:

- Amend the last commit.

- Reset several commits.

- Revert changes after pushing to a remote branch.

- Rebase commits into another commit.


Sometimes, we may start changing our code before switching to a new branch. For example, assume that we’re working in the `master` or `development` branch with a clean working directory. Now, we change something in the code file, and then we realize we need to create a new feature branch for that change.

# The `git stash` command
We can use `git stash` to temporarily save our current changes.
``` Shell
$ git stash
```
This command saves our current status of noncommitted changes so that the working directory becomes clean again.

Now, we can create a new branch:
``` Shell
$ git checkout -b new_feature_branch
```
In the new branch, we can pop the saved state by using `git stash pop`.
``` Shell
$ git stash pop
```
## Significance of stash
Stashing allows us to save the work in progress to clean the working directory. This enables us to save the changes and switch branches.

> **Note:** Please note that Git allows us to push and pop the stash in a different branch. But it could be confusing when we pop a stash into a commit that wasn’t original.

Let’s do an example where we make some changes to a file but then switch to the `master` branch to do some work. In this situation, we’ll stash the changes and then pop them when we return.
## Example

Now, let’s create a new branch called `New_Branch`, make some changes to the file, and then commit.

We’ve run these commands in the terminal below:


```Shell
$ git checkout -b New_Branch
$ echo "First Change" >> file1.txt
$ git add file1.txt
$ git commit -m "Commit in New Branch"
```
After applying some more changes, suppose we need to move to the `master` branch. We can’t commit the recent changes because we’re still working on them. So, we use `git stash`. In the commands below, with the help of `git diff`, we can see the recently added changed. When we run `git status`, we see that all the work after the last commit isn’t there and has been stashed, making the working directory clean.

```Shell
$ echo "Changes currently in progress" >> file1.txt
$ git diff
$ git stash
$ git status
```
Next, we move to the `master` branch, do the work required, and get back to the `New_Branch`.
```Shell
$ git checkout master
$ git checkout New_Branch
```
Try to read the contents of the file `file1.txt` using `cat file1.txt`. Unsaved changes aren’t there.

Now, we run the following:
 
``` Shell
$ git stash pop
```
We run the `git status` command again to confirm that the state is restored. Also, now we can see the changes in `file1.txt` with the `cat` command.
```Shell
$ git status
$ cat file1.txt
```

1. After applying some more changes, use `git stash`.
   ```Shell
   $ echo "Changes currently in progress" >> file1.txt
   $ git diff
   $ git stash
   $ git status
   ```
2. Move to the `master` branch and get back to the `New_Branch`.
   ```Shell
   $ git checkout master
   $ git checkout New_Branch
   ```
3. Run the following: 
   ``` Shell
   $ git stash pop
   ```
4. Run the `git status` command again and see the changes in `file1.txt` with the `cat` command.
   ```Shell
   $ git status
   $ cat file1.txt
   ```



Learn to temporarily save noncommitted changes so we can switch between branches without losing our work.

Getting Started

Basic Command

Behind the Scenes

Essential Techniques

Flow Control

Remote and Collaboration

Handle Conflicts

Undo Changes

Rebase and Cherry Pick

Conclusion

Stash Working Directory