Ned's Declassified Git Survival Guide ?

Welcome to Ned's Declassified Git Survival Guide! ? In this guide, you'll learn essential Git commands like git checkout and git restore to undo changes, git stash to save uncommitted work temporarily, git cherry-pick? to pull specific commits from one branch to another, and git reflog to recover "lost commits". Whether you're fixing a bug ?, changing priorities because your manager decided that, or restoring deleted code, these commands will help you handle common real-case scenarios with confidence ?. So, let’s dive in and master Git together!

This is what we'll learn today:

Index ?

1. Episode 1: First Day of Work & Bugs

   • Using git checkout to restore files from a previous commit.
   • Saving uncommitted changes with git restore.

2. Episode 2: We've Got a New Priority, Houston

   • How to stash untracked files with git stash.
   • Managing stashes and retrieving them when needed.

3. Episode 3: The CoolFeature Crisis!

   • Using git cherry-pick to select and apply specific commits.

4. Episode 4: I Changed My Mind Drama

   • Recovering deleted commits with git reflog.

5. Conclusion

Episode 1: First Day of Work & Bugs

Let's say we're building a Map Application for your workplace, and we have the following folder structure:

We refactor our main.tsx file because we want MapsApp.tsx to be our main application file, but we accidentally introduce a bug.

We don't realize it and proceed to commit and push it to the remote repository:

(In case you're curious, I'm using gitmoji for cool commit messages.)

Now, you run your project and realize there's a bug in main.tsx because the console tells you, but for some reason, you can't find it—maybe you're nervous, so...

Advice #1: Restoring Files Saves Lives

In this scenario, for simplicity, let's say you've already pushed the project before the refactor as a good practice (otherwise, you're in trouble). You use git log, and it shows you the following:

Since you have a previous good file, you can simply use git log and select the commit hash that you want to restore. In our case, it's this one:

Then, proceed to write:

git checkout 4d7490e src/main.tsx

And you've restored it—tadaa!

Advice #2: Use git restore for Uncommitted Changes

You have the following uncommitted changes in main.tsx:

You can confirm they are uncommitted with a git status:

And your git log only has the first commit, where you created your project:

You have two options, one easy and one hard:

# Easy one
git restore src/main.tsx
# Hard one
git checkout -- src/main.tsx

I'll go with restore:

Now our file is clean again! Hooray!

Episode 2: Hey, We've Got a New Priority, Houston

Now, your manager or team leader decides it's a good day to change priorities (because that’s their thing). Let's say you're creating a new page called MyCoolPage.tsx:

Now, you have to decide: Should I commit this and then rebase the commits, pick the ones I want, and squash them to make it clean?

Advice #3: Stash It, Bro

Be careful in this case! This special example involves creating a new file that doesn't exist in your repository, so you need to use:

git stash --include-untracked
# Or the shorter flag
git stash -u

Now, you can see the file is no longer with us:

But if you write:

It's still here:

The name of the stash is stash@{0}.

Now, we've got multiple options:

# We can pop the stash and remove it from the list with a simple
git stash pop
# Or apply it and let it stay in the list so we can access it later with
git stash apply stash@{number of your stash}

I'll go with pop, and you can see it's back:

When I try to use git stash list, nothing shows up because it ultimatewas popped from the list:

Episode 3: The CoolFeature Crisis!

You're working in a different branch for a feature called feature/myCoolFeature, which has three requirements. You've already completed two of them, so you have two commits in that branch.

Now, your manager tells you: Hey, we need the CoolFeature you implemented from your branch, but only the first one, and we need it now!

You could create a branch from your current one, delete the HEAD commit, and merge it into main, but that’s too much for such a simple task.

Advice #4: Use Cherry-Pick to Get That Commit

GitSurvivalGuide
Go to your main branch with git checkout main and get the log from the other branch with:

git log feature/myCoolFeature

Then, cherry-pick the specific commit:

And Linus Torvalds (creator of Git & Linux) saves the day again! And if you use git log, you can see your changes are there:

Episode 4: The “I Changed My Mind” Drama

Let's say you created a new feature:

You add and commit it, but you change your mind and decide to delete it, so you proceed to Google and search how to delete a commit. You find that with a git reset --hard HEAD~1, you proceed to use it.

You're fine until you realize that you want to reuse some code, but now when you use git log, you can't find it. You think:

Advice #5: If You Can't Find It in git log, It's Time to reflog

Just check the magic of this command:

Now you've got the hash to restore your commit:

Another happy ending!

Conclusion ?

Congrats dawg, you've just aced your Git survival guide! ? Just like Ned’s Declassified School Survival Guide ?, you now have a nice toolkit to navigate the tricky hallways of version control. From using git checkout to fix those accidental missteps, stashing away uncommitted changes like a pro, cherry-picking commits when the pressure's on, to rescuing lost work with git reflog, you're set to tackle any Git challenge with confidence. ??️ So, put these tips into practice and keep your projects running smoothly.

Special thanks to Midu without his Git book, I wouldn't have made this article. ??✨

Thank you for reading!

Let me know, dawg, your thoughts or any suggestions about Git in the comments down below ?