Grunnleggende om forgrening i Git
Forgrening er en vital funksjon i Git, som lar deg arbeide med spesifikke egenskaper eller deler av programvaren uten risiko for å skade hovedkoden. Dette gir utviklere muligheten til å gjøre omfattende endringer i kildekoden og selv velge om disse endringene skal integreres i prosjektet eller forkastes. Det er en måte å holde utviklingen organisert og fleksibel.
Dersom du allerede har erfaring med Git, har du kanskje oppdaget de mange måtene å opprette grener på. For de som er nye innen utvikling, vil kunnskap om versjonskontrollverktøy som Git være svært tidsbesparende og gjøre utviklingsprosessen mer håndterlig og effektiv.
Dette innlegget er en praktisk guide som hjelper deg å opprette Git-grener på en smidig måte, som en del av din definerte arbeidsflyt. Målet er at du skal tilegne deg de nødvendige ferdighetene for å vedlikeholde dine GitHub-repositories med selvtillit.
Vennligst merk: Hvis du er ny, anbefales det å sette opp GitHub-kontoen din før du fortsetter. Hvis du allerede har gjort det, kan du gå rett til steg-for-steg delen. En repetisjon kan uansett være nyttig for å styrke din forståelse.
Hva er Git-grener?
Kilde: atlassian.com
En gren i Git representerer en versjon av depotet som er uavhengig av hovedprosjektet. Dette er en funksjon som finnes i alle moderne versjonskontrollsystemer. I bunn og grunn er det en måte å avvike fra hovedlinjen for utvikling, slik at du kan arbeide uten å forstyrre den originale koden.
Mange versjonskontrollverktøy (VCS) bruker denne metoden som innebærer å lage en ny kopi av kildekodekatalogen. Når det gjelder store prosjekter, kan dette ta tid. Fordelen er at det gir deg muligheten til å teste endringer i koden.
Gits forgrening anses som en sentral funksjon som skiller Git fra andre verktøy i VCS-miljøet. Gits operasjonsmodell er enkel og gjør forgreninger nesten umiddelbare. Å mestre Git-forgrening vil åpne opp for kraftige verktøy som kan forbedre utviklingsferdighetene dine. Så, hva er egentlig poenget med grener?
Hvorfor trenger du Git-grener?
Git-grener spiller en viktig rolle i Git-versjonskontrollsystemet. Her er noen av grunnene til at du bør bruke dem:
✅ Parallell utvikling – Moderne programvare er ofte kompleks, og krever at flere utviklere samarbeider. Grener gjør det mulig for ulike utviklere å arbeide med forskjellige funksjoner samtidig, eller fikse feil, uten at arbeidet deres kommer i konflikt med hverandre. Hver gren fungerer som en ny utviklingslinje, og man kan enkelt veksle mellom dem når man arbeider med spesifikke oppgaver.
✅ Samarbeid – Git-grener gjør samarbeid med andre utviklere på en felles kodebase enklere. Du kan opprette nye grener, foreta kodeendringer og dele dem i det delte depotet, slik at andre kan se over bidragene dine før de integreres i hovedgrenen.
✅ Eksperimentering – Du kan bruke Git-grener til å teste nye funksjoner uten å forstyrre hovedgrenen. Dette gir deg muligheten til å prøve nye tilnærminger for å løse problemer. Hvis de nye metodene fungerer, kan du slå dem sammen med hovedgrenen.
✅ Utgivelseshåndtering – Grener kan brukes for å håndtere utgivelser. Du kan lage en ny gren for hver spesifikk utgivelse i prosjektet. Dette lar deg fikse feil og gjøre endringer uten å påvirke hovedutviklingsgrenen.
✅ Versjonskontroll – Git-grener kan også brukes til versjonskontroll, der hver gren representerer en ny versjon av programvaren. Det er fordelaktig for utviklere å bruke grener for hver utgivelse og spore endringer, noe som gir god kontroll over de ulike versjonene av koden.
Komme i gang med Git – En oppfriskning
Nå som du forstår hvorfor grener er nyttige, er det på tide å se på hvordan du bruker dem i praksis.
Vi antar at du allerede har satt opp GitHub-kontoen din. Hvis ikke, bør du gjøre det nå. Denne delen er praktisk orientert.
Kommandoen git checkout i Git brukes for å bytte mellom forskjellige versjoner av prosjektet ditt. I noen utviklermiljøer på nett refererer begrepet «utsjekking» til gjennomføring av betalingskommandoen. Denne kommandoen fungerer med tre enheter: grener, filer og forpliktelser.
Sjekke ut en gren
Du kan lage grener med git branch kommandoen, og navigere mellom dem med git checkout. Når du sjekker ut en gren, oppdateres filene i arbeidskatalogen din slik at de samsvarer med versjonen som er lagret i den grenen.
Med andre ord, du ber Git om å registrere alle dine endringer i grenen. Det å bruke dedikerte grener for nye funksjoner er et steg vekk fra den gamle subversion (SVN) arbeidsflyten og gjør det enklere å arbeide med kode i alle de situasjonene som er beskrevet i «Hvorfor trenger du grener?».
Det er viktig å ikke forveksle kommandoen git checkout med git clone. Den første brukes til å bytte mellom kodeversjoner, mens den andre brukes for å hente kode fra et eksternt depot.
Bruke eksisterende grener
Hvis depotet du jobber med har eksisterende grener, kan du se dem i kommandolinjegrensesnittet ved å bruke git branch kommandoen.
De tilgjengelige grenene vil listes opp, og den som er markert med grønt er den du arbeider med, forutsatt at du bruker Windows og Visual Studio Code. For å bytte mellom grener, bruker du kommandoen git checkout branchname. «branchname» er navnet på grenen, og du kan bruke hvilken som helst navnekonvensjon.
Opprette Git-grener
La oss si at du er midt i programvareutviklingen og ønsker å legge til en ny funksjon. Den beste måten å gjøre dette på er å opprette en ny gren ved hjelp av git branch kommandoen.
I praksis skriver du følgende i kommandolinjen:
git branch branchname
Dette betyr at du har opprettet en gren som er uavhengig av hovedgrenen (som ofte er der det aktive prosjektet kjøres). Navnet på den nye grenen din er i dette tilfellet «branchname».
For å bytte til den nye grenen, bruker du git checkout:
git checkout branchname
Hvis du som utvikler ønsker å spare tid, kan du opprette og umiddelbart bytte til en gren ved å bruke git checkout med argumentet -b, etterfulgt av navnet på grenen. Du kan oppnå det samme resultatet som tidligere på denne måten:
git checkout -b branchname
Parameteren -b forteller Git at den skal kjøre git branch like før den sjekker ut. La oss se på andre måter du kan opprette grener på.
Vi skal nå se på flere metoder for å lage grener, basert på dine behov:
#1. Opprette en gren fra din nåværende gren
Hvis du vil opprette en ny gren basert på den gjeldende grenen du arbeider med, kan du bruke denne metoden:
git checkout -b <branchname>
Denne metoden lager og bytter deg automatisk til den nye grenen. For å bekrefte at du er på den nye grenen, skal terminalen vise en melding om at du har byttet til et nytt filialnavn.
Hvis du er en ny utvikler, er det viktig å huske å ikke skrive inn klammene (<>) i konsollen. De er der for illustrasjons- og forklaringsformål og skal ikke forveksles med selve kommandoen.
#2. Opprette en gren fra en annen gren
Du kan opprette en ny gren basert på en annen eksisterende gren ved å inkludere navnet på utgangspunktet. Her er kommandoen:
git branch <new branch> <base branch>
Og et praktisk eksempel vil være:
git branch new-branch branchname
Dette betyr at «new-branch» er vår nye gren, og «branchname» er grunngrenen vi baserer den på.
#3. Opprette en gren fra en commit
Hvis du ønsker å basere den nye grenen på en commit (og ikke en gren), må du oppgi commit-hashen som utgangspunkt. Du finner commit-hashen ved å bruke git log kommandoen.
Commit-hashen er vanligvis en lang rekke tegn som begynner med «commit». Når du har funnet hashen, kan du opprette grenen med:
git branch <branch name> <commit-hash>
Etter det kan du bytte til den nye grenen.
#4. Opprette en gren fra en tag
For å opprette en gren fra en bestemt tag, finner du først tagnavnet du ønsker å bruke. Kjør git tag kommandoen for å vise alle tilgjengelige tagger i depotet ditt.
Når du har tagnavnet, kan du kjøre git branch <new branch> <tag name>. Etter det kan du bytte til den nye grenen og begynne å gjøre endringer i koden.
#5. Opprette en gren med løsrevet HEAD-tilstand
Du kan bruke en løsrevet HEAD-tilstand til å opprette nye grener som starter fra en spesifikk commit, uten at du må bytte til den grenen med en gang. Dette er nyttig når du ønsker å eksperimentere med endringer uten å påvirke den gjeldende grenen. Start med å finne commit-hashen ved å bruke git log.
Med commit-hashen kan du kjøre git checkout <commit hash>. Denne kommandoen plasserer deg i en løsrevet HEAD-tilstand, som betyr at du ikke er på en gren, men peker direkte til en spesifikk commit. Deretter kan du bruke git branch <branch name> for å lage en ny gren basert på den commiten.
#6. Opprette en gren fra en ekstern gren
Start med å opprette en lokal gren. Nå bør du være komfortabel med å bruke: git checkout -b <branchname>. Den eksterne grenen vil automatisk opprettes når du sender den lokalt opprettede grenen til det eksterne depotet.
Du kan sende en gren til det eksterne depotet ved å bruke: git push origin <branch name>. I denne kommandoen representerer «origin» det eksterne depotet du sender endringer til. Du kan erstatte «origin» med navnet på ditt eksterne depot, hvis det er nødvendig.
#7. Opprette en gren i et eksternt depot
For å opprette en gren i et eksternt depot, bør du først hente de siste endringene fra det eksterne depotet med git fetch. Etter at du har oppdatert, kan du opprette en ny gren ved å sjekke den ut. Og når grenen er sjekket ut, kan du sende de nye endringene med:
git push -u <remote repo> <new branch name>
Når du jobber, vil det ofte være enklest å bruke «origin» (som vist i eksemplet der du opprettet en gren fra en ekstern gren). Dette sparer tid og minsker sjansen for å skrive feil depotnavn.
GitHub online-grensesnitt
Alle oppgavene som utføres på kommandolinjen kan gjøres via det grafiske grensesnittet. For å opprette en ny gren, går du til prosjektets lagringsside og ser etter grener øverst til venstre – vanligvis master/main.
Ved å klikke på den, vil en liste over eksisterende grener vises, sammen med et tekstfelt der du kan søke etter eller opprette en ny gren.
For å opprette en gren, skriver du inn navnet i tekstfeltet. Nettgrensesnittet er automatisert og lar deg opprette grener fra spesifikke elementer som tagger, grener og commits. Hvis du er ny på forgrening, kan det være nyttig å lese GitHubs offisielle dokumentasjon om emnet.
Avsluttende ord
Etter å ha lært de ulike teknikkene for å opprette Git-grener, kan du nå inkludere disse ferdighetene i programvareutviklingen din, for en mer effektiv og smidig arbeidsflyt med Git.
Den beste forgreningstilnærmingen vil i stor grad avhenge av teamet ditt, arbeidsflytkriterier og prosjekttype. For eksempel kan samarbeidspartnere lage grener eksternt og bidra med verdifullt arbeid.
Du har sett hvordan Git-forgrening gir deg et kraftig verktøy for å arbeide mer effektivt med programvareprosjekter. Det finnes andre Git-kontrollalternativer, men dette innlegget har fokusert på hvordan du navigerer deg frem med Git-grener via kommandolinjen. Dette vil forhåpentligvis gjøre deg mer selvsikker i din bruk av Git.
Etter at du har styrket dine ferdigheter i å lage grener, kan du også lese om hvordan man sletter GitHub-grener.