0
Completed
0%
Progress
0
Starred
What is TypeScript and why is it used?
What are the key benefits of using TypeScript over JavaScript?
What is the difference between TypeScript and JavaScript?
What are type annotations in TypeScript?
What are primitive types in TypeScript?
How do you define arrays and tuples in TypeScript?
What are enums in TypeScript and how do they work?
What is the 'any' type in TypeScript and when should you use it?
What is the 'unknown' type and how does it differ from 'any'?
What are the 'void' and 'never' types in TypeScript?
How does TypeScript treat null and undefined?
How does type inference work in TypeScript?
What are union types and literal types in TypeScript?
How do you type functions, optional, default, and rest parameters in TypeScript?
What is the difference between interface and type alias in TypeScript?
How do you type objects in TypeScript? Explain index signatures and excess property checks.
What are basic generics in TypeScript? How do you write a generic identity function?
How do you define classes with access modifiers in TypeScript?
What are type assertions in TypeScript? Explain `as`, `as const`, and the `as unknown as` pattern.
What are the `keyof` and `typeof` operators in TypeScript?
What are the essential tsconfig.json compiler options? Explain target, module, strict, and lib.
How do you add constraints to generic types using `extends`?
How do you use `readonly` and optional properties (`?`) in TypeScript interfaces?
What are advanced generic patterns like generic constraints with `keyof`, default type parameters, and generic parameter default values?
Explain the built-in utility types: Partial, Required, Pick, Omit, Record, Exclude, Extract, ReturnType, and Parameters.
What are mapped types in TypeScript and how do you create custom ones?
How do conditional types work in TypeScript? Explain with examples and the `infer` keyword.
What are type guards and type narrowing techniques in TypeScript?
What are discriminated unions (tagged unions) and how do they enable exhaustive type checking?
What are intersection types and how do they differ from union types and interfaces?
What is declaration merging in TypeScript and how can you use it to extend existing types?
How does function overloading work in TypeScript?
How do ES modules and namespace modules work in TypeScript?
What are decorators in TypeScript and how are they used?
What are abstract classes and methods in TypeScript?
What are indexed access types and how do you use them to access nested property types?
How do you type async functions and Promises in TypeScript?
How do you type React components, props, and hooks (useState, useEffect, useRef) with TypeScript?
How do you type Vue components, props, emits, and refs with TypeScript?
How do you use TypeScript effectively in Nuxt 3? (auto-imports, pages, composables, runtimeConfig)
What are best practices for error handling and typing errors in TypeScript?
What does `strict: true` enable in TypeScript and why is it recommended?
What are other important compiler options like `noUnusedLocals`, `noUnusedParameters`, `noImplicitReturns`, and `noFallthroughCasesInSwitch`?
What are the advanced differences between `interface` and `type` in TypeScript? Compare declaration merging, `extends`, `implements`, and performance.
What is the difference between `extends` and `implements` in TypeScript classes and interfaces?
How do you type API responses in TypeScript with runtime validation (Zod, io-ts) and type predicates?
How does the `infer` keyword work in advanced conditional types? Can you give examples of extracting return types, promise unwrapping, and function parameters?
How do you define and use recursive types in TypeScript? Provide examples with JSON, tree structures, and deeply nested objects.
What are template literal types and how can they be used for string manipulation, type-safe string concatenation, and pattern matching?
What are variadic tuple types and how do they enable higher-order functions and type-safe function composition?
What are branded (nominal) types in TypeScript and how do they simulate nominal typing to avoid primitive obsession?
How does module augmentation work? Explain with examples of extending third-party library types and global augmentations.
Explain structural vs nominal typing. How does TypeScript's structural typing affect type compatibility, and what are its limitations?
Explain variance: covariance, contravariance, and bivariance in TypeScript function type compatibility.
How do you optimize TypeScript compilation performance for large projects and monorepos?
How do you integrate Zod with TypeScript for runtime validation and type-safe API contracts?
What are distributed conditional types? How do they work with unions and how can you prevent distribution?
How do you create advanced mapped types like DeepReadonly, DeepPartial, and PathValue?
How do you write and maintain declaration files (.d.ts) for JavaScript libraries? Explain ambient declarations, export patterns, and triple-slash directives.
Explain the TypeScript compilation flow: parsing, binding, type checking, and emitting. What are the key data structures like Symbol, Type, and Node?
How do you build custom utility types like `PickByValueType`, `OmitByType`, `Merge`, `PartialByKeys`, and `RequiredByKeys`?
What are monorepo typing strategies? How do project references, path mapping, and composite tsconfig work together?
How do you type advanced React patterns like higher-order components (HOC), generic components, and polymorphic components with TypeScript?
How do you type advanced Vue 3 patterns: generic components, composables, provide/inject, and slots with TypeScript?
How do you leverage TypeScript in Nuxt 3 for typing auto-imports, pages, middleware, and modules?
How do you implement type-safe state management with Zustand (or Redux Toolkit) using TypeScript, including middleware and slices?
How do you structure a large-scale TypeScript application with layered architecture (domain, application, infrastructure, presentation)?
What are scalable typing patterns for large codebases? Discuss opaque types, fluent interfaces, builder pattern, and smart constructors.
How do you build complex type guards for union discrimination, array element validation, and object shape checks?
How do you use the TypeScript Compiler API to manipulate AST, create custom transformations, or build a code generator?