Basic Git Workflow

Question 1

Explain the following:

git init

Answer 1

The word init means initialize. The command sets up all the tools Git needs to begin tracking changes made to the project

creates a new Git repository

Question 2

How can you think of a Git project?

Answer 2

A Git project can be thought of as having three parts:

1. A Working Directory: where you’ll be doing all the work: creating, editing, deleting and organizing files
2. A Staging Area: where you’ll list changes you make to the working directory
3. A Repository: where Git permanently stores those changes as different versions of the project

The Git workflow consists of editing files in the working directory, adding files to the staging area, and saving changes to a Git repository. In Git, we save changes with a commit

Question 3

Explain following:

git status

Answer 3

When you do work, you will be changing contents of the working directory. You can check the status of these changes with

git status

inspects the contents of the working directory and staging area

Question 4

What does the

untracked files

stand for?

Answer 4

n the output, notice the file in red under

untracked files

. Untracked means that Git sees the file but has not started tracking changes yet.

Question 5

Explain the following

git add filename

Answer 5

In order to Git to start tracking a file, the file needs to be added to the staging area.

The file shows up as green colored when it is added to staging area.

adds files from the working directory to the staging area

Question 6

Explain the following:

git diff filename

Answer 6

When you make changes in a file after you added it, since the file is tracked, we can check the differences between the working directory and the staging area with

git diff filename

shows the difference between the working directory and the staging area

Question 7

Explain the following

git commit

Answer 7

A commit is the last step in our Git workflow. A commit permanently stores changes from the staging area inside the repository.

You need the

-m

option followed by a message, as so:

git commit -m "Complete first line of dialogue"

Standard convention for commit messages:
1. Must be in quotation marks
2. written in present tense
3. Should be brief (50 characters or less) when using

-m

permanently stores file changes from the staging area in the repository

Question 8

Explain the following

git log

Answer 8

Often with Git, you’ll need to refer back to an earlier version of a project. Commits are stored chronologically in the repository and can be viewed with:

git log

shows a list of all previous commits

Question 9

Explain the following

What is the purpose of Git’s staging area?

Answer 9

To stage file changes for a commit

Question 10

The output below is typical of which command?

commit bda95786432d142bbff996ad32045fa4f32ec619
Author: codecademy <ccuser@codecademy.com>
Date: on Nov 16 13:13:33 2015 -0500
First commit

Answer 10

git log

Question 11

The command “git status” shows

Answer 11

Untracked files and file changes staged for commit

Question 12

Explain the following:

git show HEAD

Answer 12

In Git, the commit you are currently on is known as the HEAD commit. In many cases, the most recently made commit is the HEAD commit.

The output of this command will display everything the git log command displays for the HEAD commit, plus all the file changes that were committed.

Question 13

What does ‘git checkout’ do and how do you use it?

Answer 13

git checkout HEAD filename

will restore the file in your working directory to look exactly as it did when you last made a commit.

Here, filename again is the actual name of the file. If the file is named changes.txt, the command would be

git checkout HEAD changes.txt

Question 14

How do you add multiple files to staging area?

Answer 14

git add filename_1 filename_2

Question 15

What does this command do:

git reset HEAD filename

Answer 15

This command lets you unstage that file from the staging area. This command resets the file in the staging area to be the same as the HEAD commit. It does not discard file changes from the working directory, it just removes them from the staging area.

If you staged a file, but then you realize you do not want to commit that file to repository, then this command restores that file as it previously was in the HEAD commit.

Notice in the output, “Unstaged changes after reset.”

M

is short for “modification”

Question 16

Explain following command:

git reset commit_SHA

Answer 16

You can “rewind” your changes to a past previous commit of your choosing.

This command works by using the first 7 characters of the SHA of a previous commit. For example, if the SHA of the previous commit is 5d692065cf51a2f50ea8e7b19b5a7ae512f633ba, use:

git reset 5d69206

HEAD is now set to that previous commit.

Question 17

Explain “git reset” diagram:

Answer 17

To better understand

git reset commit_SHA

, each circle in the diagram represents a commit.

Before reset:
* HEAD is at the most recent commit

After resetting:
* HEAD goes to a previously made commit of your choice
* The gray commits are no longer part of your project
* You have in essence rewound the project’s history

Question 18

What does the command do:

git checkout -- filename

Answer 18

It does the same exact thing that git checkout HEAD filename does.

Question 19

Explain the command:

git stash

Answer 19

Let’s say you’re working on experimental code on a fresh branch and realize that you forgot to add something to a previous commit in order to continue your work. In order to go to a different branch, one must always be at a clean commit point. In this case you don’t want to commit your experimental code since it’s not ready but you also don’t want to lose all the code you’ve been working on.

A good way to handle this is by using git stash, which allows you to get back to a clean commit point with a synchronized working tree, and avoid losing your local changes in the process. You’re “stashing” your local work temporarily in order to update a previous commit and later on retrieve your work.

The flow when using git stash might look something like this:

Question 20

Expalin a use case of
~~~
git stash
~~~

Answer 20

While working on a file, you find a small bug in a separate file from a previous commit that needs to be fixed before you continue.

$ git stash

Running the command above will store your work temporarily for later use in a hidden directory.

At this point, you can switch branches and do work elsewhere.

Once the bug is fixed, you want to retrieve the code you were working on previously, you can “pop” the work that was stored when you used git stash.

$ git stash pop

From here, you can continue your work and commit it when ready.

Question 21

Explain the following:

git log --oneline

Answer 21

shows the list of commits in one line format

Question 22

Explain

git log --oneline --graph - --graph

Answer 22

Displays a visual representation of how the branches and commits were created in order to help you make sense of your repository history. When used alone, the description can be very lengthy, so you can combine the command with –oneline in order to shorten the description.

Question 23

Explain:

git commit --amend

Answer 23

Git’s –amend flag is extremely useful when updating a commit, it allows you to correct mistakes and edit commits easily instead of creating a completely new one.

Let’s say you finish working on a lengthy feature and everything seems to be working fine so you commit your work. Shortly after, you realize you missed a few semicolons in one of your functions. You could technically create a new commit, but ideally, you want to keep all commits specific, clean, and succinct. To avoid creating a new one, you could create your changes, stage them with git add and then type the command git commit –amend to update your previous commit.

It’s important to note that although it seems like –amend is simply updating the commit, what Git actually does is replace the whole previous commit. For this reason, when you execute the command git commit –amend, your terminal editor asks you to update your commit message:

However, if you want to keep the same commit message, you can simply add the flag –no-edit:

git commit --amend --no-edit

Question 24

Explain the usefulness of Git alias?

Answer 24

When grouping commands together, you can end up writing very long lines of Git commands in the terminal such as:
~~~
$ git log –pretty=format:”%h %s” –graph
~~~

Fortunately, Git offers a helpful feature that can make your Git experience simpler, easier, and more familiar: aliases.

If you have a set of commands that you use regularly and want to save some time from typing them, you can easily set up an alias for each command using Git config.

Below are a couple of examples:
~~~
$ git config –global alias.co “checkout”
$ git config –global alias.br “branch”
$ git config –global alias.glop “log –pretty=format:”%h %s” –graph”
~~~

Once the aliases are configured, next time you want to check out to another branch you could type the command:
~~~
$ git co example_branch
~~~

Instead of:
~~~
$ git checkout example_branch
~~~

Using Git aliases can create a much more fluid and efficient workflow experience when using Git. By getting creative with your aliases, you’re able to wrap a sequence of Git commands into one in order to save time and effort.