Please enable JavaScript.

Coggle requires JavaScript to display documents.

14.1: Generics - Coggle Diagram

- - - - const mergedObj = merge( { name: 'Max', hobbies: ['Sports'] }, { age: 30 });
  - - - returns an object
      - console.log(mergedObj.name);
        
        compile error :warning:
        
        Property 'name' does not exist on type '{}'
        
        can't access name property
        
        on a vanilla object
  - - - T & U
        
        const mergedObj: { name: string; hobbies: string[]; } & { age: number; }
      - which contains the property name
- - - - { "name": "Max", "hobbies": [ "Sports" ] }
    - - because 30 isn't an object
        
        spreading it results in an empty object
- - - - let list: number[] = [1, 2, 3];
      - let list: Array<number> = [1, 2, 3];
        
        requires a type argument
        
        that describes the things it contains
        
        a generic type #
- - - - over a variety of types
      - rather than a single one
- - - - function identity(arg: number): number { return arg; }
      - to make this general
        
        function identity(arg: any): any { return arg; }
        
        but we lose type information about what's returned
    - - use a type variable
        
        example below is Type
        
        T is also popular
        
        can be anything
        
        that work on types rather than values
        
        which allows us to capture the type that the user provides
        
        defined inside angle brackets #
        
        and can be used from then on
      - function identity<Type>(arg: Type): Type { return arg; }
      - can call
        
        specifying the type argument
        
        let output = identity<string>("myString");
        
        use <> around the type arguments
        
        using type argument inference
        
        let output = identity("myString");
        
        in both cases
        
        output is of type string