Class default<T>

Internal_wasIterated

length

• get length(): number

  Gets the number of items in the enumerable or throws an error if it needs to be enumerated to get it

  Returns number

[iterator]

• "[iterator]"(): Iterator<T>

  the Enumerable instance exposes the same iterator as the wrapped iterable or generator function

  Returns Iterator<T>

  [symbol.iterator]

aggregate

• aggregate<TAcc>(
      accumulator: TAcc,
      aggregator: (acc: TAcc, item: T) => TAcc,
  ): TAcc

  Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value. (equivalent to Javascript reduce)

  Type Parameters

  • TAcc

  Parameters

  • accumulator: TAcc
  • aggregator: (acc: TAcc, item: T) => TAcc

  Returns TAcc

  aggregate

all

• all(condition: IFilter<T>): boolean

  Determines whether all elements of a sequence satisfy a condition.

  Parameters

  • condition: IFilter<T>

  Returns boolean

  true if all

any

• any(condition: IFilter<T>): boolean

  Determines whether any element of a sequence exists or satisfies a condition.

  Parameters

  • condition: IFilter<T>

  Returns boolean

  true if any

append

• append(item: T): default<T>

  Appends a value to the end of the sequence

  Parameters

  • item: T

  Returns default<T>

  append

asEnumerable

• asEnumerable(): default<T>

  Returns itself

  Returns default<T>

  enumerable

average

• average(): number | undefined

  Computes the average of a sequence of numeric values

  Returns number | undefined

  average

binarySearch

• binarySearch(value: T, comparer?: IComparer<T>): number | boolean

  returns the index of a value in an ordered enumerable or false if not found WARNING: use the same comparer as the one used in the ordered enumerable. The algorithm assumes the enumerable is already sorted.

  Parameters

  • value: T
  • Optionalcomparer: IComparer<T> = ...

  Returns number | boolean

  search

canSeek

• canSeek(): boolean

  Determines whether the Enumerable can seek (lookup an item by index)

  Returns boolean

cast

• cast(type: any): default<T>

  Checks the elements of a sequence based on their type If type is a string, it will check based on typeof, else it will use instanceof. Throws if types are different.

  Parameters

  • type: any

  Returns default<T>

  cast

concat

• concat(iterable: IterableType<T>): default<T>

  Concatenates two sequences by appending iterable to the existing one

  Parameters

  • iterable: IterableType<T>

  Returns default<T>

  concat

contains

• contains(item: T, equalityComparer?: IEqualityComparer<T>): boolean

  Determines whether a sequence contains a specified element. A custom function can be used to determine equality between elements.

  Parameters

  • item: T
  • OptionalequalityComparer: IEqualityComparer<T> = ...

  Returns boolean

  true if contains

count

• count(): number

  Returns the number of items in the Enumerable, even if it has to enumerate all items to do it

  Returns number

  count

defaultIfEmpty

• defaultIfEmpty(): never

  Not implemented

  Returns never

  if empty

distinct

• distinct(equalityComparer?: IEqualityComparer<T>): default<T>

  Returns distinct elements from a sequence. WARNING: using a comparer makes this slower. Not specifying it uses a Set to determine distinctiveness.

  Parameters

  • OptionalequalityComparer: IEqualityComparer<T>

  Returns default<T>

  distinct

distinctByHash

• distinctByHash<TResult>(hashFunc: ISelector<T, TResult>): default<T>

  Returns the distinct values based on a hashing function

  Type Parameters

  • TResult

  Parameters

  • hashFunc: ISelector<T, TResult>

  Returns default<T>

  by hash

elementAt

• elementAt(index: number): T

  Returns the element at a specified index in a sequence

  Parameters

  • index: number

  Returns T

  at

elementAtOrDefault

• elementAtOrDefault(index: number): T | undefined

  Returns the element at a specified index in a sequence or undefined if the index is out of range.

  Parameters

  • index: number

  Returns T | undefined

  at or default

except

