Git Flashcards

Kategorisponsor

Git är ett distribuerat versionskontrollsystem skapat av Linus Torvalds. Det är ett verktyg designat för hastighet, dataintegritet och stöd för distribuerade, icke-linjära arbetsflöden. Git kännetecknas av flexibilitet och effektivitet, vilket möjliggör effektiv hantering av både små och stora mjukvaruprojekt. Detta system erbjuder avancerade förgrening- och sammanfogningsfunktioner, och ger utvecklare verktyg för effektivt samarbete, ändringsspårning och källkodshantering. Git stödjer också offline-arbete och snabb växling mellan projektversioner, och bibehåller tillförlitlighet och enkel återställning av ändringshistorik.

Vår flashcard-app innehåller noggrant utvalda Git-intervjufrågor med omfattande svar som effektivt förbereder dig för alla intervjuer som kräver Git-kunskap. IT Flashcards är inte bara ett verktyg för arbetssökande - det är ett utmärkt sätt att förstärka och testa din kunskap, oavsett dina nuvarande karriärplaner. Regelbunden användning av appen hjälper dig att hålla dig uppdaterad med de senaste Git-trenderna och hålla dina färdigheter på en hög nivå.

Exempel på Git-flashcards från vår app

Ladda ner vår app från App Store eller Google Play för att få fler gratis flashcards eller prenumerera för tillgång till alla flashcards.

Vad är en 'branch' i Git och hur kan den användas i mjukvaruutvecklingsprocessen?

En gren, även kallad en gren i Git, är en oberoende utvecklingslinje för ett projekt. Den skapas när vi vill arbeta med nya funktioner eller buggfixar, utan att störa den huvudsakliga utvecklingslinjen (huvudgrenen). Grenning möjliggör samtidig körning av flera versioner av ett projekt, vilket är effektivt om flera utvecklare arbetar på ett projekt.

Den primära användningen av grenar i mjukvaruutvecklingsprocessen är sekvensen: skapa en ny gren, lägga till ändringar, begå ändringar och sedan slå samman dessa ändringar med huvudgrenen.

Följande exempel visar de grundläggande operationer som kan utföras på grenar.

# Skapa en ny gren
git branch new_feature

# Växla mellan grenar
git checkout new_feature

# Lägga till ändringar till grenen
# (...) gör vissa ändringar i filer
git add .
git commit -m "Ny funktionalitet tillagd"

# Gå tillbaka till master och slå samman ändringar från new_feature grenen
git checkout master
git merge new_feature

# Ta bort grenen efter att ha avslutat arbetet
git branch -d new_feature

Tack vare grenar i Git, har vi möjlighet att oberoende arbeta på olika delar av projektet, vilket vi sedan kan slå samman när som helst.

Beskriv skillnaden mellan git merge och git rebase kommandona.

Kommandot git merge används för att kombinera två eller flera förgreningar i ett projekt. När du utför git merge skapar Git ett nytt åtagande som inkluderar ändringar från båda förgrenarna. Fördelen med git merge är att projektets historia bevaras i dess ursprungliga tillstånd. Det skapar en kronologisk väg av händelser, vilket gör det enklare att förstå vad som har hänt.

Å andra sidan används git rebase för att flytta eller "tillämpa" en serie av åtaganden till en ny bas. Detta används när du vill bibehålla en linjär historisk diagram av projektet. När du utför git rebase 'klistrar' Git dina ändringar ovanpå den valda grenen. Vi kan säga att git rebase på något sätt 'rensar upp' historien om åtaganden, vilket kan leda till förlust av sammanhang om en sammanslagning / konflikt missuppfattas och dåligt löst.

Kort sagt, git merge används för att kombinera grenar och bevara den historiska vägen av projektet, medan git rebase tillåter att bibehålla en ren, linjär projektgraf, men på bekostnad av att förlora sammanhang. Båda metoderna har sina för- och nackdelar, valet beror mycket på den specifika situationen.

Vad är ett 'detached HEAD' och hur kan man hamna där när man arbetar med Git?

"Detached HEAD" är ett tillstånd där HEAD i Git inte är kopplat till någon specifik gren. Detta kan jämföras med en situation där våra ändringar inte sparas på någon specifik gren.

Det finns flera sätt att få en "detached HEAD". Detta inträffar vanligtvis under en utcheckning till en annan åtagande, till exempel:

git checkout <commit_id>

Vi kan dock även uppnå detta tillstånd under operationer som rebase eller cherry-pick som inte lyckades.

Git hänvisar till detta tillstånd med meddelandet:

Obs: checkar ut 'commit_id'.
Du är i 'detached HEAD' tillstånd.

"Detached HEAD" är inte ett farligt tillstånd, det är en naturlig del av att arbeta med Git. Det är emellertid viktigt att spara våra ändringar som vi har gjort medan vi är i "detached HEAD" tillståndet innan vi växlar till en annan åtagande eller gren. Vi kan göra detta genom att skapa en ny gren, vars källa kommer att vara vår "detached HEAD". Vi gör detta med kommandot:

git branch new_branch_name

Hur kan du flytta senaste commits från en branch till en annan?

För att överföra de senaste åtagandena från en gren till en annan kan du använda kommandot `git cherry-pick`. I GIT-sammanhanget betyder cherry picking att välja ett godtyckligt åtagande från en gren och tillämpa det på en annan.

Det första steget är att byta till grenen från vilken vi vill överföra åtagandena (låt oss kalla den för grenA):

git checkout branchA

Därefter behöver vi identifiera hashvärdet för de åtaganden vi vill överföra. Vi kan göra detta med kommandot `git log`, som kommer att visa en lista över åtaganden för denna gren. Hashvärdet för ett åtagande är en lång sträng av tecken i början av varje åtagandeinträde.

Nästa steg är att byta till grenen till vilken vi vill överföra åtagandena (låt oss kalla den för grenB):

git checkout branchB

Slutligen använder vi kommandot `git cherry-pick` tillsammans med hashvärdet för det åtagande vi vill överföra:

git cherry-pick commit-hash

Om vi vill överföra flera åtaganden kan vi ange deras hashvärden efter varandra, separerade av ett mellanslag.