Git Tutorial for nybegynnere

Programvareutvikling er en samarbeidsjobb. Som programvareingeniør må du dele arbeidet ditt med andre. Men å dele kode og samarbeide kan bli komplisert. Det er vanskelig å holde rede på forskjellige endringer som skjer i løpet av programvaren. Så utviklingsteam stoler på versjonskontrollverktøy for å hjelpe med programvaresamarbeidsprosessen. Git er et av de mest fremtredende versjonskontrollverktøyene i programvareindustrien.

Tips: I denne opplæringen lærer du hvordan du bruker det grunnleggende i Git. Hver seksjon avsluttes med noen spørsmål. Du kan lese spørsmålene før du begynner å lese delen. Dette vil hjelpe deg å forstå og ta hensyn til viktige punkter.

Ha det gøy å lære Git!

Git: En kort oversikt

Git er et distribuert versjonskontrollsystem. Den holder rede på eventuelle endringer du gjør i filene og mappene dine. Det gjør det lettere å lagre pågående arbeid. Hvis det er et problem, kan du enkelt sjekke en tidligere versjon av filen eller mappen. Om nødvendig kan du til og med tilbakestille hele kodebasen til en eldre versjon.

Utviklingen av Git startet i 2005. Linux-kjernegruppen pleide å opprettholde koden sin i BitKeeper, et proprietært distribuert versjonskontrollsystem. Imidlertid trakk BitKeeper sin gratis bruk av produktet. Så Linus Torvalds, skaperen og hovedutvikleren av Linux, designet et nytt open source-distribuert versjonskontrollsystem som ville oppfylle kravene til Linux-utviklingssamfunnet. Og Git ble født.

Som et distribuert versjonskontrollsystem krever Git ikke en sentralisert myndighet for å holde rede på koden. Eldre sentraliserte versjonskontroller som CVS, SVN eller Perforce krever sentrale servere for å opprettholde historikken til endringene. Git kan holde rede på alle endringene lokalt og arbeide peer-to-peer. Så det er mer allsidig enn sentraliserte systemer.

Spørsmål:

Hvorfor bør du bruke Git?
Hva er fordelen med distribuert versjonskontroll?

Installere Git

For Linux-systemer er det enkelt å installere Git. Hvis du bruker en Debian-basert distribusjon som Ubuntu, kan du bruke apt install:

$ sudo apt installere git-all

For Fedora, RHEL eller CentOS kan du bruke:

$ sudo dnf installer git-all

Du kan sjekke om Git er installert ved hjelp av følgende kommando:

$ git --versjon

Den skal vise deg versjonen av Git du installerte, for eksempel:

git versjon 2.17.0

Når du har installert Git, er det på tide å sette opp brukernavn og e-post:

$ git config - global bruker.navn "dittbrukernavn"
$ git config - global bruker.e-post "[email protected]"

Du kan sjekke om konfigurasjonene er riktig innstilt ved hjelp av følgende kommando:

$ git config - liste
bruker.navn = ditt brukernavn
bruker.e-post = ditt brukernavn @ eksempel.com

Tips: Det er viktig å stille inn brukeren.navn og bruker.e-post fordi disse konfigurasjonene brukes til å spore endringene dine.

Spørsmål

Hva er kommandoen for å installere Git på Linux-systemet ditt?
Hvorfor bør du sette opp bruker.navn og bruker.e-postkonfigurasjon? Hvordan setter du dem opp?

Forstå Git konseptuelt

For å kunne bruke Git, må du først forstå disse fire konseptene:

Arbeidskatalog
Scene område
Oppbevaringssted
Fjernregister

Arbeidskatalogen, oppstillingsområdet og depotet er lokalt for maskinen din. Fjernregisteret kan være hvilken som helst annen datamaskin eller server. La oss tenke på disse konseptene som fire bokser som kan inneholde standard A1-papirer.