• except(
      iterable: IterableType<T>,
      equalityComparer?: IEqualityComparer<T>,
  ): default<T>

  Produces the set difference of two sequences WARNING: using the comparer is slower

  Parameters

  • iterable: IterableType<T>
  • OptionalequalityComparer: IEqualityComparer<T>

  Returns default<T>

  except

exceptByHash

• exceptByHash<TResult>(
      iterable: IterableType<T>,
      hashFunc: ISelector<T, TResult>,
  ): default<T>

  Returns the values that have different hashes from the items of the iterable provided

  Type Parameters

  • TResult

  Parameters

  • iterable: IterableType<T>
  • hashFunc: ISelector<T, TResult>

  Returns default<T>

  by hash

first

• first(): T

  Returns the first element of a sequence

  Returns T

  first

firstOrDefault

• firstOrDefault(): T | undefined

  Returns the first element of a sequence, or undefined if no element is found

  Returns T | undefined

  or default

groupBy

• groupBy<TKey>(
      keySelector: ISelector<T, TKey>,
  ): default<GroupEnumerable<T, TKey>>

  Groups the elements of a sequence

  Type Parameters

  • TKey

  Parameters

  • keySelector: ISelector<T, TKey>

  Returns default<GroupEnumerable<T, TKey>>

  by

groupJoin

• groupJoin<TOther, TKey, TResult>(
      iterable: IterableType<TOther>,
      innerKeySelector: ISelector<T, TKey>,
      outerKeySelector: ISelector<TOther, TKey>,
      resultSelector: (item1: T, item2: TOther[]) => TResult,
      equalityComparer?: IEqualityComparer<TKey>,
  ): default<TResult>

  Correlates the elements of two sequences based on key equality and groups the results. A specified equalityComparer is used to compare keys WARNING: using the equality comparer will be slower

  Type Parameters

  • TOther
  • TKey
  • TResult

  Parameters

  • iterable: IterableType<TOther>
  • innerKeySelector: ISelector<T, TKey>
  • outerKeySelector: ISelector<TOther, TKey>
  • resultSelector: (item1: T, item2: TOther[]) => TResult
  • OptionalequalityComparer: IEqualityComparer<TKey>

  Returns default<TResult>

  join

intersect

• intersect(
      iterable: IterableType<T>,
      equalityComparer?: IEqualityComparer<T>,
  ): default<T>

  Produces the set intersection of two sequences. WARNING: using a comparer is slower

  Parameters

  • iterable: IterableType<T>
  • OptionalequalityComparer: IEqualityComparer<T>

  Returns default<T>

  intersect

intersectByHash

• intersectByHash<TResult>(
      iterable: IterableType<T>,
      hashFunc: ISelector<T, TResult>,
  ): default<T>

  Returns the values that have the same hashes as items of the iterable provided

  Type Parameters

  • TResult

  Parameters

  • iterable: IterableType<T>
  • hashFunc: ISelector<T, TResult>

  Returns default<T>

  by hash

join

• join<TOther, TKey, TResult>(
      iterable: IterableType<TOther>,
      innerKeySelector: ISelector<T, TKey>,
      outerKeySelector: ISelector<TOther, TKey>,
      resultSelector: (item1: T, item2: TOther) => TResult,
      equalityComparer?: IEqualityComparer<TKey>,
  ): default<TResult>

  Correlates the elements of two sequences based on matching keys WARNING: using the equality comparer will be slower

  Type Parameters

  • TOther
  • TKey
  • TResult

  Parameters

  • iterable: IterableType<TOther>
  • innerKeySelector: ISelector<T, TKey>
  • outerKeySelector: ISelector<TOther, TKey>
  • resultSelector: (item1: T, item2: TOther) => TResult
  • OptionalequalityComparer: IEqualityComparer<TKey>

  Returns default<TResult>

  join

lag

• lag<TResult>(
      offset: number,
      zipper: (item1: T, item2?: T) => TResult,
  ): default<TResult>

  Joins each item of the enumerable with previous items from the same enumerable

  Type Parameters

  • TResult

  Parameters

  • offset: number
  • zipper: (item1: T, item2?: T) => TResult

  Returns default<TResult>

  lag

