Ignoring Code

Learn how to configure ESLint to ignore specific files, directories, and patterns during linting

Ignoring Code

You can configure ESLint to ignore certain files and directories while linting. This is useful for excluding build outputs, dependencies, and other files that shouldn’t be linted.

Quick Start

Global Ignores

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([".config/*", "dist/", "build/"])
]);

Default Ignore Patterns

ESLint automatically ignores these patterns:

**/node_modules/

All node_modules directories

.git/

Git directory

Files and directories starting with a dot (like .foo.js or .fixtures) are NOT ignored by default (except .git).

Global Ignores

Global ignores apply to every configuration object in your config file:

eslint.config.js

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  // These ignores apply to ALL configurations below
  globalIgnores([".config/", "dist/", "tsconfig.json"]),
  
  {
    rules: {
      semi: "error"
    }
  },
  {
    files: ["**/*.ts"],
    rules: {
      "@typescript-eslint/no-explicit-any": "warn"
    }
  }
]);

Use globalIgnores() helper function to clearly indicate which ignores are global.

Named Global Ignores

You can provide a name for debugging:

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores(["build/**/*"], "Ignore Build Directory")
]);

Ignore Files

Ignore Specific Files

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    ".config/*",        // All files in .config directory
    "webpack.config.js", // Specific file
    "*.config.js"       // All files ending with .config.js
  ])
]);

Ignore Multiple File Types

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "**/*.min.js",    // Minified files
    "**/*.bundle.js",  // Bundle files
    "**/*.test.js",    // Test files
    "**/*.spec.js"     // Spec files
  ])
]);

Ignore Default Patterns

By default, ESLint lints **/*.js, **/*.cjs, and **/*.mjs. To ignore these:

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  // Ignore default patterns
  globalIgnores(["**/*.js", "**/*.cjs", "**/*.mjs"]),
  
  // Only lint TypeScript files
  {
    files: ["**/*.ts"],
    rules: { /* ... */ }
  }
]);

Ignore Directories

Single Directory

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([".config/"])  // Note the trailing slash
]);

Without a trailing /, the pattern only ignores a file named .config in the same directory as the config file.

Recursive Directory Ignore

Ignore all directories with a specific name:

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "**/.config/",    // All .config directories recursively
    "**/dist/",       // All dist directories
    "**/build/",      // All build directories
    "**/node_modules/" // Redundant (already default)
  ])
]);

Common Directory Patterns

Build Outputs

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "dist/",
    "build/",
    "out/",
    ".next/",
    ".nuxt/",
    "public/build/"
  ])
]);

Dependencies

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "node_modules/",  // Already default
    "bower_components/",
    "vendor/",
    "jspm_packages/"
  ])
]);

Coverage and Tests

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "coverage/",
    ".nyc_output/",
    "test-results/",
    "*.test.js",
    "*.spec.js"
  ])
]);

Generated Files

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "**/*.generated.js",
    "**/*.g.js",
    "**/generated/**",
    "**/__generated__/**"
  ])
]);

Unignore Files and Directories

Use negation patterns (starting with !) to unignore previously ignored files:

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "!node_modules/",      // Unignore node_modules
    "node_modules/*",      // Ignore its content
    "!node_modules/mylibrary/", // Unignore specific library
  ])
]);

Negation patterns must come after the patterns they’re negating.

Unignore Specific Files in Ignored Directory

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "build/**/*",        // Ignore all contents (not the directory itself)
    "!build/test.js"     // Unignore specific file
  ])
]);

Use build/**/* instead of build/**. The pattern build/** ignores the entire directory and traversal will skip it completely.

Unignore Files at Any Level

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "build/**/*",         // Ignore all contents
    "!build/**/*/",       // Unignore subdirectories
    "!build/**/test.js"   // Unignore test.js at any level
  ])
]);

Unignore While Ignoring Defaults

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "**/*.js",           // Ignore all .js files
    "**/*.cjs",          // Ignore all .cjs files
    "**/*.mjs",          // Ignore all .mjs files
    "!**/src/**/*.js"    // Except .js files in src directories
  ])
]);

Non-Global Ignores

Non-global ignores only apply to their configuration object:

export default [
  {
    files: ["src/**/*.js"],
    ignores: [".config/**", "dir1/script1.js"],
    rules: {
      semi: "error"
    }
  },
  {
    files: ["tests/**/*.js"],
    ignores: ["fixtures/**"],
    rules: {
      "no-unused-expressions": "off"
    }
  }
];

Non-global ignores can only match file names, not directory names like global ignores can.

Global vs Non-Global

Global

// No other keys = global ignores
export default [
  {
    ignores: [".config/", "dist/"]
  },
  // Applies to all configurations below
  {
    rules: { semi: "error" }
  }
];

Characteristics:

• Applies to every configuration object
• Can match directories: "dir/"
• Patterns: files, directories, and wildcards

Non-Global

// Has other keys = non-global ignores
export default [
  {
    ignores: [".config/**"],
    rules: { semi: "error" }
  },
  // Does NOT apply here
  {
    rules: { "no-console": "off" }
  }
];

Characteristics:

• Only applies to its configuration object
• Can only match file names
• Patterns: files and wildcards only

Command Line Ignores

Ignore patterns from the command line:

# Ignore a specific pattern
npx eslint . --ignore-pattern ".config/*"

