Denna sida är en undersökning av kommandot git checkout. Det kommer att täcka användningsexempel och kantfall. I Git-termer är en ”kassa” handlingen att växla mellan olika versioner av en målenhet. Kommandot git checkout fungerar på tre olika enheter: filer, åtaganden och filialer. Förutom definitionen av ”kassa” används frasen ”utcheckning” ofta för att antyda kommandot git checkout. I avsnittet Ångra ändringar såg vi hur git checkout kan användas för att visa gamla åtaganden. Fokus för merparten av detta dokument kommer att vara kassaåtgärder på filialer.

Att kolla in filialer liknar att checka ut gamla åtaganden och filer genom att arbetskatalogen uppdateras för att matcha den valda filialen / revisionen; dock sparas nya ändringar i projekthistoriken – det vill säga det är inte en skrivskyddad åtgärd.

Kolla in filialer

git checkout kommando låter dig navigera mellan grenarna som skapats av git branch. Kolla in en gren uppdaterar filerna i arbetskatalogen så att de matchar den version som är lagrad i den grenen, och den berättar för Git att spela in alla nya åtaganden på den grenen. Tänk på det som ett sätt att välja vilken utvecklingslinje du arbetar med.

Att ha en dedikerad filial för varje ny funktion är en dramatisk förändring från ett traditionellt SVN-arbetsflöde. Det gör det löjligt enkelt att testa nya experiment utan rädslan för att förstöra befintlig funktionalitet, och det gör det möjligt att arbeta på många icke-relaterade funktioner samtidigt. Dessutom underlättar filialer också flera samarbetsflöden.

Kommandot git checkout kan ibland förväxlas med git clone. Skillnaden mellan de två kommandona är att klon arbetar för att hämta kod från ett fjärrförvar, alternativt fungerar kassan för att växla mellan kodversioner som redan finns i det lokala systemet.

Användning: Befintliga grenar

Förutsatt att repo du arbetar i innehåller befintliga filialer kan du växla mellan dessa grenar med git checkout. För att ta reda på vilka grenar som är tillgängliga och vad det aktuella filialnamnet är, exekvera git branch.

Exemplet ovan visar hur man visar en lista över tillgängliga grenar genom att köra git branch -kommando och byt till en angiven gren, i det här fallet feature_inprogress_branch.

Nya grenar

Git checkout fungerar hand i hand med git branch. Kommandot git branch kan användas för att skapa en ny gren. När du vill starta en ny funktion skapar du en ny gren från med git branch new_branch. När du väl har skapat kan du använda git checkout new_branch för att växla till den grenen. Dessutom accepterar kommandot git checkout ett -b -argument som fungerar som en bekvämmetod som skapar den nya grenen och omedelbart byter till den. Du kan arbeta med flera funktioner i en enda databas genom att växla mellan dem med git checkout.

Exemplet ovan skapar och kontrollerar samtidigt . Alternativet -b är en bekvämlighetsflagga som säger att Git ska köra git branch innan du kör git checkout .

Som standard git checkout -b baserar new-branch från aktuell HEAD. En valfri ytterligare grenparameter kan skickas till git checkout. I ovanstående exempel skickas som sedan baserar new-branch av existing-branch istället för den aktuella HEAD.

Växla grenar

Att byta gren är en enkel åtgärd. Utförande av följande pekar HEAD till spetsen för .

Git spårar en historik över kassafunktioner i refloggen. Du kan köra git reflog för att se historiken.

Git Checkout a Remote Branch

När du samarbetar med ett team är det vanligt att använda fjärrkontroll förvar. Dessa förvar kan vara värd och delas eller de kan vara en annan kollegas lokala kopia. Varje fjärrförvar kommer att innehålla sin egen uppsättning grenar. För att checka ut en avlägsen gren måste du först hämta innehållet i grenen.

I moderna versioner av Git kan du sedan kolla in fjärrgrenen som en lokal gren.

Äldre versioner av Git kräver att en ny gren skapas baserat på remote.

Dessutom kan du kolla in en ny lokal filial och återställa den till fjärrgrenarnas senaste engagemang.

Fristående HEADS

Nu när vi har sett de tre huvudsakliga användningarna av git checkout på grenar är det viktigt att diskutera "detached HEAD” tillstånd. Kom ihåg att HEAD är Gits sätt att hänvisa till den aktuella ögonblicksbilden. Internt är git checkout kommandot uppdaterar helt enkelt HEAD för att peka på antingen den angivna grenen eller begå. När det pekar på en gren klagar Git inte, men när du checkar ut ett engagemang, växlar till ett "detached HEAD” -tillstånd.

Detta är en varning som säger att allt du gör är ”lossnat” från resten av projektets utveckling. Om du skulle börja utveckla en funktion medan det i ett fristående HEAD tillstånd skulle det inte finnas någon gren som gör att du kan komma tillbaka t o det. När du oundvikligen kolla in en annan gren (t.ex. att slå samman din funktion i), skulle det inte finnas något sätt att referera till din funktion:

Poängen är, din utveckling ska alltid ske på en gren – aldrig på en fristående HEAD. Detta gör att du alltid har en hänvisning till dina nya åtaganden. Men om du bara tittar på ett gammalt engagemang spelar det ingen roll om du befinner dig i ett fristående HEAD -tillstånd eller inte.

Sammanfattning

Den här sidan fokuserade på användningen av kommandot git checkout när du byter gren. Sammanfattningsvis ändrar git checkout, när det används på grenar, målet för HEAD ref. Den kan användas för att skapa filialer, byta grenar och kolla fjärrkontor. Kommandot git checkout är ett viktigt verktyg för standard Git-operation. Det är en motsvarighet till git merge. Kommandona git checkout och git merge är viktiga verktyg för att möjliggöra git workflows.