How to use Git Stash

João Ricardo Mattedi Cetto — Thu, 19 Sep 2024 14:36:23 +0000

While you work on a project in Git, you may encounter situations where you need to temporarily set aside your current work to switch branches or handle other tasks. In these cases, committing the changes of an uncompleted work isn’t always ideal. This is where the command “git stash” becomes useful. With this feature, you can save your uncommitted changes and clean up your workspace, it allows you to return to them later without losing progress. In this post, we’ll explore how to effectively use this feature and some key commands to manage your stashes.

STASH

In Git, the git stash command allows you to temporarily save changes made in your working directory without committing them. This is particularly useful when you’re working on a project but need to switch branches or handle another task without losing your uncommitted changes, which may not yet be ready to commit.

How does `git stash` work?

When you use git stash, it stores changes from both the working directory and the index (staging area), cleaning up your workspace and allowing you to switch focus to another part of the project. These changes are saved in a "stash stack," which allows you to retrieve them later when you’re ready to continue.

Basic Commands

git stash: Saves uncommitted changes in a temporary stash and cleans up the working directory.
git stash apply: Reapplies the stashed changes without removing them - from the stash stack.
git stash pop: Restores the stashed changes and removes them from the stash stack.
git stash list: Lists all saved stashes.
git stash drop [stash_id]: Removes a specific stash from the list.
git stash clear: Removes all stashes from the stack.

Using stash

Scenario:
You're working on a new feature in your project, but a bug appears and you need to switch branches to fix it. You don't want to commit your incomplete work yet, but also don't want to lose your changes.

Steps to stash:

1. Current Situation: You've made several changes to files while working on the feature-branch. Use the command git add . to add your work in progress (WIP) to the stage and, with git status you'll see that your WIP is in the stage.

$ git status
On branch feature-branch
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
        modified:   teste/testando.txt

2. Save the Changes to temporarily save your work without committing it, use git stash.

$ git stash
Saved working directory and index state WIP on feature-branch: 7e9ca1a first commit

3. Fix the bug on main, commit the changes, and push them.

4. Return to Your Feature Branch once the bug fix is done with git checkout feature-branch

5. Reapply Your Stashed Changes using git stash pop.

$ git stash pop
On branch feature-branch
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   teste/testando.txt

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (8e60d99fc7d822c5c0c67b7c3f709d2085026eb2)

Obs: This command applies your saved changes back to the working directory and removes them from the stash list.

Did you enjoy the post? If you’d like to explore more Git and GitHub features, check out: Forks in GitHub

Forks in GitHub

João Ricardo Mattedi Cetto — Thu, 19 Sep 2024 13:07:55 +0000

In this post, I will introduce a important Git/GitHub feature: Forks

FORK

A fork creates an exact copy of the original repository within the user’s profile, while maintaining a link to the source repository. The primary purpose of a fork is to allow users to modify the original project, experiment with new features, or contribute to the project without directly impacting the main repository.

MAIN USES OF FORK

Collaboration in Open-Source Projects: Developers can contribute to projects without needing direct permission from the original repository;
Project Personalization: Users can make modifications to suit their specific needs while maintaining a separate repository.

HOW TO MAKE A FORK?

1. Navigate to the repository you wish to fork and click on the "Fork" option:

2. Create your fork by selecting the repository:

3. Copy the clone link of your forked repository to your local machine. You can then make changes or implement new features:

4. Clone the repository in your IDE and begin coding!!

$ git clone https://github.com/JoaoRicardoCetto/RNA-Evolutiva-C-.git
Cloning into 'RNA-Evolutiva-C-'...
remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0 (from 0)
Receiving objects: 100% (3/3), 4.74 KiB | 4.74 MiB/s, done.

5. Enter the local repository, open the folder in your IDE, make your modifications, add them to the stage, commit and push it to make a pull request.

$ git commit -am "adding to the stage and committing"
warning: in the working copy of '.vscode/settings.json', LF will be replaced by CRLF the next time Git touches it
[main eedc221] adding to the stage and committing
 1 file changed, 1 insertion(+), 1 deletion(-)

6. Once you have made your changes and committed them, you can create a pull request to the main repository, suggesting your modifications to be merged into the original project.

OBS: To incorporate commits and updates from the upstream repository into your fork, use the following command: git pull upstream main.

This command fetches the latest changes from the upstream repository’s main branch and merges them into your local fork. Make sure you've previously set up the upstream repository with the correct URL:
git remote add upstream https://github.com/Owner-Name/Repository-You-Forked

This ensures that your fork stays in sync with the original project.

Did you enjoy the post? If you’d like to explore more Git and GitHub features, check out: How to use Git Stash

Forem: João Ricardo Mattedi Cetto