isFloat
检查值是否为浮点数类型。
基础用法
typescript
import { isFloat } from 'radash'
console.log(isFloat(3.14)) // true
console.log(isFloat(42)) // false
console.log(isFloat('3.14')) // false
console.log(isFloat(NaN)) // false
console.log(isFloat(Infinity)) // false语法
typescript
function isFloat(value: any): value is number参数
value(any): 要检查的值
返回值
返回一个布尔值，如果值是浮点数则返回 true，否则返回 false。同时作为TypeScript类型守卫。
示例
基本类型检查
typescript
import { isFloat } from 'radash'
// 浮点数
console.log(isFloat(3.14)) // true
console.log(isFloat(-2.5)) // true
console.log(isFloat(0.0)) // true
console.log(isFloat(1.0)) // true
// 整数
console.log(isFloat(42)) // false
console.log(isFloat(0)) // false
console.log(isFloat(-10)) // false
// 字符串
console.log(isFloat('3.14')) // false
console.log(isFloat('42')) // false
console.log(isFloat('')) // false
// 其他类型
console.log(isFloat(null)) // false
console.log(isFloat(undefined)) // false
console.log(isFloat(true)) // false
console.log(isFloat(false)) // false
console.log(isFloat([])) // false
console.log(isFloat({})) // false特殊数值检查
typescript
import { isFloat } from 'radash'
// NaN
console.log(isFloat(NaN)) // false
// 无穷大
console.log(isFloat(Infinity)) // false
console.log(isFloat(-Infinity)) // false
// 最大/最小值
console.log(isFloat(Number.MAX_VALUE)) // false
console.log(isFloat(Number.MIN_VALUE)) // true (最小正浮点数)
console.log(isFloat(Number.MAX_SAFE_INTEGER)) // false
console.log(isFloat(Number.MIN_SAFE_INTEGER)) // false边界值检查
typescript
import { isFloat } from 'radash'
// 接近整数的浮点数
console.log(isFloat(1.0000000000000001)) // true
console.log(isFloat(1.0)) // true
console.log(isFloat(1.0000000000000000)) // true
// 科学计数法
console.log(isFloat(1.23e-4)) // true
console.log(isFloat(1.23e+4)) // true
console.log(isFloat(1.23E4)) // true
// 十六进制
console.log(isFloat(0x1.23p4)) // true
console.log(isFloat(0x1.23P4)) // true类型守卫使用
typescript
import { isFloat } from 'radash'
function processNumber(value: unknown) {
if (isFloat(value)) {
// TypeScript 知道 value 是浮点数
console.log(`Processing float: ${value}`)
return value * 2
}
if (typeof value === 'number') {
// 处理整数
console.log(`Processing integer: ${value}`)
return value * 2
}
console.log('Not a number')
return null
}
console.log(processNumber(3.14)) // Processing float: 3.14 6.28
console.log(processNumber(42)) // Processing integer: 42 84
console.log(processNumber('abc')) // Not a number null数组过滤
typescript
import { isFloat } from 'radash'
const mixedArray = [1, 2.5, 3, 4.7, '5', 6.0, 7, 8.9, null, undefined]
const floats = mixedArray.filter(isFloat)
console.log(floats) // [2.5, 4.7, 6.0, 8.9]
const nonFloats = mixedArray.filter(item => !isFloat(item))
console.log(nonFloats) // [1, 3, '5', 7, null, undefined]对象属性检查
typescript
import { isFloat } from 'radash'
const data = {
price: 19.99,
quantity: 5,
rating: 4.5,
id: 123,
name: 'Product A',
weight: 2.5,
isAvailable: true
}
const floatProperties = Object.entries(data)
.filter(([key, value]) => isFloat(value))
.map(([key, value]) => ({ key, value }))
console.log(floatProperties)
// [
// { key: 'price', value: 19.99 },
// { key: 'rating', value: 4.5 },
// { key: 'weight', value: 2.5 }
// ]表单验证
typescript
import { isFloat } from 'radash'
interface FormData {
price: unknown
quantity: unknown
discount: unknown
}
function validateForm(data: FormData) {
const errors: string[] = []
if (!isFloat(data.price)) {
errors.push('Price must be a valid decimal number')
}
if (typeof data.quantity !== 'number' || !Number.isInteger(data.quantity)) {
errors.push('Quantity must be a whole number')
}
if (data.discount !== null && data.discount !== undefined) {
if (!isFloat(data.discount)) {
errors.push('Discount must be a valid decimal number')
}
}
return errors
}
console.log(validateForm({
price: 19.99,
quantity: 5,
discount: 0.1
})) // []
console.log(validateForm({
price: '19.99',
quantity: 5.5,
discount: '10%'
})) // ['Price must be a valid decimal number', 'Quantity must be a whole number', 'Discount must be a valid decimal number']API响应处理
typescript
import { isFloat } from 'radash'
interface ApiResponse {
id: number
price: unknown
rating: unknown
score: unknown
}
function processApiResponse(response: ApiResponse) {
const processed = {
id: response.id,
price: isFloat(response.price) ? response.price : 0,
rating: isFloat(response.rating) ? response.rating : 0,
score: isFloat(response.score) ? response.score : 0
}
return processed
}
const response1: ApiResponse = {
id: 1,
price: 29.99,
rating: 4.5,
score: 85.7
}
const response2: ApiResponse = {
id: 2,
price: '29.99',
rating: '4.5',
score: null
}
console.log(processApiResponse(response1))
// { id: 1, price: 29.99, rating: 4.5, score: 85.7 }
console.log(processApiResponse(response2))
// { id: 2, price: 0, rating: 0, score: 0 }数学计算
typescript
import { isFloat } from 'radash'
function calculateAverage(values: unknown[]): number {
const validFloats = values.filter(isFloat)
if (validFloats.length === 0) {
return 0
}
const sum = validFloats.reduce((acc, val) => acc + val, 0)
return sum / validFloats.length
}
const measurements = [1.5, 2.3, 3, 4.7, 'invalid', 5.1, null, 6.2]
console.log(calculateAverage(measurements)) // 3.76数据库查询结果处理
typescript
import { isFloat } from 'radash'
interface DatabaseRecord {
id: number
value: unknown
amount: unknown
percentage: unknown
}
function sanitizeDatabaseRecord(record: DatabaseRecord) {
return {
id: record.id,
value: isFloat(record.value) ? record.value : 0,
amount: isFloat(record.amount) ? record.amount : 0,
percentage: isFloat(record.percentage) ? record.percentage : 0
}
}
const dbRecord: DatabaseRecord = {
id: 1,
value: 123.45,
amount: '67.89',
percentage: null
}
console.log(sanitizeDatabaseRecord(dbRecord))
// { id: 1, value: 123.45, amount: 0, percentage: 0 }配置文件处理
typescript
import { isFloat } from 'radash'
interface Config {
timeout: unknown
retryDelay: unknown
maxRetries: unknown
threshold: unknown
}
function validateConfig(config: Config) {
const errors: string[] = []
if (!isFloat(config.timeout)) {
errors.push('timeout must be a decimal number')
}
if (!isFloat(config.retryDelay)) {
errors.push('retryDelay must be a decimal number')
}
if (typeof config.maxRetries !== 'number' || !Number.isInteger(config.maxRetries)) {
errors.push('maxRetries must be a whole number')
}
if (!isFloat(config.threshold)) {
errors.push('threshold must be a decimal number')
}
return errors
}
const validConfig: Config = {
timeout: 5000.5,
retryDelay: 1000.0,
maxRetries: 3,
threshold: 0.95
}
const invalidConfig: Config = {
timeout: '5000',
retryDelay: '1000ms',
maxRetries: 3.5,
threshold: '95%'
}
console.log(validateConfig(validConfig)) // []
console.log(validateConfig(invalidConfig)) // ['timeout must be a decimal number', 'retryDelay must be a decimal number', 'maxRetries must be a whole number', 'threshold must be a decimal number']科学计算
typescript
import { isFloat } from 'radash'
function calculateStandardDeviation(values: unknown[]): number {
const validFloats = values.filter(isFloat)
if (validFloats.length < 2) {
return 0
}
const mean = validFloats.reduce((sum, val) => sum + val, 0) / validFloats.length
const squaredDifferences = validFloats.map(val => Math.pow(val - mean, 2))
const variance = squaredDifferences.reduce((sum, val) => sum + val, 0) / validFloats.length
return Math.sqrt(variance)
}
const measurements = [1.5, 2.3, 3.1, 4.7, 5.2, 'invalid', 6.1, null, 7.3]
console.log(calculateStandardDeviation(measurements)) // 2.05游戏开发
typescript
import { isFloat } from 'radash'
interface PlayerStats {
health: unknown
mana: unknown
experience: unknown
level: unknown
}
function validatePlayerStats(stats: PlayerStats) {
const validStats: Partial<PlayerStats> = {}
if (isFloat(stats.health)) {
validStats.health = stats.health
}
if (isFloat(stats.mana)) {
validStats.mana = stats.mana
}
if (isFloat(stats.experience)) {
validStats.experience = stats.experience
}
if (typeof stats.level === 'number' && Number.isInteger(stats.level)) {
validStats.level = stats.level
}
return validStats
}
const playerStats: PlayerStats = {
health: 100.0,
mana: 50.5,
experience: 1250.75,
level: 10
}
console.log(validatePlayerStats(playerStats))
// { health: 100.0, mana: 50.5, experience: 1250.75, level: 10 }金融计算
typescript
import { isFloat } from 'radash'
interface FinancialData {
principal: unknown
rate: unknown
time: unknown
amount: unknown
}
function calculateInterest(data: FinancialData): number {
if (!isFloat(data.principal) || !isFloat(data.rate) || !isFloat(data.time)) {
return 0
}
return data.principal * data.rate * data.time
}
function validateFinancialData(data: FinancialData) {
const errors: string[] = []
if (!isFloat(data.principal)) {
errors.push('Principal must be a decimal number')
}
if (!isFloat(data.rate)) {
errors.push('Rate must be a decimal number')
}
if (!isFloat(data.time)) {
errors.push('Time must be a decimal number')
}
if (!isFloat(data.amount)) {
errors.push('Amount must be a decimal number')
}
return errors
}
const loanData: FinancialData = {
principal: 10000.0,
rate: 0.05,
time: 2.5,
amount: 11250.0
}
console.log(calculateInterest(loanData)) // 1250
console.log(validateFinancialData(loanData)) // []注意事项
- 整数检查: 整数不被认为是浮点数
- NaN检查: NaN不被认为是浮点数
- 无穷大: Infinity和-Infinity不被认为是浮点数
- 类型守卫: 作为TypeScript类型守卫使用
- 性能: 检查速度很快，适合高频使用
与其他方法的区别
isFloat(): 检查是否为浮点数isNumber(): 检查是否为数字（包括整数）Number.isInteger(): 检查是否为整数typeof value === 'number': 检查是否为数字类型
实际应用场景
- 表单验证: 验证用户输入的浮点数
- API处理: 处理API响应中的浮点数字段
- 数据库操作: 验证数据库字段类型
- 数学计算: 确保计算参数为浮点数
- 金融应用: 处理货币和利率计算
- 科学计算: 处理测量和统计数据