blinq
Options
All
  • Public
  • Public/Protected
  • All
Menu

Type parameters

  • TKey

  • TValue

Hierarchy

Implements

  • Iterable<TValue>

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Properties

Private _key

_key: any

gen

gen: function

Type declaration

    • (): IterableIterator<TValue>

    • Returns IterableIterator<TValue>

Accessors

key

key:

Methods

__@iterator

  • __@iterator(): IterableIterator<TValue>

aggregate

  • aggregate<TOut>(seed: TOut, aggFunc: function): TOut

  • Type parameters

    • TOut

    Parameters

    • seed: TOut
    • aggFunc: function
        • (prev: TOut, curr: TValue, idx: number): TOut

        • Parameters

          • prev: TOut
          • curr: TValue
          • idx: number

          Returns TOut

    Returns TOut

all

any

  • any<T>(this: Enumerable<T>): boolean
  • any<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): boolean

append

  • append<T>(this: Enumerable<T>, item: T): Enumerable<T>

average

  • average<T>(this: Enumerable<number>): number

concat

  • concat<T>(this: Enumerable<T>, ...sequences: Array<Iterable<T>>): Enumerable<T>

count

  • count<T>(this: Enumerable<T>): number
  • count<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): number

defaultIfEmpty

  • defaultIfEmpty<T>(this: Enumerable<T>): Enumerable<T | undefined>

distinct

  • distinct<T>(this: Enumerable<T>, equalityComparer?: EqualityComparer<T>): Enumerable<T>

distinctBy

elementAt

  • elementAt<T>(this: Enumerable<T>, index: number): T

except

  • except<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): Enumerable<T>

first

  • first<T>(this: Enumerable<T>): T
  • first<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): T

firstOrDefault

  • firstOrDefault(this: Enumerable<TValue>): TValue | undefined
  • firstOrDefault(this: Enumerable<TValue>, pred: IndexedPredicate<TValue>): TValue | undefined

flatten

  • flatten<TT>(this: Enumerable<Enumerable<TT>>): Enumerable<TValue>

forEach

  • forEach<T>(this: Enumerable<T>, action: function): void

  • Type parameters

    • T

    Parameters

    • this: Enumerable<T>
    • action: function
        • (x: T, i: number): void

        • Parameters

          • x: T
          • i: number

          Returns void

    Returns void

fullOuterGroupJoin

  • fullOuterGroupJoin<T, TRight, TKey, TOut>(this: Enumerable<T>, rightSeq: Iterable<TRight>, leftKeySelector: IndexedSelector<T, TKey>, rightKeySelector: IndexedSelector<TRight, TKey>, selector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TOut>

fullOuterJoin

  • fullOuterJoin<TRight, TKey, TOut>(this: Enumerable<TValue>, rightSeq: Iterable<TRight>, leftKeySelector: IndexedSelector<TValue, TKey>, rightKeySelector: IndexedSelector<TRight, TKey>, selector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TOut>

  • Type parameters

    • TRight

    • TKey

    • TOut

    Parameters

    • this: Enumerable<TValue>
    • rightSeq: Iterable<TRight>
    • leftKeySelector: IndexedSelector<TValue, TKey>
    • rightKeySelector: IndexedSelector<TRight, TKey>
    • selector: function
        • (o: TValue | undefined, v: TRight | undefined, k: TKey): TOut

        • Parameters

          • o: TValue | undefined
          • v: TRight | undefined
          • k: TKey

          Returns TOut

    • Optional equalityComparer: EqualityComparer<TKey>

    Returns Enumerable<TOut>

groupAdjacent

  • groupAdjacent<TSource, TKey, TElement, TResult>(this: Enumerable<TSource>, keySelector: IndexedSelector<TSource, TKey>, elementSelector: IndexedSelector<TSource, TElement>, resultSelector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TResult>

groupBy

groupJoin

  • groupJoin<T, TInner, TKey, TOut>(this: Enumerable<T>, innerSeq: Iterable<TInner>, outerKeySelector: IndexedSelector<T, TKey>, innerKeySelector: IndexedSelector<TInner, TKey>, selector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TOut>

intersect

  • intersect<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): Enumerable<T>

isSubsetOf

  • isSubsetOf<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): boolean

isSupersetOf

  • isSupersetOf<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): boolean

join

  • join<T, TInner, TKey, TOut>(this: Enumerable<T>, innerSeq: Iterable<TInner>, outerKeySelector: IndexedSelector<T, TKey>, innerKeySelector: IndexedSelector<TInner, TKey>, selector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TOut>

  • Type parameters

    • T

    • TInner

    • TKey

    • TOut

    Parameters

    • this: Enumerable<T>
    • innerSeq: Iterable<TInner>
    • outerKeySelector: IndexedSelector<T, TKey>
    • innerKeySelector: IndexedSelector<TInner, TKey>
    • selector: function
        • (outer: T, inner: TInner): TOut

        • Parameters

          • outer: T
          • inner: TInner

          Returns TOut

    • Optional equalityComparer: EqualityComparer<TKey>

    Returns Enumerable<TOut>

last

  • last<T>(this: Enumerable<T>): T
  • last<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): T

lastOrDefault

  • lastOrDefault<T>(this: Enumerable<T>): T | undefined
  • lastOrDefault<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): T | undefined

