Git
Chapters ▾ 2nd Edition

10.2 Εσωτερική λειτουργία του Git - Αντικείμενα του Git

Αντικείμενα του Git

Το Git είναι ένα σύστημα αρχείων διευθυνσιοδοτούμενο από το περιεχόμενο. Εξαιρετικά. Τι σημαίνει αυτό; Σημαίνει ότι ουσιαστικά το Git είναι κατά βάση ένα απλό κατάστημα δεδομένων ζευγαριών κλειδιού-τιμής (key-value data store). Μπορούμε να εισάγουμε οποιουδήποτε είδους περιεχόμενο σε αυτό και θα μας δώσει πίσω ένα κλειδί που μπορούμε να χρησιμοποιήσουμε για να επανακτήσουμε το περιεχόμενο ξανά ανά πάσα στιγμή. Για να το επιδείξουμε, μπορούμε να χρησιμοποιήσουμε την εντολή διοχέτευσης hash-object, η οποία λαμβάνει ορισμένα δεδομένα, τα αποθηκεύει στον κατάλογο .git και μας επιστρέφειτο κλειδί στο οποίο αποθηκεύονται τα δεδομένα. Αρχικά, αρχικοποιούμε ένα νέο αποθετήριο Git και βεβαιωνόμαστε ότι δεν υπάρχει τίποτα στον κατάλογο objects:

$ git init test
Initialized empty Git repository in /tmp/test/.git/
$ cd test
$ find .git/objects
.git/objects
.git/objects/info
.git/objects/pack
$ find .git/objects -type f

Το Git έχει αρχικοποιήσει τον κατάλογο objects και έχει δημιουργήσει τους υποκαταλόγους pack και info σε αυτόν, αλλά δεν έχει κανονικά αρχεία. Τώρα, ας αποθηκεύσουμε κάποιο κείμενο στη βάση δεδομένων του Git:

$ echo 'test content' | git hash-object -w --stdin
d670460b4b4aece5915caf5c68d12f560a9fe3e4

Το -w λέει στην hash-object να αποθηκεύσει το αντικείμενο· διαφορετικά, η εντολή απλά θα μας έλεγε ποιο είναι το κλειδί. Η επιλογή --stdin λέει στην εντολή να διαβάσει το περιεχόμενο από την stdin· αν δεν το καθορίσουμε αυτό, η hash-object αναμένει μια διαδρομή αρχείου στο τέλος. Η έξοδος από την εντολή είναι ένα άθροισμα ελέγχου 40 χαρακτήρων. Αυτός είναι ο αριθμός SHA-1 hash —ένα άθροισμα ελέγχου του περιεχομένου που αποθηκεύουμε συν μια κεφαλίδα, για την οποία θα μάθουμε σε λίγο. Τώρα μπορούμε να δούμε πώς το Git έχει αποθηκεύσει τα δεδομένα μας:

$ find .git/objects -type f
.git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4

Βλέπουμε ένα αρχείο στον κατάλογο objects. Αυτός είναι ο τρόπος με τον οποίο το Git αποθηκεύει αρχικά το περιεχόμενο —ως ένα μοναδικό αρχείο ανά τεμάχιο περιεχομένου, το οποίο ονομάζεται με το άθροισμα ελέγχου SHA-1 του περιεχομένου και την κεφαλίδα του. Ο υποκατάλογος ονομάζεται με τους πρώτους 2 χαρακτήρες του SHA-1 και το όνομα αρχείου είναι οι υπόλοιποι 38 χαρακτήρες.

Μπορούμε να τραβήξουμε περιεχόμενο έξω από το Git με την εντολή cat-file. Αυτή η εντολή είναι ένα είδος ελβετικού σουγιά για την επιθεώρηση αντικειμένων Git. Η επιλογή -p στην εντολή cat-file την καθοδηγεί να καταλάβει τον τύπο του περιεχομένου και να το εμφανίσει κατάλληλα:

$ git cat-file -p d670460b4b4aece5915caf5c68d12f560a9fe3e4
test content

Τώρα, μπορούμε να προσθέσουμε περιεχόμενο στο Git και να το τραβήξουμε πίσω ξανά. Μπορούμε επίσης να το κάνουμε αυτό με περιεχόμενο σε αρχεία. Για παράδειγμα, μπορούμε να κάνουμε κάποιο απλό έλεγχο εκδόσεων σε ένα αρχείο. Αρχικά, δημιουργούμε ένα νέο αρχείο και αποθηκεύουμε τα περιεχόμενά του στη βάση δεδομένων μας:

