Håndtering av filendringer med Git

Git fungerer på en interessant måte å bære en historie med filendringer. Selv om det kan virke som det ser etter endringene i hver av disse, er det egentlig å bære en fil som heter indeks, der endringene som skjer settes inn. På denne måten, bare ved å lese filen indeks du kan vite hvilke filer og hvilket innhold i dem som er endret.

Når vi forstår det begrepet hvordan Git Det tar endringene som er registrert, det er når vi kan begynne å dra full nytte av verktøyet, siden det er i dette øyeblikket vi kan begynne å bruke de forskjellige kommandoene for å ta endringene fra vårt depot og håndtere dem fra en logisk perspektiv.

Klassifisering av filer i Git

Før vi fortsetter med dypere poeng, må vi se hvordan Git klassifiserer filene dine. Dette betyr ikke en klassifisering etter filtype på grunn av utvidelsen, men snarere av dens status i forhold til vårt depot og dets indeks.

Vi har i utgangspunktet tre filtyper GIT, hver og en har sitt eget øyeblikk i depotet, la oss se hva disse er:

SporesDenne filtypen er allerede lagt til i vårt depot og blir tatt hensyn til av indeks og en fil tar denne tilstanden når vi har lagt den til med følgende kommando.

 git legg til filnavn

IgnoreresI denne klassifiseringen en fil ignorert blir ikke tatt i betraktning av Git Når du gjør endringer, blir filer som gjennomgår mange endringer eller som ikke er avgjørende for stabiliteten i prosjektet normalt klassifisert på denne måten, for eksempel bildefiler på grunn av deres vekt eller kanskje skript av Database at vi ikke alltid trenger å modifisere. For å ignorere en fil må navnet være inkludert i en fil som heter .gitignore og legg det til vårt depot.

UsporetDenne filtypen tilhører ikke vårt depot ennå fordi vi ikke har lagt den til ennå og den er ny i filsystemet, det skjer vanligvis når vi oppretter en ny fil i et allerede initialisert depot eller når vi initialiserer et depot i en mappe som har eksisterende filer.

Praktisk eksempel på filklassifisering

La oss nå se et lite praktisk eksempel på hvordan vi kan oppdage filtyper i et depot Git, for dette må vi følge følgende trinn:

1- Vi skal lage en ny mappe på datamaskinen vår som heter git -filer.

2- Når mappen er opprettet, skal vi legge den inn fra konsollen vår, og der skal vi utføre kommandoen git init og så gjør vi det git -status For å se statusen til depotet vårt, la oss se hvordan anvendelsen av de tidligere kommandoene ser ut:

3- Når vi har fullført forrige trinn vil vi ha et depot Git initialisert og klar til å arbeide, så kan vi opprette en ny fil i den mappen, og vi vil gjøre det igjen git -status For å se endringen må vi ha vår nye fil under klassifiseringen usporet.

4- Vi kommer til å gjenta det forrige trinnet og lage en ny fil, hvis vi ser resultatet av å gjøre det igjen git -status Vi teller begge filene, la oss se:

5- Nå skal vi lage en ny fil som heter .gitignore, merk punktet før filen og inne skal vi plassere navnet på en av våre tidligere filer, gjør vi igjen git -status og vi vil se at nå får vi bare filen som ikke er i den .gitignore og filen .gitignore vi har nettopp opprettet:

6- Da skal vi gjøre en git legge til. for å legge til alle filene våre, og til slutt vil vi utføre en git commit -m "initial commit" med dette å legge til filene våre i depotet, hvis vi gjør en endring i filen som vi ikke plasserer inne i .gitignore og vi lagrer det hvis vi løper igjen git -status vi vil se en fil i status eller klassifisering spores.

Kommandoen git add

I forrige eksempel kunne vi se bruken av git legge til og kanskje kan vi tenke at det er enda en kommando over verktøyet vårt, men dette er veldig viktig, det er det som tillater oss legg til en fil i vårt depot hvis den ikke eksisterer ennå, og den lar oss også legge til endringene som har skjedd i en eksisterende fil i vårt depot.

Hvordan å bruke?Den har noen få måter å brukes på, den vanligste er å gjøre git legg til filnavn, der vi forteller ham hvilken fil vi skal legge til, eller hvis vi ikke kan gjøre det git legge til. der prikken representerer alle filene som er endret eller ikke er i depotet.

Det er veldig viktig at etter at vi har gjort noen endringer i depotet, legger vi til filene med git legge til, siden vi ellers ikke kan lagre endringene våre, i tillegg til å lage forskjellige versjoner av filen, noe som kan føre til en mulig konflikt i fremtiden.