Anta at du skriver et dokument for hånd på et A1-papir ved skrivebordet ditt. Du oppbevarer dette dokumentet i arbeidsboksen. På et bestemt stadium av arbeidet ditt bestemmer du deg for å være klar til å beholde en kopi av arbeidet du allerede har gjort. Så du tar en kopi av gjeldende papir og legger den i iscenesettingsboksen.

Iscenesettingsboksen er et midlertidig område. Hvis du bestemmer deg for å forkaste fotokopien i iscenesettingsboksen og oppdatere den med en ny kopi av arbeidskatalogdokumentet, vil det ikke være noen permanent oversikt over det iscenesatte dokumentet.

Anta at du er ganske sikker på at du vil ha permanent oversikt over dokumentet du har i oppstillingsboksen. Deretter tar du en kopi av iscenesettingsboksdokumentet og flytter det til depotboksen.

Når du flytter den til depotboksen, skjer det to ting:

Et øyeblikksbilde av dokumentet lagres permanent.
En loggfiloppføring er laget for å følge med øyeblikksbildet.

Loggoppføringen vil hjelpe deg med å finne det aktuelle øyeblikksbildet av dokumentet ditt hvis du trenger det i fremtiden.

Nå, i den lokale arkivboksen, har du et øyeblikksbilde av arbeidet ditt og en loggoppføring. Men det er bare tilgjengelig for deg. Så du lager en kopi av ditt lokale depotdokument sammen med loggfilen og legger den i en boks i selskapets forsyningsrom. Nå kan alle i ditt firma komme og lage en kopi av dokumentet og ta det med til skrivebordet. Boksen i forsyningsrommet vil være det eksterne depotet.

Fjernregisteret er som å dele dokumentet ditt ved hjelp av Google Docs eller Dropbox.

Spørsmål:

Kan du definere arbeidskatalog, staging, repository og remote repository?
Kan du tegne hvordan dokumenter beveger seg fra ett trinn til et annet?

Ditt første Git-arkiv

Når du har installert Git, kan du begynne å lage dine egne Git-arkiver. I denne delen skal du initialisere Git-depotet ditt.

Anta at du jobber med et webutviklingsprosjekt. La oss lage en mappe som heter project_helloworld og bytte til katalogen:

$ mkdir project_helloworld
$ cd project_helloworld

Du kan be Git om å overvåke denne katalogen med følgende kommando:

$ git init

Du bør se en utgang som dette:

Initialisert tomt Git-arkiv i / Brukere / zakh / _work / LearnGIT / git_tutorial /
project_helloworld /.git

Nå vil alle filer og mapper i project_helloworld bli sporet av Git.

Spørsmål:

Hvordan initialiserer du en katalog som skal spores av Git?

Grunnleggende Git-kommandoer: status, logg, legg til og forplikt

Statuskommandoen viser den nåværende tilstanden til arbeidskatalogen din, og loggkommandoen viser historikken. La oss prøve statuskommandoen:

$ git-status
På grenmester
Første forpliktelse
ingenting å begå (lag / kopier filer og bruk "git add" for å spore)

Utgangen fra git-statuskommandoen sier at du er på hovedgrenen. Dette er standardgrenen som Git initialiserer. (Du kan lage dine egne grener. Mer om filialer senere). Dessuten sier produksjonen at det ikke er noe å begå.

La oss prøve loggkommandoen:

$ git-logg
dødelig: din nåværende filial 'mester' har ingen forpliktelser ennå

Så det er på tide å lage litt kode. La oss lage en fil som heter indeks.html:

Min webside

Hei Verden

Du kan bruke teksteditoren til å opprette filen. Når du har lagret filen, sjekk statusen på nytt:

$ git-status
På grenmester
Første forpliktelse
Usporede filer:
(bruk "git add ... "å inkludere i det som vil bli forpliktet)
indeks.html
ingenting lagt til å begå, men ikke-sporede filer til stede (bruk "git add" for å spore)

