inRange

Check whether a number is within a specified range.

Syntax

inRange(
  value: number,
  min: number,
  max: number,
  inclusive?: boolean
): boolean

Parameters

• value (number): The number to check
• min (number): The minimum value of the range
• max (number): The maximum value of the range
• inclusive (boolean, optional): Whether to include the boundary values, default is true

Return Value

• boolean: Returns true if the number is within the range, otherwise returns false

Examples

Basic Usage

import { inRange } from 'radash'

inRange(5, 1, 10) // true
inRange(1, 1, 10) // true
inRange(10, 1, 10) // true
inRange(0, 1, 10) // false
inRange(11, 1, 10) // false

Excluding Boundary Values

import { inRange } from 'radash'

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

Handling Negative Numbers

import { inRange } from 'radash'

inRange(-5, -10, 0) // true
inRange(-10, -10, 0) // true
inRange(0, -10, 0) // true
inRange(-11, -10, 0) // false
inRange(1, -10, 0) // false

Handling Decimals

import { inRange } from 'radash'

inRange(3.5, 1, 5) // true
inRange(1.0, 1, 5) // true
inRange(5.0, 1, 5) // true
inRange(0.5, 1, 5) // false
inRange(5.5, 1, 5) // false

Handling Zero

import { inRange } from 'radash'

inRange(0, 0, 10) // true
inRange(0, -5, 5) // true
inRange(0, 1, 10) // false
inRange(0, -10, -1) // false

Handling Equal Min and Max

import { inRange } from 'radash'

inRange(5, 5, 5) // true
inRange(5, 5, 5, false) // false
inRange(4, 5, 5) // false
inRange(6, 5, 5) // false

Handling Negative Ranges

import { inRange } from 'radash'

inRange(-3, -5, -1) // true
inRange(-5, -5, -1) // true
inRange(-1, -5, -1) // true
inRange(-6, -5, -1) // false
inRange(0, -5, -1) // false

Handling Large Numbers

import { inRange } from 'radash'

inRange(1000000, 0, 2000000) // true
inRange(0, 0, 2000000) // true
inRange(2000000, 0, 2000000) // true
inRange(-1, 0, 2000000) // false
inRange(2000001, 0, 2000000) // false

Handling Floating Point Precision

import { inRange } from 'radash'

inRange(0.1 + 0.2, 0.3, 0.4) // true (0.30000000000000004)
inRange(0.3, 0.3, 0.4) // true
inRange(0.4, 0.3, 0.4) // true
inRange(0.2, 0.3, 0.4) // false
inRange(0.5, 0.3, 0.4) // false

Form Validation

import { inRange } from 'radash'

function validateAge(age: number): boolean {
  return inRange(age, 0, 120)
}

function validatePercentage(value: number): boolean {
  return inRange(value, 0, 100)
}

function validateTemperature(temp: number): boolean {
  return inRange(temp, -273.15, 1000000) // Absolute zero to extremely high temperature
}

validateAge(25) // true
validateAge(-1) // false
validateAge(150) // false

validatePercentage(50) // true
validatePercentage(0) // true
validatePercentage(100) // true
validatePercentage(101) // false

Array Index Checking

import { inRange } from 'radash'

function safeArrayAccess<T>(array: T[], index: number): T | undefined {
  if (inRange(index, 0, array.length - 1)) {
    return array[index]
  }
  return undefined
}

const arr = ['a', 'b', 'c', 'd']

safeArrayAccess(arr, 0) // 'a'
safeArrayAccess(arr, 2) // 'c'
safeArrayAccess(arr, 3) // 'd'
safeArrayAccess(arr, -1) // undefined
safeArrayAccess(arr, 4) // undefined

Color Value Validation

import { inRange } from 'radash'

function validateRGB(r: number, g: number, b: number): boolean {
  return inRange(r, 0, 255) && 
         inRange(g, 0, 255) && 
         inRange(b, 0, 255)
}

function validateAlpha(alpha: number): boolean {
  return inRange(alpha, 0, 1)
}

validateRGB(255, 128, 0) // true
validateRGB(256, 128, 0) // false
validateRGB(255, -1, 0) // false

validateAlpha(0.5) // true
validateAlpha(0) // true
validateAlpha(1) // true
validateAlpha(1.5) // false

Time Validation

import { inRange } from 'radash'

function validateHour(hour: number): boolean {
  return inRange(hour, 0, 23)
}

function validateMinute(minute: number): boolean {
  return inRange(minute, 0, 59)
}

function validateSecond(second: number): boolean {
  return inRange(second, 0, 59)
}

function validateMonth(month: number): boolean {
  return inRange(month, 1, 12)
}

function validateDay(day: number, month: number, year: number): boolean {
  const daysInMonth = new Date(year, month, 0).getDate()
  return inRange(day, 1, daysInMonth)
}

validateHour(12) // true
validateHour(24) // false

validateMonth(6) // true
validateMonth(13) // false

validateDay(15, 6, 2023) // true (June has 30 days)
validateDay(31, 6, 2023) // false

Game Logic

import { inRange } from 'radash'

class Game {
  private playerHealth = 100
  private playerPosition = { x: 0, y: 0 }
  private gameBounds = { width: 800, height: 600 }

  takeDamage(damage: number): void {
    if (inRange(damage, 0, 100)) {
      this.playerHealth = Math.max(0, this.playerHealth - damage)
    }
  }

  movePlayer(dx: number, dy: number): boolean {
    const newX = this.playerPosition.x + dx
    const newY = this.playerPosition.y + dy

    if (inRange(newX, 0, this.gameBounds.width) && 
        inRange(newY, 0, this.gameBounds.height)) {
      this.playerPosition.x = newX
      this.playerPosition.y = newY
      return true
    }
    return false
  }

  isAlive(): boolean {
    return inRange(this.playerHealth, 1, 100)
  }
}

Notes

1. Boundary Inclusion: Boundaries are included by default
2. Parameter Order: The order of min and max does not matter
3. Floating Point Numbers: Handles floating point precision issues correctly
4. Performance: Time complexity is O(1)

Differences from Other Functions

• inRange: Checks if a number is within a range
• clamp: Restricts a number within a range
• random: Generates a random number within a range

Performance

• Time Complexity: O(1)
• Space Complexity: O(1)
• Applicable Scenarios: Numeric validation, boundary checking