Git
Ignorera filer och mappar

Introduktion

Ignorera filer och kataloger med en .gitignore-fil

Du kan få Git att ignorera vissa filer och kataloger - det vill säga utesluta dem från att spåras av Git - genom att skapa en eller flera .gitignore filer i ditt arkiv.

I mjukvaruprojekt innehåller .gitignore vanligtvis en lista över filer och / eller kataloger som genereras under byggprocessen eller vid körning. Poster i .gitignore filen kan innehålla namn eller sökvägar som pekar på:

1. tillfälliga resurser t.ex. cachar, loggfiler, sammanställd kod etc.
2. lokala konfigurationsfiler som inte ska delas med andra utvecklare
3. filer som innehåller hemlig information, till exempel inloggningslösenord, nycklar och referenser

När de skapas i den översta katalogen kommer reglerna att gälla rekursivt för alla filer och underkataloger i hela förvaret. När de skapas i en underkatalog kommer reglerna att gälla för den specifika katalogen och dess underkataloger.

När en fil eller katalog ignoreras kommer den inte att vara:

1. spåras av Git
2. rapporteras av kommandon som git status eller git diff
3. iscensatt med kommandon som git add -A

I det ovanliga fallet att du behöver ignorera spårade filer bör du vara särskilt försiktig. Se: Ignorera filer som redan har åtagits i ett Git-arkiv .

exempel

Här är några generiska exempel på regler i en .gitignore fil, baserade på glob-filmönster :

# Lines starting with `#` are comments.

# Ignore files called 'file.ext'
file.ext

# Comments can't be on the same line as rules!
# The following line ignores files called 'file.ext # not a comment'
file.ext # not a comment 

# Ignoring files with full path.
# This matches files in the root directory and subdirectories too.
# i.e. otherfile.ext will be ignored anywhere on the tree.
dir/otherdir/file.ext
otherfile.ext

# Ignoring directories
# Both the directory itself and its contents will be ignored.
bin/
gen/

# Glob pattern can also be used here to ignore paths with certain characters.
# For example, the below rule will match both build/ and Build/
[bB]uild/

# Without the trailing slash, the rule will match a file and/or
# a directory, so the following would ignore both a file named `gen`
# and a directory named `gen`, as well as any contents of that directory
bin
gen

# Ignoring files by extension
# All files with these extensions will be ignored in
# this directory and all its sub-directories.
*.apk
*.class

# It's possible to combine both forms to ignore files with certain
# extensions in certain directories. The following rules would be
# redundant with generic rules defined above.
java/*.apk
gen/*.class

# To ignore files only at the top level directory, but not in its
# subdirectories, prefix the rule with a `/`
/*.apk
/*.class

# To ignore any directories named DirectoryA 
# in any depth use ** before DirectoryA
# Do not forget the last /, 
# Otherwise it will ignore all files named DirectoryA, rather than directories
**/DirectoryA/
# This would ignore 
# DirectoryA/
# DirectoryB/DirectoryA/ 
# DirectoryC/DirectoryB/DirectoryA/
# It would not ignore a file named DirectoryA, at any level

# To ignore any directory named DirectoryB within a 
# directory named DirectoryA with any number of 
# directories in between, use ** between the directories
DirectoryA/**/DirectoryB/
# This would ignore 
# DirectoryA/DirectoryB/ 
# DirectoryA/DirectoryQ/DirectoryB/ 
# DirectoryA/DirectoryQ/DirectoryW/DirectoryB/

# To ignore a set of files, wildcards can be used, as can be seen above.
# A sole '*' will ignore everything in your folder, including your .gitignore file.
# To exclude specific files when using wildcards, negate them.
# So they are excluded from the ignore list:
!.gitignore 

# Use the backslash as escape character to ignore files with a hash (#)
# (supported since 1.6.2.1)
\#*#

De flesta .gitignore filer är vanliga på olika språk, så för att komma igång, här är en uppsättning av prov .gitignore filer som listas efter språk att klona eller kopiera / modifiera till ditt projekt. Alternativt kan du för ett nytt projekt överväga att automatiskt generera en startfil med ett onlineverktyg .

