TypeScript Generics

End-of-lesson check

15 questions · take it digitally for instant feedback at tendril.neural-forge.io/learn/quiz/end-progx-ts-generics-creators

1. What does a generic type parameter represent in TypeScript?

   1. A placeholder that TypeScript fills in based on how the function is called
   2. A concrete type that is hardcoded into the function
   3. A way to remove type information from JavaScript code
   4. A special keyword that automatically infers the return type

2. What is the primary benefit of using generics over writing separate functions for each type?

   1. Generics provide type safety while maintaining reusability across many types
   2. Generics run faster because they skip type checking
   3. Generics automatically generate documentation for functions
   4. Generics allow you to use any JavaScript value without restrictions

3. What does the `extends` keyword do when used with a generic type parameter?

   1. It creates a new type inheritance hierarchy
   2. It narrows the allowed types to those that satisfy a constraint
   3. It makes the generic type optional
   4. It forces the generic to be a specific primitive type

4. When should you prefer `function f(x: string)` over `function f<T extends string>(x: T)`?

   1. When you want the function to accept any type
   2. When the function will only ever receive strings in your codebase
   3. When working with utility types
   4. When you need to return a generic type

5. What is the difference between `Pick<T, K>` and `Omit<T, K>`?

   1. Pick creates optional properties, Omit creates required ones
   2. Pick works only with strings, Omit works with any type
   3. They are interchangeable names for the same concept
   4. Pick includes K, Omit excludes K

6. What does `Record<'a' | 'b', number>` produce?

   1. A tuple containing two numbers
   2. An object with keys 'a' and 'b', both with number values
   3. A union of number types
   4. A function that returns a number

7. Why would you add a constraint like `<T extends { name: string }>` to a generic function?

   1. To make the type parameter mandatory
   2. To remove all properties from the type
   3. To convert the type to a string
   4. To ensure the type has a specific property or structure

8. In the function signature `function identity<T>(arg: T): T`, what does the first `T` represent?

   1. The return type of the function
   2. The type parameter declaration
   3. The argument's type annotation
   4. A generic class constructor

9. What error would TypeScript catch if you called a generic function with an incorrect type that violates its constraint?

   1. A compile-time type error
   2. A runtime JavaScript error
   3. A linter warning about code style
   4. A network error from the TypeScript server

10. You need to create a type for an object that might have some optional properties from a User type. Which utility type should you use?

    1. Partial<User>
    2. Record<string, User>
    3. Omit<User, 'email'>
    4. Pick<User, 'name'>

11. What is wrong with this code: `function process<T extends object>(item: T) { return item.name; }`?

    1. There's no constraint guaranteeing `name` exists on T
    2. The function returns the wrong type
    3. Generics cannot be used with objects
    4. The syntax uses wrong brackets

12. What is the 'big idea' that the lesson describes about generics?

    1. Generics replace the need for any type
    2. Generics carry types through reusable functions
    3. Generics let you write faster executing code
    4. Generics automatically convert JavaScript to TypeScript

13. When is it appropriate to create a custom generic instead of using a built-in utility type?

    1. When the built-in utilities don't cover your transformation needs
    2. When you want your code to run faster
    3. When you need a simple string parameter
    4. When working with only primitive types

14. Consider: `function log<T extends { toString(): string }>(val: T): void`. What types could validly be passed to this function?

    1. Only string primitive types
    2. Any type with a toString method
    3. Only object types
    4. Only number primitive types

15. A teammate writes `function getProps<T>(obj: T): string[] { return Object.keys(obj); }`. What's wrong with this?

    1. The return type should be number[]
    2. The function should use any instead of generic
    3. Object.keys doesn't work with generic types in TypeScript without constraints
    4. T is not a valid type parameter name