Git-Mastery: Lessons

T1L5. Saving a Snapshot


After staging, you can now proceed to save the snapshot, aka creating a commit.

This lesson covers that part.

Saving a snapshot of a repository is called committing, and the saved snapshot itself is called a commit.

Git constructs a commit based on the staging area. When you examine the staging area using a CLI command or a Git GUI, you are typically shown only a list of staged changes. This presentation can give the misleading impression that the staging area is merely a record of changes you have selected to include in the commit. In reality, the staging area which Git internally calls the index, is a complete record of the exact version of every tracked file that would be written into the next commit, not just a record of staged changes. This behaviour aligns more closely with the name "index" than the name "staging area".

A Git commit is therefore a full snapshot of all tracked files. More precisely, a record of the exact state of all files in the staging area at that moment -- even the files that have not changed since the previous commit. This contrasts with to the intuitive expectation that only the is stored in a commit. Consequently, a Git commit has all the information it needs to recreate the snapshot of the tracked files in working directory at that point in time. In addition to the file contents, a commit also stores metadata such as the author, date, and an optional commit message describing the change.

Working Directory
.git Folder

C1 ← a commit

↑ ├── a snapshot of all tracked files │ ├── fruits.txt (snapshot) │ └── colours.txt (snapshot) └── other metadata about the commit
      e.g., author, date, commit message
other Git metadata ...

staging area

[if this is right after the commit was created, no changes will appear here, i.e., the staging area matches the snapshot in the commit]


├─ fruits.txt (tracked)
└─ colours.txt (tracked)

Following from this, the state of the staging area is not "empty" right after a commit. Rather, it is empty of changes. It still contains a record of all tracked files, reflecting exactly the versions that were written into the previous commit.

A Git commit is a snapshot of all tracked files, not simply a delta of what changed since the last commit.

HANDS-ON: Creating your first commit

Target To create a commit based on staged changes.

Preparation

Option 1: Create a fresh sandbox using the Git-Mastery app

  • Navigate inside the gitmastery-exercises folder.
  • Run gitmastery download hp-first-commit command.

The sandbox will be set up inside the gitmastery-exercises/hp-first-commit folder.

Git-Mastery commands list | Report Git-Mastery bugs | How to update Git-Mastery

Option 2: Continue with the sandbox from the previous hands-on practical

 CLI

1 First, let us do a sanity check using the git status command, to confirm there are staged files.

git status
⤷
On branch main

No commits yet

Changes to be committed:
(use "git rm --cached <file>..." to unstage)
  new file:   fruits.txt

2 Now, create a commit using the commit command. The -m switch is used to specify the commit message.

git commit -m "Add fruits.txt"
⤷
[main (root-commit) d5f91de] Add fruits.txt
 1 file changed, 4 insertions(+)
 create mode 100644 fruits.txt

3 Verify the staging area is empty using the git status command again.

git status
⤷
On branch main
nothing to commit, working tree clean

Note how the output says nothing to commit which means the staging area is now empty.

 Sourcetree

1 Ensure the new file fruits.txt has been staged.

2 Click the Commit button at the top of the window.

3 Enter a commit message (e.g. add fruits.txt) into the text box.

4 Click Commit.

done!

EXERCISE: grocery-shopping

DETOUR: Staging File Deletions

When you delete a tracked file from your working directory, Git doesn’t automatically assume you want that change to be part of your next commit. To tell Git you intend to record a file deletion in the repository’s history, you need to stage the deletion explicitly.

When you stage a deleted file, you’re adding the removal of the file to the staging area, just like you’d stage a modified or newly-created file. After staging, the next commit will reflect that the file was removed from the project.

Note that staging a file deletion matters only if there is at least one commit in the repository. Before any commits are made, there is no file history, so deletions have no effect on the repository.

 CLI

To delete a file and stage the deletion in one go, you can use the git rm <pathspec> command. It removes the file from the working directory and stages the deletion at the same time.

git rm data/list.txt plan.txt

If you’ve already deleted the file manually (for example, using rm or deleting it in your file explorer), you can still stage the deletion using the stage command (or its synonym add) command. Even though the file no longer exists, staging the deletion records its deletion into the staging area.

git stage data/list.txt  # same as: git add data/list.txt

Unstaging file deletions is covered in the tour Unstaging Changes given in the lesson T1L4. Specifying What to Include in a Snapshot.

Staging a file deletion is done similar to staging other changes.

 Sourcetree

Staging a file deletion is done similar to staging other changes.

Related DETOUR: Updating the Last Commit

Git allows you to amend the most recent commit. This is useful when you realise there’s something you’d like to change — e.g., fix a typo in the commit message, or to exclude some unintended change from the commit.

That aspect is covered in the tour Updating the Last Commit given in the lesson T5L3. Reorganising Commits.

Related DETOUR: Resetting Uncommitted Changes

At times, you might need to get rid of uncommitted changes so that you have a fresh start to the next commit.

That aspect is covered in the tour Resetting Uncommitted Changes given in the lesson T4L5. Rewriting History to Start Over.

Related DETOUR: Undoing/Deleting Recent Commits

How do you undo or delete the last few commits if you realise they were incorrect, unnecessary, or done too soon?

That aspect is covered in the tour Undoing/Deleting Recent Commits given in the lesson T4L5. Rewriting History to Start Over.