Typescript Interview Questions and Answers for 10 years experience

1. What is TypeScript and why would you use it over JavaScript?

   • Answer: TypeScript is a superset of JavaScript that adds optional static typing. Using it offers several advantages: improved code maintainability and readability due to type checking, early error detection during development (reducing runtime errors), better code organization through interfaces and classes, enhanced tooling support (like autocompletion and refactoring in IDEs), and improved collaboration in larger teams. It's particularly beneficial for large-scale projects where JavaScript's dynamic nature can lead to increased complexity and debugging challenges.

2. Explain the concept of interfaces in TypeScript. Provide an example.

   • Answer: Interfaces define a contract that specifies the shape of an object. They define the properties and methods an object must have. They don't provide implementation details, only the structure. This improves code organization and maintainability. Example: ```typescript interface Person { firstName: string; lastName: string; age: number; greet(): string; } let person: Person = { firstName: 'John', lastName: 'Doe', age: 30, greet: function() { return `Hello, my name is ${this.firstName} ${this.lastName}`; } }; ```

3. What are generics in TypeScript and how do they improve code reusability?

   • Answer: Generics allow you to write functions and classes that can work with different types without losing type safety. They use type parameters (e.g., `T`, `U`) as placeholders for concrete types. This avoids type assertions and promotes code reusability. Example: ```typescript function identity(arg: T): T { return arg; } let myString: string = identity("hello"); let myNumber: number = identity(10); ```

4. Explain the difference between `let`, `const`, and `var` in TypeScript.

   • Answer: `let` declares a block-scoped variable, meaning it's only accessible within the block it's defined in. `const` declares a block-scoped constant whose value cannot be reassigned after initialization. `var` declares a function-scoped variable (or globally if not within a function), which can lead to unexpected behavior in larger applications. `let` and `const` are generally preferred for better code clarity and preventing accidental variable reassignments.

5. What are type aliases in TypeScript and when would you use them?

   • Answer: Type aliases create new names for existing types. They improve code readability and reduce repetition, especially when dealing with complex types. They don't create new types, they just give existing types a new name. Example: ```typescript type StringArray = string[]; let myArray: StringArray = ["hello", "world"]; ```

6. Describe the concept of namespaces in TypeScript. Are they still relevant in modern TypeScript development?

   • Answer: Namespaces in TypeScript help organize code into logical units, preventing naming collisions. They are similar to modules but predate the modern module system. While still functional, they're generally less preferred in modern development, with modules (using `import` and `export`) being the recommended approach for managing code organization and dependencies.

7. Explain how to use enums in TypeScript. Give an example demonstrating its use.

   • Answer: Enums define a set of named constants. They improve code readability and maintainability by providing descriptive names for numeric values. Example: ```typescript enum Color { Red = 1, Green, Blue } let myColor: Color = Color.Green; console.log(myColor); // Outputs 2 ```

8. How do you handle optional parameters in TypeScript functions?

   • Answer: Optional parameters are defined by adding a question mark (`?`) after the parameter name. This indicates that the parameter is not required when calling the function. Example: ```typescript function greet(name: string, lastName?: string): string { if (lastName) { return `Hello, ${name} ${lastName}!`; } else { return `Hello, ${name}!`; } } ```

9. Explain the concept of function overloading in TypeScript.

   • Answer: Function overloading allows you to define multiple functions with the same name but different parameter types or numbers of parameters. TypeScript's compiler determines which function to call based on the arguments passed. This enhances code flexibility and readability. Example: ```typescript function add(x: number, y: number): number; function add(x: string, y: string): string; function add(x: any, y: any): any { return x + y; } ```

Thank you for reading our blog post on 'Typescript Interview Questions and Answers for 10 years experience'.We hope you found it informative and useful.Stay tuned for more insightful content!