• lag(offset: number): default<[T, T | undefined]>

  Joins each item of the enumerable with previous items from the same enumerable

  Parameters

  • offset: number

  Returns default<[T, T | undefined]>

  lag

last

• last(): T

  Returns the last element of a sequence

  Returns T

  last

lastOrDefault

• lastOrDefault(): T | undefined

  Returns the last element of a sequence, or undefined if no element is found

  Returns T | undefined

  or default

lead

• lead<TResult>(
      offset: number,
      zipper: (item1: T, item2?: T) => TResult,
  ): default<TResult>

  Joins each item of the enumerable with next items from the same enumerable

  Type Parameters

  • TResult

  Parameters

  • offset: number
  • zipper: (item1: T, item2?: T) => TResult

  Returns default<TResult>

  lead

• lead(offset: number): default<[T, T | undefined]>

  Joins each item of the enumerable with next items from the same enumerable

  Parameters

  • offset: number

  Returns default<[T, T | undefined]>

  lead

longCount

• longCount(): number

  Same as count

  Returns number

  count

max

• max(comparer?: IComparer<T>): T | undefined

  Returns the maximum value in a sequence of values. A custom function can be used to establish order (the result 0 means equal, 1 means larger, -1 means smaller)

  Parameters

  • Optionalcomparer: IComparer<T>

  Returns T | undefined

  max

min

• min(comparer?: IComparer<T>): T | undefined

  Returns the minimum value in a sequence of values. A custom function can be used to establish order (the result 0 means equal, 1 means larger, -1 means smaller)

  Parameters

  • Optionalcomparer: IComparer<T>

  Returns T | undefined

  min

ofType

• ofType(type: any): default<T>

  Filters the elements of a sequence based on their type If type is a string, it will filter based on typeof, else it will use instanceof

  Parameters

  • type: any

  Returns default<T>

  type

orderBy

• orderBy<TOther>(keySelector: ISelector<T, TOther>): OrderedEnumerable<T>

  Sorts the elements of a sequence in ascending order

  Type Parameters

  • TOther

  Parameters

  • keySelector: ISelector<T, TOther>

  Returns OrderedEnumerable<T>

  by

• orderBy(): OrderedEnumerable<T>

  Sorts the elements of a sequence in ascending order

  Returns OrderedEnumerable<T>

  by

orderByDescending

• orderByDescending<TOther>(
      keySelector: ISelector<T, TOther>,
  ): OrderedEnumerable<T>

  Sorts the elements of a sequence in descending order

  Type Parameters

  • TOther

  Parameters

  • keySelector: ISelector<T, TOther>

  Returns OrderedEnumerable<T>

  by descending

• orderByDescending(): OrderedEnumerable<T>

  Sorts the elements of a sequence in descending order

  Returns OrderedEnumerable<T>

  by descending

padEnd

• padEnd(minLength: number, filler: T | ((index: number) => T)): default<T>

  Returns an enumerable of at least minLength, padding the end with a value or the result of a function

  Parameters

  • minLength: number
  • filler: T | ((index: number) => T)

  Returns default<T>

  end

padStart

• padStart(minLength: number, filler: T | ((index: number) => T)): default<T>

  Returns an enumerable of at least minLength, padding the start with a value or the result of a function if the enumerable cannot seek, then it will be iterated minLength time

  Parameters

  • minLength: number
  • filler: T | ((index: number) => T)

  Returns default<T>

  start

prepend

• prepend(item: T): default<T>

  Adds a value to the beginning of the sequence.

  Parameters

  • item: T

  Returns default<T>

  prepend

randomSample

• randomSample(k: number, limit?: number): default<T>

  Implements random reservoir sampling of k items, with the option to specify a maximum limit for the items

  Parameters

  • k: number
  • Optionallimit: number = Number.MAX_SAFE_INTEGER

  Returns default<T>

  sample

reverse

• reverse(): default<T>

  Inverts the order of the elements in a sequence

  Returns default<T>

  reverse

select

