TypeScript Fundamentals

Question 1

What is TypeScript?

Answer 1

TypeScript is a strongly typed superset of JavaScript that compiles to plain JavaScript.

Question 2

What is the purpose of tsconfig.json?

Answer 2

tsconfig.json is a configuration file that specifies the root files and compiler options required to compile a TypeScript project.

Question 3

What are basic types in TypeScript?

Answer 3

Basic types include string, number, boolean, null, undefined, void, and any.

Question 4

What is the difference between let and const in TypeScript?

Answer 4

let allows reassignment of variables, while const creates read-only references that cannot be reassigned.

Question 5

What is type annotation in TypeScript?

Answer 5

Type annotation is the explicit declaration of a variable’s type, e.g., let age: number = 25;

Question 6

What is type inference in TypeScript?

Answer 6

TypeScript automatically infers the type of a variable based on its assigned value if no annotation is provided.

Question 7

How do you compile TypeScript code?

Answer 7

Use the command ‘tsc’ (TypeScript Compiler) in the terminal to compile .ts files to .js files.

Question 8

What is the CLI command to initialize a TypeScript project?

Answer 8

tsc –init creates a tsconfig.json file with default configuration settings.

Question 9

What are the advantages of using TypeScript?

Answer 9

Improved code quality, better tooling support, early bug detection, and enhanced developer productivity.

Question 10

What are the disadvantages of TypeScript?

Answer 10

Steeper learning curve, longer setup time, and sometimes verbose syntax compared to plain JavaScript.

Question 11

What is a best practice when using TypeScript types?

Answer 11

Prefer explicit type annotations for function parameters and return types to improve readability and type safety.

Question 12

What is a common use case for TypeScript?

Answer 12

Large-scale applications where strong typing and IDE support can significantly improve maintainability and refactoring.

Question 13

How does TypeScript impact system design?

Answer 13

It enforces contracts via types, improving modularity, code correctness, and long-term maintainability of large systems.

Question 14

What is an example of using a string type?

Answer 14

let name: string = ‘Alice’;

Question 15

What is an architectural implication of using TypeScript?

Answer 15

TypeScript encourages cleaner module boundaries and makes refactoring safer across large codebases.

Question 16

How does TypeScript affect performance?

Answer 16

TypeScript adds no runtime overhead since it compiles to JavaScript; performance is mostly unaffected.

Question 17

Can TypeScript help with fault tolerance?

Answer 17

Yes, TypeScript helps catch type-related errors at compile-time, reducing runtime failures.

Question 18

What is a debugging benefit of TypeScript?

Answer 18

TypeScript’s strict typing and error messages help identify issues earlier in the development cycle.

Question 19

What’s a real-world tradeoff of using TypeScript?

Answer 19

You gain safer, maintainable code at the cost of additional complexity and a compile step in your build process.

Question 20

What’s a common interview question about TypeScript?

Answer 20

What are the differences between TypeScript and JavaScript, and when would you use TypeScript?

Question 21

What is a potential gotcha with type inference?

Answer 21

If the inferred type is too broad (like ‘any’), it can silently allow bugs that strict typing would have caught.

Question 22

What does ‘strict’ mode in tsconfig.json do?

Answer 22

It enables all strict type-checking options, making the compiler more rigorous and reducing bugs.

Question 23

What’s the difference between ‘any’ and ‘unknown’?

Answer 23

‘any’ disables type checking, while ‘unknown’ is safer and forces type checking before usage.

Question 24

What happens if you omit a variable’s type in TypeScript?

Answer 24

The compiler infers the type from the value assigned, or uses ‘any’ if there’s no context.

Question 25

What’s the benefit of using const for variables?

Answer 25

const ensures that variables cannot be reassigned, making code more predictable and reducing bugs.

Question 26

What is a common pitfall when using 'any'?

Answer 26

Using 'any' too frequently defeats the purpose of TypeScript and can lead to runtime errors.

Question 27

Why is type inference useful?

Answer 27

It allows cleaner code while still benefiting from type checking where the compiler can determine the type.

Question 28

What is a basic example of a function with type annotations?

Answer 28

function greet(name: string): string { return `Hello, ${name}`; }

Question 29

What’s a best practice for organizing tsconfig.json?

Answer 29

Use extends for shared base config, and override specifics in individual projects or packages.

Question 30

How does tsconfig.json help with project scalability?

Answer 30

It centralizes compiler settings, enabling consistent builds and easier configuration across large codebases.

Question 31

What are composite projects in tsconfig.json?

Answer 31

Composite projects support project references, enabling faster builds and modular monorepo structures.

Question 32

What’s a potential issue with using JavaScript libraries in TypeScript?

Answer 32

If type definitions aren’t available, you may need to install @types packages or manually define them.

Question 33

What is the use of 'include' and 'exclude' in tsconfig.json?

Answer 33

They define which files should be compiled or ignored by the TypeScript compiler.

Question 34

What’s the role of 'outDir' in tsconfig.json?

Answer 34

It specifies the output directory for compiled JavaScript files.

Question 35

What’s a best practice for variable declarations?

Answer 35

Use const by default, let when reassignment is necessary, and avoid var altogether.

Question 36

What does the TypeScript compiler do?

Answer 36

It checks type correctness and converts TypeScript code into JavaScript code.

Question 37

What’s a potential gotcha with using 'const'?

Answer 37

'const' prevents reassignment, but the values inside objects or arrays declared with const can still be mutated.

Question 38

Can you use JavaScript files in a TypeScript project?

Answer 38

Yes, by enabling 'allowJs' in tsconfig.json, but you lose type safety unless you add annotations or JSDoc.

Question 39

What’s a good way to transition from JavaScript to TypeScript?

Answer 39

Start by renaming .js files to .ts and gradually add types and stricter compiler settings.

Question 40

What is an example of number type usage?

Answer 40

let age: number = 30;

Question 41

What is the default type if you don’t specify or assign a value?

Answer 41

The type defaults to 'any', which disables type checking.

Question 42

What’s the purpose of 'noImplicitAny' in tsconfig.json?

Answer 42

It prevents variables from implicitly having the 'any' type, forcing explicit typing or inference.

Question 43

How can you enable stricter type checking across a project?

Answer 43

Set 'strict': true in tsconfig.json to enable all strict mode checks.

Question 44

What’s the tradeoff of using strict mode?

Answer 44

It increases safety and code clarity but may require more boilerplate and upfront type definitions.

Question 45

Why is it important to avoid the 'any' type?

Answer 45

It disables type checking and can lead to runtime errors, negating the benefits of TypeScript.

Question 46

What’s a common interview question about tsconfig.json?

Answer 46

What are some important compiler options in tsconfig.json and how do they impact your build process?

Question 47

What is the TypeScript compiler CLI command for a single file?

Answer 47

tsc filename.ts

Question 48

What is the benefit of static typing in large codebases?

Answer 48

It enables better tooling, easier refactoring, and earlier error detection.