Ved hjelp av git add

Inne i mappen vår git -filer som vi har opprettet i forrige eksempel på opplæringen, skal vi legge til en ny fil som vi vil plassere newFile3 og deretter i den eksisterende filen som ikke er i den .gitignore la oss gjøre en endring.

Det vi ønsker å oppnå med dette er å teste hvordan vi bruker kommandoen vår git legge til, la oss se hvordan dette ser ut i kommandokonsollen:

Etter å ha fulgt de forrige instruksjonene, burde vi ha fått noe som det ovennevnte på skjermen, der vi blir vist a endret fil og a helt ny fil i depotet.

Nå skal vi legge til den nye filen i depotet, men vi vil ikke gjøre det med den eksisterende filen eller den vi har endret tidligere. For dette må vi bare gjøre git legg til vårt filnavn. Så gjør vi det git -status. La oss se:

Som vi kan se, tar vårt depot allerede hensyn til filen vi har lagt til git legge til, dette er måten vi i utgangspunktet kan jobbe med endringer i filene våre.

Slett filer fra depotet

Den neste handlingen vi må vite hvordan vi skal utføre, er å eliminere filene fra depotet vårt, siden det er veldig vanlig at vi har opprettet noe ved en feiltakelse eller at vi rett og slett setter ting i orden i det.

Det er to ting å ta hensyn til, vi kan fjerne filen fra indeksen av depotet vårt, men behold filen i systemet i mappen vår, så hvis vi gjør en git -status Vi vil se det tilgjengelig igjen. Eller hvis vi ikke kan slette filen fra både mappen vår og fra indeks fra vårt depot, for dette kan vi bruke kommandoen git rm.

Kommandoen git rm - cachet

Ved å bruke kommandoen rm med det ekstra alternativet bufret, det vi gjør er å slette den aktuelle filen fra indeksImidlertid vil vi beholde den på datamaskinen vår, denne kommandoen brukes mye når vi ikke ønsker å legge denne filen til vårt depot ennå, men vi må lagre de andre endringene.

For å bruke det gjør vi ganske enkelt kommandoen når vi allerede har lagt til med git legge til noen filer, la oss se hvordan dette ser ut i kommandokonsollen:

Vi merker oss at filen newFile3 som vi hadde lagt til i vårt depot nå, er ikke der og har klassifiseringen sporløst.

Kommandoen Git rm

La oss nå se hvordan du bruker kommandoen git rmDenne kommandoen er mye kraftigere siden den fjerner filen direkte fra indeks og av fil, derfor må vi være forsiktige når vi bestemmer oss for å bruke den i vårt depot, det er svært sannsynlig at når vi har brukt den, vil vi ikke kunne gjenopprette endringen.

La oss se i det følgende eksemplet hvordan det fungerer når vi bruker det på en fil, i dette tilfellet skal vi legge til newFile3 med git legge til og så vil vi søke om dette git rm:

Det ser vi når vi gjør det direkte git viser oss en feil og ber oss om å gjøre en tvungen sletting når vi legger til parameteren -F til instruksjonen skyldes dette viktigheten av endringen, til slutt vil vi lage en git -status og vi vil legge merke til at filen forsvant fra vårt depot i sin helhet.

Mer fra .gitignore

Vi kunne se at vi kan legge til en bestemt fil i filen vår .gitignoreMen når vi jobber i et miljø der vi håndterer hundrevis eller kanskje tusenvis av filer, er det ikke veldig praktisk, det er derfor vi kan bruke mønstre.

Et mønster lar oss indikere for Git at en fil som oppfyller rekkefølgen av tegn eller uttrykk skal ignoreres, med dette kan vi indikere spesifikke utvidelser, enten i hele prosjektet eller i en spesiell mappe. La oss se på et eksempel på dette.

* .jpg.webp den vil ignorere alle .jpg.webp -filene i prosjektet vårt, men hvis vi ønsker å beholde sporet av en spesielt må vi bare legge til:

 ! filnavn.jpg.webp

Så enkelt er det, vi har en sterk og kompleks struktur som gjør at vi kan holde vårt depot organisert.

Med dette fullfører vi denne opplæringen, vi har på en omfattende måte sett måten Git bærer eller administrerer endringene i filene våre, er det viktig å mestre denne saken, siden vi med dette vil kunne jobbe mer effektivt i teammiljøer der det håndteres Git som en versjonskontroller.