# Ignore multiple patterns
npx eslint . --ignore-pattern "/lib/" --ignore-pattern "/src/vendor/*"

# Unignore a pattern
npx eslint . --ignore-pattern "!node_modules/"

Command line patterns are evaluated relative to the current working directory.

Include .gitignore Files

You can include patterns from .gitignore files:

eslint.config.js

import { defineConfig } from "eslint/config";
import { includeIgnoreFile } from "@eslint/compat";
import { fileURLToPath } from "node:url";
import path from "node:path";

const gitignorePath = fileURLToPath(new URL(".gitignore", import.meta.url));

export default defineConfig([
  includeIgnoreFile(gitignorePath),
  {
    rules: { /* ... */ }
  }
]);

1. Install @eslint/compat

   npm install --save-dev @eslint/compat
   
2. Import includeIgnoreFile

   import { includeIgnoreFile } from "@eslint/compat";
   
3. Load .gitignore patterns

   const gitignorePath = path.resolve(__dirname, ".gitignore");
   export default [
     includeIgnoreFile(gitignorePath)
   ];
   

Named .gitignore Import

import { includeIgnoreFile } from "@eslint/compat";
import { fileURLToPath } from "node:url";

const gitignorePath = fileURLToPath(new URL(".gitignore", import.meta.url));

export default [
  includeIgnoreFile(gitignorePath, "Imported .gitignore patterns"),
  { /* ... */ }
];

Pattern Syntax

Ignore patterns use minimatch syntax:

Wildcards

Pattern	Matches
*	Any characters except /
**	Any characters including /
?	Single character
[abc]	Character set
{a,b}	Alternatives

Examples:

"*.js"        // file.js, test.js
"**/*.js"     // src/file.js, lib/test.js
"test?.js"    // test1.js, testa.js
"test[123].js" // test1.js, test2.js, test3.js
"*.{js,ts}"   // file.js, file.ts

Negation

Prefix with ! to negate:

[
  "*.js",      // Ignore all .js files
  "!test.js"   // Except test.js
]

Directory Matching

Trailing / matches directories:

"build/"      // Matches build directory
"**/dist/"    // Matches all dist directories
"node_modules/" // Matches node_modules directory

Relative Paths

Patterns are evaluated relative to:

• eslint.config.js location for config file patterns
• Current working directory for CLI patterns

"./src/*.js"  // Relative to config file
"src/*.js"    // Also relative to config file

Pattern Resolution

How patterns are evaluated depends on where they’re used:

Config File

// Evaluated relative to eslint.config.js location
import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores(["dist/", "build/"])
]);

Alternate Config

# Patterns evaluated relative to current directory
npx eslint --config other-config.js src/

Command Line

# Patterns evaluated relative to current directory
npx eslint . --ignore-pattern "build/"

Ignored File Warnings

When you pass a specific file to ESLint that is ignored, you’ll see a warning:

npx eslint foo.js

foo.js
  0:0  warning  File ignored because of a matching ignore pattern.
               Use "--no-ignore" to disable file ignore settings or
               use "--no-warn-ignored" to suppress this warning.

✖ 1 problem (0 errors, 1 warning)

• Use --no-ignore to lint the file anyway
• Use --no-warn-ignored to suppress the warning

Common Patterns

Node.js Project

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "node_modules/",
    "dist/",
    "build/",
    "coverage/",
    "*.min.js",
    "*.bundle.js"
  ])
]);

React Project

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "node_modules/",
    "build/",
    "dist/",
    "public/",
    "coverage/",
    "*.config.js",
    "*.config.ts"
  ])
]);

TypeScript Project

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "node_modules/",
    "dist/",
    "build/",
    "coverage/",
    "*.js",          // Compiled output
    "*.d.ts",        // Type definitions
    "tsconfig.json"
  ])
]);

Monorepo

import { defineConfig, globalIgnores } from "eslint/config";

export default defineConfig([
  globalIgnores([
    "node_modules/",
    "**/dist/",
    "**/build/",
    "**/coverage/",
    "**/node_modules/",
    ".turbo/",
    ".next/"
  ])
]);

Complete Example

eslint.config.js

import { defineConfig, globalIgnores } from "eslint/config";
import { includeIgnoreFile } from "@eslint/compat";
import { fileURLToPath } from "node:url";

const gitignorePath = fileURLToPath(new URL(".gitignore", import.meta.url));

export default defineConfig([
  // Include .gitignore patterns
  includeIgnoreFile(gitignorePath, "Git Ignore Patterns"),
  
  // Global ignores
  globalIgnores([
    "dist/",
    "build/",
    "coverage/",
    "*.min.js",
    "*.bundle.js",
    "**/__generated__/**"
  ], "Build and Generated Files"),
  
  // Configuration for source files
  {
    name: "source-files",
    files: ["src/**/*.js"],
    ignores: ["**/*.test.js"],  // Non-global ignore
    rules: {
      "no-console": "error"
    }
  },
  
  // Configuration for test files
  {
    name: "test-files",
    files: ["**/*.test.js", "**/*.spec.js"],
    rules: {
      "no-console": "off"
    }
  }
]);

Related Resources

Configuration

Learn about configuration files and objects

Command Line

CLI options including —ignore-pattern

Core Concepts

Understanding ESLint fundamentals

Rule Configuration

Configure rules for matched files