$ echo 'version 1' > test.txt
$ git hash-object -w test.txt
83baae61804e65cc73a7201a7252750c76066a30

Στη συνέχεια, γράφουμε νέο περιεχόμενο στο αρχείο και το αποθηκεύουμε ξανά:

$ echo 'version 2' > test.txt
$ git hash-object -w test.txt
1f7a7a472abf3dd9643fd615f6da379c4acb3e3a

Η βάση δεδομένων μας περιέχει τις δύο νέες εκδόσεις του αρχείου καθώς και το πρώτο περιεχόμενο που αποθηκεύσαμε εκεί:

$ find .git/objects -type f
.git/objects/1f/7a7a472abf3dd9643fd615f6da379c4acb3e3a
.git/objects/83/baae61804e65cc73a7201a7252750c76066a30
.git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4

Τώρα μπορούμε να επαναφέρουμε το αρχείο στην πρώτη έκδοση

$ git cat-file -p 83baae61804e65cc73a7201a7252750c76066a30 > test.txt
$ cat test.txt
version 1

ή τη δεύτερη έκδοση:

$ git cat-file -p 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a > test.txt
$ cat test.txt
version 2

Αλλά το να θυμόμαστε το κλειδί SHA-1 για κάθε έκδοση του αρχείου μας δεν είναι πρακτικό. Επιπλέον, δεν αποθηκεύουμε το όνομα αρχείου στο σύστημά μας —απλά το περιεχόμενο. Αυτός ο τύπος αντικειμένου ονομάζεται blob. Μπορούμε να βάλουμε το Git να μας πει τον τύπο οποιουδήποτε αντικειμένου στο Git, δεδομένου του κλειδιού του SHA-1, με την cat-file -t:

$ git cat-file -t 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a
blob

Αντικείμενα δέντρων

Ο επόμενος τύπος που θα εξετάσουμε είναι το δέντρο, το οποίο λύνει το πρόβλημα της αποθήκευσης του ονόματος αρχείου και επίσης μας επιτρέπει να αποθηκεύσουμε μια ομάδα αρχείων μαζί. Το Git αποθηκεύει περιεχόμενο λίγο-πολύ όπως το σύστημα αρχείων του UNIX αλλά λίγο απλοποιημένα. Όλα τα περιεχόμενα αποθηκεύοντται ως αντικείμενα δέντρου και blob, με τα δέντρα να αντιστοιχίζονται στους καταλόγους UNIX και τα blob να αντιστοιχίζονται χονδρικά σε inodes ή περιεχόμενα αρχείων. Ένα αντικείμενο δέντρου περιέχει μία ή περισσότερες καταχωρίσεις δέντρων, καθεμία από τις οποίες περιέχει έναν δείκτη SHA-1 σε ένα blob ή ένα υποδέντρο με το σχετικό δικαίωμα πρόσβασης, τύπο και όνομα αρχείου. Για παράδειγμα, το πιο πρόσφατο δέντρο ενός έργου μπορεί να μοιάζει με αυτό:

$ git cat-file -p master^{tree}
100644 blob a906cb2a4a904a152e80877d4088654daad0c859      README
100644 blob 8f94139338f9404f26296befa88755fc2598c289      Rakefile
040000 tree 99f1a6d12cb4b6f19c8655fca46c3ecf317074e0      lib

Η σύνταξη master^{tree} καθορίζει το αντικείμενο δέντρου στο οποίο δείχνει η τελευταία υποβολή στον κλάδο master. Παρατηρούμε ότι ο υποκατάλογος lib δεν είναι blob αλλά ένας δείκτης σε ένα άλλο δέντρο:

$ git cat-file -p 99f1a6d12cb4b6f19c8655fca46c3ecf317074e0
100644 blob 47c6340d6459e05787f644c2447d2595f5d3a54b      simplegit.rb

Τα δεδομένα που αποθηκεύει το Git είναι δυνατό να απεικονιστούν με κάτι τέτοιο:

Απλή εκδοχή του μοντέλου δεδομένων Git.
Figure 149. Απλή εκδοχή του μοντέλου δεδομένων του Git.

