Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Alot<T>

Type parameters

  • T = any

Hierarchy

  • AlotProto<T>
    • Alot

Index

Constructors

Properties

Methods

Constructors

constructor

  • new Alot<T>(array: T[], meta?: AlotMeta): Alot<T>

  • Type parameters

    • T = any

    Parameters

    • array: T[]
    • Optional meta: AlotMeta

    Returns Alot<T>

Properties

array

array: T[]

isAsync

isAsync: boolean = false

Optional meta

meta: AlotMeta

stream

stream: IAlotStream<T>

Methods

[iterator]

  • [iterator](): Alot<T>

concat

  • concat<TSourceB>(arr: TSourceB[]): ConcatStream<T, TSourceB>

  • Type parameters

    • TSourceB

    Parameters

    • arr: TSourceB[]

    Returns ConcatStream<T, TSourceB>

distinct

  • distinct(): DistinctByStream<T, string | number>

  • Returns DistinctByStream<T, string | number>

distinctBy

  • distinctBy(fn: DistinctByKeyFn<T, string | number>): DistinctByStream<T, string | number>

  • Parameters

    • fn: DistinctByKeyFn<T, string | number>

    Returns DistinctByStream<T, string | number>

filter

  • filter(fn: MethodFilter<T>): FilterStream<T>

  • Creates filtered stream. Is Lazy.

    alot(users).filter(x => x.age > 20).take(3).toArray();

    Filter is evaluated only N times, to match only 3 items.

    Parameters

    • fn: MethodFilter<T>

    Returns FilterStream<T>

filterAsync

  • filterAsync(fn: MethodFilter<T>): FilterStreamAsync<T>

  • Creates async filted stream. Same as filter, but accepts async methods, and returns awaitable stream.

    Parameters

    • fn: MethodFilter<T>

    Returns FilterStreamAsync<T>

find

  • find(matcher?: (x: T, i?: number) => boolean): T

  • Parameters

    • Optional matcher: (x: T, i?: number) => boolean
        • (x: T, i?: number): boolean

        • Parameters

          • x: T
          • Optional i: number

          Returns boolean

    Returns T

findAsync

  • findAsync(matcher?: (x: T, i?: number) => boolean | Promise<boolean>): Promise<T>

  • Parameters

    • Optional matcher: (x: T, i?: number) => boolean | Promise<boolean>
        • (x: T, i?: number): boolean | Promise<boolean>

        • Parameters

          • x: T
          • Optional i: number

          Returns boolean | Promise<boolean>

    Returns Promise<T>

first

  • first(matcher?: (x: T, i?: number) => boolean): T

  • Parameters

    • Optional matcher: (x: T, i?: number) => boolean
        • (x: T, i?: number): boolean

        • Parameters

          • x: T
          • Optional i: number

          Returns boolean

    Returns T

firstAsync

  • firstAsync(matcher?: (x: T, i?: number) => boolean | Promise<boolean>): Promise<T>

  • Parameters

    • Optional matcher: (x: T, i?: number) => boolean | Promise<boolean>
        • (x: T, i?: number): boolean | Promise<boolean>

        • Parameters

          • x: T
          • Optional i: number

          Returns boolean | Promise<boolean>

    Returns Promise<T>

forEach

  • forEach(fn: ForEachMethod<T>): ForEachStream<T>

  • Parameters

    • fn: ForEachMethod<T>

    Returns ForEachStream<T>

forEachAsync

  • forEachAsync<TResult>(fn: ForEachMethod<T>): ForEachStream<T>

  • Type parameters

    • TResult

    Parameters

    • fn: ForEachMethod<T>

    Returns ForEachStream<T>

fork

  • fork(fn: (stream: Alot<T>) => any): Alot<T>

  • Parameters

    • fn: (stream: Alot<T>) => any
        • (stream: Alot<T>): any

        • Parameters

          Returns any

    Returns Alot<T>

groupBy

  • groupBy<TKey>(fn: GroupByKeyFn<T, TKey>): GroupByStream<T, TKey>

  • Type parameters

    • TKey = string

    Parameters

    • fn: GroupByKeyFn<T, TKey>

    Returns GroupByStream<T, TKey>

join

  • join<TInner, TResult>(inner: TInner[], getKey: (x: T) => string | number, getForeignKey: (x: TInner) => string | number, joinFn: (a: T, b: TInner) => TResult): JoinStream<T, TInner, TResult>

  • Join Left Inner

    Type parameters

    • TInner = T

    • TResult = T

    Parameters

    • inner: TInner[]
    • getKey: (x: T) => string | number
        • (x: T): string | number

        • Parameters

          • x: T

          Returns string | number

    • getForeignKey: (x: TInner) => string | number
        • (x: TInner): string | number

        • Parameters

          • x: TInner

          Returns string | number

    • joinFn: (a: T, b: TInner) => TResult
        • (a: T, b: TInner): TResult

        • Parameters

          • a: T
          • b: TInner

          Returns TResult

    Returns JoinStream<T, TInner, TResult>

