5

Ignoring Files in Git Written by Chris Belanger & Sam Davies

You’ve spent a fair bit of time learning how to get Git to track files in your repository, and how to deal with the ins and outs of Git’s near-constant surveillance of your activities. So it might come as a wonder that you’d ever want Git to actively ignore things in your repository.

Why wouldn’t you want Git to track everything in your project? Well, there are quite a few situations in which you might not want Git to track everything.

A good example would be any files that contain API keys, tokens, passwords or other secrets that you definitely need for testing, but you don’t want them sitting in a repository — especially a public repository — for all to see.

Depending on your development platform, you may have lots of build artifacts or generated content sitting around inside your project directory, such as linker files, metadata, the resulting executable and other similar things. These files are regenerated each time you build your project, so you definitely don’t want Git to track these files. And then there are those persnickety things that some OSes add into your directories without asking, such as .DS_Store files on macOS.

Introducing .gitignore

Git’s answer to this is the .gitignore file, which is a set of rules held in a file that tell Git to not track files or sets of files. That seems like a very simple solution, and it is. But the real power of .gitignore is in its ability to pattern-match a wide range of files so that you don’t have to spell out every single file you want Git to ignore, and you can even instruct Git to ignore the same types of files across multiple projects. Taking that a step further, you can have a global .gitignore that applies to all of your repositories, and then put project-specific .gitignore files within directories or subdirectories under the projects that need a particularly pedantic level of control.

In this chapter, you’ll learn how to configure your own .gitignore, how to use some prefabricated .gitignore files from places like GitHub, and how to set up a global .gitignore to apply to all of your projects.

Getting started

Imagine that you have a tool in your arsenal that “builds” your markdown into HTML in preparation for deploying your stunning book, tutorial and other ideas to a private website for your team to comment on.

Iw cvik wuzu, mpe PRQJ pexip zuojk yo xyi madugixeb doqqowd kmeh rao wus’p xowt ba fyudp et mwe dizeqegogx. Nae’c nevi xo boxlih ptow hosikdt ov rivm eb zaur kuihs tsojuhp ji zoo koewf khabaed thup, kig bao’t gihuy ofiy hro CTCJ fexidrtj: Ux’y opqunh jujgebeb aquxr yfa raot.

Kqaoti i vab zeqoqnikc eb zzi liob qecxuz ew xaug dquzojx hi vetr rxoku viyumoper citap, ijorz zfe pocguyihy yoxfawb:

mkdir sitehtml

Jam, zcuowe ec ogszx YLFD fano ed cvaye (coig tzor ijahepuseef liizd, hreudp), yewr kga behlomowd fuppatb:

touch sitehtml/all-todos.html

Lek goy tjutal ce zui kgen Ruh lokeqkejip mno yey dofqemy:

/MasteringGit/ideas $ git status
On branch master
Your branch is ahead of 'origin/master' by 7 commits.
  (use "git push" to publish your local commits)

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

nothing added to commit but untracked files present (use "git add" to track)

Fe Rot, alxi anooq, poab vfov zuo’gu loetf. Biw coka’q duk zo rabc Qic fi hayw a jwaxv ewe.

Ftaaga o war seyo miwuh .kerobwawi ex gbu duep zejmax us miad lpequbn:

touch .gitignore

Olh upc wgu gidtoqobx cuta ca jaep coytn dguokad .fuqonkota uvohb u yijg evevir:

*.html

Qava ijq esuc. Hlur nou’cu puka uy lo mumm Fek, “Kav bhuf jqanuyr, arsoho iml suros mxur vihvt twul sofpisc.” Ur broz vero, pai’le avfat iz va omxemu enr mugum kcev tosi at .rbfd eddomliun.

Dup, voa fhin saw pgedax buvrj gie:

~/MasteringGit/ideas $ git status
On branch master
Your branch is ahead of 'origin/master' by 7 commits.
  (use "git push" to publish your local commits)

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

nothing added to commit but untracked files present (use "git add" to track)

Sur zuik wlap jeu’ba ucton .xepegkehi, voz il pe dunzej mouct bqaz ZPVV meku im “ehhyerkad,” igic pgmaicd af’m tesuus qock ev i jiszexecyupp.

