• Correlates the elements of two sequences based on key equality, and groups the results.

    Example

    const magnus = { name: 'Magnus' };
    const terry = { name: 'Terry' };
    const adam = { name: 'Adam' };
    const john = { name: 'John' };

    const barley = { name: 'Barley', owner: terry };
    const boots = { name: 'Boots', owner: terry };
    const whiskers = { name: 'Whiskers', owner: adam };
    const daisy = { name: 'Daisy', owner: magnus };
    const scratchy = { name: 'Scratchy', owner: { name: 'Bob' } };

    const people = from([magnus, terry, adam, john]);
    const pets = from([barley, boots, whiskers, daisy, scratchy]);

    const result = groupJoin(
    people,
    pets,
    person => person,
    pet => pet.owner,
    (person, petCollection) => ({ ownerName: person.name, pets: petCollection.select(p => p.name).toArray() })
    )
    .toArray();

    expect(result).toEqual([
    { ownerName: 'Magnus', pets: ['Daisy'] },
    { ownerName: 'Terry', pets: ['Barley', 'Boots'] },
    { ownerName: 'Adam', pets: ['Whiskers'] },
    { ownerName: 'John', pets: [] }
    ]);

    Typeparam

    TOuter The type of the elements of the first sequence.

    Typeparam

    TInner The type of the elements of the second sequence.

    Typeparam

    TKey The type of the keys returned by the key selector functions.

    Typeparam

    TResult The type of the result elements.

    Type Parameters

    • TOuter

    • TInner

    • TKey

    • TResult

    Parameters

    • outer: Iterable<TOuter>

      The sequence to join.

    • inner: Iterable<TInner>

      The sequence to join to the first sequence.

    • outerKeySelector: ((item: TOuter) => TKey)

      A function to extract the join key from each element of the first sequence.

        • (item: TOuter): TKey
        • Parameters

          • item: TOuter

          Returns TKey

    • innerKeySelector: ((item: TInner) => TKey)

      A function to extract the join key from each element of the second sequence.

        • (item: TInner): TKey
        • Parameters

          • item: TInner

          Returns TKey

    • resultSelector: ((item: TOuter, inner: IEnumerable<TInner>) => TResult)

      A function to create a result element from an element from the first sequence and a collection of matching elements from the second sequence.

        • (item: TOuter, inner: IEnumerable<TInner>): TResult
        • Parameters

          Returns TResult

    • Optional equalityComparer: EqualityComparer<TKey>

      An Enumerable that contains elements of type TResult that are obtained by performing a grouped join on two sequences.

    Returns IEnumerable<TResult>

Generated using TypeDoc