Options
All
  • Public
  • Public/Protected
  • All
Menu

Index

Type aliases

Nullable

Nullable<T>: {[ K in keyof T]: T[K] | null }

제네릭으로 받은 맵의 키를 유지한 채 밸류의 타입을 nullable하게 변경합니다

Type parameters

  • T

QueryParam

QueryParam: Record<string, QueryParamValue>

QueryParamValue

QueryParamValue: string | number | boolean | undefined

TypeMap

TypeMap<T, Value>: {[ K in keyof T]: Value }

제네릭으로 받은 맵의 키를 유지한 채 밸류의 타입을 Value로 변경합니다

Type parameters

  • T

  • Value

UnwrapArray

UnwrapArray<T>: T extends infer U[] ? UnwrapArray<U> : T

Array 타입을 T 타입으로 변환합니다

Type parameters

  • T

UnwrapPromise

UnwrapPromise<T>: T extends PromiseLike<infer U> ? UnwrapPromise<U> : T

Promise 타입을 T 타입으로 변환합니다

Type parameters

  • T

Properties

memoize

memoize: Memoize

Functions

average

  • average(array: number[]): number
  • 인자로 받은 배열 내 원소들의 평균을 구합니다

    example
    average([1, 2, 3, 4]); // 2.5
    

    Parameters

    • array: number[]

    Returns number

averageBy

  • averageBy<T>(array: T[], mapper: (item: T) => number): number
  • 인자로 받은 배열을 한번 매핑한 후 평균을 구합니다

    example
    averageBy(
      [{ value: 1 }, { value: 2 }, { value: 3 }],
      (item) => item.value,
    ); // 2
    

    Type parameters

    • T

    Parameters

    • array: T[]
    • mapper: (item: T) => number
        • (item: T): number
        • Parameters

          • item: T

          Returns number

    Returns number

camelCase

  • camelCase(text: string, splitter?: string[]): string
  • 인자로 받은 문자열을 Camel Case로 변환합니다.

    splitter 인자에 아무런 값을 주지 않을 경우 공백, -, _ 기준으로 단어를 구분합니다.

    example
    camelCase('FooBar'); // fooBar
    camelCase('foo-bar'); // fooBar
    camelCase('foo&bar', ['&']); // fooBar
    

    Parameters

    • text: string
    • splitter: string[] = ...

    Returns string

