The Essential Git Handbook

Introduktion

Hej! Jeg er Sanjula, og i denne guide håber jeg at lære dig lidt om Git, herunder:

  • Hvad Git er
  • Hvorfor lære Git
  • Indstilling af konfigurationsvariabler
  • Introduktion til hjælpekommandoen i Git
  • Sådan konverteres et eksisterende projekt til et lokalt Git-arkiv
  • Ting at gøre inden den første begåelse
  • Sådan tilføjes filer til iscenesættelsesområdet
  • Sådan fjernes filer fra iscenesættelsesområdet
  • Foretag dit første engagement
  • Sådan klones et eksternt lager
  • Få vist oplysninger om det eksterne lager
  • Sådan skubber du dine ændringer til fjernlageret
  • Sådan oprettes en filial til en bestemt funktion eller problem
  • Skub grenen til fjernlageret efter at have begået
  • Sådan flettes en filial
  • Sådan slettes en filial

Lad os komme igang!

Hvad er Git?

I enkle vendinger er Git et open source-distribueret versionskontrolsystem .

Versionskontrolsystemer hjælper ethvert softwareteam med at administrere ændringer i kildekoden til et produkt eller en tjeneste over tid. Det holder styr på alle ændringer til kildekoden i en database. Hvis der er lavet en kritisk fejl i kildekoden, kan udviklerne på et softwareteam spole kildekoden tilbage til en version, før den fejlagtige ændring blev foretaget. Som et resultat beskytter versionskontrolsystemer kildekoden mod katastrofer, menneskelige fejl og utilsigtede konsekvenser (når en fejlrettelse f.eks. Bryder en anden del af applikationen).

Så hvorfor lære Git?

Git er det mest anvendte versionskontrolsystem i verden i dag. Det er et modent og aktivt vedligeholdt open source-projekt oprindeligt udviklet af Linus Torvalds.

En forbløffende mængde softwareprojekter er afhængige af Git til versionskontrol, herunder både kommercielle og open source-projekter, især ved hjælp af git repository-hostingtjenesten, GitHub, som nu ejes af Microsoft. Derfor er det vigtigt at lære Git.

Forudsætning for denne vejledning

Download og installer git her

Tjek version af git

git --version

Hvis versionsnummeret returneres, betyder det, at git er installeret med succes på din computer.

Indstilling af konfigurationsværdier

Nu skal vi indstille de globale konfigurationsvariabler, som er meget vigtige, især hvis du arbejder med andre udviklere. Den største fordel ved dette er, at det f.eks. Er lettere at finde ud af, hvem der har begået en bestemt kodeblok.

git config --global user.name “Sanjula Madurapperuma”
git config --global user.email “[email protected]
git config --list

Hjælp med kommandoen

Som du måske bemærker, er config et verbum, der hidtil har været brugt ofte i denne håndbog, og verb kan også bruges som enten et præfiks eller suffiks med hjælpekommandoen. Vi kan bruge det samme eksempel (verbet config ) ovenfra for at forklare disse kommandoer.

git help config
git config --help

Begge ovenstående kommandoer udfører den samme handling. Vis manualsiden for det angivne verbum. Dette vil være nyttigt at identificere mere avancerede muligheder for git.

Sådan initialiseres et lager fra eksisterende kode

Hvis du har et lokalt lager, som du vil konvertere til et git-projekt for at begynde at spore det, kan vi starte med at køre kommandoen nedenfor i projektmappen.

git init

Færdig! Ligesom det har du konverteret dit projekt til et lokalt git-arkiv. Hvis du åbner projektmappen, vil du se, at der er oprettet en ny mappe kaldet .git.

Hvad skal man gøre inden den første forpligtelse?

Indtast følgende kommando for at se filer, der ikke er sporet:

git status

Hvis der er filer, som du ikke ønsker, at andre skal se i arkivet, såsom filer, der indeholder personlige præferencer eller dem fra IDE, skal du gøre følgende:

touch .gitignore

For at specificere hvilke filer der ikke skal føjes til git-arkivet, skal du åbne en teksteditor og se .gitignore-filen, som kan redigeres som en normal tekstfil. Nu kan vi f.eks. Indtaste følgende i filen:

.project
*.java

Jokertegn kan også bruges. I dette tilfælde er det blevet brugt til at specificere ikke at tilføje alle filer, der slutter med .java-udvidelsen til lageret.

