Options
All
  • Public
  • Public/Protected
  • All
Menu

Module utils/array-utils

Index

Functions

Functions

analyzeArrayChanges

  • analyzeArrayChanges<T>(prev: T[], act: T[], comparator?: (a: T, b: T) => boolean): { toAdd: T[]; toRemove: T[] }
  • example

    analyzeArrayChanges(["a", "b", "c"], ["a", "b", "c"]) ==> {toAdd: [], toRemove: []} analyzeArrayChanges(["a", "b", "c"], ["b", "c", "d"]) ==> {toAdd: ["d"], toRemove: ["a"]}

    Type parameters

    • T

    Parameters

    • prev: T[]
    • act: T[]
    • comparator: (a: T, b: T) => boolean = ...
        • (a: T, b: T): boolean

        • Parameters

          • a: T
          • b: T

          Returns boolean

    Returns { toAdd: T[]; toRemove: T[] }

    • toAdd: T[]
    • toRemove: T[]

avg

  • avg(array: number[]): number

  • Function returns average of numeric array given as input

    example

    avg([1, 2, 3, 4, 5]) => 3

    Parameters

    • array: number[]

      array of numbers

    Returns number

    average of all numbers in array

compareArrays

  • compareArrays<T>(prev: T[], act: T[], comparator?: (a: T, b: T) => boolean): boolean
  • example

    compareArrays(["a", "b", "c"], ["a", "b", "c"]) => true compareArrays([{v: "a"}, {v: "b"}, {v: "c"}], [{v: "a"}, {v: "b"}, {v: "c"}]) => false compareArrays([{v: "a"}, {v: "b"}, {v: "c"}], [{v: "a"}, {v: "b"}, {v: "c"}], (a, b) => a.v === b.v) => true

    Type parameters

    • T

    Parameters

    • prev: T[]
    • act: T[]
    • comparator: (a: T, b: T) => boolean = ...
        • (a: T, b: T): boolean

        • Parameters

          • a: T
          • b: T

          Returns boolean

    Returns boolean

createFilledArray

  • createFilledArray<T>(length: number, provider: ((index: number) => T) | T): T[]

eachOther

  • eachOther<T>(arr: T[], callback: (a: T, b: T) => void): void

  • Combine 2 array each other

    Type parameters

    • T

    Parameters

    • arr: T[]
    • callback: (a: T, b: T) => void
        • (a: T, b: T): void

        • Parameters

          • a: T
          • b: T

          Returns void

    Returns void

findArrayDiff

  • findArrayDiff<T>(arrA: T[], arrB: T[], comparator: (a: T, b: T) => number, merger?: (a: T, b: T) => T): { missingInA: T[]; missingInB: T[]; same: T[] }

  • Type parameters

    • T

    Parameters

    • arrA: T[]
    • arrB: T[]
    • comparator: (a: T, b: T) => number
        • (a: T, b: T): number

        • Parameters

          • a: T
          • b: T

          Returns number

    • Optional merger: (a: T, b: T) => T
        • (a: T, b: T): T

        • Parameters

          • a: T
          • b: T

          Returns T

    Returns { missingInA: T[]; missingInB: T[]; same: T[] }

    • missingInA: T[]
    • missingInB: T[]
    • same: T[]

getLast

  • getLast<T>(array: T[]): T | undefined

  • Method returns last element from array or null if array is empty. If argument is not array, method returns argument

    example

    getLast([]) => undefined getLast(["a", "b"]) => b getLast([5, 6]) => 6

    Type parameters

    • T

    Parameters

    • array: T[]

      not empty array

    Returns T | undefined

    last value from array

getNRandom

  • getNRandom<T>(args: T[], count: number): T[]

getRandomItem

  • getRandomItem<T>(array: T[]): T | null

  • Method returns random element from array

    Type parameters

    • T = unknown

    Parameters

    • array: T[]

      not empty array

    Returns T | null

    random value from array

groupByLast

  • groupByLast<T, S>(arr: T[], key: S): {[ k in S]: T }
  • example

    groupByLast([{a: "a", b: "A"}, {a: "b", b: "B"}, {a: "c", b: "C"}, {a: "a", b: "D"}], "a") ==> {a: {a: "a", b: "D"}, b: {a: "b", b: "B"}, c: {a: "c", b: "C"}}

    Type parameters

    • T

    • S: string | number | symbol

    Parameters

    • arr: T[]
    • key: S

    Returns {[ k in S]: T }