leftOuterJoin

  • leftOuterJoin<T, TInner, TKey, TOut>(this: Enumerable<T>, innerSeq: Iterable<TInner>, outerKeySelector: IndexedSelector<T, TKey>, innerKeySelector: IndexedSelector<TInner, TKey>, selector: function, equalityComparer?: EqualityComparer<TKey>): Enumerable<TOut>

max

  • max(): TValue | undefined
  • max<TOut>(selector: IndexedSelector<TValue, TOut>): TOut | undefined
  • max<TOut>(selector: IndexedSelector<TValue, TOut>, comparer: Comparer<TOut>): TOut | undefined
  • max<TOut>(this: Enumerable<TValue>, selector: IndexedSelector<TValue, TValue | TOut>, comparer: Comparer<TValue | TOut>): TValue | TOut | undefined

maxBy

  • maxBy<T, TKey>(this: Enumerable<T>, selector: IndexedSelector<T, TKey>): Enumerable<T>
  • maxBy<T, TKey>(this: Enumerable<T>, selector: IndexedSelector<T, TKey>, comparer: Comparer<TKey>): Enumerable<T>

min

  • min(): TValue | undefined
  • min<TOut>(selector: IndexedSelector<TValue, TOut>): TOut | undefined
  • min<TOut>(selector: IndexedSelector<TValue, TOut>, comparer: Comparer<TOut>): TOut | undefined
  • min<TOut>(this: Enumerable<TValue>, selector: IndexedSelector<TValue, TValue | TOut>, comparer: Comparer<TValue | TOut>): TValue | TOut | undefined

minBy

  • minBy<T, TKey>(this: Enumerable<T>, selector: IndexedSelector<T, TKey>): Enumerable<T>
  • minBy<T, TKey>(this: Enumerable<T>, selector: IndexedSelector<T, TKey>, comparer: Comparer<TKey>): Enumerable<T>

orderBy

  • orderBy<TCmp>(this: Enumerable<TValue>, selector: function): OrderedIterable<TValue>

orderByDescending

  • orderByDescending<TCmp>(this: Enumerable<TValue>, selector: function): OrderedIterable<TValue>

prepend

  • prepend<T>(this: Enumerable<T>, item: T): Enumerable<T>

reverse

  • reverse<T>(this: Enumerable<T>): Enumerable<T>

select

  • select<T, TOut>(this: Enumerable<T>, selector: IndexedSelector<T, TOut>): Enumerable<TOut>

selectMany

  • selectMany<T, TOut>(this: Enumerable<T>, selector: IndexedSelector<T, Iterable<TOut>>): Enumerable<TOut>

sequenceEqual

  • sequenceEqual<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): boolean

single

  • single<T>(this: Enumerable<T>): T
  • single<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): T

singleOrDefault

  • singleOrDefault<T>(this: Enumerable<T>): T | undefined
  • singleOrDefault<T>(this: Enumerable<T>, pred: IndexedPredicate<T>): T | undefined

skip

  • skip<T>(this: Enumerable<T>, numItems: number): Enumerable<T>

skipWhile

sum

  • sum(this: Enumerable<number>): number

take

  • take<T>(this: Enumerable<T>, numItems: number): Enumerable<T>

takeWhile

toArray

  • toArray<T>(this: Enumerable<T>): T[]

toLookup

toMap

toSet

union

  • union<T>(this: Enumerable<T>, seq: Iterable<T>, equalityComparer?: EqualityComparer<T>): Enumerable<T>

where

zip

  • zip<T, TOther, TOut>(this: Enumerable<T>, seq: Iterable<TOther>, selector: function): Enumerable<TOut>

  • Type parameters

    • T

    • TOther

    • TOut

    Parameters

    • this: Enumerable<T>
    • seq: Iterable<TOther>
    • selector: function
        • (item1: T, item2: TOther): TOut

        • Parameters

          • item1: T
          • item2: TOther

          Returns TOut

    Returns Enumerable<TOut>

zipAll

  • zipAll<TT>(this: Enumerable<Enumerable<TT>>): Enumerable<Enumerable<TT>>

Legend

  • Module
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Index signature
  • Type alias
  • Enumeration
  • Enumeration member
  • Property
  • Method
  • Interface
  • Interface with type parameter
  • Constructor
  • Property
  • Method
  • Index signature
  • Class
  • Class with type parameter
  • Constructor
  • Property
  • Method
  • Accessor
  • Index signature
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Protected property
  • Protected method
  • Protected accessor
  • Private property
  • Private method
  • Private accessor
  • Static property
  • Static method

Generated using TypeDoc