Git forteller deg at du har en fil som heter index.html i arbeidskatalogen din som ikke er sporet.

La oss sørge for å indeksere.html spores. Du må bruke add-kommandoen:

$ git add index.html

Alternativt kan du bruke “.”Mulighet for å legge til alt i katalogen:

$ git add .

La oss nå sjekke statusen igjen:

$ git-status
På grenmester
Første forpliktelse
Endringer som skal begås:
(bruk "git rm --cached ... "for å avvikle scenen)
ny fil: indeks.html

Det grønne indikerer at indeksen.html-filen spores av Git.

Tips: Som nevnt i instruksjonene ovenfor, hvis du bruker kommandoen:

$ git rm - hurtigbufret indeks.html

Indeksen din.html vil gå tilbake til status som ikke er sporet. Du må legge den til igjen for å bringe den tilbake til iscenesettelsen.]

La oss sjekke loggen igjen:

$ git-logg
dødelig: din nåværende filial 'mester' har ingen forpliktelser ennå

Så selv om Git sporer indeks.html, det er ikke noe i Git-arkivet om filen ennå. La oss begå endringene våre:

$ git commit -m "Forpliktende indeks.html "
Utgangen skal se ut slik:
[master (root-commit) f136d22] Forpliktende indeks.html
1 fil endret, 6 innsettinger (+)
opprett modus 100644 indeks.html

Teksten inne i anførselstegn etter “-m” er en kommentar som vil gå inn i loggfilen. Du kan bruke git commit uten “-m”, men så åpner Git en tekstredigerer som ber deg om å skrive kommentarene. Det er lettere å bare legge kommentarene direkte på kommandolinjen.

La oss nå sjekke loggfilen vår:

$ git-logg
begå f136d22040ba81686c9522f4ff94961a68751af7
Forfatter: Zak H
Dato: Man 4. juni 16:53:42 2018 -0700
Forpliktende indeks.html

Du kan se at det viser en forpliktelse. Du har fullført endringene dine i ditt lokale depot. Hvis du vil se den samme loggen på en kortfattet måte, kan du bruke følgende kommando:

$ git log --online
f136d22 Forpliktende indeks.html

Fremover vil vi bruke denne formen for loggkommandoen fordi den gjør det lettere å forstå hva som skjer.

La oss begynne å redigere indeksen.html. Åpne indeksen.html-fil i en redaktør og endre "Hello world" -linjen til "Hello world! Det er meg!”Og lagre det. Hvis du sjekker statusen igjen, ser du at Git har lagt merke til at du redigerer filen:

$ git-status
På grenmester
Endringer ikke iscenesatt for forpliktelse:
(bruk "git add ... "for å oppdatere hva som blir forpliktet)
(bruk "git checkout -- ... "for å forkaste endringer i arbeidskatalogen)
endret: indeks.html
ingen endringer lagt til forpliktelsen (bruk "git add" og / eller "git commit -a")

Endringen er fremdeles i arbeidskatalogen din. Du må skyve den til iscenesettelsesområdet. Bruk add-kommandoen du brukte før:

$ git add .

Sjekk statusen igjen:

$ git-status
På grenmester
Endringer som skal begås:
(bruk "git reset HEAD ... "for å avvikle scenen)
endret: indeks.html

Nå er endringene dine i iscenesettelsesområdet. Du kan forplikte det til depotet for permanent oppbevaring:

$ git commit -m "Endret indeks.html til en lykkeligere melding "
[master 0586662] Endret indeks.html til en lykkeligere melding
1 fil endret, 1 innsetting (+), 1 sletting (-)

Du kan sjekke loggen for permanente endringer:

$ git log --online
0586662 Endret indeks.html til en lykkeligere melding
f136d22 Forpliktende indeks.html

I denne delen har du lært å bruke status, logge, legge til og begå kommandoer for å holde oversikt over dokumentene dine i Git.

Spørsmål:

Hva gjør git status?
Hva gjør git log?
Hva gjør git add?
Hva gjør git commit??

Gå tilbake til eldre filer ved hjelp av kassen

Når du forplikter en fil i Git, skaper den en unik hash for hver kommisjon. Du kan bruke disse som identifikatorer for å gå tilbake til en eldre versjon.

La oss anta at du vil gå tilbake til den tidligere versjonen av indeksen.html. La oss først se på indeksen.html i gjeldende tilstand:

$ kattindeks.html

Min webside

Hei Verden! Det er meg!

Du kan se at du har den nyere versjonen (“Hello world! Det er meg!”). La oss sjekke loggen:

$ git log --online
0586662 Modifisert indeks.html til en lykkeligere melding
f136d22 Forpliktende indeks.html

Hashet for den forrige versjonen var f136d22 (“Hello world”). Du kan bruke kassen for å komme til den versjonen:

$ git kassa f136d22
Merk: sjekke ut 'f136d22'.
Du er i 'frittliggende HEAD'-tilstand. Du kan se deg rundt, gjøre eksperimentelle endringer
og begå dem, og du kan forkaste alle forpliktelser du gjør i denne tilstanden
uten å påvirke noen grener ved å utføre en ny kasse.
Hvis du vil opprette en ny gren for å beholde forpliktelser du oppretter, kan du
gjør det (nå eller senere) ved å bruke -b med kassen kommandoen igjen. Eksempel:
git kassa -b
HEAD er nå på f136d22 ... Forpliktende indeks.html

Hvis du ser på innholdet i indeksen.html, du ser:

$ kattindeks.html

Min webside

Hei Verden

Den har bare "Hello world". Så indeksen din.html har endret seg til den eldre versjonen. Hvis du sjekker statusen:

$ git-status
HODET løsrevet på f136d22
ingenting å begå, arbeider katalogen ren

Git forteller i utgangspunktet at HEAD ikke er på det siste. Du kan gå tilbake til den siste forpliktelsen ved å sjekke ut hovedgrenen ved hjelp av følgende kommando:

$ git checkout master
Forrige HEAD-posisjon var f136d22 ... Forpliktende indeks.html
Byttet til gren 'master'

Nå hvis du sjekker status:

$ git-status
På grenmester
ingenting å begå, arbeider katalogen ren

Den røde advarselen er borte. Også hvis du sjekker indeksen din.html, du bør være tilbake til den siste versjonen:

$ kattindeks.html

Min webside

Hei Verden! Det er meg!

Kassen kommandoen fører deg til forskjellige stater. Vi vil lære mer om kassen i neste avsnitt.

Spørsmål:

Hvordan bruker du git checkout-kommandoen for å gå til en eldre versjon av en fil?
Hvordan bruker du git checkout for å komme tilbake til den siste versjonen av filen?

Kasse, forgrening og sammenslåing

Forgrening er en av Gits beste funksjoner. Det hjelper deg med å skille arbeidet ditt og eksperimentere mer. I andre versjonskontrollsystemer var forgrening tidkrevende og vanskelig. Git gjorde forgrening og sammenslåing enklere.

Som du la merke til i statuskommandoen, er du i hovedgrenen når du oppretter et nytt Git-depot.

$ git-status
På grenmester
ingenting å begå, arbeider katalogen ren

Anta at du lager et nettsted for din venn David. Du vil bruke koden til ditt eget nettsted på nytt. Forgrening er en flott løsning. La oss kalle grenen david_website.

Du kan utstede følgende kommando:

$ git gren david_website

Du kan bruke følgende kommando for å se alle grenene:

$ git gren - liste
david_website
* mester

Stjernen (*) ved siden av mester betyr at du fortsatt er i mestergrenen. Du kan sjekke ut david_website-grenen med følgende kommando:

$ git checkout david_website
Byttet til filialen 'david_website'

Nå hvis du igjen sjekker grenlisten, ser du:

$ git gren - liste
* david_website
herre