• select<TResult>(selector: ISelector<T, TResult>): default<TResult>

  Projects each element of a sequence into a new form (equivalent to Javascript map)

  Type Parameters

  • TResult

  Parameters

  • selector: ISelector<T, TResult>

  Returns default<TResult>

  select

selectMany

• selectMany<TResult>(
      selector?: ISelector<T, Iterable<TResult, any, any>>,
  ): default<TResult>

  Projects each element of a sequence to an iterable and flattens the resulting sequences into one sequence

  Type Parameters

  • TResult

  Parameters

  • Optionalselector: ISelector<T, Iterable<TResult, any, any>>

  Returns default<TResult>

  many

sequenceEqual

• sequenceEqual(
      iterable: IterableType<T>,
      equalityComparer?: IEqualityComparer<T>,
  ): boolean

  Determines whether two sequences are equal and in the same order according to an equality comparer

  Parameters

  • iterable: IterableType<T>
  • OptionalequalityComparer: IEqualityComparer<T> = ...

  Returns boolean

  true if equal

shuffle

• shuffle(): default<T>

  Returns a randomized sequence of items from an initial source

  Returns default<T>

  shuffle

single

• single(): T

  Returns the single element of a sequence and throws if it doesn't have exactly one

  Returns T

  single

singleOrDefault

• singleOrDefault(): T | undefined

  Returns the single element of a sequence or undefined if none found. It throws if the sequence contains multiple items

  Returns T | undefined

  or default

skip

• skip(nr: number): default<T>

  Bypasses a specified number of elements in a sequence and then returns an Enumerable of the remaining elements

  Parameters

  • nr: number

  Returns default<T>

  skip

skipLast

• skipLast(nr: number): default<T>

  Returns a new enumerable collection that contains the elements from source with the last nr elements of the source collection omitted

  Parameters

  • nr: number

  Returns default<T>

  last

skipWhile

• skipWhile(condition: IFilter<T>): default<T>

  Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

  Parameters

  • condition: IFilter<T>

  Returns default<T>

  while

slice

• slice(start?: number, end?: number): default<T>

  Selects the elements starting at the given start argument, and ends at, but does not include, the given end argument

  Parameters

  • Optionalstart: number = 0
  • Optionalend: number

  Returns default<T>

  slice

splice

• splice(start: number, howmany: number, ...newItems: T[]): default<T>

  Takes start elements, ignores howmany elements, continues with the new items and continues with the original enumerable Equivalent to the value of an array after performing splice on it with the same parameters

  Parameters

  • start: number
  • howmany: number
  • ...newItems: T[]

  Returns default<T>

  splice

stats

• stats(comparer?: IComparer<T>): { count: number; max?: T; min?: T }

  Returns the count, minimum and maximum value in a sequence of values. A custom function can be used to establish order (the result 0 means equal, 1 means larger, -1 means smaller)

  Parameters

  • Optionalcomparer: IComparer<T>

  Returns { count: number; max?: T; min?: T }

  stats

sum

• sum(): number | undefined

  Computes the sum of a sequence of numeric values

  Returns number | undefined

  sum

sumAndCount

• sumAndCount(): { count: number; sum: number }

  Computes the sum and count of a sequence of numeric values

  Returns { count: number; sum: number }

  and count

take

• take(nr: number): default<T>

  Returns a specified number of contiguous elements from the start of a sequence

  Parameters

  • nr: number

  Returns default<T>

  take

takeLast

• takeLast(nr: number): default<T>

  Returns a new enumerable collection that contains the last nr elements from source

  Parameters

  • nr: number

  Returns default<T>

  last

takeWhile

• takeWhile(condition: IFilter<T>): default<T>

  Returns elements from a sequence as long as a specified condition is true, and then skips the remaining elements

  Parameters

  • condition: IFilter<T>

  Returns default<T>

  while

toArray

• toArray(): T[]

  Creates an array from an Enumerable

  Returns T[]

  array

toDictionary

• toDictionary(): never

  Not implemented (use toMap)

  Returns never

  dictionary

toHashSet

• toHashSet(): never

  Not implemented (use toSet)

  Returns never

  hash set

toList

