【源码学习】Radash（六）Number

1
import { inRange } from 'radash'
2

3
inRange(10, 0, 20) // true
4
inRange(9.99, 0, 10) // true
5
inRange(Math.PI, 0, 3.15) // true
6
inRange(10, 10, 20) // true
7
inRange(10, 0, 10) // false
8

9
inRange(1, 2) // true
10
inRange(1, 0) // false

1
export function inRange(number: number, end: number): boolean
2
export function inRange(number: number, start: number, end: number): boolean
3
export function inRange(number: number, start: number, end?: number): boolean {
4
  // isTypeSafe 变量用于存储类型检查的结果
5
  const isTypeSafe =
6
    typeof number === 'number' &&
7
    typeof start === 'number' &&
8
    (typeof end === 'undefined' || typeof end === 'number')
9

10
  // 类型检查：
11
  // 首先检查 number、start 和 end 是否都是数字类型
12
  // 如果不是，函数立即返回 false。
13
  if (!isTypeSafe) {
14
    return false
15
  }
16

17
  // 参数调整：
18
  // 如果 end 参数未定义，则将 end 设置为 start，并将 start 设置为 0
19
  // 这样，函数可以处理只有一个参数的情况，即检查数字是否在 0 到 start 之间
20
  if (typeof end === 'undefined') {
21
    end = start
22
    start = 0
23
  }
24

25
  // 判断逻辑：
26
  // 使用 Math.min(start, end) 和 Math.max(start, end) 来确定范围的起始和结束值，确保 start 小于等于 end。
27
  // 检查 number 是否大于等于范围的起始值且小于范围的结束值。如果是，返回 true；否则，返回 false
28
  return number >= Math.min(start, end) && number < Math.max(start, end)
29
}

1
import { toFloat } from 'radash'
2

3
toFloat(0) // => 0.0
4
toFloat(null) // => 0.0
5
toFloat(null, 3.33) // => 3.33

1
export const toFloat = <T extends number | null = number>(
2
  value: any,
3
  defaultValue?: T
4
): number | T => {
5
  // 定义一个常量 def，用于存储默认值
6
  const def = defaultValue === undefined ? 0.0 : defaultValue
7
  // 边界判断
8
  // 检查 value 是否为 null 或 undefined，如果是，则返回默认值 def
9
  if (value === null || value === undefined) {
10
    return def
11
  }
12
  // 尝试将 value 转换为浮点数，并将结果存储在 result 中。
13
  const result = parseFloat(value)
14

15
  // 检查 result 是否为 NaN（非数字）
16
  // 如果 result 是 NaN，则返回默认值 def。
17
  // 否则，返回转换后的浮点数 result
18
  return isNaN(result) ? def : result
19
}

1
import { toInt } from 'radash'
2

3
toInt(0) // => 0
4
toInt(null) // => 0
5
toInt(null, 3) // => 3

1
export const toInt = <T extends number | null = number>(
2
  value: any,
3
  defaultValue?: T
4
): number | T => {
5
  // 定义一个常量 def，用于存储默认值
6
  const def = defaultValue === undefined ? 0 : defaultValue
7
  // 边界判断，同上
8
  if (value === null || value === undefined) {
9
    return def
10
  }
11
  // 尝试将 value 转换为整数，并将结果存储在 result 中
12
  const result = parseInt(value)
13
  return isNaN(result) ? def : result
14
}