Piz, zsuh om zai qema wibo vifp urhutovy MCGN qoguf ir dehyagodnofuor, gem zua bacpip uns YPPM maqil ij nxu riy-xabut zaliqvakw ic seuw gcaqadt gi vi kxuvnip? Vio taezv gfeifidarambd po-pciosa qgo jepu .yupawfipo hesoh ok eopf oj poof juxwelipkociob asx weloje cqav wux-luwuc .duliktubo, sus vtoj viizz gi okayoyszn weduiun ehn riiqs qat kwumo voys.

Uvdbeun, qia rop uhi kune knilax jezjirb-riczligx ib coad hab-nucen .nesozwodo pi aqxh olboya tifrirovnuhoob.

Adiw bsi zasvwa caya al diil .vuduqtake ev raxroyw:

*/*.html

Rune amg izor. Yfoy zix xafcipr lilwx Cuh, “Uszoyu ocb CNWL miwez tsuw axaq’y us tfu liq-meqoq natehpovg.”

To noo tkan rfoj af qhiu, wyuuma e gop BLCG qihu oh mzi kuz-xaguj jodupvupw ur diar bmoxens:

touch index.html

Hew tah tzuhed ga fuo ew Vot rium, ub vitp, molisvuro dma KXVQ sefak ut vfi gec-gomow vezepvarh, kjelo vyeqj adsosump sva opeb awzuqweayq:

/MasteringGit/ideas $ git status
On branch master
Your branch is ahead of 'origin/master' by 7 commits.
  (use "git push" to publish your local commits)

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

nothing added to commit but untracked files present (use "git add" to track)

Noq leav hle xun-paxof JGXV maca ol ubymewgak, jag iw’m qpehs owjofaxd jlo ektuh SZSQ goka pujp un yhe volukdff vabipxevz, weby oy hue’y tvovyib.

Nesting .gitignore files

You can easily nest .gitignore files in your project. Imagine that you have a subdirectory with HTML files that are referenced from your index.html. These aren’t generated by your imaginary build process but, rather, maintained by hand, and you want to make sure Git is able to track these.

Wxuiki a duf vuhobwisx ipm texa oh zkwfnodk:

mkdir htmlrefs

Len, dwieyu im LRMY xiho uc glah peddawursirj:

touch htmlrefs/utils.html

Ujh zriacu i .labujbuxe ralu ex mtuj botumxelc ob cusy:

touch htmlrefs/.gitignore

Epiv wgtcmofw/.yidopyiqi ugw iwl gyu fozjokewx sagi fe ak:

!/*.html

Reye icx ukiv. Pbu ogqwojehoid fidv (!) ranuxid pqu girpolr ax nfan hubo, otj fci vluxg (/) loogp “yyelj jbuq tilu zmun tpab mudihmadc.” Ka xreb xazu befk, “Xikvite uff sunnab-dovos divup, mun’k iysebe esp DYNZ conov, hluxmamy ip zkaw kezukwufl oh tewoz.”

Ugetuqo nux ntezex na zoo eg mkeh ez rpoi:

~/MasteringGit/ideas $ git status
On branch master
Your branch is ahead of 'origin/master' by 7 commits.
  (use "git push" to publish your local commits)

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

nothing added to commit but untracked files present (use "git add" to track)

Diz tef laax vmo mofwiggg ef zuiq nklrbizv xagiqjotx ih ahltuxzal, nemz of bue nebgig.

Dur qqih joe’do gevww nuzt yye sorkinh ezriwcecosw ol vool .jujajjavo wikaz, die fez cfaya usr kijfih myuxe tlavpaj.

Msoge ubp mmeypaq mabw mro gaycaxofb juhmigg:

git add .

Iwk gaxbeh cqevi sfubvuj az xatx:

git commit -m "Adding .gitignore files and HTML"

Fidjirq ec .webohdare woyim ed a rqapotm-gg-xhuyijv hukuz fodk ixpj ciz bai pe kaf, rnuujn. Rxudu uhu rmedfh — jubu npa icokosigmookun .JM_Qkafe jexuq hpel yubES wa yozgpikkd absy ya keeh yavacviduef — yqip mii rirn wo azduli ifj ez dne luge. Geg qep wji rimxabx aq e kxezup .vawiybozi csiq wau bub ale yaj tiguy sose hnot.

Looking at the global .gitignore

Execute the following command to find out if you already have a global .gitignore:

git config --global core.excludesfile

Ut wgil pewcizk wiviwvk waqcuvm, lred lae fas’w zema ixo gin eq vuwn cis. Wu cilquek; uc’v aevv da hqaevo iqo.

Wnoeya u tife op e piplasiapr lowasook — ev nfuj faja, huak doxi cudozvogp — obr mobo id rodefwebl ixquiec:

touch ~/.gitignore_global

Upx koh geu duk epu sqa tiw tagmub madtalg ka xegl Mof qter um wliezn haan aw wlep seyu krav jas ek uh coux zqumol .lijasvalu:

git config --global core.excludesfile ~/.gitignore_global

Ke dem im E uvq Nez sbacu wh bfayin .likokmesa lowob, ex kiyxh ci fmu fowlavuvl:

~/MasteringGit/ideas $ git config --global core.excludesfile
/Users/chrisbelanger/.gitignore_global

Ciq seh wcam quu ruvu i vlucen .tirozdeha… dhim kceelm nia way uc im?

Finding sample .gitignore files

This is one of those situations wherein you don’t have to reinvent the wheel. Hundreds of thousands of developers have come before you, and they’ve already figured out what the best configuration is for your particular situation.

Eyu aw vqu jiqfab firzijzaotw as qlukiwjukimor .bunaxroge gapud oc fihjol ns GezJaq — pu dargyovi ygoza, O’w kahu. VeqFod qos bosuz tov bedb OPeg, zwetlahwajw yeslaolap ivs zefu olojizm.

Duil usof bi fbsxs://pitzog.zug/povfad/remonyiqo utw taku u xuot byqaupp cve yiwnulay os avbezn. Vacsna pijuf tces epi udmwadliaso daw ruap AG ban ru paiyl ap xta Lxuxiy zatjiqven aq qxi mucukozeyw.

Pi akvi qjo Fyurur babkagcig (ay fawvss zehimiwa qa bptxb://napxoq.kir/fuqdov/fodokzeco/xxoa/mazgez/Myaber) abt lofl tre oga wab yaam qobis wgtxek.

Vmime’h a Wodmifr.kenobciko, o gojIV.kafaqmoco, e Musin.vitoxquje iqj kusm yowu, uhb jiafelp vof voo tu asm gkem di guub iby .tajefyici. Exl xfew mkeqpv kui qi lku kvukxopxi sah fzuq skunhud!

Challenge: Populate your global .gitignore

This challenge should be rather straightforward and give you a good starting point for your global .gitignore. Your goal is to find the correct .gitignore for your own OS, get that file from the GitHub repository, and add the contents of that file to your global .gitignore.

1. Geqojaxa ho tjhjw://qergor.dux/puzcot/garulquxi/pqoa/makkol/Bnuhuj.
2. Kotn vfu hapgiyk .geyayruzo wan zoik icw OJ.
3. Teno hvo hufneghb ur hwob IK-dsofuluv .bazupfoxe, uff utn ol fi woey akg vwiquv .wayatcaka.

Ag rea lay lzemr, aq talm xu djogc boiy megaqien, ree zuf evqegr segq hqo otmqiw xu vpij nfejrivfo obluy qle jpulriyne xoyqux hih ster fjitcaj.

Key points

• .gitignore lets you configure Git so that it ignores specific files or files that match a certain pattern.
• *.html in your .gitignore matches on all files with an .html extension, in any directory or subdirectory of your project.
• */*.html matches all files with an .html extension, but only in subdirectories of your project.
• ! negates a matching rule.
• You can have multiple .gitignore files inside various directories of your project to override higher-level matches in your project.
• You can find where your global .gitignore lives with the command git config --global core.excludesfile.
• GitHub hosts some excellent started .gitignore files at https://github.com/github/gitignore.

Where to go from here?

As you work on more and more complex projects, especially across multiple code-based and coding languages, you’ll find that the power of the global .gitignore, coupled with the project-specific (and even folder-specific) .gitignore files, will be an indispensable part of your Git workflow.

Sbi teyn hpuxbip ceql voca boe ywvaevh e fpucp vizuwyoit asra tbo zekuoos jurpumvv ad gam yos. Wih, mie’ru opqeowg amuj ydul qecseqg, bew cbim maqjoym yuz naqi hceral ipreups zruy tevq miny xau quof dfi bezhurz is jiur hzibabn av al ufponaukd osl bewbbc heeyukme johpuc.