Μπορούμε εύκολα να δημιουργήσουμε το δικό μας δέντρο. Το Git δημιουργεί κανονικά ένα δέντρο λαμβάνοντας την κατάσταση του σταδίου καταχώρισης ή ευρετηρίου και γράφοντας μια σειρά από αντικείμενα δέντρων από αυτό. Επομένως, για να δημιουργήσουμε ένα αντικείμενο δέντρου, πρέπει πρώτα να ορίσουμε ένα ευρετήριο βάζοντας μερικά αρχεία στο στάδιο καταχώρισης. Για να δημιουργήσουμε ένα ευρετήριο με μια μοναδική καταχώρηση —την πρώτη έκδοση του αρχείου test.txt— μπορούμε να χρησιμοποιήσουμε την εντολή διοχέτευσης updates-index. Χρησιμοποιούμε αυτήν την εντολή για να προσθέσουμε τεχνητά την παλαιότερη έκδοση του αρχείου test.txt σε ένα νέο στάδιο καταχώρισης. Πρέπει να περάσουμε την επιλογή --add επειδή το αρχείο δεν υπάρχει ακόμη στο στάδιο καταχώρισής μας (για την ακρίβεια δεν έχουμε καν στάδιο καταχώρισης ακόμα, αφού δεν το έχουμε δημιουργήσει) και την --cacheinfo επειδή το αρχείο που προσθέτουμε δεν βρίσκεται στον κατάλογό μας αλλά βρίσκεται στη βάση δεδομένων μας. Στη συνέχεια, καθορίζουμε το δικαίωμα πρόσβασης, τον SHA-1 και το όνομα αρχείου:

$ git update-index --add --cacheinfo 100644 \
  83baae61804e65cc73a7201a7252750c76066a30 test.txt

Σε αυτήν την περίπτωση, καθορίζουμε δικαίωμα πρόσβασης 100644, που σημαίνει ότι είναι ένα κανονικό αρχείο. Άλλες επιλογές είναι 100755, πράγμα που σημαίνει ότι είναι ένα εκτελέσιμο αρχείο· και "120000", που καθορίζει έναν συμβολικό σύνδεσμο. Το δικαίωμα πρόσβασης λαμβάνεται από τα συνήθη δικαιώματα πρόσβασης του UNIX, αλλά είναι πολύ λιγότερο ευέλικτα —αυτά τα τρία δικαιώματα πρόσβασης είναι τα μόνα που ισχύουν για τα αρχεία (blobs) στο Git (για καταλόγους και υπομονάδες χρησιμοποιούνται άλλες μορφές).

Τώρα, μπορούμε να χρησιμοποιήσουμε την εντολή write-tree για να γράψουμε το στάδιο καταχώρισης σε ένα αντικείμενο δέντρου. Δεν χρειάζεται η επιλογή -w —η κλήση της write-tree δημιουργεί αυτόματα ένα αντικείμενο δέντρου από την κατάσταση του ευρετηρίου, αν το δέντρο δεν υπάρχει ακόμα:

$ git write-tree
d8329fc1cc938780ffdd9f94e0d364e0ea74f579
$ git cat-file -p d8329fc1cc938780ffdd9f94e0d364e0ea74f579
100644 blob 83baae61804e65cc73a7201a7252750c76066a30      test.txt

Μπορούμε επίσης να επαληθεύσουμε ότι πρόκειται για ένα αντικείμενο δέντρου:

$ git cat-file -t d8329fc1cc938780ffdd9f94e0d364e0ea74f579
tree

Θα δημιουργήσουμε τώρα ένα νέο δέντρο με τη δεύτερη έκδοση του test.txt και ένα νέο αρχείο:

$ echo 'new file' > new.txt
$ git update-index test.txt
$ git update-index --add new.txt

Το στάδιο καταχώρισής μας διαθέτει τώρα τη νέα έκδοση του test.txt καθώς και το νέο αρχείο new.txt. Γράφουμε αυτό το δέντρο (καταγράφοντας την κατάσταση του σταδίου καταχώρισης ή ευρετηρίου σε ένα αντικείμενο δέντρου) και βλέπουμε πώς φαίνεται:

$ git write-tree
0155eb4229851634a0f03eb265b69f5a2d56f341
$ git cat-file -p 0155eb4229851634a0f03eb265b69f5a2d56f341
100644 blob fa49b077972391ad58037050f2a75f74e3671e92      new.txt
100644 blob 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a      test.txt

Παρατηρούμε ότι αυτό το δέντρο έχει και τις δύο καταχωρήσεις αρχείων και ότι ο SHA-1 του αρχείου test.txt είναι ο SHA-1 του “version 2” από παλαιότερα (1f7a7a). Για πλάκα θα προσθέσουμε το πρώτο δέντρο ως υποκατάλογο σε αυτό. Μπορούμε να διαβάσουμε τα δέντρα που βρίσκονται στο στάδιο καταχώρισής μας καλώντας την read-tree. Σε αυτήν την περίπτωση, μπορούμε να διαβάσουμε ένα υπάρχον δέντρο στο στάδιο καταχώρισής μας ως υποδέντρο χρησιμοποιώντας την επιλογή --prefix στην read-tree:

$ git read-tree --prefix=bak d8329fc1cc938780ffdd9f94e0d364e0ea74f579
$ git write-tree
3c4e9cd789d88d8d89c1073707c3585e41b0e614
$ git cat-file -p 3c4e9cd789d88d8d89c1073707c3585e41b0e614
040000 tree d8329fc1cc938780ffdd9f94e0d364e0ea74f579      bak
100644 blob fa49b077972391ad58037050f2a75f74e3671e92      new.txt
100644 blob 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a      test.txt

Αν δημιουργούσαμε έναν κατάλογο εργασίας από το νέο δέντρο που μόλις γράψαμε, θα παίρναμε τα δύο αρχεία στο ανώτερο επίπεδο του καταλόγου εργασίας και έναν υποκατάλογο με όνομα bak που θα περιείχε την πρώτη έκδοση του αρχείου test.txt. Μπορούμε να σκεφτόμαστε τα δεδομένα που περιέχει το Git για αυτές τις δομές ως εξής:

Η δομή περιεχομένων των τωρινών δεδομένων μας στο Git.
Figure 150. Η δομή περιεχομένων των τωρινών δεδομένων μας στο Git.

Αντικείμενα υποβολής

Έχουμε τρία δέντρα που καθορίζουν τα διαφορετικά στιγμιότυπα του έργου μας που θέλουμε να παρακολουθήσουμε, αλλά το προηγούμενο πρόβλημα παραμένει: πρέπει να θυμόμαστε και τις τρεις τιμές SHA-1 για να ανακαλούμε τα στιγμιότυπα. Επίσης, δεν έχουμε πληροφορίες σχετικά με το ποιος αποθήκευσε τα στιγμιότυπα, πότε αποθηκεύτηκαν ή γιατί αποθηκεύτηκαν. Αυτή είναι η βασική πληροφορία που αποθηκεύει το αντικείμενο υποβολής για μας.

Για να δημιουργήσουμε ένα αντικείμενο υποβολής, καλούμε την commit-tree και καθορίζουμε τον SHA-1 ενός μόνο δέντρου και ποια αντικείμενα υποβολής, αν υπάρχουν, προηγούνταν ακριβώς πριν από αυτό. Ξεκινάμε με το πρώτο δέντρο που γράψαμε:

$ echo 'first commit' | git commit-tree d8329f
fdf4fc3344e67ab068f836878b6c4951e3b15f3d

Τώρα μπορούμε να δούμε το νέο μας αντικείμενο υποβολής με την cat-file:

$ git cat-file -p fdf4fc3
tree d8329fc1cc938780ffdd9f94e0d364e0ea74f579
author Scott Chacon <schacon@gmail.com> 1243040974 -0700
committer Scott Chacon <schacon@gmail.com> 1243040974 -0700

first commit

Η μορφή ενός αντικειμένου υποβολής είναι απλή: καθορίζει το δέντρο ανώτερου επιπέδου για το στιγμιότυπο του έργου σε εκείνο το σημείο· τις πληροφορίες συγγραφέα/υποβάλλοντος (οι οποίες χρησιμοποιούν τις ρυθμίσεις διαμόρφωσης user.name και user.email και μία χρονοσήμανση)· μια κενή γραμμή και στη συνέχεια το μήνυμα υποβολής.

Στη συνέχεια, θα γράψουμε τα άλλα δύο αντικείμενα υποβολής, καθένα από τα οποία αναφέρεται στην ακριβώς προηγούμενή του υποβολή:

$ echo 'second commit' | git commit-tree 0155eb -p fdf4fc3
cac0cab538b970a37ea1e769cbbde608743bc96d
$ echo 'third commit'  | git commit-tree 3c4e9c -p cac0cab
1a410efbd13591db07496601ebc7a059dd55cfe9

Καθένα από τα τρία αντικείμενα υποβολής δείχνει σε ένα από τα τρία δέντρα στιγμιοτύπων που δημιουργήσαμε. Περιέργως, έχουμε πλέον ένα πραγματικό ιστορικό Git, το οποίο μπορούμε να δούμε με την εντολή git log, αν την εκτελέσουμε στον SHA-1 της τελευταίας υποβολής:

$ git log --stat 1a410e
commit 1a410efbd13591db07496601ebc7a059dd55cfe9
Author: Scott Chacon <schacon@gmail.com>
Date:   Fri May 22 18:15:24 2009 -0700

	third commit

 bak/test.txt | 1 +
 1 file changed, 1 insertion(+)

commit cac0cab538b970a37ea1e769cbbde608743bc96d
Author: Scott Chacon <schacon@gmail.com>
Date:   Fri May 22 18:14:29 2009 -0700

	second commit

 new.txt  | 1 +
 test.txt | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

commit fdf4fc3344e67ab068f836878b6c4951e3b15f3d
Author: Scott Chacon <schacon@gmail.com>
Date:   Fri May 22 18:09:34 2009 -0700

    first commit

 test.txt | 1 +
 1 file changed, 1 insertion(+)

Καταπληκτικό. Έχουμε χρησιμοποιήσει λειτουργίες χαμηλού επιπέδου για να δημιουργήσουμε ένα ιστορικό Git χωρίς να χρησιμοποιήσουμε καμία από τις εντολές του υψηλού επιπέδου. Αυτό είναι ουσιαστικά αυτό που κάνει το Git όταν τρέχουμε τις εντολές git add και git commit —αποθηκεύει blob για τα αλλαγμένα αρχεία, ενημερώνει το ευρετήριο, γράφει δέντρα και γράφει αντικείμενα υποβολής που αναφέρονται στα δέντρα του ανώτερου επιπέδου και τις προηγούμενες υποβολές. Αυτά τα τρία κύρια αντικείμενα Git —το blob, το δέντρο και η υποβολή— αποθηκεύονται αρχικά ως ξεχωριστά αρχεία στον κατάλογο .git/objects. Εδώ είναι όλα τα αντικείμενα στον κατάλογο τώρα, σχολιασμένα με αυτό που αποθηκεύουν:

$ find .git/objects -type f
.git/objects/01/55eb4229851634a0f03eb265b69f5a2d56f341 # δέντρο 2
.git/objects/1a/410efbd13591db07496601ebc7a059dd55cfe9 # υποβολή 3
.git/objects/1f/7a7a472abf3dd9643fd615f6da379c4acb3e3a # test.txt v2
.git/objects/3c/4e9cd789d88d8d89c1073707c3585e41b0e614 # δέντρο 3
.git/objects/83/baae61804e65cc73a7201a7252750c76066a30 # test.txt v1
.git/objects/ca/c0cab538b970a37ea1e769cbbde608743bc96d # υποβολή 2
.git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4 # 'test content'
.git/objects/d8/329fc1cc938780ffdd9f94e0d364e0ea74f579 # δέντρο 1
.git/objects/fa/49b077972391ad58037050f2a75f74e3671e92 # new.txt
.git/objects/fd/f4fc3344e67ab068f836878b6c4951e3b15f3d # υποβολή 1

Αν ακολουθήσουμε όλους τους εσωτερικούς δείκτες, παίρνουμε ένα γράφημα αντικειμένων περίπου σαν αυτό:

Όλα τα αντικείμενα στον κατάλογό μας Git.
Figure 151. Όλα τα αντικείμενα στον κατάλογό μας Git.

Αποθήκευση αντικειμένων

Αναφέραμε προηγουμένως ότι μαζί με το περιεχόμενο αποθηκεύεται μια κεφαλίδα. Ας σταθούμε ένα λεπτό για να δούμε πώς το Git αποθηκεύει τα αντικείμενά του. Θα δούμε πώς μπορούμε να αποθηκεύσουμε ένα αντικείμενο blob —στην περίπτωση αυτή, τη συμβολοσειρά “what’s up, doc?”— διαδραστικά στη γλώσσα Ruby.