Andra former av .gitignore

.gitignore filer är avsedda att begå som en del av förvaret. Om du vill ignorera vissa filer utan att begå ignoreringsreglerna är här några alternativ:

• Redigera .git/info/exclude filen (med samma syntax som .gitignore ). Reglerna kommer att vara globala inom förvaret;
• Ställ in en global gitignore-fil som kommer att tillämpa ignoreringsregler på alla dina lokala förvar:

Dessutom kan du ignorera lokala ändringar av spårade filer utan att ändra den globala GIT-konfigurationen med:

• git update-index --skip-worktree [<file>...] : för mindre lokala ändringar
• git update-index --assume-unchanged [<file>...] : för produktionsklar, icke-ändrade filer uppströms

Se mer information om skillnader mellan de senare flaggorna och dokumentationen för git update-index för ytterligare alternativ.

Rengöring av ignorerade filer

Du kan använda git clean -X att rensa ignorerade filer:

git clean -Xn #display a list of ignored files
git clean -Xf #remove the previously displayed files

Obs: -X (mössor) rensar endast ignorerade filer. Använd -x (inga lock) för att också ta bort ospårade filer.

Se git clean dokumentationen för mer information.

Se Git-manualen för mer information.

Undantag i en .gitignore-fil

Om du ignorerar filer genom att använda ett mönster men har undantag, förinställer du ett utropstecken (!) Till undantaget. Till exempel:

*.txt
!important.txt

Exemplet ovan instruerar Git att ignorera alla filer med .txt förlängningen förutom för filer som heter important.txt .

Om filen finns i en ignorerad mapp kan du INTE ta med den så enkelt:

folder/
!folder/*.txt

I detta exempel skulle alla .txt-filer i mappen förbli ignorerade.

Det rätta sättet är att återigen inkludera själva mappen på en separat rad, ignorera sedan alla filer i folder med * , och slutligen ta med *.txt i folder , som följande:

!folder/
folder/*
!folder/*.txt

Obs : För filnamn som börjar med ett utropstecken, lägg till två utropstecken eller undkomma med tecknet \ :

!!includethis
\!excludethis

En global .gitignore-fil

För att få Git att ignorera vissa filer i alla förvar kan du skapa en global .gitignore med följande kommando i din terminal eller kommandotolk:

$ git config --global core.excludesfile <Path_To_Global_gitignore_file>

Git kommer nu att använda detta utöver varje förvaras egen .gitignore- fil. Regler för detta är:

• Om den lokala .gitignore filen uttryckligen inkluderar en fil medan den globala .gitignore ignorerar den, tar den lokala .gitignore prioritet (filen kommer att inkluderas)
• Om förvaret är klonat på flera maskiner måste den globala .gigignore laddas på alla maskiner eller åtminstone inkludera den, eftersom de ignorerade filerna kommer att skjutas upp till repo medan datorn med den globala .gitignore skulle uppdatera den . Det är därför en .gitignore är en bättre idé än en global om projektet arbetar med av ett team

Denna fil är ett bra ställe att hålla ignorera plattform, maskin eller användarspecifik, t.ex. OSX .DS_Store , Windows Thumbs.db eller Vim *.ext~ och *.ext.swp ignorerar om du inte vill behålla dem i förvaret . Så en teammedlem som arbetar på OS X kan lägga till alla .DS_STORE och _MACOSX (som faktiskt är värdelös), medan en annan thumbs.bd på Windows kan ignorera alla thumbs.bd

Ignorera filer som redan har åtagits i ett Git-arkiv

Om du redan har lagt till en fil i ditt Git-arkiv och nu vill sluta spåra den (så att den inte kommer att finnas i framtida åtaganden) kan du ta bort den från indexet:

git rm --cached <file>

Detta kommer att ta bort filen från förvaret och förhindra att ytterligare ändringar spåras av Git. --cached säkerställer att filen inte raderas fysiskt.

Observera att tidigare lagrat innehåll i filen fortfarande kommer att synas via Git-historiken.

Tänk på att om någon annan drar från arkivet efter att du tagit bort filen från indexet kommer deras kopia att raderas fysiskt .

Du kan låta Git låtsas att den katalogversion av filen är uppdaterad och läsa indexversionen istället (och därmed ignorera ändringar i den) med " hoppa över arbetsbords- bit":

git update-index --skip-worktree <file>

Skrivning påverkas inte av denna bit, innehållssäkerhet är fortfarande första prioritet. Du kommer aldrig att förlora dina värdefulla ignorerade förändringar; å andra sidan den här biten konflikter med stashing: för att ta bort den här biten, använd

git update-index --no-skip-worktree <file>

Det rekommenderas ibland felaktigt att ljuga för Git och låta den anta att filen är oförändrad utan att granska den. Det ser vid första anblicken att ignorera ytterligare ändringar i filen utan att ta bort den från dess index:

git update-index --assume-unchanged <file>

Detta kommer att tvinga git att ignorera alla ändringar som gjorts i filen (kom ihåg att om du drar några ändringar i den här filen, eller om du stash den, kommer dina ignorerade ändringar att gå förlorade )

Om du vill att git ska "bry sig" om den här filen igen, kör följande kommando:

git update-index --no-assume-unchanged <file>

Kontrollera om en fil ignoreras

git check-ignore kommandorapporter om filer som ignoreras av Git.

Du kan skicka filnamn på kommandoraden, och git check-ignore de filnamn som ignoreras. Till exempel:

$ cat .gitignore
*.o
$ git check-ignore example.o Readme.md
example.o

Här definieras endast * .o-filer i .gitignore, så Readme.md är inte listad i utgången från git check-ignore .

Om du vill se rad som .gitignore ansvarar för att ignorera en fil lägger du till -v till kommandot git check-ignor:

$ git check-ignore -v example.o Readme.md
.gitignore:1:*.o        example.o

Från Git 1.7.6 och framåt kan du också använda git status --ignored för att se ignorerade filer. Du kan hitta mer information om detta i den officiella dokumentationen eller i Hitta filer som ignoreras av .gitignore .

Ignorera filer i undermappar (Flera gitignore-filer)

Anta att du har en lagringsstruktur som denna:

examples/
    output.log
src/
    <files not shown>
    output.log
README.md

output.log i output.log med exempel är giltigt och krävs för att projektet ska få en förståelse medan den under src/ skapas under felsökning och bör inte vara i historik eller del av förvaret.

Det finns två sätt att ignorera den här filen. Du kan placera en absolut sökväg i .gitignore filen i roten till arbetskatalogen:

# /.gitignore
src/output.log

Alternativt kan du skapa en .gitignore fil i src/ katalogen och ignorera filen som är relativt denna .gitignore :

# /src/.gitignore
output.log

Att ignorera en fil i valfri katalog

För att ignorera en fil foo.txt i valfri katalog bör du bara skriva dess namn:

foo.txt # matches all files 'foo.txt' in any directory

Om du bara vill ignorera filen i en del av trädet kan du ange underkataloger för en specifik katalog med ** -mönster:

bar/**/foo.txt # matches all files 'foo.txt' in 'bar' and all subdirectories

Eller så kan du skapa en .gitignore fil i bar/ katalogen. Likvärdigt med föregående exempel skulle skapa bar/.gitignore med dessa innehåll:

foo.txt # matches all files 'foo.txt' in any directory under bar/

Ignorera filer lokalt utan att begå ignoreringsregler

.gitignore ignorerar filer lokalt, men det är avsett att vara engagerat i förvaret och delas med andra bidragsgivare och användare. Du kan ställa in en global .gitignore , men alla dina förvar skulle dela dessa inställningar.

Om du vill ignorera vissa filer i ett förvar lokalt och inte göra filen till en del av ett arkiv kan du redigera .git/info/exclude i ditt arkiv.

