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. 配置驗證: 驗證配置文件中的字符串設置