![\"fsd](\"https:\/\/www.placementpreparation.io\/blog\/wp-content\/uploads\/2025\/01\/fsd-student-program-banner-horizontal.webp\")
<\/a><\/p>Practice TypeScript Interview Questions and Answers<\/h2>
Below are the top 50 TypeScript interview questions for freshers with answers:<\/p>
1. What is TypeScript?<\/h3>
Answer:<\/strong><\/p> TypeScript is a strongly typed, object-oriented, compiled language. It is a superset of JavaScript, meaning any valid JavaScript is also valid TypeScript. It adds features like static typing, classes, and interfaces to JavaScript.<\/p> Answer:<\/strong><\/p> TypeScript helps developers catch errors early during development, making the code more reliable and maintainable. It adds type definitions, which improve IDE support for autocompletion and refactoring. It also allows the use of modern JavaScript features, even on older JavaScript engines.<\/p> Answer:<\/strong><\/p> Some key features include static typing, interfaces, classes, and inheritance. It supports ES6 and ES7 features like async\/await and modules. TypeScript also compiles to JavaScript, ensuring compatibility with various browsers.<\/p> Answer:<\/strong><\/p> JavaScript is a loosely typed language, while TypeScript is strongly typed. TypeScript compiles to plain JavaScript and adds features like type checking, classes, and interfaces, which are not available in JavaScript by default.<\/p> Answer:<\/strong><\/p> You can install TypeScript globally using npm with the following command: Answer:<\/strong><\/p> A .ts file<\/strong> is a TypeScript file. It contains TypeScript code, which is eventually compiled into JavaScript. These files use TypeScript syntax and must be compiled into .js<\/strong> files before running in a browser or Node.js environment.<\/p> Answer:<\/strong><\/p> Types define the kind of value a variable can hold. TypeScript uses static types like number<\/strong>, string<\/strong>, boolean<\/strong>, and custom types like interfaces<\/strong> or enums<\/strong>. They help to ensure variables are used in the intended manner.<\/p> Answer:<\/strong><\/p> Static typing means that variable types are known at compile time. This allows TypeScript to catch errors early before the code is executed. It contrasts with JavaScript’s dynamic typing, where types are checked at runtime.<\/p> Answer:<\/strong><\/p> You can declare variables using let<\/strong>, const<\/strong>, or var<\/strong>. You can also explicitly specify the type during declaration. Answer:<\/strong><\/p> Type annotations explicitly define the type of a variable or function parameter. They ensure that variables are assigned values of the correct type, making the code safer and more predictable. Answer:<\/strong><\/p> TypeScript can automatically infer the type of a variable based on the assigned value. If you declare a variable without a type, TypeScript will assign a type based on the initial value. Answer:<\/strong><\/p> Interfaces define the structure of an object by specifying properties and their types. They act as a contract to ensure that objects adhere to a specific structure. Answer:<\/strong><\/p> Classes are blueprints for creating objects. They contain properties and methods and support inheritance. TypeScript adds strict type-checking and encapsulation to the classes. Answer:<\/strong><\/p> Access modifiers control the visibility of class members (properties or methods). TypeScript has three modifiers: public<\/strong>, private<\/strong>, and protected<\/strong>. public<\/strong> is accessible anywhere, private<\/strong> within the class, and protected<\/strong> within the class and its subclasses.<\/p> Answer:<\/strong><\/p> A constructor is a special method in a class that is called when an instance of the class is created. It is used to initialize object properties and can accept parameters to set initial values.<\/p> Answer:<\/strong><\/p> Inheritance allows one class to extend<\/strong> another class, inheriting its properties and methods. The extends keyword is used to create a subclass in TypeScript. Answer:<\/strong><\/p> Both interface<\/strong> and type<\/strong> allow you to define shapes of objects. However, interface<\/strong> is specifically used for object types, while type<\/strong> can define more complex types like unions, intersections, or primitive types.<\/p> Answer:<\/strong><\/p> Enums allow you to define a set of named constants, making your code more readable and easier to manage. They can be numeric or string-based. Answer:<\/strong><\/p> Union types allow a variable to hold one of several types. This provides more flexibility while still enabling type safety. Answer:<\/strong><\/p> A tuple is a type of array that has a fixed number of elements, where each element can have a different type. Tuples are useful when you know the exact number and type of elements in an array. Answer:<\/strong><\/p> The any<\/strong> type allows you to assign any type of value to a variable. It disables type-checking, making it similar to JavaScript’s dynamic typing. Use it sparingly to avoid losing the benefits of TypeScript’s type system.<\/p> Answer:<\/strong><\/p> The unknown<\/strong> type is similar to any<\/strong>, but it is safer because you can’t perform operations on a value of type unknown<\/strong> without first narrowing the type through type checking.<\/p> Answer:<\/strong><\/p> Generics allow you to create reusable components that work with a variety of data types. Instead of specifying a type when defining a function, class, or interface, you use a placeholder type. Answer:<\/strong><\/p> The void<\/strong> type represents the absence of a value. It is commonly used as the return type for functions that don’t return a value. Answer:<\/strong><\/p> null<\/strong> represents an intentional absence of value, while undefined<\/strong> indicates that a variable has been declared but has not been assigned a value. Both are subtypes of all types in TypeScript.<\/p> Answer:<\/strong><\/p> Arrays in TypeScript can be created using two syntaxes: square brackets or Array<T><\/strong> notation. The elements of the array must match the specified type. Answer:<\/strong><\/p> Type casting allows you to tell the compiler that you know the type of a value better than TypeScript does. It helps when you want to treat a variable as a different type. Answer:<\/strong><\/p> Namespaces provide a way to group related code together, preventing naming collisions. They help organize large codebases by grouping variables, functions, and classes into a single logical unit.<\/p> Answer:<\/strong><\/p> Modules are a way to organize and reuse code by exporting and importing variables, functions, classes, and interfaces. They allow you to split your code into multiple files. Answer:<\/strong><\/p> Exception handling in TypeScript works the same way as in JavaScript, using try<\/strong>, catch<\/strong>, and finally<\/strong> blocks. This helps manage runtime errors gracefully. Answer:<\/strong><\/p> The never<\/strong> type represents values that never occur. It is used as a return type for functions that always throw an exception or never return. Answer:<\/strong><\/p> The Readonly<\/strong> modifier ensures that the properties of an object cannot be modified after they are set. It makes the object immutable. Answer:<\/strong><\/p> Type assertion is a way to override TypeScript’s inferred type and explicitly specify a different type. It is useful when you know more about the type of a value than TypeScript. Answer:<\/strong><\/p> Type narrowing is the process of refining the type of a variable based on control flow, such as type checks. This allows TypeScript to narrow a union type to a more specific type. Answer:<\/strong><\/p> Decorators are a special kind of declaration that can be attached to classes, methods, or properties to modify their behavior. They are widely used in frameworks like Angular.<\/p> Answer:<\/strong><\/p> Declaration files (with a .d.ts<\/strong> extension) are used to describe the shape of JavaScript libraries, allowing TypeScript to understand the types of third-party libraries that don’t have built-in TypeScript support. They define the types and signatures of the library functions, so you can use JavaScript libraries with TypeScript type safety. Answer:<\/strong><\/p> Type guards are a way of checking the type of a variable at runtime and allow you to narrow down the type within a conditional block. You can use typeof<\/strong>, instanceof<\/strong>, or custom type predicates to create type guards. They help make your code more predictable and safer by narrowing types. Answer: <\/strong><\/p> Function overloading allows you to define multiple signatures for a function but with different parameters. TypeScript resolves which function signature to use based on the arguments passed to the function. However, all overloads share a common implementation. Answer:<\/strong><\/p> Type aliasing allows you to create a new name for an existing type. This is useful for simplifying complex type declarations or creating reusable, self-documenting types. It can be used with primitive types, object types, and even union or intersection types. Answer:<\/strong><\/p> Mapped types allow you to create new types by transforming an existing type’s properties. They are often used in scenarios where you need to make certain properties optional, readonly, or alter the type of the properties in bulk. Answer:<\/strong><\/p> keyof<\/strong> is a TypeScript operator that returns a union of the keys of a given object type. It is commonly used in generic functions to restrict the input to known property names of an object. Answer:<\/strong><\/p> Conditional types allow you to create types that change based on a condition. They follow the pattern T extends U ? X : Y<\/strong>, meaning if T<\/strong> extends U<\/strong>, the type will be X<\/strong>; otherwise, it will be Y<\/strong>. This is useful for making flexible, reusable types. Answer:<\/strong><\/p> Answer:<\/strong><\/p> The Record<K, T><\/strong> utility type creates an object type with a set of keys K<\/strong> of one type and values T<\/strong> of another type. It is used when you want to create an object that maps keys to specific value types. Answer:<\/strong><\/p> An index signature allows you to define the shape of an object where you don’t know all the property names, but you know the types of the keys and values. This is useful when creating dynamic or flexible objects. Answer:<\/strong><\/p> The Exclude<T, U><\/strong> utility type removes from T<\/strong> all types that are assignable to U<\/strong>. It is helpful when you want to exclude certain values from a union type. Answer:<\/strong><\/p> Omit<T, K><\/strong> creates a new type by removing one or more properties K<\/strong> from type T<\/strong>. This is useful when you want to exclude certain properties from an object type. Answer:<\/strong><\/p> Custom utility types allow you to create reusable types by leveraging TypeScript’s type manipulation capabilities like conditional types, mapped types, and utility types. You can create types that follow specific patterns in your codebase. Answer:<\/strong><\/p> A discriminated union is a pattern where each type in a union has a common property (the “discriminant”) that allows TypeScript to narrow the type of an object. This is often used in conjunction with tagged unions for type-safe conditional logic. Answer:<\/strong><\/p> The infer<\/strong> keyword is used in conditional types to infer a type within the true branch of the condition. This allows you to extract and manipulate types based on the structure of other types.2. Why do we use TypeScript?<\/h3>
3. What are the key features of TypeScript?<\/h3>
4. How is TypeScript different from JavaScript?<\/h3>
5. How do you install TypeScript?<\/h3>
\n<\/p>
\n<\/div><\/div>6. What is a .ts file?<\/h3>
7. What are types in TypeScript?<\/h3>
8. What is static typing?<\/h3>
9. How do you declare a variable in TypeScript?<\/h3>
\n<\/p>
\nconst age: number = 30;
\n<\/div><\/div>10. What are type annotations in TypeScript?<\/h3>
\n<\/p>
\nlet score: number = 95;
\n<\/div><\/div>11. What is type inference in TypeScript?<\/h3>
\n<\/p>
\n<\/div><\/div>12. What is an interface in TypeScript?<\/h3>
\n<\/p>
\nname: string;
\nage: number;
\n}
\nlet john: Person = { name: “John”, age: 25 };
\n<\/div><\/div>13. What are classes in TypeScript?<\/h3>
\n<\/p>
\nmodel: string;
\nconstructor(model: string) {
\nthis.model = model;
\n}
\n}
\nlet myCar = new Car(“Toyota”);
\n<\/div><\/div>14. What are access modifiers in TypeScript?<\/h3>
15. What is a constructor in TypeScript?<\/h3>
16. What is inheritance in TypeScript?<\/h3>
\n<\/p>
\nmakeSound() {
\nconsole.log(“Animal sound”);
\n}
\n}
\nclass Dog extends Animal {
\nbark() {
\nconsole.log(“Woof!”);
\n}
\n}
\n<\/div><\/div>17. What is the difference between interface and type in TypeScript?<\/h3>
18. What is an enum in TypeScript?<\/h3>
\n<\/p>
\nUp = 1,
\nDown,
\nLeft,
\nRight
\n}
\n<\/div><\/div>19. What is a union type in TypeScript?<\/h3>
\n<\/p>
\nvalue = “Hello”;
\nvalue = 10;
\n<\/div><\/div>20. What is a tuple in TypeScript?<\/h3>
\n<\/p>
\n<\/div><\/div>21. What is the any type in TypeScript?<\/h3>
22. What is the unknown type in TypeScript?<\/h3>
23. What are generics in TypeScript?<\/h3>
\n<\/p>
\nreturn arg;
\n}
\n<\/div><\/div>24. What is the void type in TypeScript?<\/h3>
\n<\/p>
\nconsole.log(“This function returns nothing”);
\n}
\n<\/div><\/div>25. What is the difference between null and undefined in TypeScript?<\/h3>
26. How do you create an array in TypeScript?<\/h3>
\n<\/p>
\nlet list2: Array<number> = [4, 5, 6];
\n<\/div><\/div>27. What is type casting in TypeScript?<\/h3>
\n<\/p>
\nlet strLength: number = (someValue as string).length;
\n<\/div><\/div>28. What are namespaces in TypeScript?<\/h3>
29. What are modules in TypeScript?<\/h3>
\n<\/p>
\nexport const myFunction = () => “Hello”;
\n\/\/ main.ts
\nimport { myFunction } from “.\/module”;
\n<\/div><\/div>30. How do you handle exceptions in TypeScript?<\/h3>
\n<\/p>
\nthrow new Error(“An error occurred”);
\n} catch (error) {
\nconsole.error(error.message);
\n}
\n<\/div><\/div>31. What is the never type in TypeScript?<\/h3>
\n<\/p>
\nthrow new Error(“This function never returns”);
\n}
\n<\/div><\/div>32. What is the Readonly modifier in TypeScript?<\/h3>
\n<\/p>
\nreadonly name: string;
\n}
\nlet person: Person = { name: “John” };
\n\/\/ person.name = “Jane”; \/\/ Error
\n<\/div><\/div>33. What is type assertion in TypeScript?<\/h3>
\n<\/p>
\nlet length: number = (value as string).length;
\n<\/div><\/div>34. What is type narrowing in TypeScript?<\/h3>
\n<\/p>
\nif (typeof value === “string”) {
\nconsole.log(value.length);
\n} else {
\nconsole.log(value);
\n}
\n}
\n<\/div><\/div>35. What are decorators in TypeScript?<\/h3>
36. What are TypeScript declaration files and how do they work?<\/h3>
\n<\/p>
\nexport function myFunction(a: string): void;
\n}
\n<\/div><\/div>37. How do you use type guards in TypeScript?<\/h3>
\n<\/p>
\nif (typeof id === “string”) {
\nconsole.log(id.toUpperCase()); \/\/ TypeScript knows it’s a string here
\n} else {
\nconsole.log(id); \/\/ Here, TypeScript knows it’s a number
\n}
\n}
\n<\/div><\/div>38. What is function overloading in TypeScript?<\/h3>
\n<\/p>
\nfunction add(a: number, b: number): number;
\nfunction add(a: any, b: any): any {
\nreturn a + b;
\n}
\n<\/div><\/div>39. What is type aliasing in TypeScript?<\/h3>
\n<\/p>
\nlet myPoint: Point = { x: 10, y: 20 };
\n<\/div><\/div>40. How do you create a mapped type in TypeScript?<\/h3>
\n<\/p>
\nreadonly [P in keyof T]: T[P];
\n};
\ninterface Person {
\nname: string;
\nage: number;
\n}
\nconst readonlyPerson: Readonly<Person> = { name: “John”, age: 25 };
\n\/\/ readonlyPerson.name = “Jane”; \/\/ Error: Cannot assign to ‘name’ because it is a read-only property.
\n<\/div><\/div>41. What is the keyof operator in TypeScript?<\/h3>
\n<\/p>
\nmodel: string;
\nyear: number;
\n}
\ntype CarKeys = keyof Car; \/\/ ‘model’ | ‘year’
\n<\/div><\/div>42. What is conditional typing in TypeScript?<\/h3>
\n<\/p>
\nlet msg: Message<string>; \/\/ inferred as string
\nlet count: Message<number>; \/\/ inferred as number
\n<\/div><\/div>43. What is the difference between Partial and Required utility types in TypeScript?<\/h3>
\n
\nname: string;
\nage?: number;
\n}
\nlet partialPerson: Partial<Person> = { name: “John” };
\nlet requiredPerson: Required<Person> = { name: “John”, age: 25 }; \/\/ ‘age’ is required here
\n<\/div><\/div>44. How does the Record utility type work in TypeScript?<\/h3>
\n<\/p>
\ntype FruitPrices = Record<Fruit, number>;
\nconst prices: FruitPrices = { apple: 10, banana: 5, orange: 8 };
\n<\/div><\/div>45. What is an index signature in TypeScript?<\/h3>
\n<\/p>
\n[key: string]: string;
\n}
\nconst user: StringMap = { name: “Alice”, city: “Paris” };
\n<\/div><\/div>46. What is the Exclude utility type in TypeScript?<\/h3>
\n<\/p>
\ntype WithoutA = Exclude<T, “a”>; \/\/ ‘b’ | ‘c’
\n<\/div><\/div>47. What is the Omit utility type in TypeScript?<\/h3>
\n<\/p>
\nname: string;
\nage: number;
\ncity: string;
\n}
\ntype PersonWithoutAge = Omit<Person, “age”>; \/\/ name and city remain
\n<\/div><\/div>48. How do you create a custom utility type in TypeScript?<\/h3>
\n<\/p>
\nlet username: Nullable<string> = null;
\n<\/div><\/div>49. What is discriminated union in TypeScript and how do you use it?<\/h3>
\n<\/p>
\nkind: “square”;
\nsize: number;
\n}
\ninterface Circle {
\nkind: “circle”;
\nradius: number;
\n}
\ntype Shape = Square | Circle;
\nfunction getArea(shape: Shape) {
\nif (shape.kind === “square”) {
\nreturn shape.size * shape.size;
\n} else if (shape.kind === “circle”) {
\nreturn Math.PI * shape.radius ** 2;
\n}
\n}
\n<\/div><\/div>50. How do you use the infer keyword in TypeScript?<\/h3>
\n<\/p>