typeor

Return default value if wrong type

Install

$ npm install typeor

API

strOr(v: unknown, defaultValue = ""): string

typeof v === "string" ? v : defaultValue

import { strOr } from 'typeor'

strOr("aaa", "bbb")
// "aaa"
strOr("", "bbb")
// ""
strOr(1, "bbb")
// "bbb"
strOr(null, "bbb")
// "bbb"
strOr(NaN, "bbb")
// "bbb"

strOr("abc")
// "abc"
strOr(10)
// ""

numOr(v: unknown, defaultValue = 0): number

typeof v === "number" ? v : defaultValue

|check|ok| |-|-| |NaN|:o:|

import { numOr } from 'typeor'

numOr(0, 2)
// 0
numOr(100, 2)
// 100
numOr(-1, 2)
// -1

numOr("a", 2)
// 2
numOr(null, 2)
// 2
numOr(NaN, 2)
// NaN

  numOr(10)
// 10
  numOr("")
// 0

numHardOr(v: unknown, defaultValue = 0): number

|check|ok| |-|-| |NaN|:x:|

typeof v === "number" && !isNaN(v) ? v : defaultValue

numHardOr(10, 12)
// 10

numHardOr(NaN, 12)
// 12

numHardOr(10)
// 10
numHardOr(NaN)
// 0

boolOr(v: unknown, defaultValue = false): boolean

typeof v === "boolean" ? v : defaultValue

import { boolOr } from 'typeor'

boolOr(true, false)
// true

boolOr(1, false)
// false
boolOr(undefined, false)
// false

boolOr(true)
// true
boolOr(false)
// false
boolOr(10)
// false

objOr(v: unknown, defaultValue: object = {}): object

typeof v === "object" && !Array.isArray(v) && v !== null ? v : defaultValue

|check|ok| |-|-| |null|:x:| |[]|:x:|

import { objOr } from 'typeor'

objOr({ b: 2 }, { a: 1 })
// { b: 2 }

objOr(1, { a: 1 })
// { a: 1 }
objOr(null, { a: 1 })
// { a: 1 }
objOr([], { a: 1 })
// { a: 1 }

objOr({ a: 1 })
// { a: 1 }
objOr(false)
// {}

objNullOr(v: unknown, defaultValue: object = {}): object | null

typeof v === "object" ? v : defaultValue

|check|ok| |-|-| |null|:o:| |[]|:x:|

import { objNullOr } from 'typeor'

objNullOr({ b: 2 }, { a: 1 })
// { b: 2 }
objNullOr(1, { a: 1 })
// { a: 1 }
objNullOr(null, { a: 1 })
// null

objNullOr([], { a: 1 })
// { a: 1 }

objNullOr({ a: 1 })
// { a: 1 }
objNullOr(false)
// {}

funcOr(v: unknown, defaultValue: Function): Function

typeof v === "function" ? v : defaultValue

import { funcOr } from 'typeor'

funcOr(() => 1, () => 2))
// () => 1
funcOr(true, () => 2))
// () => 2

arrayOr(v: unknown, defaultValue: any[] = []): any[]

Array.isArray(v) ? v : defaultValue

import { arrayOr } from 'typeor'

arrayOr([1], [2])
// [1]
arrayOr([1, 2], [2])
// [1]

arrayOr(100, [2])
// [2]
arrayOr({}, [2])
// [2]

arrayOr([1])
// [1]
arrayOr(false)
// []