Kør nu git-status igen

Nu kan du se, at de filer, vi ekskluderede i .gitignore-filen, ikke længere vises på listen over ikke-sporede filer. .Gitignore-filen skal være forpligtet til lageret for at opretholde de samme udelukkelser alle andre steder.

Tilføjelse af filer til mellemstationer

Al denne tid var vi i arbejdsmappen. Iscenesættelsesområdet er, hvor vi organiserer alle de filer, der spores og skal begås, inden vi skubber til git-arkivet. Det er en fil, der gemmer, hvad der skal medtages i den næste forpligtelse.

Hvis du vil tilføje alle de filer, der i øjeblikket ikke er sporet, og du har ændret til iscenesættelsesområdet, skal du bruge følgende kommando:

git add -A

Hvis du vil tilføje filer individuelt, kan vi give filnavnet efter git-tilføjelse. For eksempel,

git add .gitignore

Hvis du nu skriver git-status, vil du se, at .gitignore-filen nu er i iscenesættelsesområdet.

Fjernelse af filer fra iscenesættelsesområdet

Hvis du vil fjerne filer individuelt fra iscenesættelsesområdet, skal du skrive følgende (f.eks.):

git reset simple.py

Dette fjerner filen simple.py fra iscenesættelsesområdet. For at se denne ændring, skriv git-status igen.

Hvis du vil fjerne alle filerne fra mellemstationer, skal du køre følgende:

git reset

Hvis vi nu skriver git-status, ser vi, at alle filerne er blevet ændret til ikke-sporede filer.

At foretage den første forpligtelse

Kør nu følgende for at tilføje alle filerne til det iscenesættelsesområde, der skal begås.

git add -A

Hvis du vil, kan du køre git-status for at se alle de filer, der vil blive begået.

For at begå, skriv følgende.

git commit -m “Initial Commit”

“-M” angiver en meddelelse, der skal sendes, der beskriver forpligtelsen. Da dette er vores første forpligtelse, vil vi sige Initial Commit.

Som du kan se, er filerne blevet begået med succes.

Hvis du kører git-status nu, vil du se, at det står, at arbejdsmappen er ren, fordi vi har forpligtet filerne og ikke har ændret nogen fil siden.

Hvis vi kører følgende kommando:

git log

så kan vi se den forpligtelse, vi netop har lavet, inklusive hash-nummeret på forpligtelsen.

Vi sporer nu med succes det lokale projekt med git!

Kloning af et eksternt lager

Hvis vi vil spore et eksisterende fjernprojekt med git, skal vi indtaste en kommando i følgende format:

git clone  

For eksempel bruger jeg git-arkivet på dette link.

Jeg flytter først ind i den mappe, som jeg vil klone projektet i, selvom du også kan angive dette som vist ovenfor.

Gå til lagringslinket, der er angivet ovenfor, og klik på knappen "Klon eller download", og kopier derefter linket der.

Indtast derefter:

git clone //github.com/sanjulamadurapperuma/GitDemoMedium.git

Nu har vi klonet arkivet med succes.

Hvis vi indtaster følgende kommando, ser vi alle de filer, der er i den lokale mappe nu.

ls -la

Visning af oplysninger om fjernlageret

Hvis du skriver følgende kommando:

git remote -v

Denne kommando viser de placeringer, hvor det lokale lager ville hente eksterne forpligtelser fra, og skubbe dine forpligtelser til det eksterne lager.

Hvis du skulle skrive kommandoen

git branch -a

Dette viser alle de grene, der findes i arkivet, både lokalt og eksternt.

For at demonstrere opdatering af det eksterne lager, foretager vi nogle ændringer i filerne i det lager, vi klonede.

Nu hvor vi har foretaget en ændring af vores kode, er den næste handling, vi skal foretage, at skubbe disse ændringer til det eksterne lager

Skubber ændringer til fjernlageret

Den følgende kommando viser alle de ændringer, der er foretaget i filerne.

git diff

Hvis vi indtaster git-status igen, kan vi se, at ændringer er blevet sporet, og at simple.py er blevet ændret.

Føj dem nu til iscenesættelsesområdet

git add -A

Kør git-status igen

Nu kan vi se, at simple.py er klar til at blive begået.

Indtast derefter kommandoen commit med en besked

git commit -m “Updated hello function”

Nu er vi nødt til at skubbe de forpligtede ændringer til fjernlageret, så andre mennesker har adgang til dem.

