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 å følge med på forskjellige endringer som skjer under en programvaresyklus. Så utviklingsteam er avhengige av 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 grunnleggende om Git. Hver seksjon avsluttes med noen få spørsmål. Du kan lese spørsmålene før du begynner å lese delen. Dette vil hjelpe deg å forstå og ta hensyn til de viktige punktene.

Ha det gøy å lære git!

Git: En kort oversikt

Git er et distribuert versjonskontrollsystem. Det holder oversikt over endringer du gjør i filene og mappene dine. Det gjør det lettere å spare arbeid i gang. Hvis det er et problem, kan du enkelt sjekke en tidligere versjon av filen eller mappen. Om nødvendig kan du til og med tilbakeføre hele kodebasen til en eldre versjon.

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

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

Spørsmål:

• Hvorfor skal 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-installasjon:

$ sudo apt install git-all

For Fedora, RHEL eller Centos, kan du bruke:

$ sudo dnf installer git-all

Du kan sjekke om GIT er installert, ved å bruke følgende kommando:

$ git --version

Det 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 brukernavnet og e -post:

$ git config -global bruker.Navn "YourUsername"
$ git config -global bruker.e -post "[email protected] "

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

$ git config -liste
bruker.Navn = YourUsName
bruker.e -post = [email protected]

Tips: Det er viktig å angi 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 skal du sette opp bruker.navn og bruker.E -postkonfigurasjon? Hvordan setter du dem opp?

Forstå git konseptuelt

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

• Arbeidskatalog
• Scene område
• Oppbevaringssted
• Eksternt depot

Arbeidskatalogen, iscenesettelsesområdet og depotet er lokalt for maskinen din. Det eksterne depotet 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 arbeidskatalogboksen. På et bestemt stadium av arbeidet ditt bestemmer du at du er klar til å oppbevare en kopi av arbeidet du allerede har gjort. Så du lager en fotokopi av det nåværende papiret ditt og legger den i iscenesettelsesboksen.

Iscenesettelsesboksen er et midlertidig område. Hvis du bestemmer deg for å kaste fotokopien i iscenesettelsesboksen og oppdatere den med en ny kopi av arbeidskatalogdokumentet, vil det ikke være noen permanent registrering av det iscenesatte dokumentet.

Anta at du er ganske sikker på at du vil føre den faste journalen til dokumentet du har i iscenesettelsesboksen. Så lager du en fotokopi av iscenesettingsboksdokumentet og flytter det til depotboksen.

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

1. Et øyeblikksbilde av dokumentet lagres permanent.
2. En loggfiloppføring er laget for å gå med øyeblikksbildet.

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

Nå, i den lokale depotboksen, 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 selskapet ditt komme og lage en kopi av dokumentet ditt og ta det til skrivebordet sitt. Boksen i forsyningsrommet ville være det eksterne depot.

Det eksterne depotet er liksom å dele dokumentet ditt ved å bruke Google Docs eller Dropbox.

Spørsmål:

• Kan du definere arbeidskatalog, iscenesettelse, depot og eksternt depot?
• Kan du tegne hvordan dokumenter beveger seg fra et trinn til et annet?

Ditt første Git -depot

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

Anta at du jobber med et nettutviklingsprosjekt. La oss opprette en mappe kalt Project_Helloworld og endre til katalogen:

$ mkdir prosjekt_helloworld
$ CD Project_Helloworld

Du kan fortelle GIT om å overvåke denne katalogen med følgende kommando:

$ git init

Du bør se en utdata som denne:

Initialisert tom Git -depot i/brukere/zakh/_work/learngit/git_tutorial/
Project_helloworld/.git

Nå blir alle filer og mapper i Project_Helloworld sporet av Git.

Spørsmål:

• Hvordan initialiserer du en katalog som skal spores av Git?

Grunnleggende GIT -kommandoer: Status, logge, legg til og forplikte