Så du er på david_website-grenen.

La oss endre indeksen.html fra “Hello world! Det er meg!”Til“ Hei verden! Det er David!”Og deretter iscenesette og begå det:

$ git add .
$ git commit -m "Endret nettsted for David"

Hvis du sjekker loggene, bør du se:

$ git log --online
345c0f4 Endret nettside for David
0586662 Modifisert indeks.html til en lykkeligere melding
f136d22 Forpliktende indeks.html

Og indeksfilen din skal se slik ut:

$ kattindeks.html

Min webside

Hei Verden! Det er David!

La oss nå sjekke ut hovedgrenen igjen:

$ git checkout master
Byttet til gren 'master'

Hvis du sjekker statusen og logger:

$ git-status
På grenmester
ingenting å begå, arbeider katalogen ren
$ git log --online
0586662 Modifisert indeks.html til en lykkeligere melding
f136d22 Forpliktende indeks.html

Legg merke til at du ikke har din tredje forpliktelse i mesteren. Fordi denne forpliktelsen bare opprettholdes i david_website-grenen.

Dette er hva som skjedde

Anta at du på dette stadiet bestemmer at du ikke vil fortsette nettstedet ditt. Du blir bare utvikler for David. Så du vil slå sammen endringene i david_website-grenen til mesteren. Fra hovedgrenen må du bare utstede følgende kommandoer (statuskommandoen brukes til å sjekke om du er på rett sted):

$ git-status
På grenmester
ingenting å begå, arbeider katalogen ren

$ git flette david_website
Oppdaterer 0586662… 345c0f4
Spol fremover
indeks.html | 2 +-
1 fil endret, 1 innsetting (+), 1 sletting (-)

Tips: Du drar endringer fra david_website til master. Du må være på mesteren for å oppnå dette.

Nå hvis du sjekker loggen på masteren, ser du at den tredje forpliktelsen er der:

$ git log --online
345c0f4 Endret nettside for David
0586662 Endret indeks.html til en lykkeligere melding
f136d22 Forpliktende indeks.html

Du har slått sammen david_website-grenen til master. Og indeksen din.html for hovedfilial ser identisk ut med david_website gren:

$ kattindeks.html

Min webside

Hei Verden! Det er David!

Du kan beholde david_website-grenen:

$ git gren - liste
david_website
* mester

Eller du kan slette det:

$ git gren -d david_website
Slettet filial david_website (var 345c0f4).

Etter sletting bør du ikke se david_website-grenen lenger:

$ git gren - liste
* mester

Tips: Hvis Git ikke kan slå seg sammen automatisk under en sammenslåing, vil det gi deg sammenslåtte konfliktfeil. I så fall må du løse fletteproblemene manuelt.

Spørsmål:

Hvorfor trenger du forgrening??
Hvordan forgrener og fletter du filer og mapper?

Fjernregister

Til nå har alt arbeidet ditt vært lokalt. Du har foretatt endringene dine i et lokalt depot. Men det er på tide å dele arbeidet ditt med verden.

Git remote repository er i utgangspunktet en annen kopi av ditt lokale depot som andre kan få tilgang til. Du kan sette opp en server og gjøre den til det eksterne depotet. Men de fleste bruker GitHub eller Bitbucket for dette formålet. Du kan opprette offentlige depoter gratis der som alle kan få tilgang til.

La oss opprette et eksternt lager på GitHub.

Først må du opprette en GitHub-konto []. Når du har kontoen, oppretter du et nytt depot ved å bruke knappen "New repository". Bruk “project_website” som depotnavn (du kan velge noe annet hvis du vil).

Du bør se en kodefane med instruksjoner som disse:

... eller opprett et nytt lager på kommandolinjen

ekko "# project_website" >> README.md
git init
git legg til README.md
git commit -m "first commit"
git remote legg til opprinnelse git @ github.com: ditt brukernavn / prosjekt_nettsted.git
git push -u origin master

