Do you really know Git?

#javascript #programming #git #learning

Images in this blog come from "Pro Git" by Scott Chacon, Ben Straub

In this blog, you'll get to read about all kinds of neat facts about some of the every-day features within Git that you use in programming!

It's easy for developers to blindly use tools and not know how they work under the hood. While this abstractions is for the better, knowing how things work can sometimes be what makes the difference between a seasoned and amateur programmer.

Let's dive into some cool facts!

1 - Short Status

If you've used Git for quite a while, you should know about git status. However, did you know there's an option to get a more readable and minimal status output?

By using the short status flag, -s, you get a more compact format.

$ git status -s
 M README
MM Rakefile
A  lib/git.rb
M  lib/simplegit.rb
?? LICENSE.txt

You'll notice that there are 2 columns on the left section of the output. The left column represents the status of the staging area, while the right column represents the status of the working tree. The order of actions chronologically is represented from left to right as well.

Let's interpret the output above:

" M" - modified but not staged
"MM" - staged and then modified again. Thus, an additional stage is required for the next commit.
"A " - a new file was created and staged
"M " - staged
"??" - a new file was created but was not staged (untracked)

2 - Skipping the Staging Area

What if you want to stage your tracked files and commit all in one command?

You can do so by using git commit -a -m "message".

Note that untracked files (newly created files) will not be staged with this magical command unfortunately.

3 - View your Commit History

Use git log to list the commits made in your repository in reverse chronological order (most recent commits show up first).

There are various options that allow you to customize the output. Let's go over some useful ones:

-{number} limits the number of log entries displayed (e.g., git log -2 shows the last two entries)
--stat shows abbreviated stats like # of files or # of insertions/deletions for each commit
--pretty=oneline prints each commit on a single line
--graph adds an ASCII graph showing your branch and merge history

4 - Undoing Things using Git Restore

When you want to unstage a file, use git reset HEAD . When you want to unmodify a modified file, use git checkout -- {file}.

Now there's an easier way to do both! Git version 2.23.0 introduced git restore, which brings a 2-in-1 ability to both unstage and unmodify files.

git restore {file} - unmodify a modified file
git restore --staged {file} - unstage a staged file

5 - Git Fetch vs. Git Pull

Most likely, you've used git pull at least once as a programmer. Additionally, you've most likely heard about git fetch but never really had the need to use it. Well, let's talk about what it actually does and how it's different from git pull.

You can think of fetch as just the first step of what happens within a pull.

In a pull, we download all the data from the remote repository and transfer it onto the local repository. This is what a fetch does.

At this point, your local repository has the data but hasn't merged it with the working directory so that you can work on the latest changes. The next step within a pull is a merge with your branch so that the latest changes are then in your working directory.

Thus, a pull fetches and merges all at once, while a fetch only does the first step.

6 - Git Aliases

What if I told you there was a way to make your git commands customizable? Through the git config, you can!

You can set aliases for frequently used commands like so:

$ git config --global alias.co checkout
$ git config --global alias.br branch
$ git config --global alias.ci commit
$ git config --global alias.st status

Now, instead of typing git commit, you just need to type git ci.

This is especially useful for commands that help make a certain task more intuitive.

$ git config --global alias.unstage 'reset HEAD --'
# the double dash serves as an option separator. 
# It tells Git to treat anything after it as a filename

The command above makes the following commands equivalent:

git unstage fileA
git reset HEAD -- fileA

It's also common to add a last command to see your most recent commit:

$ git config --global alias.last 'log -1 HEAD'

That's all for this blog! I hope you learned a few neat tricks for your next project with Git that will improve the quality of your workflow. Thanks for reading!