Status -kommandoen viser gjeldende tilstand i arbeidskatalogen din, og loggkommandoen viser historien. La oss prøve statuskommandoen:

$ git status
På grenmester
Første forpliktelse
Ingenting å forplikte seg (opprette/kopiere filer og bruke "git add" til sporet)

Utgangen fra GIT -status -kommandoen sier at du er på mastergrenen. Dette er standardgrenen som Git initialiserer. (Du kan lage dine egne grener. Mer om grener senere). Utgangen sier også at det ikke er noe å begå.

La oss prøve loggkommandoen:

$ git log
Fatal: Din nåværende gren 'master' har ingen forpliktelser ennå

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

Hei Verden

Du kan bruke tekstredigereren til å opprette filen. Når du har lagret filen, sjekk statusen igjen:

$ git status
På grenmester
Første forpliktelse
Ikke -sporede filer:
(Bruk "git add ..." for å inkludere i det som vil bli begått)
indeks.html
Ingenting lagt til for å forplikte seg, men ikke -sporede filer til stede (bruk "git add" til sporet)

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

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

$ git Legg til indeks.html

Alternativt kan du bruke ".”Alternativ for å legge til alt i katalogen:

$ git Legg til .

La oss nå sjekke statusen igjen:

$ git status
På grenmester
Første forpliktelse
Endringer som skal forpliktet:
(Bruk "git rm -cache…" til uncage)
Ny fil: indeks.html

Det grønne indikerer at indeksen.HTML -fil spores av Git.

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

$ git rm -cached indeks.html

Indeksen din.HTML vil gå tilbake til ikke -sporet status. Du må legge den til igjen for å bringe den tilbake til iscenesettelse.]

La oss sjekke loggen igjen:

$ git log
Fatal: Din nåværende gren 'master' har ingen forpliktelser ennå

Så selv om Git sporer indeks.HTML, det er ikke noe i Git -depotet om filen ennå. La oss begå våre endringer:

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

Teksten i sitatene etter "-m" er en kommentar som vil gå inn i loggfilen. Du kan bruke git-forpliktelse uten "-m", men da å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 log
Forpliktelse F136D22040BA81686C9522F4FF94961A68751AF7
Forfatter: Zak H
Dato: man 4. juni 16:53:42 2018 -0700
Begå indeks.html

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

$ git log --oneline
F136D22 forpliktelsesindeks.html

Fremover vil vi bruke denne formen for loggkommandoen fordi det 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, vil du se at Git har lagt merke til at du redigerer filen:

$ git status
På grenmester
Endringer ikke iscenesatt for forpliktelse:
(Bruk "git add ..." for å oppdatere det som blir begått)
(Bruk "Git Checkout - ..." for å forkaste endringer i arbeidskatalogen)
Endret: indeks.html
Ingen endringer lagt til for å forplikte seg (bruk "git add" og/eller "git commit -a")

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

$ git Legg til .

Sjekk statusen igjen:

$ git status
På grenmester
Endringer som skal forpliktet:
(Bruk "Git Reset Head ..." til Unsage)
Endret: indeks.html

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

$ git commit -m "modifisert indeks.html til en lykkeligere melding "
[Master 0586662] Modifisert indeks.html til en lykkeligere melding
1 Fil endret, 1 innsetting (+), 1 sletting (-)

Du kan sjekke loggen for dine permanente endringer:

$ git log --oneline
0586662 Modified Index.html til en lykkeligere melding
F136D22 forpliktelsesindeks.html

I dette avsnittet har du lært å bruke status, logge, legge til og forplikte kommandoer for å holde rede på dokumentene dine i git.

Spørsmål:

• Hva gjør git -status?
• Hva gjør git -loggen?
• Hva gjør git legger til?
• Hva gjør git forpliktelse gjør?

Går tilbake til eldre filer ved hjelp av kassen

Når du begår en fil i git, skaper den en unik hasj for hver forpliktelse. Du kan bruke disse som identifikatorer for å gå tilbake til en eldre versjon.

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

