What is a .gitignore file and how do you use it?

Question

IT Interview Practice · Accepted Answer

A **.gitignore** file tells Git which files and directories to **ignore** — not track in version control. It's used to exclude generated files, dependencies, secrets, and environment-specific files that shouldn't be committed.

## What .gitignore does

```text
# .gitignore — patterns of files Git should NOT track
node_modules/          # dependencies (reinstalled from package files, don't commit)
dist/                  # build output (generated, don't commit)
*.log                  # log files
.env                   # ⚠️ SECRETS / environment variables — NEVER commit!
.DS_Store              # OS-specific junk
.vscode/               # editor config (often personal)
build/
coverage/
*.tmp
```

Git ignores files matching these patterns — they won't appear in `git status`, won't be staged, and won't be committed.

## Pattern syntax

```text
node_modules/    → ignore a directory (and everything in it)
*.log            → ignore all files with a .log extension
!important.log   → EXCEPTION: do NOT ignore this (negation)
/build           → ignore "build" only in the root (leading slash = root-relative)
doc/*.txt        → .txt files in doc/ but not subdirectories
**/temp          → "temp" anywhere in the tree
```

## What to ignore (common categories)

```text
✓ DEPENDENCIES — node_modules/, vendor/ (reinstalled from manifests; huge, don't commit)
✓ BUILD OUTPUT — dist/, build/, *.o (generated from source)
✓ SECRETS — .env, credentials, keys (⚠️ NEVER commit secrets — a serious security issue)
✓ ENVIRONMENT/OS/EDITOR files — .DS_Store, .idea/, .vscode/ (personal/machine-specific)
✓ LOGS, caches, temp files
```

```text
⚠️ Already-tracked files aren't ignored by adding them later — untrack first:
   git rm --cached <file>   (then commit; .gitignore prevents re-adding)
```

## Why it matters

Understanding `.gitignore` is important for **keeping repositories clean and secure**, so it's essential practical Git knowledge.

A `.gitignore` file excludes files that **shouldn't be in version control**, addressing several real needs.

It keeps repositories clean by excluding **generated/derived files** (build output, compiled artifacts) and **dependencies** (`node_modules`, which are huge and reinstalled from manifest files — committing them would bloat the repo) — so the repository contains only the meaningful source.

It excludes **environment-specific and personal files** (OS junk like `.DS_Store`, editor configs) that would clutter the repo and cause noise.

Most critically, it's essential for **security**: excluding **secrets** (`.env` files, credentials, API keys) is vital because **committing secrets is a serious security mistake** — once committed, secrets are in the repository's history (and potentially pushed to remote/public repos where they can be exploited), so `.gitignore` is a key defense against accidentally committing sensitive data.

Understanding the **pattern syntax** (directories, wildcards, negation, root-relative) lets you write effective ignore rules, and knowing the important gotcha that **already-tracked files must be untracked** (`git rm --cached`) before `.gitignore` takes effect prevents a common confusion.

Since clean repositories (no generated files, dependencies, or clutter) and especially **not committing secrets** matter for repository quality and security, and since `.gitignore` is the standard mechanism for excluding files that shouldn't be tracked, understanding `.gitignore` — what to ignore (dependencies, build output, and critically secrets), the pattern syntax, and the untracking gotcha — is essential, frequently-applied Git knowledge for maintaining clean, secure repositories, with the security aspect of keeping secrets out of version control being particularly important.

What .gitignore does

Pattern syntax

What to ignore (common categories)

Why it matters

Related questions