• toList(): default<T>

  Similar to toArray, but returns a seekable Enumerable (itself if already seekable) that can do count and elementAt without iterating

  Returns default<T>

  list

toLookup

• toLookup(): never

  Not implemented (use groupBy)

  Returns never

  lookup

toMap

• toMap<TKey, TResult>(
      keySelector: ISelector<T, TKey>,
      valueSelector: ISelector<T, TResult>,
  ): Map<TKey, TResult>

  Creates a map from an Enumerable based on a key function and a value function

  Type Parameters

  • TKey
  • TResult

  Parameters

  • keySelector: ISelector<T, TKey>
  • valueSelector: ISelector<T, TResult>

  Returns Map<TKey, TResult>

  map

• toMap<TKey>(keySelector: ISelector<T, TKey>): Map<TKey, T>

  Creates a map from an Enumerable based on a key function and the value from the Enumerable

  Type Parameters

  • TKey

  Parameters

  • keySelector: ISelector<T, TKey>

  Returns Map<TKey, T>

  map

toObject

• toObject(
      keySelector: ISelector<T, string>,
      valueSelector?: ISelector<T, any>,
  ): { [key: string]: any }

  Creates an object from an enumerable

  Parameters

  • keySelector: ISelector<T, string>
  • OptionalvalueSelector: ISelector<T, any> = ...

  Returns { [key: string]: any }

  object

toSet

• toSet(): Set<T>

  Creates a set from an enumerable

  Returns Set<T>

  set

union

• union(
      iterable: IterableType<T>,
      equalityComparer?: IEqualityComparer<T>,
  ): default<T>

  Produces the set union of two sequences

  Parameters

  • iterable: IterableType<T>
  • OptionalequalityComparer: IEqualityComparer<T>

  Returns default<T>

  union

useBrowserSort

• useBrowserSort(): default<T>

  use the default browser sort implementation for ordering at all times

  Returns default<T>

  browser sort

useQuickSort

• useQuickSort(): default<T>

  use QuickSort for ordering (default). Recommended when take, skip, takeLast, skipLast are used after orderBy

  Returns default<T>

  quick sort

where

• where(condition: IFilter<T>): default<T>

  Filters a sequence of values based on a predicate (equivalent to Javascript filter)

  Parameters

  • condition: IFilter<T>

  Returns default<T>

  where

zip

• zip<TOther, TResult>(
      iterable: IterableType<TOther>,
      zipper: (item1: T, item2: TOther, index: number) => TResult,
  ): default<TResult>

  Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.

  Type Parameters

  • TOther
  • TResult

  Parameters

  • iterable: IterableType<TOther>
  • zipper: (item1: T, item2: TOther, index: number) => TResult

  Returns default<TResult>

  zip

• zip<TOther>(iterable: IterableType<TOther>): default<[T, TOther]>

  Takes the corresponding elements of two sequences, producing a sequence of tuples of elements.

  Type Parameters

  • TOther

  Parameters

  • iterable: IterableType<TOther>

  Returns default<[T, TOther]>

  zip

Staticempty

• empty<T>(): default<T>

  returns an empty Enumerable

  Type Parameters

  • T

  Returns default<T>

  empty

Staticfrom

• from<T>(iterable: IterableType<T>): default<T>

  wraps an iterable item into an Enumerable if it's not already one

  Type Parameters

  • T

  Parameters

  • iterable: IterableType<T>

  Returns default<T>

  from

Staticrange

• range(start: number, count: number): default<number>

  generates a sequence of integer numbers within a specified range.

  Parameters

  • start: number
  • count: number

  Returns default<number>

  range

Staticrepeat

• repeat<T>(item: T, count: number): default<T>

  generates a sequence that contains one repeated value

  Type Parameters

  • T

  Parameters

  • item: T
  • count: number

  Returns default<T>

  repeat

Staticsort

• sort<T>(arr: T[], comparer?: IComparer<T>): T[]

  Sorts an array in place using Quicksort

  Type Parameters

  • T

  Parameters

  • arr: T[]
  • Optionalcomparer: IComparer<T>

  Returns T[]

  sort