$ katteindeks.html



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 --oneline
0586662 Modified Index.html til en lykkeligere melding
F136D22 forpliktelsesindeks.html

Hashen for den forrige versjonen var F136D22 (“Hello World”). Du kan bruke Checkout -kommandoen for å komme til den versjonen:

$ git Checkout F136D22
Merk: Sjekk ut 'F136D22'.
Du er i "frittliggende hode" -stat. Du kan se deg rundt, gjøre eksperimentelle endringer
og forplikte dem, og du kan forkaste alle forpliktelser du gjør i denne tilstanden
uten å påvirke noen grener ved å utføre en annen 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 igjen. Eksempel:
Git Checkout -B
Hodet er nå på F136D22 ... forpliktende indeks.html

Hvis du ser på innholdet i indeksen.HTML, du får se:

$ katteindeks.html



Hei Verden

Det har bare "Hello World". Så indeksen din.HTML har endret seg til den eldre versjonen. Hvis du sjekker statusen:

$ git status
Hodet løsrevet ved F136D22
Ingenting å begå, arbeidskatalog ren

Git forteller deg i utgangspunktet at hodet ikke er i den siste forpliktelsen. Du kan gå tilbake til den siste forpliktelsen ved å sjekke ut mastergrenen ved hjelp av følgende kommando:

$ git Checkout Master
Tidligere hodeposisjon var F136D22 ... forpliktende indeks.html
Byttet til filial 'master'

Nå hvis du sjekker status:

$ git status
På grenmester
Ingenting å begå, arbeidskatalog ren

Den røde advarselen er borte. Hvis du sjekker indeksen din.HTML, du bør være tilbake til den siste versjonen:

$ katteindeks.html


Hei Verden! Det er meg!

Kassekommandoen får deg til forskjellige stater. Vi lærer mer om kassen i neste avsnitt.

Spørsmål:

• Hvordan bruker du Git Checkout -kommando for å gå til en eldre versjon av en fil?
• Hvordan bruker du Git -kassen for å komme tilbake til den nyeste versjonen av filen?

Kasse, forgrening og sammenslåing

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

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

$ git status
På grenmester
Ingenting å begå, arbeidskatalog ren

Anta at du lager et nettsted for vennen din David. Du vil gjenbruke koden til ditt eget nettsted. Forgrening er en flott løsning. La oss ringe filialen David_Website.

Du kan utstede følgende kommando:

$ git filial 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 fremdeles er i mastergrenen. Du kan sjekke ut David_Website -grenen med følgende kommando:

$ git -kassen David_website
Byttet til filialen 'David_website'

Nå hvis du igjen sjekker filiallisten, ser du:

$ git gren -liste
* David_website
herre

Så du er på David_Website -filialen.

La oss endre indeksen.HTML fra “Hello World! Det er meg!”Til“ Hello World! Det er David!”Og deretter scene og begå det:

$ git Legg til .
$ git commit -m "endret nettsted for David"

Hvis du sjekker loggene, bør du se:

$ git log --oneline
345C0F4 endret nettsted for David
0586662 Modified Index.html til en lykkeligere melding
F136D22 forpliktelsesindeks.html

Og indeksfilen din skal se slik ut:

$ katteindeks.html



Hei Verden! Det er David!

La oss nå sjekke ut mastergrenen igjen:

$ git Checkout Master
Byttet til filial 'master'

Hvis du sjekker status og logg:

$ git status
På grenmester
Ingenting å begå, arbeidskatalog ren
$ git log --oneline
0586662 Modified Index.html til en lykkeligere melding
F136D22 forpliktelsesindeks.html

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

Dette er hva som skjedde

Anta at du på dette stadiet bestemmer deg, vil du ikke fortsette nettstedet ditt. Du vil bare være utvikleren 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å, arbeidskatalog ren
$ git fusjon David_website
Oppdatering 0586662 ... 345C0F4
Spol fremover
indeks.html | 2 +-
1 Fil endret, 1 innsetting (+), 1 sletting (-)

