Chapters ▾ 2nd Edition

10.1 Git bakom kulisserna - Lågnivådel och användardel

Du kanske hoppade till det här kapitlet från ett tidigare kapitel, eller så har du kommit hit efter att ha läst hela boken i ordning – oavsett vilket går vi här igenom Gits inre funktion och implementation. Vi har märkt att en förståelse för den här informationen är grundläggande för att uppskatta hur användbart och kraftfullt Git är, men vi har också hört att den kan upplevas som förvirrande och onödigt komplex för nybörjare. Därför har vi lagt den här diskussionen sist i boken, så att du kan läsa den när det passar i din inlärningsprocess. Det avgör du själv.

Nu när du är här, låt oss sätta igång. Först, om det ännu inte är tydligt, är Git i grunden ett innehållsadresserbart filsystem med ett VCS‑gränssnitt ovanpå. Du kommer att lära dig mer om vad det betyder om en stund.

I Gits tidiga dagar (främst före 1.5) var användargränssnittet mycket mer komplext eftersom det betonade detta filsystem snarare än ett polerat VCS. De senaste åren har gränssnittet förfinats tills det är lika rent och lätt att använda som vilket annat system som helst, men bilden av att det är svårt och komplext att lära sig lever kvar.

Lagret med det innehållsadresserbara filsystemet är otroligt kraftfullt, så vi börjar med det i det här kapitlet; därefter lär du dig om transportmekanismerna och de kodförrådsförvaltningsuppgifter du kan behöva hantera.

Lågnivådel och användardel

Den här boken handlar främst om hur du använder Git med ett trettiotal underkommandon som checkout, branch, remote och så vidare. Men eftersom Git från början var en verktygslåda för ett versionshanteringssystem snarare än ett helt användarvänligt VCS har det ett antal underkommandon som gör lågnivåarbete och är tänkta att kedjas ihop i UNIX‑stil eller anropas från skript. Dessa kommandon brukar kallas Gits lågnivåkommandon (plumbing‑kommandon), medan de mer användarvänliga kommandona kallas användarkommandon (porcelain‑kommandon).

Som du redan har märkt handlar bokens första nio kapitel nästan uteslutande om användarkommandon. Men i det här kapitlet arbetar du mest med lågnivåkommandon, eftersom de ger dig tillgång till Gits innandöme och hjälper till att visa hur och varför Git gör som det gör. Många av dessa kommandon är inte tänkta att användas manuellt på kommandoraden, utan snarare som byggstenar för nya verktyg och anpassade skript.

När du kör git init i en ny eller befintlig katalog skapar Git katalogen .git, där nästan allt som Git lagrar och manipulerar finns. Om du vill säkerhetskopiera eller klona ditt kodförråd ger det dig nästan allt du behöver att kopiera den här katalogen till en annan plats. Hela detta kapitel handlar i praktiken om det du kan se i den här katalogen. Så här ser en nyinitierad .git‑katalog vanligtvis ut:

$ ls -F1
config
description
HEAD
hooks/
info/
objects/
refs/

Beroende på din version av Git kan du se lite extra innehåll där, men detta är ett färskt git init‑kodförråd – det du normalt ser. Filen description används bara av GitWeb‑programmet, så bry dig inte om den. Filen config innehåller dina projektspecifika konfigurationsalternativ, och katalogen info håller en global exkluderingsfil för ignorerade mönster som du inte vill spåra i en .gitignore‑fil. Katalogen hooks innehåller dina krok‑skript på klient‑ eller serversidan, som vi går igenom i detalj i Git‑krokar.

Kvar finns fyra viktiga poster: filerna HEAD och index (som ännu inte har skapats), samt katalogerna objects och refs. Dessa är Gits kärndelar. Katalogen objects lagrar allt innehåll i din databas, katalogen refs lagrar pekare till incheckningsobjekt i den datan (grenar, taggar, fjärrreferenser med mera), filen HEAD pekar på grenen du har utcheckad just nu och filen index är där Git lagrar information om din köyta. Nu tittar vi närmare på var och en av dessa delar för att se hur Git fungerar.