Till exempel:

# these files are only ignored on this repo
# these rules are not shared with anyone
# as they are personal                                              
gtk_tests.py
gui/gtk/tests/*
localhost
pushReports.py
server/

Prefilled .gitignore mallar

Om du är osäker på vilka regler som ska listas i din .gitignore fil, eller bara vill lägga till allmänt accepterade undantag till ditt projekt, kan du välja eller generera en .gitignore fil:

• https://www.toptal.com/developers/gitignore
• https://github.com/github/gitignore

Många värdtjänster som GitHub och BitBucket erbjuder möjligheten att generera .gitignore filer baserade på de programmeringsspråk och IDE som du kanske använder:

Ignorera efterföljande ändringar av en fil (utan att ta bort den)

Ibland vill du ha en fil i Git men ignorera efterföljande ändringar.

Be Git att ignorera ändringar i en fil eller katalog med update-index :

git update-index --assume-unchanged my-file.txt

Ovanstående kommando instruerar Git att anta att my-file.txt inte har ändrats och att inte kontrollera eller rapportera ändringar. Filen finns fortfarande i förvaret.

Detta kan vara användbart för att tillhandahålla standardvärden och tillåta åsidosättningar av lokal miljö, t.ex.

# create a file with some values in
cat <<EOF
MYSQL_USER=app
MYSQL_PASSWORD=FIXME_SECRET_PASSWORD
EOF > .env

# commit to Git
git add .env
git commit -m "Adding .env template"

# ignore future changes to .env
git update-index --assume-unchanged .env

# update your password
vi .env

# no changes!
git status

Ignorerar endast en del av en fil [stub]

Ibland kanske du vill ha lokala ändringar i en fil som du inte vill begå eller publicera. Idealt bör lokala inställningar koncentreras i en separat fil som kan placeras i .gitignore , men ibland som en kortvarig lösning kan det vara bra att ha något lokalt i en incheckad fil.

Du kan göra Git "oöverträffa" de raderna med rent filter. De kommer inte ens att dyka upp i diff.

Anta att här är kodavsnittet från filen file1.c :

struct settings s;
s.host = "localhost";
s.port = 5653;
s.auth = 1;
s.port = 15653; // NOCOMMIT
s.debug = 1; // NOCOMMIT
s.auth = 0; // NOCOMMIT

Du vill inte publicera NOCOMMIT rader någonstans.

Skapa "nocommit" -filter genom att lägga till detta i Git-konfigurationsfilen som .git/config :

[filter "nocommit"]
    clean=grep -v NOCOMMIT

Lägg till (eller skapa) detta till .git/info/attributes eller .gitmodules :

file1.c filter=nocommit

Och dina NOCOMMIT-linjer är dolda från Git.

varningar:

• Att använda rent filter bromsar bearbetningen av filer, särskilt på Windows.
• Den ignorerade linjen kan försvinna från filen när Git uppdaterar den. Det kan motverkas med ett fläckfilter, men det är svårare.
• Testas inte på Windows

Ignorera ändringar i spårade filer. [stump]

.gitignore och .git/info/exclude arbete endast för ospårade filer.

För att ställa ignoreringsflagga på en spårad fil använder du kommandot update-index :

git update-index --skip-worktree myfile.c

För att återställa detta använder du:

git update-index --no-skip-worktree myfile.c

Du kan lägga till detta utdrag i din globala GIT-konfiguration för att ha mer bekvämt git hide , git unhide och git hidden kommandon:

[alias]
    hide   = update-index --skip-worktree
    unhide = update-index --no-skip-worktree
    hidden  = "!git ls-files -v | grep ^[hsS] | cut -c 3-"

Du kan också använda alternativet - antas oförändrat med uppdateringsindexfunktionen

git update-index --assume-unchanged <file>

Om du vill titta på den här filen igen för ändringarna använder du

git update-index --no-assume-unchanged <file>

När - antagande-oförändrad flagga anges, lovar användaren att inte ändra filen och tillåter Git att anta att arbetsträdfilen matchar vad som är registrerat i indexet. Git kommer att misslyckas i fall det måste ändra den här filen i indexet t.ex. vid sammanslagning i en åtagande; Om den antagna ospårade filen ändras uppströms måste du därför hantera situationen manuellt. Fokus ligger på prestanda i det här fallet.

Medan - ship-worktree-flaggan är användbar när du instruerar git att inte röra vid en specifik fil någonsin eftersom filen kommer att ändras lokalt och du inte vill göra felaktiga ändringar (dvs. konfigurations- / egenskaper-fil konfigurerad för en viss miljö). Skip-worktree har företräde framför antagande oförändrad när båda är inställda.

Rensa redan åtagda filer, men ingår i .gitignore

Ibland händer det att en fil spårades av git, men i en senare tidpunkt läggs till till .gitignore för att sluta spåra den. Det är ett mycket vanligt scenario att glömma att rensa upp sådana filer innan de läggs till .gitignore. I det här fallet kommer den gamla filen fortfarande att hänga i förvaret.

För att åtgärda problemet kan man utföra ett "torrkörnings" borttagning av allt i förvaret, följt av att lägga till alla filer tillbaka. Så länge du inte har några väntande ändringar och - --cached parametern har passerat är detta kommando ganska säkert att köra:

# Remove everything from the index (the files will stay in the file system) 
$ git rm -r --cached .

# Re-add everything (they'll be added in the current state, changes included)
$ git add .

# Commit, if anything changed. You should see only deletions
$ git commit -m 'Remove all files that are in the .gitignore'

# Update the remote
$ git push origin master

Skapa en tom mapp

Det är inte möjligt att lägga till och begå en tom mapp i Git på grund av att Git hanterar filer och kopplar deras katalog till dem, vilket slirar ned åtaganden och förbättrar hastigheten. För att komma runt detta finns det två metoder:

Metod ett: .gitkeep

En hack för att komma runt detta är att använda en .gitkeep fil för att registrera mappen för Git. För att göra detta, skapa bara den önskade katalogen och lägg till en .gitkeep fil i mappen. Denna fil är tom och tjänar inte något annat syfte än att bara registrera mappen. För att göra detta i Windows (som har besvärliga filnamnkonventioner) öppnar du bara git bash i katalogen och kör kommandot:

$ touch .gitkeep

Detta kommando skapar bara en tom .gitkeep fil i den aktuella katalogen

Metod två: dummy.txt

En annan hack för detta är mycket lik ovanstående och samma steg kan följas, men istället för en .gitkeep , använd bara en dummy.txt istället. Detta har den extra bonusen att enkelt kunna skapa den i Windows med snabbmenyn. Och du får lämna roliga meddelanden också i dem. Du kan också använda .gitkeep filen för att spåra den tomma katalogen. .gitkeep normalt en tom fil som läggs till för att spåra den tomma riktningen.

Hitta filer som ignoreras av .gitignore

Du kan lista alla filer som ignoreras av git i nuvarande katalog med kommando:

git status --ignored

Så om vi har lagringsstruktur som denna:

.git
.gitignore
./example_1
./dir/example_2
./example_2

... och .gitignore-fil som innehåller:

example_2

... än resultatet av kommandot blir:

$ git status --ignored

On branch master

Initial commit

Untracked files:
  (use "git add <file>..." to include in what will be committed)

.gitignore
.example_1

Ignored files:
  (use "git add -f <file>..." to include in what will be committed)

dir/
example_2

Om du vill lista rekursivt ignorerade filer i kataloger måste du använda ytterligare parameter - --untracked-files=all

Resultatet kommer att se ut så här:

$ git status --ignored --untracked-files=all
On branch master

Initial commit

Untracked files:
  (use "git add <file>..." to include in what will be committed)

.gitignore
example_1

Ignored files:
  (use "git add -f <file>..." to include in what will be committed)

dir/example_2
example_2