join

  • join<T>(array: T[], delimiter: string, prefix?: string, postfix?: string): string

  • Function join array by delimiter and append prefix and postfix

    example

    join(["a", "b", "c", "d"], "") => abcd join(["a", "b", "c", "d"], "=") => a=b=c=d join(["a", "b", "c", "d"], "=", ">>", "<<") => >>a=b=c=d<<

    Type parameters

    • T

    Parameters

    • array: T[]

      not empty array

    • delimiter: string

      character used for join elements in array

    • prefix: string = ""

      string append at the beginning of final string

    • postfix: string = ""

      string append at the end of final string

    Returns string

    final string

makeUnique

  • makeUnique<T>(array: T[]): T[]

  • Method return copy of array with only distinct elements

    example

    makeUnique([5, 5, 3, 2, 1, 4, 5, 4]) ==> [5, 3, 2, 1, 4] makeUnique(["5", "5", "3", "2", "1", "4", "5", "4"]) ==> ["5", "3", "2", "1", "4"]

    Type parameters

    • T

    Parameters

    • array: T[]

      array with duplicate elements

    Returns T[]

    unique array

max

  • max(array: number[]): number

  • Function return maximal value from numeric array

    deprecated

    use {@link Math.max} instead

    Parameters

    • array: number[]

      array of numbers

    Returns number

    maximal number from array

maxRowLength

  • maxRowLength<T>(arr: T | T[] | T[][]): number

mergeArrays2

  • mergeArrays2<S, T, R>(arr1: S[], arr2: T[], callback: (item1: S, item2: T) => R): R[]

  • Type parameters

    • S

    • T

    • R

    Parameters

    • arr1: S[]
    • arr2: T[]
    • callback: (item1: S, item2: T) => R
        • (item1: S, item2: T): R

        • Parameters

          • item1: S
          • item2: T

          Returns R

    Returns R[]

mergeArrays3

  • mergeArrays3<S, T, U, R>(arr1: S[], arr2: T[], arr3: U[], callback: (item1: S, item2: T, item3: U) => R): R[]

  • Type parameters

    • S

    • T

    • U

    • R

    Parameters

    • arr1: S[]
    • arr2: T[]
    • arr3: U[]
    • callback: (item1: S, item2: T, item3: U) => R
        • (item1: S, item2: T, item3: U): R

        • Parameters

          • item1: S
          • item2: T
          • item3: U

          Returns R

    Returns R[]

min

  • min(array: number[]): number

  • Function return minimal value from numeric array

    deprecated

    use {@link Math.min} instead

    Parameters

    • array: number[]

      array of numbers

    Returns number

    minimal number from array

minRowLength

  • minRowLength<T>(arr: T | T[] | T[][]): number

subArray

  • subArray<T>(array: T[], minIndex?: number, maxIndex?: number): T[]

  • Return sub array from array

    deprecated

    use {@link Array.prototype.slice} instead

    Type parameters

    • T = any

    Parameters

    • array: T[]

      input array

    • minIndex: number = 0

      start index

    • maxIndex: number = ...

      end index

    Returns T[]

    final array

sum

  • sum(array: number[]): number

  • Function return total value of all elements in numeric array

    example

    sum([1, 2, 3, 4, 5]) => 15

    Parameters

    • array: number[]

      array of numbers

    Returns number

    summary of all numbers in array

where

  • where<T>(array: T[], condition: Partial<T>): T[]
  • example

    const array = [{name: "Michael", age: 23}, {name: "Joachim", age: 15}, {name: "Enrico", age: 15}, {name: "Monica", age: 59}] const conditions = {age: 23, name: "Monica"} where(array, conditions); // [{name: "Michael", age: 23}, {name: "Enrico", age: 15}, {name: "Monica", age: 59}]

    Type parameters

    • T: Record<string, unknown>

    Parameters

    • array: T[]
    • condition: Partial<T>

    Returns T[]

Generated using TypeDoc