castArray

  • castArray<T>(...v: T[]): T
  • castArray<T>(...v: T[]): T[]
  • value가 배열이 아닌 경우 배열으로 캐스팅합니다.`

    example
    castArray(1)
    // => [1]
    
    castArray({ 'a': 1 })
    // => [{ 'a': 1 }]
    
    castArray('abc')
    // => ['abc']
    
    castArray(null)
    // => [null]
    
    castArray(undefined)
    // => [undefined]
    
    castArray()
    // => []
    
    const array = [1, 2, 3]
    console.log(castArray(array) === array)
    // => true
    

    Type parameters

    • T: unknown[]

    Parameters

    • Rest ...v: T[]

    Returns T

    캐스팅 된 배열을 반환.

  • Type parameters

    • T

    Parameters

    • Rest ...v: T[]

    Returns T[]

chunk

  • chunk<T>(array: T[], size?: number): T[][]
  • 첫 번째 인자로 주어진 배열을 두 번째 인자로 주어진 크기의 배열로 쪼갭니다.

    example
    chunk([1, 2, 3, 4]); // [[1], [2], [3], [4]]
    chunk([1, 2, 3, 4], 2); // [[1, 2], [3, 4]]
    

    Type parameters

    • T

    Parameters

    • array: T[]
    • size: number = 1

    Returns T[][]

clone

  • clone<T>(value: T): T
  • example
    const objects = [{ 'a': 1 }, { 'b': 2 }]
    
    const shallow = clone(objects)
    console.log(shallow[0] === objects[0])
    // => true
    

    Type parameters

    • T

    Parameters

    • value: T

      복제 할 값.

    Returns T

    복제 된 값을 반환.

cloneDeep

  • cloneDeep<T>(value: T): T
  • 오브젝트를 깊은 복사합니다.

    example
    const objects = [{ 'a': 1 }, { 'b': 2 }]
    
    const deep = cloneDeep(objects)
    console.log(deep[0] === objects[0])
    // => false
    

    Type parameters

    • T

    Parameters

    • value: T

      복제 할 값

    Returns T

    복제 된 값

cloneDeepWith

  • cloneDeepWith<T, R>(value: T, customizer: (params: T) => R): R
  • value를 깊은 복사 한다. customizer는 깊은복사 된 value를 매게변수로 받는다.

    see

    cloneWith

    example
    function customizer(value) {
      if (isElement(value)) {
        return value.cloneNode(true)
      }
    }
    
    const el = cloneDeepWith(document.body, customizer)
    
    console.log(el === document.body)
    // => false
    console.log(el.nodeName)
    // => 'BODY'
    console.log(el.childNodes.length)
    // => 20
    

    Type parameters

    • T

    • R

    Parameters

    • value: T

      value를 깊은 복사 합니다.

    • customizer: (params: T) => R
        • (params: T): R
        • Parameters

          • params: T

          Returns R

    Returns R

    Returns 깊은 복사 된 value 또는 customizer의 결과 값

cloneWith

  • cloneWith<T, R>(value: T, customizer?: (params: T) => R): R
  • value를 얕은 복사 한다. customizer는 얕은 복사 된 value를 매게변수로 받는다.

    see

    cloneDeepWith

    example
    function customizer(value) {
      if (isElement(value)) {
        return value.cloneNode(false)
      }
    }
    
    const el = cloneWith(document.body, customizer)
    
    console.log(el === document.body)
    // => false
    console.log(el.nodeName)
    // => 'BODY'
    console.log(el.childNodes.length)
    // => 0
    

    Type parameters

    • T

    • R

    Parameters

    • value: T

      value를 얕은 복사 합니다.

    • Optional customizer: (params: T) => R
        • (params: T): R
        • Parameters

          • params: T

          Returns R

    Returns R

    Returns 얕은 복사 된 value 또는 customizer의 결과 값

Const commaizeNumber

  • commaizeNumber(value: string | number): string
  • 인자로 주어진숫자의 3자리수 마다 콤마를 찍은 문자열을 반환합니다. ex) 1000000 -> 1,000,000

    Parameters

    • value: string | number

    Returns string

compact

  • compact<T>(array: T[]): T[]
  • 배열 내에서 0, "", undefined, null, NaN과 같은 Falsy 값을 모두 제거합니다.

    example
    compact([0, 1, false, 2, '', 3]); // [1, 2, 3]
    

    Type parameters

    • T

    Parameters

    • array: T[]

    Returns T[]

conformsTo

  • conformsTo<T>(object: T, source: Conform<T>): boolean
  • 'object'가 인라인 함수 'source'와 일치하는지 확인 'source'의 프로퍼티와 'object'의 프로퍼티는 일치

    example
    const object = { 'a': 1, 'b': 2 }
    
    conformsTo(object, { 'b': function(n) { return n > 1 } })
    // => true
    
    conformsTo(object, { 'b': function(n) { return n > 2 } })
    // => false
    

    Type parameters

    • T

    Parameters

    • object: T

      검사할 오브젝트

    • source: Conform<T>

      오브젝트의 프로퍼티를 검증할 오브젝트

    Returns boolean

    'object'가 일치하면 'true'를 반환하고, 그렇지 않으면 'false'를 반환

createAverageFilter

  • createAverageFilter(): (newValue: number) => number
  • 이전 평균 값과 새롭게 입력된 값을 토대로 새로운 평균을 계산하는 클로저 필터 함수를 반환하며, 이전 평균 값과 현재까지의 데이터 개수는 createAverageFilter 함수 스코프에 자유 변수로 저장됩니다.

    항상 O(1)의 시간복잡도를 보장하여 평균을 계산하기 때문에, 센서 데이터 등 빠르게 입력된 데이터를 후처리하는 상황에 적합합니다.

    example
    const average = createAverageFilter();
    console.log(average(1)); // 1
    console.log(average(2)); // 1.5
    console.log(average(3)); // 2
    console.log(average(4)); // 2.5
    

    Returns (newValue: number) => number

      • (newValue: number): number
      • Parameters

        • newValue: number

        Returns number

createMapFromArray

  • createMapFromArray<T, K>(array: T[], key: K): Map<T[K], T>
  • 인자로 받은 배열을 기반으로 key를 키로 가지는 Map을 생성합니다.

    example
    interface Foo {
      id: string;
      name: string;
    }
    const fooList: Foo[] = [];
    createMapFromArray(fooList, 'id'); // Map<string, Foo>
    

    Type parameters

    • T

    • K: string | number | symbol

    Parameters

    • array: T[]
    • key: K

    Returns Map<T[K], T>

createObjectFromArray

  • createObjectFromArray<T, K>(array: T[], key: K): Record<string, T>
  • 인자로 받은 배열을 기반으로 key를 키로 가지는 Object를 생성합니다.

    example
    interface Foo {
      id: string;
      name: string;
    }
    const fooList: Foo[] = [];
    createObjectFromArray(fooList, 'id'); // Record<string, Foo>
    

    Type parameters

    • T: Record<string, any>

    • K: string | number | symbol

    Parameters

    • array: T[]
    • key: K

    Returns Record<string, T>

cumulativeAverage

  • cumulativeAverage(prevAverage: number, newValue: number, dataListLength: number): number
  • 이전 평균 값과 새롭게 입력된 값을 토대로 새로운 평균을 계산하는 평균 필터 알고리즘을 사용하여 값을 계산합니다.

    항상 O(1)의 시간복잡도를 보장하여 평균을 계산하기 때문에, 센서 데이터 등 빠르게 입력된 데이터를 후처리하는 상황에 적합합니다.

    example
    let averageLux = 0;
    let calcCount = 0;
    
    const sensor = new AmbientLightSensor();
    sensor.onreading = () => {
      calcCount++;
      averageLux = cumulativeAverage(averageLux, sensor.illuminance, calcCount);
      console.log(`지금까지의 평균 조도는 ${averageLux}lux 입니다`);
    };
    
    sensor.start();
    

    Parameters

    • prevAverage: number
    • newValue: number
    • dataListLength: number

    Returns number

defer

  • Promise defer 패턴을 사용할 수 있는 함수입니다.

    example
    const {
      promise: sdkLoadPromise,
      resolve: sdkLoadPromiseResolver
    } = defer();
    
    async function call() {
      const isLoaded = await sdkLoadPromise;
      console.log('SDK 로딩 완료');
    }
    
    function completeLoading () {
      // 로딩 중....
      sdkLoadPromiseResolver(true);
    }
    

    Type parameters

    • T

    Returns Defer<T>

Const delay

  • delay(miliseconds: number): Promise<void>

difference

  • difference<T>(xs: T[], ys: T[]): T[]
  • 두 배열을 깊은 비교한 이후, 동일하지 않은 원소를 담은 배열을 반환합니다.

    example
    difference([1, 2, 3], [2, 3]); // [1]
    difference(
      [{ info: { id: 1 }, name: 'evan' }, { info: { id: 2 }, name: 'john' }],
      [{ info: { id: 2 }, name: 'john' }],
    ); // [{ info: { id: 1 }, name: 'evan' }]
    

    Type parameters

    • T

    Parameters

    • xs: T[]
    • ys: T[]

    Returns T[]

differenceWith

  • differenceWith<T>(xs: T[], ys: T[], comparator: (x: T, y: T) => boolean): T[]
  • 두 배열 간의 동일하지 않은 원소를 담은 배열을 반환합니다. 이때 동일 여부는 세 번째 인자인 comparator 함수로 판단합니다.

    example
    differenceWith([1, 2, 3], [2, 3], (x, y) => x === y); // [1]
    differenceWith(
      [{ info: { id: 1 }, name: 'evan' }, { info: { id: 2 }, name: 'john' }],
      [{ info: { id: 2 }, name: 'john' }],
      (x, y) => x.info.id === y.info.id
    ); // [{ info: { id: 1 }, name: 'evan' }]
    

    Type parameters

    • T

    Parameters

    • xs: T[]
    • ys: T[]
    • comparator: (x: T, y: T) => boolean
        • (x: T, y: T): boolean
        • Parameters

          • x: T
          • y: T

          Returns boolean

    Returns T[]

drop

  • drop<T>(array: T[], count: number): T[]
  • 두 번째 인자로 받은 개수만큼 왼쪽부터 원소를 버리고, 얕은 복사된 배열을 반환합니다.

    example
    drop([1, 2, 3], 1); // [2, 3]
    

    Type parameters

    • T

    Parameters

    • array: T[]
    • count: number

    Returns T[]

dropRight

  • dropRight<T>(array: T[], count: number): T[]
  • 두 번째 인자로 받은 개수만큼 오른쪽부터 원소를 버리고, 얕은 복사된 배열을 반환합니다.

    example
    dropRight([1, 2, 3], 1); // [1, 2]
    

    Type parameters

    • T

    Parameters

    • array: T[]
    • count: number

    Returns T[]

flatten

  • flatten<T, Depth>(arr: T[], depth?: Depth): FlatArray<T, Depth>[]
  • 고차원의 배열을 Flatten 합니다. 두 번째 인자로 어느 정도의 Depth까지 탐색하여 Flatten 할지 정할 수 있습니다. 만약 Depth를 지정하지 않는다면 기본적으로 한 단계의 Flatten만 수행합니다.

    (Native JS의 Array.prototype.flat 메소드보다 더 빠른 속도를 보장하지만 더 많은 Heap 메모리를 사용합니다)

    example
    flatten([[1, 2], ['hello', 'world', [ 30 ]]]);
    // [1, 2, 'hello', 'world', [30]]
    
    flatten([[1, 2], ['hello', 'world', [ 30 ]]], 2);
    // [1, 2, 'hello', 'world', 30]
    

    Type parameters

    • T

    • Depth: number = 0

    Parameters

    • arr: T[]
    • Optional depth: Depth

    Returns FlatArray<T, Depth>[]

flattenDeep

  • flattenDeep<T>(arr: T[]): (T extends readonly InnerArr[] ? FlatArray<InnerArr, 0 | 2 | 1 | 3 | -1 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20> : T)[]
  • 고차원의 배열을 끝까지 탐색하여 모든 원소를 Flatten 합니다.

    (Native JS의 Array.prototype.flat 메소드보다 더 빠른 속도를 보장하지만 더 많은 Heap 메모리를 사용하기 때문에, 너무 깊은 차원의 배열을 Flatten하게되면 out of memory가 발생할 수도 있습니다)

    example
    flattenDeep([[1, 2, [3, [true]]], ['hello', 'world', [ 30 ]]]);
    // [1, 2, 3, true, 'hello', 'world', 30]
    

    Type parameters

    • T

    Parameters

    • arr: T[]

    Returns (T extends readonly InnerArr[] ? FlatArray<InnerArr, 0 | 2 | 1 | 3 | -1 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20> : T)[]

generateUUID

  • generateUUID(): string

Const getArc

  • desc

    중심 좌표 (x, y)를 기준으로 degree(θ)만큼 +방향으로 호를 그리는 패스 명령어를 반환합니다.

    example
    const ArcSvg = () => {
      return (
        <svg width={100} height={100}>
    <path d={getArc({ x: 50, y: 50, radius: 50, degree: 90 })} fill="#000000" />
    </svg>
    );
    }
    

    Parameters

    Returns string

getArrayFromCount

  • getArrayFromCount(count: number): number[]
  • getArrayFromCount<T>(count: number, mapper: (i: number) => T): T[]
  • 인자로 받은 숫자만큼의 길이를 가진 배열을 반환합니다. 두 번째 인자의 mapper를 넘기지 않으면, 인덱스를 원소 값으로 가집니다.

    example

    getArrayFromCount(5) // [0, 1, 2, 3, 4]; getArrayFromCount(5, i => ${i}!); // ['0!', '1!', '2!', '3!', '4!']

    Parameters

    • count: number

    Returns number[]

  • Type parameters

    • T

    Parameters

    • count: number
    • mapper: (i: number) => T
        • (i: number): T
        • Parameters

          • i: number

          Returns T

    Returns T[]

Const getCoordsOnCircle

  • getCoordsOnCircle(__namedParameters: ArcData): { x: number; y: number }
  • desc

    삼각함수를 사용하여 x축으로부터 시계 방향으로 degree(θ)만큼 벌어진 좌표를 구합니다

    example
    // 중심 좌표가 (0, 0)이고 반지름이 50인 원을 기준으로 90만큼 벌어진 곳의 좌표를 구합니다
    const { x, y } = getCoordsOnCircle({ x: 50, y: 50, radius: 50, degree: 90 }); // { x: 50, y: 100 }
    

    Parameters

    Returns { x: number; y: number }

    • x: number
    • y: number

getObjectKeys

  • getObjectKeys<T>(object: T): keyof T[]
  • 객체의 키가 아닌 string을 반환하는 Object.keys 대신 사용할 수 있는 Type Safe한 함수입니다

    Type parameters

    • T: Record<string, any>

    Parameters

    • object: T

    Returns keyof T[]

groupBy

  • groupBy<T>(array: T[], iterator: (item: T) => Key): Record<Key, T[]>
  • 배열의 원소들을 iterator가 반환하는 값을 기준으로 그룹핑합니다.

    example
    groupBy([6.1, 4.2, 6.3], Math.floor);
    // { 4: [4.2], 6: [6.1, 6.3] }
    
    groupBy(
      [
        { age: 31, name: 'evan' },
        { age: 32, name: 'john' },
        { age: 25, name: 'kevin' },
      ],
      ({ age }) => `${Math.floor(age / 10) * 10}대`
    ) // { '20대': [{ age: 25, name: 'kevin' }], '30대': [{ age: 31, name: 'evan' }, { age: 32, name: 'john' }]}
    

    Type parameters

    • T

    Parameters

    • array: T[]
    • iterator: (item: T) => Key
        • (item: T): Key
        • Parameters

          • item: T

          Returns Key

    Returns Record<Key, T[]>

gt

  • gt(value: number, other: number): boolean
  • value가 other보다 큰지 확인

    example
    gt(3, 1)
    // => true
    
    gt(3, 3)
    // => false
    
    gt(1, 3)
    // => false
    

    Parameters

    • value: number

      비교할 값

    • other: number

      바교할 다른 값

    Returns boolean

    값이 other 보다 크면 true 반환 아닌 경우 false 반환

gte

  • gte(value: number, other: number): boolean
  • value가 other보다 큰지 확인

    example
    gte(3, 1)
    // => true
    
    gte(3, 3)
    // => true
    
    gte(1, 3)
    // => false
    

    Parameters

    • value: number

      비교할 값

    • other: number

      바교할 다른 값

    Returns boolean

    값이 other 보다 크거나 같으면 true 반환 아닌 경우 false 반환

Const identify

  • identify<T>(v: T): T

iif

  • iif<T>(condition: boolean, trueResult: T): T | undefined
  • iif<T>(condition: true, trueResult: T): T
  • iif<T>(condition: false, trueResult: T): undefined
  • iif<T, K>(condition: boolean, trueResult: T, falseResult: K): T | K
  • iif<T, K>(condition: true, trueResult: T, falseResult: K): T
  • iif<T, K>(condition: false, trueResult: T, falseResult: K): K
  • 첫 번째 인자로 조건을 받아, 조건 결과에 따라 참, 거짓에 해당하는 값을 반환합니다.

    Type parameters

    • T

    Parameters

    • condition: boolean
    • trueResult: T

    Returns T | undefined

  • Type parameters

    • T

    Parameters

    • condition: true
    • trueResult: T

    Returns T

  • Type parameters

    • T

    Parameters

    • condition: false
    • trueResult: T

    Returns undefined

  • Type parameters

    • T

    • K

    Parameters

    • condition: boolean
    • trueResult: T
    • falseResult: K

    Returns T | K

  • Type parameters

    • T

    • K

    Parameters

    • condition: true
    • trueResult: T
    • falseResult: K

    Returns T

  • Type parameters

    • T

    • K

    Parameters

    • condition: false
    • trueResult: T
    • falseResult: K

    Returns K

intersection

  • intersection<T>(xs: T[], ys: T[]): T[]
  • 두 배열을 깊은 비교한 이후, 겹치는 원소를 담은 배열을 반환합니다.

    example
    intersection([1, 2, 3], [2, 3]); // [2, 3]
    intersection(
      [{ info: { id: 1 }, name: 'evan' }, { info: { id: 2 }, name: 'john' }],
      [{ info: { id: 2 }, name: 'john' }],
    ); // [{ info: { id: 2 }, name: 'john' }]
    

    Type parameters

    • T

    Parameters

    • xs: T[]
    • ys: T[]

    Returns T[]

intersectionWith

  • intersectionWith<T>(xs: T[], ys: T[], comparator: (x: T, y: T) => boolean): T[]
  • 두 배열 간의 겹치는 원소를 담은 배열을 반환합니다. 이때 동일 여부는 세 번째 인자인 comparator 함수로 판단합니다.

    example
    intersectionWith([1, 2, 3], [2, 3, 4], (x, y) => x === y); // [2, 3]
    intersectionWith(
      [{ info: { id: 1 }, name: 'evan' }, { info: { id: 2 }, name: 'john' }],
      [{ info: { id: 2 }, name: 'john' }],
      (x, y) => x.info.id === y.info.id
    ); // [{ info: { id: 2 }, name: 'john' }]
    

    Type parameters

    • T

    Parameters

    • xs: T[]
    • ys: T[]
    • comparator: (x: T, y: T) => boolean
        • (x: T, y: T): boolean
        • Parameters

          • x: T
          • y: T

          Returns boolean

    Returns T[]

is

  • is<T>(value: unknown, validator: (v: unknown) => boolean): value is T
  • 타입가드를 편하게 사용할 수 있는 유틸 함수 입니다.

    하지만 타입 가딩을 하는 타입이 string | number <=> string과 같은 서브타입 관계가 아니더라도, 이 함수는 그대로 타입가드를 적용하기 때문에 Type Safely하지 않은 상황이 발생할 수 있습니다.

    이 함수를 사용하면 반드시 타입 가딩 이후에 타입이 어떻게 평가되었는지 확인해주세요.

    Type parameters

    • T

    Parameters

    • value: unknown
    • validator: (v: unknown) => boolean
        • (v: unknown): boolean
        • Parameters

          • v: unknown

          Returns boolean

    Returns value is T

isAfterOrEqual

  • isAfterOrEqual(date1: Date, date2: Date): boolean
  • 첫 번째 인자로 주어진 날짜가 두 번째 인자로 주어진 날짜와 같거나 미래인지 확인합니다.

    example
    isAfterOrEqual(new Date(2021, 8, 9), new Date(2021, 8, 9)); // true
    isAfterOrEqual(new Date(2021, 8, 31), new Date(2021, 8, 9)); // true
    

    Parameters

    • date1: Date
    • date2: Date

    Returns boolean

isArguments

  • isArguments(value: any): boolean

isArrayBuffer

  • isArrayBuffer(value: any): value is ArrayBuffer
  • value가 ArrayBuffer인지 확인

    example
    isArrayBuffer(new ArrayBuffer(2))
    // => true
    
    isArrayBuffer(new Array(2))
    // => false
    

    Parameters

    • value: any

      검사할 값

    Returns value is ArrayBuffer

    ArrayBuffer이면 true 반환 아닌 경우 false 반환

isArrayLike

  • isArrayLike(value: any): boolean
  • value가 유사 배열인지 확인. value가 다음과 같은 경우 유사배열으로 간주한다. 함수가 아니며 또는 0이상의 value.length를 가진 경우

    example
    isArrayLike([1, 2, 3])
    // => true
    
    isArrayLike(document.body.children)
    // => true
    
    isArrayLike('abc')
    // => true
    
    isArrayLike(Function)
    // => false
    

    Parameters

    • value: any

      검사할 값

    Returns boolean

    유사 배열이면 true 반환 아닌 경우 false 반환

isArrayLikeObject

  • isArrayLikeObject(value: any): boolean
  • value가 object인지 확인 한다는 점을 제외하면 isArrayLike와 동일하다.

    example
    isArrayLikeObject([1, 2, 3])
    // => true
    
    isArrayLikeObject(document.body.children)
    // => true
    
    isArrayLikeObject('abc')
    // => false
    
    isArrayLikeObject(Function)
    // => false
    

    Parameters

    • value: any

      검사할 값

    Returns boolean

    array-like object이면 true 반환 아닌 경우 false 반환

isBeforeOrEqual

  • isBeforeOrEqual(date1: Date, date2: Date): boolean
  • 첫 번째 인자로 주어진 날짜가 두 번째 인자로 주어진 날짜와 같거나 과거인지 확인합니다.

    example
    isBeforeOrEqual(new Date(2021, 8, 9), new Date(2021, 8, 9)); // true
    isBeforeOrEqual(new Date(2021, 8, 1), new Date(2021, 8, 9)); // true
    

    Parameters

    • date1: Date
    • date2: Date

    Returns boolean

isBoolean

  • isBoolean(value: unknown): value is boolean
  • 인자로 받은 값이 Boolean 타입인지 여부를 반환합니다.

    example
    isBoolean(false); // true
    

    Parameters

    • value: unknown

    Returns value is boolean

isBuffer

  • isBuffer(arg: any): arg is Buffer
  • value가 Buffer인지 확인합니다.

    example
    isBuffer(new Buffer(2))
    // => true
    
    isBuffer(new Uint8Array(2))
    // => false
    

    Parameters

    • arg: any

    Returns arg is Buffer

    Returns value가 Buffer인지 여부

isDate

  • isDate(value: any): value is Date
  • value가 Date인지 확인합니다.

    example
    isDate(new Date)
    // => true
    
    isDate('2021-12-31')
    // => false
    

    Parameters

    • value: any

      확인할 값

    Returns value is Date

    Returns value가 Date인지 여부

isElement

  • isElement(value: any): value is Element
  • value가 Element인지 확인합니다.

    example
    isElement(document.body)
    // => true
    
    isElement('<body>')
    // => false
    

    Parameters

    • value: any

      확인할 값

    Returns value is Element

    Returns value가 Element인지 여부

isEqual

  • isEqual<T>(a: any, b: T): a is T
  • 첫 번째 인자의 값과 두 번째 인자의 값을 깊은 비교합니다.

    isEqual이 true를 반환한다면 첫 번째 인자의 타입은 두 번째 인자의 타입과 동일하다고 평가됩니다.

    example
    type Foo = { a: number; b?: string };
    const obj1 = { a: 1 };
    const obj2: Type = { a: 1 };
    
    if (isEqual(a, b)) {
      // a는 Foo 타입으로 추론됩니다.
    }
    

    Type parameters

    • T

    Parameters

    • a: any
    • b: T

    Returns a is T

isEqualWith

  • isEqualWith<V, O>(value: V, other: O, customizer: (value: V, other: O) => any): boolean
  • 이 메서드는 isEqual와 동일하지만 customizer를 전달합니다. customizerundefined를 반환하면 비교는 메서드에 의해 처리됩니다. customizer는 최대 여섯 개의 인수를 전달합니다. (objValue, othValue [, index|key, object, other, stack])

    example
    function isGreeting(value) {
      return /^h(?:i|ello)$/.test(value)
    }
    
    function customizer(objValue, othValue) {
      if (isGreeting(objValue) && isGreeting(othValue)) {
        return true
      }
    }
    
    const array = ['hello', 'goodbye']
    const other = ['hi', 'goodbye']
    
    isEqualWith(array, other, customizer)
    // => true
    

    Type parameters

    • V

    • O

    Parameters

    • value: V

      비교할 값

    • other: O

      value와 비교할 값

    • customizer: (value: V, other: O) => any
        • (value: V, other: O): any
        • Parameters

          • value: V
          • other: O

          Returns any

    Returns boolean

    Returns value가 other와 동일한지 여부

isError

  • isError(value: any): value is Error
  • value가 Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, or URIError 객체인지 확인합니다.

    example
    isError(new Error)
    // => true
    
    isError(Error)
    // => false
    

    Parameters

    • value: any

      확인할 값

    Returns value is Error

    Returns value가 Error 객체인지 여부

isFinite

  • isFinite(value: number): boolean
  • value가 유한한 숫자인지 확인합니다.

    example
    isFinite(3);
    // => true
    
    isFinite(Number.MIN_VALUE);
    // => true
    
    isFinite(Infinity);
    // => false
    
    

    Parameters

    • value: number

      확인할 값

    Returns boolean

    value가 유한한 숫자이면 true 아니면 false

isFunction

  • isFunction(value: any): value is Function
  • Checks if value is classified as a Function object. value가 Function 객체인지 확인합니다.

    example
    isFunction(class Any{})
    // => true
    
    isFunction(() => {})
    // => true
    
    isFunction(async () => {})
    // => true
    
    isFunction(function * Any() {})
    // => true
    
    isFunction(Math.round)
    // => true
    
    isFunction(/abc/)
    // => false
    

    Parameters

    • value: any

      확인할 값

    Returns value is Function

    Returns value가 Function 객체인지 여부

isInteger

  • isInteger(value: number): boolean
  • value가 정수인지 확인합니다.

    example
    isInteger(3);
    // => true
    
    isInteger(Number.MIN_VALUE);
    // => false
    
    isInteger(Infinity);
    // => false
    

    Parameters

    • value: number

      확인 할 값

    Returns boolean

    value가 정수이면 true 아니면 false

isMap

  • isMap(value: unknown): value is Map<unknown, unknown>
  • 인자로 받은 값이 Map인지 여부를 반환합니다.

    example
    const map = new Map();
    isMap(map); // true
    

    Parameters

    • value: unknown

    Returns value is Map<unknown, unknown>

isMatch

  • isMatch(object: ObjectType, source: ObjectType): boolean

isNative

  • isNative(value: any): boolean
  • value가 native function인지 확인합니다.

    example
    isNative(Array.prototype.push);
    // => true
    
    isNative(cloneDeep);
    // => false
    

    Parameters

    • value: any

      확인할 값

    Returns boolean

    만약 value가 native function이면 true를, 그렇지 않다면 false를 반환합니다.

isNil

  • isNil(value: unknown): value is null
  • isNil 은 value가 null, undefined 인지 확인해주는 함수입니다.

    example
    isNil(null); // true
    isNil(void 0); // true
    isNil(NaN); // false
    

    Parameters

    • value: unknown

    Returns value is null

isNull

  • isNull(value: any): value is null
  • value가 안전한 정수인지 확인합니다.

    Note: 이 메소드 아래 메소드를 사용합니다. Number.isSafeInteger.

    example
    isSafeInteger(3);
    // => true
    
    isSafeInteger(Number.MIN_VALUE);
    // => false
    
    isSafeInteger(Infinity);
    // => false
    
    isSafeInteger('3');
    // => false
    

    Parameters

    • value: any

      확인할 값

    Returns value is null

    만약 value가 안전한 정수라면 true를, 그렇지 않다면 false를 반환합니다.

isNumber

  • isNumber(value: unknown): value is number
  • 인자로 받은 값이 Number 타입인지 여부를 반환합니다.

    example
    isNumber(-1); // true
    

    Parameters

    • value: unknown

    Returns value is number

isObject

  • isObject(value: any): boolean
  • value가 오브젝트의 언어타입인지 확인합니다. (e.g. arrays, functions, objects, regexes, new Number(0), and new String(''))

    example
    isObject({});
    // => true
    
    isObject([1, 2, 3]);
    // => true
    
    isObject(null);
    // => false
    

    Parameters

    • value: any

      확인할 값

    Returns boolean

    만약 value가 오브젝트이면 true를, 그렇지 않다면 false를 반환합니다.

isObjectLike

  • isObjectLike(value: any): boolean
  • value가 object-like인지 확인 typeof 결과는 object이다.

    example
    isObjectLike({})
    // => true
    
    isObjectLike([1, 2, 3])
    // => true
    
    isObjectLike(Function)
    // => false
    
    isObjectLike(null)
    // => false
    

    Parameters

    • value: any

      검사할 값

    Returns boolean

    object-like이면 true 반환 아닌 경우 false 반환

isPlainObject

  • isPlainObject(obj: any): boolean
  • value가 plane object 인지 확인합니다. (e.g. Object 생성자로부터 생성된 오브젝트, [[Prototype]]null인 오브젝트)

    example
    function Foo() {
      this.a = 1;
    }
    
    isPlainObject(new Foo);
    // => false
    
    isPlainObject([1, 2, 3]);
    // => false
    
    isPlainObject({ 'x': 0, 'y': 0 });
    // => true
    
    isPlainObject(Object.create(null));
    // => true
    

    Parameters

    • obj: any

    Returns boolean

    만약 value가 plane object라면 true를, 그렇지 않다면 false를 반환합니다.

isPrimitiveType

  • isPrimitiveType(value: unknown): value is string | number | boolean
  • 인자로 받은 값이 원시 자료형인지 여부를 반환합니다.

    example
    isPrimitiveType('') // true
    isPrimitiveType(1) // true
    isPrimitiveType(false) // true
    isPrimitiveType(NaN) // true
    isPrimitiveType({}) // false
    isPrimitiveType([]) // false
    

    Parameters

    • value: unknown

    Returns value is string | number | boolean

isRegExp

  • isRegExp(value: any): value is RegExp
  • 인자로 받은 값이 정규식 객체인지 여부를 반환합니다.

    example
    const regex = /123/;
    isRegExp(regex); // true
    

    Parameters

    • value: any

    Returns value is RegExp

isSet

  • isSet(value: unknown): value is Set<unknown>
  • 인자로 받은 값이 Set인지 여부를 반환합니다.

    example
    const set = new Set();
    isSet(set); // true
    

    Parameters

    • value: unknown

    Returns value is Set<unknown>

isString

  • isString(value: unknown): value is string
  • 인자로 받은 값이 String 타입인지 여부를 반환합니다.

    example
    isString('foo'); // true
    

    Parameters

    • value: unknown

    Returns value is string

isSymbol

  • isSymbol(value: any): value is symbol
  • value가 Symbol primitive 혹은 object 인지 확인합니다.

    example
    isSymbol(Symbol.iterator);
    // => true
    
    isSymbol('abc');
    // => false
    

    Parameters

    • value: any

      확인할 값

    Returns value is symbol

    만약 value가 Symbol primitive 혹은 object 이면 true를, 그렇지 않다면 false를 반환합니다.

isTypedArray

  • isTypedArray(value: unknown): value is TypedArray
  • 인자로 받은 값이 TypedArray인지 여부를 반환합니다.

    example
    const arr = new Int16Array();
    isTypedArray(arr); // true
    

    Parameters

    • value: unknown

    Returns value is TypedArray

isWeakMap

  • isWeakMap(value: any): value is WeakMap<any, any>
  • value가 WeakMap 객체인지 확인합니다.

    example
    isWeakMap(new WeakMap);
    // => true
    
    isWeakMap(new Map);
    // => false
    

    Parameters

    • value: any

      확인할 값

    Returns value is WeakMap<any, any>

    만약 value가 WeakMap 객체이면 true를, 그렇지 않다면 false를 반환합니다.

isWeakSet

  • isWeakSet(value: any): value is WeakSet<any>
  • value가 WeakSet 객체인지 확인합니다.

    example
    isWeakSet(new WeakSet);
    // => true
    
    isWeakSet(new Set);
    // => false
    

    Parameters

    • value: any

      확인할 값

    Returns value is WeakSet<any>

    만약 value가 WeakSet 객체이면 true를, 그렇지 않다면 false를 반환합니다.

lowerFirstLetter

  • lowerFirstLetter(text: string): string
  • 주어진 문자열의 첫 번째 문자를 소문자로 변경합니다

    example
    lowerFirstLetter('FRED'); // fRED
    

    Parameters

    • text: string

    Returns string

lt

  • lt(a: number, b: number): boolean
  • valueother보다 작으면 true를 반환합니다.

    example

    lt(1, 3); // => true

    lt(3, 3); // => false

    lt(3, 1); // => false

    Parameters

    • a: number
    • b: number

    Returns boolean

    valueother보다 작으면 true

lte

  • lte(a: number, b: number): boolean
  • valueother보다 작거나 같으면 true를 반환합니다.

    example

    lte(1, 3); // => true

    lte(3, 3); // => true

    lte(3, 1); // => false

    Parameters

    • a: number
    • b: number

    Returns boolean

    valueother보다 작거나 같으면 true

mapKeys

  • mapKeys<T>(object: T, iterate: (value: T[keyof T], key: keyof T, object: T) => string | number): Record<string | number, T[keyof T]>
  • 객체를 순회하며 키를 매핑하여, 값을 유지한 채 새로운 키를 가진 객체를 생성합니다.

    example
    mapKeys({ a: 1, b: 2 }, (value, key) => key + value);
    // => { a1: 1, b2: 2 }
    

    Type parameters

    • T

    Parameters

    • object: T
    • iterate: (value: T[keyof T], key: keyof T, object: T) => string | number
        • (value: T[keyof T], key: keyof T, object: T): string | number
        • Parameters

          • value: T[keyof T]
          • key: keyof T
          • object: T

          Returns string | number

    Returns Record<string | number, T[keyof T]>

mapValues

  • mapValues<T>(object: T, iterate: (value: T[keyof T], key: keyof T, object: T) => string | number): {[ key in string | number | symbol]: string | number }
  • 객체를 순회하며 값을 매핑하여, 키를 유지한채 새로운 값을 가진 객체를 생성합니다.

    example
    const users = {
      fred: { name: 'fred', age: 40 },
      pebbles: { name: 'pebbles', age: 1 }
    };
    
    mapValues(users, (o) => o.age);
    // => { fred: 40, pebbles: 1 }
    

    Type parameters

    • T

    Parameters

    • object: T
    • iterate: (value: T[keyof T], key: keyof T, object: T) => string | number
        • (value: T[keyof T], key: keyof T, object: T): string | number
        • Parameters

          • value: T[keyof T]
          • key: keyof T
          • object: T

          Returns string | number

    Returns {[ key in string | number | symbol]: string | number }

max

  • max(array: number[]): number
  • 인자로 받은 배열의 원소들 중 최대 값을 반환합니다.

    example
    max([1, 2, 3, 4]); // 4
    

    Parameters

    • array: number[]

    Returns number

maxBy

  • maxBy<T>(array: T[], mapper: (item: T) => number): T
  • 인자로 받은 배열을 매핑한 후 결과 값에 따라 최대 값을 가진 원소를 반환합니다.

    example
    maxBy(
      [{ value: 1 }, { value: 2 }, { value: 3 }],
      item => item.value
    ); // { value: 3 }
    

    Type parameters

    • T

    Parameters

    • array: T[]
    • mapper: (item: T) => number
        • (item: T): number
        • Parameters

          • item: T

          Returns number

    Returns T

min

  • min(array: number[]): number
  • 인자로 받은 배열의 원소들 중 최소 값을 반환합니다.

    example
    min([1, 2, 3, 4]); // 1
    

    Parameters

    • array: number[]

    Returns number

minBy

  • minBy<T>(array: T[], mapper: (item: T) => number): T
  • 인자로 받은 배열을 매핑한 후 결과 값에 따라 최소 값을 가진 원소를 반환합니다.

    example
    minBy(
      [{ value: 1 }, { value: 2 }, { value: 3 }],
      item => item.value
    ); // { value: 1 }
    

    Type parameters

    • T

    Parameters

    • array: T[]
    • mapper: (item: T) => number
        • (item: T): number
        • Parameters

          • item: T

          Returns number

    Returns T

omit

  • omit<T, K>(object: T, keys: readonly K[]): Omit<T, K>
  • 객체를 받아 원하는 키를 제외한 새로운 객체를 반환합니다.

    example
    omit({ a: 1, b: '2', c: 3 }, ['a', 'c']); // { b: '2' }
    

    Type parameters

    • T: Record<string | number | symbol, unknown>

    • K: string | number | symbol

    Parameters

    • object: T
    • keys: readonly K[]

    Returns Omit<T, K>

parscalCase

  • parscalCase(text: string, splitter?: string[]): string
  • 인자로 받은 문자열을 Parscal Case로 변환합니다.

    splitter 인자에 아무런 값을 주지 않을 경우 공백, -, _ 기준으로 단어를 구분합니다.

    example
    parscalCase('fooBar'); // FooBar
    parscalCase('foo-bar'); // FooBar
    parscalCase('foo&bar', ['&']); // FooBar
    

    Parameters

    • text: string
    • splitter: string[] = ...

    Returns string

parseQueryString

  • parseQueryString(queryString: string): Record<string, string>
  • 쿼리 스트링을 인자로 받아서 맵을 반환하는 함수입니다.

    example

    parseQueryString('?foo=1&bar=%ED%95%98%EC%9D%B4'); // { foo: '1', bar: '하이' }

    Parameters

    • queryString: string

    Returns Record<string, string>

pick

  • pick<T, K>(object: T, keys: readonly K[]): Pick<T, K>
  • 객체를 받아 원하는 키만으로 이루어져있는 새로운 객체를 만드는 함수

    example
     const objectA = { 'a': 1, 'b': '2', 'c': 3 };
     pick(objectA, ['a', 'c']); // {'a':1 ,'c': 3}
    

    Type parameters

    • T: Record<string | number | symbol, unknown>

    • K: string | number | symbol

    Parameters

    • object: T

      (Object): 객체.

    • keys: readonly K[]

    Returns Pick<T, K>

preserveRefReplaceItem

  • preserveRefReplaceItem<T>(arr: T[], targetIndex: number, newItem: T): T[]
  • 배열 내 지정된 인덱스에 위치한 원소를 새로운 원소로 변경하고 원본 배열을 반환합니다.

    Type parameters

    • T

    Parameters

    • arr: T[]
    • targetIndex: number
    • newItem: T

    Returns T[]

replaceItem

  • replaceItem<T>(arr: T[], targetIndex: number, newItem: T): T[]
  • 배열 내 지정된 인덱스에 위치한 원소를 새로운 원소로 변경하고 새로운 배열을 반환합니다. 대상 배열은 얕은 복사 되기 때문에 내부 원소들의 레퍼런스는 변하지 않습니다.

    Type parameters

    • T

    Parameters

    • arr: T[]
    • targetIndex: number
    • newItem: T

    Returns T[]

sleep

  • sleep(delay: number): Promise<void>
  • Promise를 사용하여 일정 시간 동안 라인의 실행을 멈춥니다. delay의 단위로는 ms를 사용합니다.

    example
    console.log('슬립 시작');
    await sleep(1000);
    console.log('1초 지남');
    

    Parameters

    • delay: number

    Returns Promise<void>

stringifyQueryParams

  • stringifyQueryParams(params?: QueryParam): string
  • 맵을 인자로 받아서 쿼리스트링을 반환하는 함수입니다. 만약 맵 내부에 유효한 값이 없다면 빈 문자열을 반환합니다.

    example
    stringifyQueryParams({ foo: true, bar: 'hello', baz: '안녕' });
    // '?foo=true&bar=hello&%EC%95%88%EB%85%95'
    
    stringifyQueryParams({ foo: undefined });
    // ''
    

    Parameters

    Returns string

sum

  • sum(array: number[]): number
  • 인자로 받은 배열의 모든 원소를 합산합니다

    example
    sum([1, 2, 3, 4]); // 10
    

    Parameters

    • array: number[]

    Returns number

sumBy

  • sumBy<T>(array: T[], mapper: (item: T) => number): number
  • 인자로 받은 배열을 한번 매핑한 후 모든 반환값을 합산합니다

    example
    sumBy(
      [{ value: 1 }, { value: 2 }, { value: 3 }],
      item => item.value
    ); // 6
    

    Type parameters

    • T

    Parameters

    • array: T[]
    • mapper: (item: T) => number
        • (item: T): number
        • Parameters

          • item: T

          Returns number

    Returns number

toArray

  • toArray(value: boolean): []
  • toArray(value: number): []
  • toArray(value: string): string[]
  • toArray<T>(value: Record<string, T>): T[]

trimCharacters

  • trimCharacters(text: string, targetCharacters: string[]): string
  • 대상 문자열 중 targetCharacters에 포함되는 문자를 Trim합니다. targetCharacters에 아무런 값을 주지 않는 경우에는 공백을 Trim 합니다.

    example
    trimCharacters('   foo    '); // foo
    trimCharacters('--foo--', ['-']); // foo
    trimCharacters('--_foo-_-', ['-', '_']); // foo
    

    Parameters

    • text: string
    • targetCharacters: string[]

    Returns string

trimEndCharacters

  • trimEndCharacters(text: string, targetCharacters?: string[]): string
  • 대상 문자열 중 targetCharacters에 포함되는 문자를 End Trim합니다. targetCharacters에 아무런 값을 주지 않는 경우에는 공백을 Trim 합니다.

    example
    trimEndCharacters('foo    '); // foo
    trimEndCharacters('foo--', ['-']); // foo
    

    Parameters

    • text: string
    • targetCharacters: string[] = ...

    Returns string

trimStartCharacters

  • trimStartCharacters(text: string, targetCharacters?: string[]): string
  • 대상 문자열 중 targetCharacters에 포함되는 문자를 Start Trim합니다. targetCharacters에 아무런 값을 주지 않는 경우에는 공백을 Trim 합니다.

    example
    trimStartCharacters('    foo'); // foo
    trimStartCharacters('--foo', ['-']); // foo
    

    Parameters

    • text: string
    • targetCharacters: string[] = ...

    Returns string

uniq

  • uniq<T>(arr: T[]): T[]
  • 인자로 주어진 배열 내의 중복된 원소를 제거합니다. 같은 값을 가진 원소를 걸러내기 때문에 Object와 같은 자료형의 중복은 체크하지 않습니다.

    example
    uniq([1, 1, 2, 3, 5, 5, 7, 'foo', 'bar', 'bar']);
    // [1, 2, 3, 5, 7, 'foo', 'bar']
    

    Type parameters

    • T

    Parameters

    • arr: T[]

    Returns T[]

uniqBy

  • uniqBy<T, U>(arr: T[], converter: (item: T) => U): U[]
  • 두 번째 인자인 converter 함수로 배열의 원소를 매핑한 후, 중복된 원소를 제거합니다. 같은 값을 가진 원소를 걸러내기 때문에 Object와 같은 자료형의 중복은 체크하지 않습니다.

    example
    uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);
    // [1, 2, 3, 5, 7]
    

    Type parameters

    • T

    • U

    Parameters

    • arr: T[]
    • converter: (item: T) => U
        • (item: T): U
        • Parameters

          • item: T

          Returns U

    Returns U[]

unzip

  • unzip<T>(array: T[][]): (T | undefined)[][]
  • 인자로 주어진 배열을 순회하며, 내부 배열의 같은 인덱스에 있는 원소들끼리 그룹핑합니다.

    주어진 배열들 중 가장 긴 배열의 길이를 기준으로 순회하기 때문에, 만약 해당 인덱스에 대응하는 원소가 없다면 그 자리는 undefined로 채워집니다.

    example
    unzip(['a', 1, true], ['b', 2, false]]);
    // [['a', 'b'], [1, 2], [true, false]]
    
    unzip([['a', 1, true, 2], ['b', 2, false]]);
    // [['a', 'b'], [1, 2], [true, false], [2, undefined]]
    

    Type parameters

    • T

    Parameters

    • array: T[][]

    Returns (T | undefined)[][]

upperFirstLetter

  • upperFirstLetter(text: string): string
  • 주어진 문자열의 첫 번째 문자를 대문자로 변경합니다

    example
    upperFirstLetter('fred'); // Fred
    

    Parameters

    • text: string

    Returns string

zip

  • zip<T1, T2>(array1: T1[], array2: T2[]): [T1 | undefined, T2 | undefined][]
  • zip<T1, T2, T3>(array1: T1[], array2: T2[], array3: T3[]): [T1 | undefined, T2 | undefined, T3 | undefined][]
  • zip<T1, T2, T3, T4>(array1: T1[], array2: T2[], array3: T3[], array4: T4[]): [T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined][]
  • zip<T1, T2, T3, T4, T5>(array1: T1[], array2: T2[], array3: T3[], array4: T4[], array5: T5[]): [T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined][]
  • 인자로 주어진 배열들의 같은 인덱스에 있는 원소들끼리 그룹핑합니다.

    순회는 인자로 주어진 배열들 중 가장 긴 배열의 길이를 기준으로 수행되며, 만약 해당 인덱스에 대응하는 원소가 없다면 그 자리는 undefined로 채워집니다.

    example
    zip(['a', 'b'], [1, 2]);
    // [['a', 1], ['b', 2]]
    
    zip(['a', 'b'], [1, 2, 3]);
    // [['a', 1], ['b', 2], [undefined, 3]]
    

    Type parameters

    • T1

    • T2

    Parameters

    • array1: T1[]
    • array2: T2[]

    Returns [T1 | undefined, T2 | undefined][]

  • Type parameters

    • T1

    • T2

    • T3

    Parameters

    • array1: T1[]
    • array2: T2[]
    • array3: T3[]

    Returns [T1 | undefined, T2 | undefined, T3 | undefined][]

  • Type parameters

    • T1

    • T2

    • T3

    • T4

    Parameters

    • array1: T1[]
    • array2: T2[]
    • array3: T3[]
    • array4: T4[]

    Returns [T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined][]

  • Type parameters

    • T1

    • T2

    • T3

    • T4

    • T5

    Parameters

    • array1: T1[]
    • array2: T2[]
    • array3: T3[]
    • array4: T4[]
    • array5: T5[]

    Returns [T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined][]

Generated using TypeDoc