isString

检查值是否为字符串类型。

基础用法

import { isString } from 'radash'

console.log(isString('hello'))        // true
console.log(isString(''))             // true
console.log(isString(123))            // false
console.log(isString(true))           // false
console.log(isString(null))           // false

语法

function isString(value: any): value is string

参数

• value (any): 要检查的值

返回值

返回一个布尔值，表示该值是否为字符串类型。这是一个类型守卫函数。

示例

基本字符串检查

import { isString } from 'radash'

// 普通字符串
console.log(isString('hello'))        // true
console.log(isString('world'))        // true
console.log(isString('123'))          // true
console.log(isString('true'))         // true

// 空字符串
console.log(isString(''))             // true
console.log(isString('   '))          // true

// 特殊字符串
console.log(isString('Hello World'))  // true
console.log(isString('你好'))          // true
console.log(isString('123.45'))       // true

处理其他类型

import { isString } from 'radash'

// 数字
console.log(isString(123))            // false
console.log(isString(3.14))           // false
console.log(isString(0))              // false
console.log(isString(NaN))            // false

// 布尔值
console.log(isString(true))           // false
console.log(isString(false))          // false

// null 和 undefined
console.log(isString(null))           // false
console.log(isString(undefined))      // false

// 对象和数组
console.log(isString({}))             // false
console.log(isString([]))             // false
console.log(isString({ name: 'Alice' })) // false

// 函数
console.log(isString(() => {}))       // false
console.log(isString(function() {}))  // false

// Symbol
console.log(isString(Symbol()))       // false

类型守卫用法

import { isString } from 'radash'

function processValue(value: unknown) {
  if (isString(value)) {
    // TypeScript 知道 value 是 string 类型
    return value.toUpperCase()
  }
  
  return 'Not a string'
}

console.log(processValue('hello'))    // 'HELLO'
console.log(processValue(123))        // 'Not a string'
console.log(processValue(null))       // 'Not a string'

数组过滤

import { isString } from 'radash'

const mixedArray = ['hello', 123, 'world', true, '', null, 'test']

const strings = mixedArray.filter(isString)
console.log(strings) // ['hello', 'world', '', 'test']

// 计算字符串的总长度
const totalLength = mixedArray
  .filter(isString)
  .reduce((acc, str) => acc + str.length, 0)

console.log(totalLength) // 14 (5 + 5 + 0 + 4)

表单验证

import { isString } from 'radash'

function validateFormData(data: Record<string, any>) {
  const errors: string[] = []
  
  if (!isString(data.name) || data.name.trim() === '') {
    errors.push('Name must be a non-empty string')
  }
  
  if (!isString(data.email) || !data.email.includes('@')) {
    errors.push('Email must be a valid string with @ symbol')
  }
  
  if (!isString(data.phone) || data.phone.length < 10) {
    errors.push('Phone must be a string with at least 10 characters')
  }
  
  return errors
}

const formData = {
  name: 'Alice',
  email: 'alice@example.com',
  phone: '1234567890'
}

const errors = validateFormData(formData)
console.log(errors) // []

const invalidFormData = {
  name: '', // 空字符串
  email: 123, // 数字
  phone: '123' // 太短
}

const invalidErrors = validateFormData(invalidFormData)
console.log(invalidErrors) // ['Name must be a non-empty string', 'Email must be a valid string with @ symbol', 'Phone must be a string with at least 10 characters']

API响应处理

import { isString } from 'radash'

function processApiResponse(response: any) {
  const processed = {
    message: isString(response.message) ? response.message : 'No message',
    error: isString(response.error) ? response.error : null,
    data: isString(response.data) ? JSON.parse(response.data) : response.data
  }
  
  return processed
}

const apiResponse = {
  message: 'Success',
  error: null,
  data: { id: 1, name: 'Alice' }
}

const processed = processApiResponse(apiResponse)
console.log(processed) // { message: 'Success', error: null, data: { id: 1, name: 'Alice' } }

const errorResponse = {
  message: 500, // 数字
  error: 'Internal server error',
  data: null
}

const errorProcessed = processApiResponse(errorResponse)
console.log(errorProcessed) // { message: 'No message', error: 'Internal server error', data: null }

字符串处理

import { isString } from 'radash'

function safeStringOperation(value: unknown, operation: 'uppercase' | 'lowercase' | 'trim' | 'length') {
  if (!isString(value)) {
    throw new Error('Value must be a string')
  }
  
  switch (operation) {
    case 'uppercase':
      return value.toUpperCase()
    case 'lowercase':
      return value.toLowerCase()
    case 'trim':
      return value.trim()
    case 'length':
      return value.length
    default:
      throw new Error('Invalid operation')
  }
}

console.log(safeStringOperation('hello', 'uppercase')) // 'HELLO'
console.log(safeStringOperation('WORLD', 'lowercase')) // 'world'
console.log(safeStringOperation('  test  ', 'trim'))   // 'test'
console.log(safeStringOperation('hello', 'length'))    // 5