Kopier følgende kommando "git remote add origin" og kjør den i arbeidskatalogen din:

$ git remote legg til origin git @ github.com: ditt brukernavn / prosjekt_website.git

Merk: I ditt tilfelle bør brukernavnet ditt være det du brukte til å opprette GitHub-kontoen din.

I kommandoen ovenfor instruerte du Git plasseringen av det eksterne depotet. Kommandoen forteller Git at "opprinnelsen" for arbeidskatalogen for prosjekt_hell verden vil være "[e-postbeskyttet]: ditt brukernavn / prosjekt_nettsted.git ”.

Trykk nå koden din fra hovedgrenen til opprinnelsen (eksternt arkiv):

$ git push origin master
Telleobjekter: 9, ferdig.
Delta komprimering med opptil 4 tråder.
Komprimerende gjenstander: 100% (6/6), ferdig.
Skriveobjekter: 100% (9/9), 803 byte | 0 byte / s, ferdig.
Totalt 9 (delta 2), gjenbrukt 0 (delta 0)
fjernkontroll: Løse deltas: 100% (2/2), ferdig.
Å git @ github.com: ditt brukernavn / prosjekt_website.git
* [ny gren] master -> master

Hvis du oppdaterer nettleseren din i GitHub, bør du se at indeksen.html-filen er der oppe. Så koden din er offentlig, og andre utviklere kan sjekke ut og endre koden på det eksterne depotet.

Som utvikler jobber du med andres kode. Så det er verdt å prøve å sjekke koden fra GitHub.

La oss gå til en ny katalog der du ikke har noe. På høyre side av GitHub-depotet vil du legge merke til knappen "Klone eller laste ned". Hvis du klikker på den, bør den gi deg en SSH-adresse. Kjør følgende kommando med SSH-adressen:

$ git klon git @ github.com: ditt brukernavn / prosjekt_nettsted.git

Utgangen skal se slik ut:

$ git klon git @ github.com: ditt brukernavn / prosjekt_nettsted.git
Kloning til 'project_website' ..
fjernkontroll: Telle objekter: 9, ferdig.
fjernkontroll: Komprimering av objekter: 100% (4/4), ferdig.
ekstern: Totalt 9 (delta 2), gjenbrukt 9 (delta 2), gjenbrukt pakke 0
Mottak av gjenstander: 100% (9/9), ferdig.
Løsning av deltaer: 100% (2/2), ferdig.
Sjekker tilkobling ... ferdig.

Det vil opprette et prosjekt_nettsted i den rene mappen. Hvis du går inn, bør du se indeksen.html fra project_helloworld.

Så du har oppnådd følgende:

Opprettet og gjort endringer i project_helloworld
Lastet opp koden til GitHub i project_website
Lastet ned koden fra GitHub

La oss en annen fil fra den nye arbeidskatalogen project_website:

$ touch ReadMe.md
$ git add .
$ git commit -m "Lagt til ReadMe.md "
$ git push origin master

Hvis du oppdaterer GitHub project_website-siden, bør du se ReadMe.md-fil der.

Merk: Når du laster ned kode fra GitHub, vet arbeidskatalogen automatisk opprinnelsen. Du trenger ikke definere det med kommandoen “git remote add origin”.

Spørsmål:

Hvorfor trenger du å bruke eksterne arkiver?
Hvordan setter du opp ditt nåværende lokale lager for å koble til det eksterne depotet?
Hvordan kloner du eksterne arkiver til din lokale datamaskin?

Konklusjon

Du finner mer informasjon om alle kommandoene i Git-dokumentene []. Selv om det finnes Git UI-verktøy tilgjengelig, er kommandolinje den beste måten å mestre Git på. Det vil gi deg et sterkere grunnlag for utviklingsarbeidet ditt.

Videre studier:

https: // git-scm.com / docs
https: // git-scm.com / book / no / v2
https: // git-scm.com / videoer