Hvis du skriver programvare for å leve i 2018, så kan jeg med selvtillit si at du er kjent med Git. verktøy opprettet av Linus Torvalds har blitt synonymt med versjonskontroll. Og uten tvil er en av Gits beste funksjoner hvordan det fjerner smerten ved forgrening og sammenslåing. Det er flere måter du kan lage en filial i Git. I dette innlegget vil vi «gjennomgå noen av dem. Så vil vi avslutte med litt refleksjon over Gits forgreningsmodell og forgrening generelt.

Opprette en gren fra mester

Du oppretter grener i Git, ikke overraskende, ved å bruke grenkommandoen. Som mange andre Git-kommandoer er «gren» veldig kraftig og fleksibel. Foruten å lage grener, kan den også brukes til å liste opp og slette dem, og du kan tilpasse ytterligere kommandoen ved å bruke en bred liste over parametere. Vi begynner med den første måten å opprette en gren på. La oss si at du vil opprette en ny mappe som heter «min app», gå inn i den og starte et nytt Git-arkiv. Slik gjør du det:

mkdir my-appcd my-appgit init

Nå har du et nytt, tomt Git-arkiv. Men tomme arkiver er kjedelige. Så hva med å lage en ny markdown-fil med «Hello World!» skrevet i den?

echo Hello World! > file.md

Hvis du kjører «git status», bør du se en melding om at filen din ikke er sporet:

Usporede filer er også ukjølte, så la oss spore det:

git add file.md

Og til slutt, la oss opprette våre første forpliktelse:

git commit -m "First commit"

Vi har nå et arkiv med en gren, som har nøyaktig en forpliktelse. Det høres kanskje ikke ut som mest spennende ting i verden (fordi det virkelig ikke er det), men det er absolutt mindre kjedelig enn å ha en repo uten forpliktelser i det hele tatt, ikke sant, la oss si at av en eller annen grunn trenger du å endre filen «s innhold. Men du trenger ikke har lyst til å gjøre det. Hva om noe går galt og du på en eller annen måte ødelegger det vakre, uberørte innholdet i filen din? (Ja, jeg vet at det bare er en dum fil med «Hello World!» I den, men bruk fantasiens fantastiske krefter og tenk på filen som en fullmektig for et mye mer komplekst prosjekt.) Løsningen på dette dilemmaet oppretter selvfølgelig en ny gren:

git branch exp

Så nå har vi en ny gren kalt «exp», for eksperimentering Noen mennesker som er vant til å bruke forskjellige versjonssystemer, spesielt sentraliserte, kan si at grenene har det samme «innholdet.» Dette er ikke helt nøyaktig når man snakker om Git. Tenk på grener som referanser som peker på en gitt forpliktelse.

Opprette en gren fra en forpliktelse

Anta at vi av en eller annen grunn gir opp eksperimentet vårt, uten å legge til en eneste forplikte seg til den nye grenen. La oss gå tilbake til mesteren og slette exp-grenen:

git checkout mastergit branch -d exp

Nå som vi er tilbake til en enkelt gren, la oss legge til noen forpliktelser til det, for å simulere arbeidet som blir utført:

Se for deg at når du har gjort alt dette «arbeidet», lærer du at du uansett grunn må gå tilbake i tid til når det er var bare to linjer i filen og opprettet nye endringer fra da av. Men samtidig må du bevare fremgangen du allerede har gjort. Med andre ord, du vil opprette en gren fra en tidligere forpliktelse. Hvordan ville du gjøre det ? I Git har hver kommisjon en unik identifikator. Så du kan enkelt se dette ved hjelp av «git log» -kommandoen. For å opprette en ny gren basert på en spesifikk kommisjon, send bare hashen som parameter til grenkommandoen:

git branch new-branch 7e4decb

Som en ekstraordinær trenger du ikke engang hele hasjen mesteparten av tiden. Bare de første fem eller seks tegnene gjør det.

Opprette en gren fra en tag

Hvis du er litt mer erfaren med Git, bør du være kjent med begrepet tagger. Du bruker tagger for å indikere at en gitt forpliktelse er viktig eller spesiell på en eller annen måte. For eksempel brukes merker generelt for å indikere de faktiske versjonene av et produkt. Hvis du har jobbet i applikasjonen din en stund og du tror det er på tide å gi ut versjon 1.0. Det du vanligvis gjør er å støte på versjonsnumrene når det er nødvendig, begå endringene og deretter legge til en kode til det bestemte tidspunktet. For å lage en tag, kjører du vanligvis noe slikt:

git tag -a v1.0 -m "First major version"

Parameteren «-a» indikerer at dette går å være en merket tag. I motsetning til en lett tag, er dette et fullverdig Git-objekt som inneholder deler av informasjon som kommittørens navn og e-post, tidsstempelet og en melding. Nå har du en tag, en indikasjon på at dette punktet i historien er spesielt og har et navn. Hyggelig. Du kan fortsette å jobbe, som vanlig, opprette og foreta endringer som vil være en del av 1.1-versjonen. Inntil en feilrapport kommer inn. Noen klienter som ble oppdatert til 1.0-versjonen av produktet sier at en importfunksjon ikke fungerer som tiltenkt. Vel, du kan teoretisk fikse feilen i hovedgrenen og distribuere den. Men da vil klientene motta funksjoner som er potensielt uprøvde og ufullstendige. Det «sa nei -Nei. Så hva gjør du? Svaret: Du oppretter en ny gren fra taggen du har opprettet for å indikere hovedversjonen. Du løser problemet der, bygger og distribuerer. Og du bør sannsynligvis slå dette sammen for å mestre etterpå, så de neste utgivelsene inneholder løsningen Hvordan vil du gjøre det? Enkelt:

git branch <NAME-OF-THE-BRANCH> <TAG>

Mer spesifikt ved å bruke vårt forrige eksempel:

git branch fix-bug-123 v1.0

Etter det kan du sjekke ut den nye grenen din som vanlig. Eller enda bedre, du kan gjøre alt i ett trinn:

git checkout -b fix-bug-1234 v1.0

Opprette en filial i frittliggende tilstand

Har du noen gang ønsket å gå tilbake i tid? Med Git er dette mulig … i det minste med hensyn til filene i arkivet vårt. Du kan når som helst sjekke ut en forpliktelse hvis du vet hash:

git checkout <SHA1>

Etter å ha kjørt det, vil Git vise deg en nysgjerrig melding:

You are in "detached HEAD" state. You can look around, make experimentalchanges and commit them, and you can discard any commits you make in thisstate without impacting any branches by performing another checkout.

Når du sjekker ut en kommisjon, går du inn i en spesiell stat c alled, som du kan se, «frittliggende HEAD». Mens du kan begå endringer i denne tilstanden, hører disse forpliktelsene ikke til noen gren og vil bli utilgjengelige så snart du sjekker ut en annen gren. Men hva om du vil beholde disse forpliktelsene? Svaret er ikke overraskende å bruke kommandoen «kassa» igjen for å opprette en ny gren:

git checkout <sha1> #now you"re in detached head state# do some work and stage itgit commit -m "add some work while in detached head state"git branch new-branch-to-keep-commitsgit checkout new-branch-to-keep-commits

Og selvfølgelig vet du nå at du kan skrive siste to linjer som en enkelt kommando:

git checkout -b new-branch-to-keep-commits

Ganske enkelt, ikke sant?

Bare fordi du kan … Betyr ikke at du burde

Gits forgreningsmodell er et av salgsargumentene. Det gjør det som i andre kildekontrollsystemer er en smertefull og til og med langsom prosess til en lek. at Git vellykket har demokratisert forgrening for massene. Men det ligger en alvorlig fare. På grunn av den billige forgreningen i Git, kan noen utviklere falle i fella for å jobbe med ekstremt langvarige grener eller bruke arbeidsflyter eller forgreningsmodeller som forsinker grasjon. Vi som bransje har vært der. Vi har gjort det. Det fungerer ikke. I stedet omfavne arbeidsflyter som bruker ekstremt kortvarige filialer. Du har en sikker sandkasse der du kan kode uten frykt for å ødelegge ting eller kaste bort tid til kollegaene dine. Men spør du: «Hvordan distribuerer jeg kode med delvis fullførte funksjoner?» I så fall har den flagg til redning. Git-grener er et kraftig verktøy. Bruk dem med omhu, og ikke misbruk dem. Og når de ikke er nok, bruk kontinuerlig levering / kontinuerlig integrasjon sammen med funksjonsflagg – inkludert spesialverktøy til din disposisjon – slik at applikasjonene dine kan komme til neste nivå.