joinOuter

  • joinOuter<TInner, TResult>(inner: TInner[], getKey: (x: T) => string | number, getForeignKey: (x: TInner) => string | number, joinFn: (a?: T, b?: TInner) => TResult): JoinStream<T, TInner, TResult>

  • Join Full Outer

    Type parameters

    • TInner = T

    • TResult = T

    Parameters

    • inner: TInner[]
    • getKey: (x: T) => string | number
        • (x: T): string | number

        • Parameters

          • x: T

          Returns string | number

    • getForeignKey: (x: TInner) => string | number
        • (x: TInner): string | number

        • Parameters

          • x: TInner

          Returns string | number

    • joinFn: (a?: T, b?: TInner) => TResult
        • (a?: T, b?: TInner): TResult

        • Parameters

          • Optional a: T
          • Optional b: TInner

          Returns TResult

    Returns JoinStream<T, TInner, TResult>

map

  • map<TResult>(fn: MethodMap<T, TResult>): MapStream<T, TResult>

  • Type parameters

    • TResult

    Parameters

    • fn: MethodMap<T, TResult>

    Returns MapStream<T, TResult>

mapAsync

  • mapAsync<TResult>(fn: MethodMap<T, TResult>, meta?: AlotMeta): MapStream<T, TResult>

  • Type parameters

    • TResult

    Parameters

    • fn: MethodMap<T, TResult>
    • Optional meta: AlotMeta

    Returns MapStream<T, TResult>

mapMany

  • mapMany<TResult>(fn: MethodMapMany<T, TResult>): MapManyStream<T, TResult>

  • Type parameters

    • TResult

    Parameters

    • fn: MethodMapMany<T, TResult>

    Returns MapManyStream<T, TResult>

mapManyAsync

  • mapManyAsync<TResult>(fn: MethodMapMany<T, TResult>): MapManyStream<T, TResult>

  • Type parameters

    • TResult

    Parameters

    • fn: MethodMapMany<T, TResult>

    Returns MapManyStream<T, TResult>

max

  • max<TOut>(fn: (x: T, i?: number) => TOut): TOut

  • Type parameters

    • TOut: TAggregateNumeric

    Parameters

    • fn: (x: T, i?: number) => TOut
        • (x: T, i?: number): TOut

        • Parameters

          • x: T
          • Optional i: number

          Returns TOut

    Returns TOut

maxAsync

  • maxAsync<TOut>(fn: (x: T, i?: number) => TOut): Promise<TOut>

  • Type parameters

    • TOut: TAggregateNumeric

    Parameters

    • fn: (x: T, i?: number) => TOut
        • (x: T, i?: number): TOut

        • Parameters

          • x: T
          • Optional i: number

          Returns TOut

    Returns Promise<TOut>

maxItem

  • maxItem<TOut>(fn: (x: T, i?: number) => TOut): T

  • Type parameters

    • TOut: TAggregateNumeric

    Parameters

    • fn: (x: T, i?: number) => TOut
        • (x: T, i?: number): TOut

        • Parameters

          • x: T
          • Optional i: number

          Returns TOut

    Returns T

maxItemAsync

  • maxItemAsync<TOut>(fn: (x: T, i?: number) => TOut): Promise<T>

  • Type parameters

    • TOut: TAggregateNumeric

    Parameters

    • fn: (x: T, i?: number) => TOut
        • (x: T, i?: number): TOut

        • Parameters

          • x: T
          • Optional i: number

          Returns TOut

    Returns Promise<T>

min

  • min<TOut>(fn: (x: T, i?: number) => TOut): TOut

  • Type parameters

    • TOut: TAggregateNumeric

    Parameters

    • fn: (x: T, i?: number) => TOut
        • (x: T, i?: number): TOut

        • Parameters

          • x: T
          • Optional i: number

          Returns TOut

    Returns TOut

minAsync

  • minAsync<TOut>(fn: (x: T, i?: number) => TOut): Promise<TOut>

  • Type parameters

    • TOut: TAggregateNumeric

    Parameters

    • fn: (x: T, i?: number) => TOut
        • (x: T, i?: number): TOut

        • Parameters

          • x: T
          • Optional i: number

          Returns TOut

    Returns Promise<TOut>