Μπορούμε να ξεκινήσουμε μία διαδραστική λειτουργία Ruby με την εντολή irb:

$ irb
>> content = "what is up, doc?"
=> "what is up, doc?"

Το Git κατασκευάζει μια κεφαλίδα που ξεκινάει με τον τύπο του αντικειμένου, στην περίπτωση αυτή ένα blob. Στη συνέχεια, προσθέτει ένα κενό που ακολουθείται από το μέγεθος του περιεχομένου και τέλος ένα null:

>> header = "blob #{content.length}\0"
=> "blob 16\u0000"

Το Git συγκολλά την κεφαλίδα και το αρχικό περιεχόμενο και στη συνέχεια υπολογίζει το άθροισμα ελέγχου SHA-1 αυτού του νέου περιεχομένου. Μπορούμε να υπολογίσουμε την τιμή SHA-1 μιας συμβολοσειράς στη Ruby, αν συμπεριλάβουμε τη βιβλιοθήκη SHA1 digest, με την εντολή require και στη συνέχεια να καλέσουμε Digest::SHA1.hexdigest() με τη συμβολοσειρά:

>> store = header + content
=> "blob 16\u0000what is up, doc?"
>> require 'digest/sha1'
=> true
>> sha1 = Digest::SHA1.hexdigest(store)
=> "bd9dbf5aae1a3862dd1526723246b20206e5fc37"

Το Git συμπιέζει το νέο περιεχόμενο με το zlib, κάτι που μπορούμε να κάνουμε στη Ruby με τη βιβλιοθήκη zlib. Πρώτα, πρέπει να απαιτήσουμε τη βιβλιοθήκη και στη συνέχεια να εκτελέσουμε την Zlib::Deflate.deflate() στο περιεχόμενο:

>> require 'zlib'
=> true
>> zlib_content = Zlib::Deflate.deflate(store)
=> "x\x9CK\xCA\xC9OR04c(\xCFH,Q\xC8,V(-\xD0QH\xC9O\xB6\a\x00_\x1C\a\x9D"

Τέλος, θα γράψουμε το περιεχόμενό μας που έχει συμπιεστεί με το zlib σε ένα αντικείμενο στον δίσκο. Θα καθορίσουμε τη διαδρομή του αντικειμένου που θέλουμε να γράψουμε (οι δύο πρώτοι χαρακτήρες της τιμής SHA-1 είναι το όνομα του υποκαταλόγου και οι τελευταίοι 38 χαρακτήρες είναι το όνομα του αρχείου μέσα σε αυτόν τον κατάλογο). Στη Ruby, μπορούμε να χρησιμοποιήσουμε τη συνάρτηση FileUtils.mkdir_p() για να δημιουργήσουμε τον υποκατάλογο εάν δεν υπάρχει. Στη συνέχεια ανοίγουμε το αρχείο με τη File.open() και γράφουμε το συμπιεσμένο από το zlib περιεχόμενο στο αρχείο με κλήση της write() στον δείκτη χειρισμού του αρχείου που προκύπτει:

>> path = '.git/objects/' + sha1[0,2] + '/' + sha1[2,38]
=> ".git/objects/bd/9dbf5aae1a3862dd1526723246b20206e5fc37"
>> require 'fileutils'
=> true
>> FileUtils.mkdir_p(File.dirname(path))
=> ".git/objects/bd"
>> File.open(path, 'w') { |f| f.write zlib_content }
=> 32

Αυτό ήταν· έχουμε δημιουργήσει ένα έγκυρο αντικείμενο blob του Git. Όλα τα αντικείμενα Git αποθηκεύονται με τον ίδιο τρόπο, μόνον ο τύπος διαφέρει —αντί για τη συμβολοσειρά του blob, η κεφαλίδα θα αρχίσει με την υποβολή ή το δέντρο. Επίσης, παρόλο που το περιεχόμενο των blob μπορεί να είναι σχεδόν ο,τιδήποτε, τα περιεχόμενα της υποβολής και του δέντρου είναι μορφοποιημένα με πολύ συγκεκριμένο τρόπο.