try {
  safeStringOperation(123, 'uppercase')
} catch (error) {
  console.log(error.message) // 'Value must be a string'
}

配置验证

import { isString } from 'radash'

function validateConfig(config: any) {
  const errors: string[] = []
  
  const requiredStrings = [
    { key: 'apiUrl', minLength: 1 },
    { key: 'databaseUrl', minLength: 10 },
    { key: 'secretKey', minLength: 16 }
  ]
  
  for (const { key, minLength } of requiredStrings) {
    const value = config[key]
    
    if (!isString(value)) {
      errors.push(`${key} must be a string`)
    } else if (value.length < minLength) {
      errors.push(`${key} must be at least ${minLength} characters long`)
    }
  }
  
  return errors
}

const config = {
  apiUrl: 'https://api.example.com',
  databaseUrl: 'postgresql://localhost:5432/mydb',
  secretKey: 'my-secret-key-123'
}

const errors = validateConfig(config)
console.log(errors) // []

const invalidConfig = {
  apiUrl: 123, // 数字
  databaseUrl: 'short', // 太短
  secretKey: 'key' // 太短
}

const invalidErrors = validateConfig(invalidConfig)
console.log(invalidErrors) // ['apiUrl must be a string', 'databaseUrl must be at least 10 characters long', 'secretKey must be at least 16 characters long']

数据清理

import { isString } from 'radash'

function cleanStringData(data: any[]) {
  return data
    .filter(isString)
    .filter(str => str.trim() !== '')
    .map(str => str.trim())
}

const rawData = ['hello', '', 'world', '  test  ', 123, null, 'valid', '   ']

const cleanData = cleanStringData(rawData)
console.log(cleanData) // ['hello', 'world', 'test', 'valid']

类型安全的字符串操作

import { isString } from 'radash'

function formatUserInput(input: unknown): string {
  if (!isString(input)) {
    return ''
  }
  
  return input
    .trim()
    .toLowerCase()
    .replace(/[^a-z0-9\s]/g, '')
    .replace(/\s+/g, ' ')
}

console.log(formatUserInput('  Hello World!  ')) // 'hello world'
console.log(formatUserInput('User@123'))         // 'user123'
console.log(formatUserInput(123))                // ''
console.log(formatUserInput(null))               // ''

参数验证

import { isString } from 'radash'

function createUser(name: unknown, email: unknown, bio: unknown) {
  if (!isString(name) || name.trim() === '') {
    throw new Error('Name must be a non-empty string')
  }
  
  if (!isString(email) || !email.includes('@')) {
    throw new Error('Email must be a valid string with @ symbol')
  }
  
  const userBio = isString(bio) ? bio.trim() : ''
  
  return {
    name: name.trim(),
    email: email.toLowerCase(),
    bio: userBio,
    createdAt: new Date()
  }
}

try {
  const user = createUser('Alice', 'alice@example.com', 'Software developer')
  console.log(user) // { name: 'Alice', email: 'alice@example.com', bio: 'Software developer', createdAt: Date }
} catch (error) {
  console.log(error.message)
}

try {
  createUser('', 'invalid-email', 123) // 无效的输入
} catch (error) {
  console.log(error.message) // 'Name must be a non-empty string'
}

模板字符串处理

import { isString } from 'radash'

function processTemplate(template: unknown, data: Record<string, any>): string {
  if (!isString(template)) {
    return ''
  }
  
  return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
    return data[key] || match
  })
}

const template = 'Hello {{name}}, welcome to {{company}}!'
const data = {
  name: 'Alice',
  company: 'Tech Corp'
}

const result = processTemplate(template, data)
console.log(result) // 'Hello Alice, welcome to Tech Corp!'

const invalidTemplate = 123
const invalidResult = processTemplate(invalidTemplate, data)
console.log(invalidResult) // ''

字符串数组处理

import { isString } from 'radash'

function processStringArray(values: unknown[]): string[] {
  return values
    .filter(isString)
    .map(str => str.trim())
    .filter(str => str !== '')
}

const mixedValues = ['hello', '', 'world', '  test  ', 123, null, 'valid', '   ']

const stringArray = processStringArray(mixedValues)
console.log(stringArray) // ['hello', 'world', 'test', 'valid']

注意事项

1. 空字符串: isString('') 返回 true
2. 空白字符串: isString(' ') 返回 true
3. 类型守卫: 这是一个TypeScript类型守卫函数
4. 性能: 检查操作很快，适合频繁使用
5. 严格检查: 只接受真正的字符串类型

与其他方法的区别

• typeof value === 'string': 原生检查
• isString(): radash提供的字符串检查方法
• instanceof String: 检查String对象（不是原始字符串）

实际应用场景

1. 表单验证: 验证用户输入的字符串字段
2. API处理: 验证API响应中的字符串字段
3. 字符串操作: 确保操作的值是字符串类型
4. 数据清理: 过滤数组中的字符串
5. 配置验证: 验证配置文件中的字符串设置