minItem

  • minItem<TOut>(fn: (x: T, i?: number) => TOut): T

  • Type parameters

    • TOut: TAggregateNumeric

    Parameters

    • fn: (x: T, i?: number) => TOut
        • (x: T, i?: number): TOut

        • Parameters

          • x: T
          • Optional i: number

          Returns TOut

    Returns T

minItemAsync

  • minItemAsync<TOut>(fn: (x: T, i?: number) => TOut): Promise<T>

  • Type parameters

    • TOut: TAggregateNumeric

    Parameters

    • fn: (x: T, i?: number) => TOut
        • (x: T, i?: number): TOut

        • Parameters

          • x: T
          • Optional i: number

          Returns TOut

    Returns Promise<T>

next

  • next(): AlotStreamIterationResult<T>

  • Returns AlotStreamIterationResult<T>

nextAsync

  • nextAsync(): Promise<AlotStreamIterationResult<T>>

  • Returns Promise<AlotStreamIterationResult<T>>

reset

  • Resets current stream to the beginning.

    Returns Alot<T>

skip

  • skip(count: number): SkipStream<T>

  • Parameters

    • count: number

    Returns SkipStream<T>

skipWhile

  • skipWhile(fn: SkipWhileMethod<T>, opts?: TSkipWhileMethodOpts): SkipWhileStream<T>

  • Parameters

    • fn: SkipWhileMethod<T>
    • Optional opts: TSkipWhileMethodOpts

    Returns SkipWhileStream<T>

skipWhileAsync

  • skipWhileAsync(fn: SkipWhileMethodAsync<T>, opts?: TSkipWhileMethodOpts): SkipWhileStreamAsync<T>

  • Parameters

    • fn: SkipWhileMethodAsync<T>
    • Optional opts: TSkipWhileMethodOpts

    Returns SkipWhileStreamAsync<T>

sortBy

  • sortBy(sortByFn: SortMethod<T>, direction?: "asc" | "desc"): SortByStream<T>
  • sortBy(sortByKey: string | keyof T, direction?: "asc" | "desc"): SortByStream<T>

  • Parameters

    • sortByFn: SortMethod<T>
    • Optional direction: "asc" | "desc"

    Returns SortByStream<T>

  • Parameters

    • sortByKey: string | keyof T
    • Optional direction: "asc" | "desc"

    Returns SortByStream<T>

sortByAsync

  • sortByAsync(sortByFn: SortMethod<T>, direction?: "asc" | "desc"): SortByStream<T>
  • sortByAsync(sortByKey: string | keyof T, direction?: "asc" | "desc"): SortByStream<T>

  • Parameters

    • sortByFn: SortMethod<T>
    • Optional direction: "asc" | "desc"

    Returns SortByStream<T>

  • Parameters

    • sortByKey: string | keyof T
    • Optional direction: "asc" | "desc"

    Returns SortByStream<T>

sortByLocalCompare

  • sortByLocalCompare(getValFn: (x: T, i?: number) => string, direction?: "asc" | "desc", ...params: [locales?: string | string[], options?: CollatorOptions]): SortByLocalCompareStream<T>

  • Parameters

    • getValFn: (x: T, i?: number) => string
        • (x: T, i?: number): string

        • Parameters

          • x: T
          • Optional i: number

          Returns string

    • Optional direction: "asc" | "desc"
    • Rest ...params: [locales?: string | string[], options?: CollatorOptions]

    Returns SortByLocalCompareStream<T>

sum

  • sum(getVal: (x: T, i?: number) => number, initialValue?: number): number
  • sum(getVal: (x: T, i?: number) => bigint, initialValue: bigint): bigint

  • Parameters

    • getVal: (x: T, i?: number) => number
        • (x: T, i?: number): number

        • Parameters

          • x: T
          • Optional i: number

          Returns number

    • Optional initialValue: number

    Returns number

  • Parameters

    • getVal: (x: T, i?: number) => bigint
        • (x: T, i?: number): bigint

        • Parameters

          • x: T
          • Optional i: number

          Returns bigint

    • initialValue: bigint

    Returns bigint

sumAsync

  • sumAsync(getVal: (x: T, i?: number) => number | Promise<number>, initialValue?: number): Promise<number>

  • Parameters

    • getVal: (x: T, i?: number) => number | Promise<number>
        • (x: T, i?: number): number | Promise<number>

        • Parameters

          • x: T
          • Optional i: number

          Returns number | Promise<number>

    • Optional initialValue: number

    Returns Promise<number>

sumBigInt

  • sumBigInt(getVal: (x: T, i?: number) => bigint): bigint

  • Parameters

    • getVal: (x: T, i?: number) => bigint
        • (x: T, i?: number): bigint

        • Parameters

          • x: T
          • Optional i: number

          Returns bigint

    Returns bigint

