Understanding Git Internals: Objects, Trees, and Blobs Quiz Quiz

Explore the foundational structure of Git repositories with a focus on objects, trees, and blobs. This quiz helps users solidify their understanding of how Git manages data storage and relationships within its internals.

1. Understanding Git Blob Objects

   Which statement best describes a blob object in Git, especially when you add a new file to your repository?

   1. A blob object saves the filename and path along with the file's content.
   2. A blob links directly to all tree objects that contain it.
   3. A blob stores the raw file data without filename or directory information.
   4. A blob is used to store branch metadata like commit history.

   Explanation: A blob in Git is designed to store the contents of a file as raw data, not including the filename or any directory structure. Option B is incorrect because the blob object itself doesn't record filenames or paths; tree objects do that instead. Option C is wrong since blobs are not aware of which trees reference them; only trees reference blobs, not the other way around. Option D is unrelated, as blobs are not used for storing branch metadata or commit information.

2. Function of Tree Objects in Git

   In Git, what is the primary role of a tree object within the repository structure?

   1. A tree object keeps track of the parent commits in the repository.
   2. A tree object organizes and records directory structure, mapping filenames to their blobs or subtrees.
   3. A tree object manages the storage of file contents in compressed format.
   4. A tree object logs changes made to the main branch.

   Explanation: Tree objects in Git function to represent directories, connecting filenames to blob objects (for files) or other tree objects (for subdirectories). Option A is incorrect; blobs handle file content, not trees. Option B confuses tree objects with commits, which track parent commits. Option D is mistaken because change logging is handled elsewhere, not by tree objects.

3. Unique Identification of Git Objects

   How does Git uniquely identify each object, such as blobs and trees, in its repository storage?

   1. By a hash value generated using SHA-1 or SHA-256.
   2. By a sequential numeric ID assigned on creation.
   3. By a combination of filename and current date.
   4. By file size and line count stored together.

   Explanation: Git objects are uniquely identified by cryptographic hash values created with SHA-1 or, in newer setups, SHA-256. This ensures integrity and uniqueness regardless of file name or order. Option B is inaccurate because Git does not use sequential numeric IDs. Option C's method does not guarantee uniqueness or security. Option D is unrelated to how Git identifies or verifies objects.

4. Git Commit Objects and Their Relationships

   When a commit is created in Git after staging changes, which elements does the commit object directly reference?

   1. The branch name and last modified time.
   2. Only the changed files and their blobs.
   3. All blobs from the entire repository history.
   4. The previous commit, associated tree object, and commit message.

   Explanation: A commit object in Git points to the preceding commit (parent), the current tree object (describing the repository's state), and contains the commit message as metadata. Option B is too limited, as commits do not directly point to individual files or blobs. Option C is wrong because branch names are managed separately and not within the commit object. Option D is incorrect; commits only point to the current state, not every blob in past history.

5. Storage and Duplication in Git

   If the same file content is added to two different directories within a Git repository, how does Git store this data internally?

   1. Git creates only one blob object and references it from multiple tree objects.
   2. Git appends a location tag to each blob to distinguish them.
   3. Git creates two separate blob objects for each file location.
   4. Git merges the files and saves them as a single file object.

   Explanation: Git is designed to avoid duplication by creating a single blob object for identical content, even when that content appears in multiple places. Trees will reference the same blob wherever needed. Option A is wrong because that would waste space. Option C is misleading since Git does not merge file contents unless explicitly instructed through a merge operation. Option D is incorrect because the blob itself does not store information about its directory location; that is handled by trees.