tsconfig.json Configuration Basics in Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the tsconfig.json file in a TypeScript project?

The tsconfig.json file tells the TypeScript compiler how to compile the project. It sets options like which files to include, where to put the output, and how strict the checks should be.

beginner

What does the compilerOptions section in tsconfig.json do?

The compilerOptions section sets rules and settings for the TypeScript compiler, like the target JavaScript version, module system, and whether to allow certain language features.

intermediate

What is the effect of setting "strict": true in tsconfig.json?

Setting "strict": true turns on all strict type-checking options. This helps catch more errors early by making TypeScript more careful about types.

beginner

How do you specify which files TypeScript should compile using tsconfig.json?

You can use the include and exclude arrays to tell TypeScript which files or folders to compile or ignore.

beginner

What does the outDir option do in tsconfig.json?

The outDir option tells TypeScript where to put the compiled JavaScript files after compiling.

What is the default file name for the TypeScript configuration file?

A tsconfig.json

B typescript.json

C config.json

D tsconfig.js

The TypeScript compiler looks for a file named tsconfig.json by default.

Which compilerOptions setting controls the JavaScript version output?

A module

B target

C outDir

D strict

The target option sets the JavaScript version (like ES5, ES6) that TypeScript will output.

How do you exclude files from compilation in tsconfig.json?

A Using the <code>skip</code> option

B Using the <code>ignore</code> array

C Using the <code>exclude</code> array

D Using the <code>remove</code> option

The exclude array lists files or folders that TypeScript should not compile.

What does setting "strict": true do?

A Enables all strict type checking options

B Disables all type checking

C Only checks for syntax errors

D Allows JavaScript files to be compiled

Setting "strict": true enables all strict type checking features to catch more errors.

Where does the outDir option send compiled files?

A To the root folder

B To the <code>src</code> folder

C To the <code>node_modules</code> folder

D To the folder specified by <code>outDir</code>

The outDir option specifies the folder where compiled JavaScript files are saved.

Explain the main purpose of the tsconfig.json file and name three common options you can set inside it.

Think about how TypeScript knows what to compile and how.

Describe what happens when you set "strict": true in your tsconfig.json and why it might be helpful.

Consider how strict type checking affects your code quality.

Practice

1. What is the main purpose of the tsconfig.json file in a TypeScript project?

easy

A. To run the TypeScript compiler manually

B. To list all JavaScript files in the project

C. To install TypeScript packages

D. To configure how TypeScript compiles the project

Solution

1. Step 1: Understand the role of tsconfig.json

   The tsconfig.json file tells TypeScript how to compile the project, including options and files.

2. Step 2: Compare options

   The other options describe unrelated tasks: listing files, installing packages, or running commands manually.

3. Final Answer:

   To configure how TypeScript compiles the project -> Option D

4. Quick Check:

   tsconfig.json = compile config [OK]

Hint: Remember tsconfig.json sets compile rules [OK]

Common Mistakes:

• Thinking tsconfig.json installs packages
• Confusing tsconfig.json with package.json
• Believing tsconfig.json runs commands

2. Which of the following is the correct way to specify the JavaScript version target in tsconfig.json?

easy

A. {
"target": "ES6"
}

B. {
"compilerOptions": {
"target": "ES6"
}
}

C. {
"compilerOptions": {
"version": "ES6"
}
}

D. {
"compilerOptions": {
"jsVersion": "ES6"
}
}

Solution

1. Step 1: Identify correct property for target

   The correct property inside compilerOptions to set JavaScript version is target.

2. Step 2: Check JSON structure

   The snippet with target nested inside compilerOptions is correct. The one with target directly at root misses the compilerOptions wrapper. The ones using version or jsVersion have wrong property names.

3. Final Answer:

   { "compilerOptions": { "target": "ES6" } } -> Option B

4. Quick Check:

   target inside compilerOptions = correct [OK]

Hint: Always put target inside compilerOptions [OK]

Common Mistakes:

• Placing target outside compilerOptions
• Using wrong property names like version or jsVersion
• Incorrect JSON nesting

3. Given this tsconfig.json snippet:

{
  "compilerOptions": {
    "outDir": "dist",
    "target": "ES5"
  },
  "include": ["src/**/*"]
}

Which files will TypeScript compile?

medium

A. All files inside the src folder and its subfolders

B. Only files directly inside the src folder

C. All files in the project except node_modules

D. Only files inside the dist folder

Solution

1. Step 1: Understand the include pattern

   The pattern src/**/* means all files in src and any subfolders recursively.

2. Step 2: Check outDir effect

   outDir sets where compiled files go (dist), but does not affect which files are compiled.

3. Final Answer:

   All files inside the src folder and its subfolders -> Option A

4. Quick Check:

   include src/**/* = all src files [OK]

Hint: include with **/* means all files recursively [OK]

Common Mistakes:

• Confusing outDir with input files
• Thinking include only covers top-level files
• Assuming node_modules are included by default

4. Identify the error in this tsconfig.json snippet:

{
  "compilerOptions": {
    "target": "ES6",
    "outDir": "build"
  },
  "include": ["src/**/*"],
  "exclude": "node_modules"
}

medium

A. "target" value ES6 is invalid

B. "outDir" cannot be "build"

C. "exclude" should be an array, not a string

D. "include" should be a string, not an array

Solution

1. Step 1: Check exclude property type

   The exclude property must be an array of strings, but here it is a single string.

2. Step 2: Validate other properties

   target with "ES6" is valid, outDir can be any folder name, and include is correctly an array.

3. Final Answer:

   "exclude" should be an array, not a string -> Option C

4. Quick Check:

   exclude must be array [OK]

Hint: exclude always needs brackets [] [OK]

Common Mistakes:

• Using string instead of array for exclude
• Thinking ES6 is invalid target
• Confusing include and exclude types

5. You want to compile only TypeScript files inside the app folder but exclude test files ending with .spec.ts. Which tsconfig.json configuration achieves this?

hard

A. {
"include": ["app/**/*.ts"],
"exclude": ["**/*.spec.ts"]
}

B. {
"include": ["app/**/*.ts", "!app/**/*.spec.ts"]
}

C. {
"include": ["app/**/*.ts"],
"exclude": ["app/**/*.test.ts"]
}

D. {
"include": ["app/**/*.ts"],
"exclude": ["app/*.spec.ts"]
}

Solution

1. Step 1: Understand include and exclude patterns

   To compile files in app, include app/**/*.ts. To exclude test files ending with .spec.ts, exclude **/*.spec.ts globally.

2. Step 2: Evaluate options

   { "include": ["app/**/*.ts"], "exclude": ["app/*.spec.ts"] } excludes only top-level test files directly in app, missing those in subfolders. { "include": ["app/**/*.ts", "!app/**/*.spec.ts"] } uses negation in include, which is invalid. { "include": ["app/**/*.ts"], "exclude": ["app/**/*.test.ts"] } excludes .test.ts files, not .spec.ts.

3. Step 3: Choose best practice

   { "include": ["app/**/*.ts"], "exclude": ["**/*.spec.ts"] } correctly includes all .ts files in app and excludes all .spec.ts files anywhere, ensuring test files are excluded.

4. Final Answer:

   Include app/**/*.ts and exclude **/*.spec.ts -> Option A

5. Quick Check:

   exclude **/*.spec.ts filters test files [OK]

Hint: Use exclude with **/*.spec.ts to skip test files [OK]

Common Mistakes:

• Using negation inside include array
• Excluding wrong test file patterns
• Not excluding test files at all