Tips: Du trekker endringer fra David_Website til Master. Du må være på mesteren for å oppnå dette.

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

$ git log --oneline
345C0F4 endret nettsted for David
0586662 Modified Index.html til en lykkeligere melding
F136D22 forpliktelsesindeks.html

Du har fusjonert David_Website -grenen til Master. Og indeksen din.HTML for Master Branch ser identisk ut med David_Website Branch:

$ katteindeks.html



Hei Verden! Det er David!

Du kan beholde David_Website -grenen:

$ git gren -liste
David_Website
* mester

Eller du kan slette det:

$ git filial -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: Under en sammenslåing, hvis Git ikke kan slå seg sammen automatisk, vil det gi deg fusjonering av konfliktfeil. I så fall må du løse sammenslåingsproblemene manuelt.

Spørsmål:

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

Eksternt depot

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

Git eksternt depot er i utgangspunktet en annen kopi av ditt lokale depot som kan nås av andre. 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 kan nås av noen.

La oss lage et eksternt depot på GitHub.

Først må du opprette en GitHub -konto []. Når du har kontoen, oppretter du et nytt depot ved hjelp av "New Repository" -knappen. Bruk "Project_Website" som depotnavnet (du kan velge noe annet hvis du vil).

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

... eller opprette et nytt depot på kommandolinjen

ekko "# Project_Website" >> Readme.MD
git init
Git Legg til Readme.MD
git commit -m "First Commit"
git eksternt legg til opprinnelse [email protected]: youusname/project_website.git
git push -u opprinnelsesmester

Kopier følgende “Git Remote Legg til Origin” -kommando og kjør den i arbeidskatalogen din:

$ git eksternt legg til opprinnelse [email protected]: youusname/project_website.git

Merk: I ditt tilfelle skal du være det du brukte for å opprette GitHub -kontoen din.

I kommandoen ovenfor instruerte du å gi plasseringen av det eksterne depotet. Kommandoen forteller Git at "Origin" for din prosjekt_helloworld arbeidskatalog vil være "[email protected]: youusname/project_website.Git ”.

Skyv nå koden din fra mastergrenen din til opprinnelse (eksternt depot):

$ git push origin master
Teller objekter: 9, gjort.
Delta -komprimering ved bruk av opptil 4 tråder.
Komprimerende objekter: 100% (6/6), gjort.
Skrive objekter: 100% (9/9), 803 byte | 0 byte/s, gjort.
Totalt 9 (Delta 2), gjenbrukt 0 (Delta 0)
Fjern: Løsning Deltas: 100% (2/2), gjort.
Å [email protected]: youusname/project_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 kode på det eksterne depotet.

Som utvikler vil du jobbe med andres kode. Så det er verdt å prøve å kasse kode fra github.

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

$ git clone [email protected]: youusname/project_website.git

Utgangen skal se slik ut:

$ git clone [email protected]: youusname/project_website.git
Kloning til 'Project_website' ..
Fjern: Teller objekter: 9, gjort.
Fjern: Komprimerende objekter: 100% (4/4), gjort.
Fjern: Totalt 9 (Delta 2), gjenbrukt 9 (Delta 2), Pack-Resused 0
Motta objekter: 100% (9/9), gjort.
Løsning Deltas: 100% (2/2), gjort.
Sjekk tilkobling ... ferdig.

Det vil opprette en Project_Website i den rene mappen din. 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 Working Directory Project_Website:

$ Touch Readme.MD
$ git Legg til .
$ git commit -m "la 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, kjenner arbeidskatalogen automatisk opprinnelsen. Du trenger ikke å definere det med kommandoen “Git Remote Add Origin”.

Spørsmål:

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

Konklusjon

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

Videre studier:

• https: // git-cm.com/dokumenter
• https: // git-cm.com/bok/en/v2
• https: // git-cm.com/videoer