Da det almindelige tilfælde er, at der er flere udviklere, der arbejder på et enkelt projekt, skal vi først trække de ændringer, der er foretaget i fjernlageret, før vi skubber vores ændringer til det for at undgå konflikter.

Kør følgende kommando:

git pull origin master

Da vi allerede er opdaterede, kan vi nu skubbe vores ændringer til det eksterne lager.

Kør nu følgende:

git push origin master

Vi har med succes skubbet vores ændringer til mastergrenen i fjernlageret!

Oprettelse af en filial til en funktion eller et emne

Indtil videre har vi arbejdet på vores mastergren, men det er ikke sådan, du skal arbejde i git som udvikler, fordi mastergrenen skal være en stabil frigivelse af det projekt, du arbejder på. Så for hver funktion eller problem er det normalt normen at oprette din egen gren og derefter arbejde ud af den gren.

Kommandoen til at oprette en ny gren kaldet simple-greeting er som følger:

git branch simple-greeting

Nu hvis du løber

git branch

så vil du se alle grenene i arkivet, og den aktuelle gren, du er i, er fremhævet med en stjerne på venstre side.

Hvis du vil skifte til den gren, du lige har oprettet, skal du skrive følgende:

git checkout simple-greeting

Hvis du nu skriver git-gren, vil du se, at du nu er på den enkle hilsen-gren.

Nu skal vi foretage ændringer i projektet. Vi skifter til projektet og definerer hilsenfunktionen.

Nu gentager vi processen med at foretage disse ændringer:

git status
git add -A
git commit -m “Greeting Function”

Denne forpligtelse ændrer kun filerne i den lokale filialhilsen, og den har endnu ikke haft nogen indflydelse på den lokale hovedfilial eller fjernlager.

Skubber gren til fjernlager efter at have begået

Indtast følgende kommando:

git push -u origin simple-greeting

hvor oprindelsen er navnet på arkivet, og simpel hilsen er den gren, som vi vil skubbe til.

Nu har vi skubbet den enkle hilsen-gren til fjernlageret. Hvis du skriver:

git branch -a

Vi kan se, at vi i vores fjernlager nu har den enkle hilsen-gren. Hvorfor skal vi skubbe grenen til fjernlageret? For i nogle virksomheder er det her, de kører deres enhedstest og forskellige andre for at sikre, at koden kører godt, før den fusioneres med mastergrenen.

I betragtning af at al testning er kommet godt ud (vi går ikke i detaljer her), kan vi nu flette filialens enkle hilsen med mastergren.

Fletning af en gren

Først skal vi tjekke ind i den lokale mesterfilial

git checkout master

Træk alle ændringerne i den eksterne masterfilial:

git pull origin master

Vi ser nu de grene, vi hidtil har fusioneret:

git branch —-merged

Enkel hilsen-gren vises ikke her, fordi vi ikke har flettet den endnu.

For at flette enkel hilsen med master skal du indtaste:

git merge simple-greeting

(Vær opmærksom på, at vi er i mestergrenen lige nu)

Nu hvor det er blevet flettet, kan vi skubbe ændringerne til master-filialens eksterne fil.

git push origin master

Nu er ændringerne skubbet til mastergrenen i fjernlageret.

Sletning af en filial

Da funktionen nu er blevet implementeret, kan vi slette den enkle hilsen-gren. For at dobbelttjekke fletningen i det foregående afsnit kan vi køre:

git branch --merged

Hvis der vises en simpel hilsen her, betyder det, at vi har flettet alle ændringerne, og at grenen nu kan kasseres.

git branch -d simple-greeting

Nu er filialen slettet lokalt.

Men da vi skubbede grenen til fjernlageret, er den stadig der i fjernlageret. Dette kan ses ved at løbe:

git branch -a

For at fjerne grenen fra fjernlageret skal du indtaste:

git push origin --delete simple-greeting

Hvis vi kører igen

git branch -a

vi kan se, at filialen nu også er slettet fra fjernlageret.

Tillykke!!! Du er nu en mester i grundlæggende, men kritiske Git-kommandoer!

Til reference eller brug af denne vejledning er her det offentlige GitHub Repository Link

I mellemtiden, giv så mange klapper som du vil til denne artikel, hvis du kunne lide det, kommenter nedenunder for eventuelle bekymringer. Tjek også min profil på LinkedIn og følg mig på Twitter!