sumBigIntAsync

  • sumBigIntAsync(getVal: (x: T, i?: number) => bigint | Promise<bigint>, initialValue?: bigint): Promise<bigint>

  • Parameters

    • getVal: (x: T, i?: number) => bigint | Promise<bigint>
        • (x: T, i?: number): bigint | Promise<bigint>

        • Parameters

          • x: T
          • Optional i: number

          Returns bigint | Promise<bigint>

    • Optional initialValue: bigint

    Returns Promise<bigint>

take

  • take(count: number): TakeStream<T>

  • Parameters

    • count: number

    Returns TakeStream<T>

takeWhile

  • takeWhile(fn: TakeWhileMethod<T>, opts?: TTakeWhileMethodOpts): TakeWhileStream<T>

  • Parameters

    • fn: TakeWhileMethod<T>
    • Optional opts: TTakeWhileMethodOpts

    Returns TakeWhileStream<T>

takeWhileAsync

  • takeWhileAsync(fn: TakeWhileMethodAsync<T>, opts?: TTakeWhileMethodOpts): TakeWhileStreamAsync<T>

  • Parameters

    • fn: TakeWhileMethodAsync<T>
    • Optional opts: TTakeWhileMethodOpts

    Returns TakeWhileStreamAsync<T>

toArray

  • toArray(): T[]

toArrayAsync

  • toArrayAsync(meta?: AlotMetaAsync): PromiseLike<T[]>

  • Parameters

    • meta: AlotMetaAsync = ...

    Returns PromiseLike<T[]>

toDictionary

  • toDictionary<TKey, TValue>(keyFn: (x: T) => TKey, valFn?: (x: T) => TValue): {}

  • Type parameters

    • TKey = string

    • TValue = any

    Parameters

    • keyFn: (x: T) => TKey
        • (x: T): TKey

        • Parameters

          • x: T

          Returns TKey

    • Optional valFn: (x: T) => TValue
        • (x: T): TValue

        • Parameters

          • x: T

          Returns TValue

    Returns {}

    • [key: string]: TValue

toDictionaryAsync

  • toDictionaryAsync<TKey, TValue>(keyFn: (x: T) => TKey | Promise<TKey>, valFn?: (x: T) => TValue | Promise<TValue>): Promise<{}>

  • Type parameters

    • TKey = string

    • TValue = any

    Parameters

    • keyFn: (x: T) => TKey | Promise<TKey>
        • (x: T): TKey | Promise<TKey>

        • Parameters

          • x: T

          Returns TKey | Promise<TKey>

    • Optional valFn: (x: T) => TValue | Promise<TValue>
        • (x: T): TValue | Promise<TValue>

        • Parameters

          • x: T

          Returns TValue | Promise<TValue>

    Returns Promise<{}>

toMap

  • toMap<TKey, TValue>(keyFn: (x: T) => TKey, valFn?: (x: T) => TValue): Map<TKey, TValue>

  • Type parameters

    • TKey = string

    • TValue = any

    Parameters

    • keyFn: (x: T) => TKey
        • (x: T): TKey

        • Parameters

          • x: T

          Returns TKey

    • Optional valFn: (x: T) => TValue
        • (x: T): TValue

        • Parameters

          • x: T

          Returns TValue

    Returns Map<TKey, TValue>

toMapAsync

  • toMapAsync<TKey, TValue>(keyFn: (x: T) => TKey | Promise<TKey>, valFn?: (x: T) => TValue | Promise<TValue>): Promise<Map<TKey, TValue>>

  • Type parameters

    • TKey = string

    • TValue = any

    Parameters

    • keyFn: (x: T) => TKey | Promise<TKey>
        • (x: T): TKey | Promise<TKey>

        • Parameters

          • x: T

          Returns TKey | Promise<TKey>

    • Optional valFn: (x: T) => TValue | Promise<TValue>
        • (x: T): TValue | Promise<TValue>

        • Parameters

          • x: T

          Returns TValue | Promise<TValue>

    Returns Promise<Map<TKey, TValue>>

Static fromObject

  • fromObject<TValue>(obj: {}): Alot<{ key: string; value: TValue }>

  • Type parameters

    • TValue

    Parameters

    • obj: {}
      • [key: string]: TValue

    Returns Alot<{ key: string; value: TValue }>

Static fromRange

  • fromRange(start: number, endExcluded: number): Alot<any>

  • Parameters

    • start: number
    • endExcluded: number

    Returns Alot<any>

Generated using TypeDoc