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.

Question 49

what is tsc

Answer 49

tsc is the command line tool for the TypeScript compiler. It compiles TypeScript code into JavaScript code, making it compatible with the browser or any JavaScript runtime environment. You can use the tsc command to compile your TypeScript code by running the following command in your terminal or command prompt:

Question 50

what is ts-node

Answer 50

ts-node is a TypeScript execution engine and REPL for Node.js. It JIT transforms TypeScript into JavaScript, enabling you to directly execute TypeScript on Node.js without precompiling. This is accomplished by hooking node's module loading APIs, enabling it to be used seamlessly alongside other Node.js tools and libraries.

Question 51

TypeScript vs JavaScript

Answer 51

TypeScript is a superset of JavaScript that adds optional type annotations and other features such as interfaces, classes, and namespaces. JavaScript is a dynamically-typed language that is primarily used for client-side web development and can also be used for server-side development. Here are a few key differences between TypeScript and JavaScript: Types: TypeScript has optional type annotations while JavaScript is dynamically-typed. This means that in TypeScript, you can specify the data type of variables, parameters, and return values, which can help catch type-related errors at compile-time. Syntax: TypeScript extends JavaScript syntax with features like interfaces, classes, and namespaces. This provides a more robust and organized structure for large-scale projects. Tooling: TypeScript has better tooling support, such as better editor integration, type checking, and code refactoring. Backwards Compatibility: TypeScript is fully compatible with existing JavaScript code, which means you can use TypeScript in any JavaScript environment.

Question 52

Unknown in typescript

Answer 52

unknown is the type-safe counterpart of any. Anything is assignable to unknown, but unknown isn’t assignable to anything but itself and any without a type assertion or a control flow based narrowing. Likewise, no operations are permitted on an unknown without first asserting or narrowing to a more specific type. function f1(a: any) { a.b(); // OK } function f2(a: unknown) { // Error: Property 'b' does not exist on type 'unknown'. a.b(); }

Question 53

Any in typescript

Answer 53

TypeScript has a special type, any, that you can use whenever you don’t want a particular value to cause typechecking errors. When a value is of type any, you can access any properties of it (which will in turn be of type any), call it like a function, assign it to (or from) a value of any type, or pretty much anything else that’s syntactically legal

Question 54

Never in typescript

Answer 54

The never type represents the type of values that never occur. For instance, never is the return type for a function expression or an arrow function expression that always throws an exception or one that never returns. Variables also acquire the type never when narrowed by any type guards that can never be true. The never type is a subtype of, and assignable to, every type; however, no type is a subtype of, or assignable to, never (except never itself). Even any isn’t assignable to never. Examples of functions returning never: // Function returning never must not have a reachable end point function error(message: string): never { throw new Error(message); }

Question 55

Interface in typescript

Answer 55

TypeScript allows you to specifically type an object using an interface that can be reused by multiple objects. interface Person { name: string; age: number; } function greet(person: Person) { return 'Hello ' + person.name; }

Question 56

class