【源码学习】Radash（二）String & Random

1
export const capitalize = (str: string): string => {
2
  // 函数在输入字符串为空或空字符串时返回空字符串
3
  // 这是一个良好的实践，有助于避免在后续处理中出现错误
4
  if (!str || str.length === 0) return ''
5
  const lower = str.toLowerCase()
6
  return lower.substring(0, 1).toUpperCase() + lower.substring(1, lower.length)
7
}

1
export const camel = (str: string): string => {
2
  const parts =
3
    str
4
      // 使用正则表达式，将输入字符串中的所有大写字母转换为小写字母
5
      ?.replace(/([A-Z])+/g, capitalize)
6
      // 并将非大写字母的连续字符组合分割为数组
7
      ?.split(/(?=[A-Z])|[\.\-\s_]/)
8
      .map(x => x.toLowerCase()) ?? []
9

10
  // 函数在输入字符串为空或空字符串时返回空字符串
11
  if (parts.length === 0) return ''
12
  // 函数在输入字符串只有一个字符时，直接返回该字符（大写的）
13
  if (parts.length === 1) return parts[0]
14

15
  // 使用reduce方法，将遍历后的字符串数组拼接成一个完整的字符串
16
  return parts.reduce((acc, part) => {
17
    // part.charAt(0) 拿到第一个字符，通过 toUpperCase() 变成大写
18
    // port.slice(1) 拿到除了第一个字符以外的所有字符
19
    // 最后拼接起来
20
    return `${acc}${part.charAt(0).toUpperCase()}${part.slice(1)}`
21
  })
22
}

1
export const snake = (
2
  str: string,
3
  options?: {
4
    splitOnNumber?: boolean
5
  }
6
): string => {
7
  const parts =
8
    str
9
      // 使用正则匹配大写字母组成的单词，并将这些单词转换为小写
10
      ?.replace(/([A-Z])+/g, capitalize)
11
      // 然后，使用split方法将字符串分割成一个数组
12
      // 并将所有的点、减号、空格和下划线替换为空格。
13
      .split(/(?=[A-Z])|[\.\-\s_]/)
14
      // 使用map方法将数组中的每个元素转换为小写
15
      .map(x => x.toLowerCase()) ?? []
16
  // 如果数组为空，则返回空字符串
17
  if (parts.length === 0) return ''
18
  // 如果数组只有一个元素，则直接返回该元素。
19
  if (parts.length === 1) return parts[0]
20

21
  // 使用reduce方法将数组中的元素连接成一个字符串，每个元素之间使用下划线连接。
22
  const result = parts.reduce((acc, part) => {
23
    return `${acc}_${part.toLowerCase()}`
24
  })
25
  return options?.splitOnNumber === false
26
    ? result
27
    : // 匹配一个字母后跟一个数字的情况，并将这些匹配到的字符串替换为下划线分隔的形式
28
      result.replace(/([A-Za-z]{1}[0-9]{1})/, val => `${val[0]!}_${val[1]!}`)
29
}

1
export const dash = (str: string): string => {
2
  const parts =
3
    str
4
      // 匹配大写字母组成的单词（capitalize）
5
      // 将匹配到的单词的首字母转换为小写，并将其余字母保持原样
6
      ?.replace(/([A-Z])+/g, capitalize)
7
      // 根据正则表达式匹配到的单词和各种标点符号来分割字符串
8
      ?.split(/(?=[A-Z])|[\.\-\s_]/)
9
      // 将分割后的字符串数组中的每个字符串转换为小写
10
      .map(x => x.toLowerCase()) ?? []
11

12
  // 如果分割后的字符串数组为空，则返回空字符串
13
  if (parts.length === 0) return ''
14
  if (parts.length === 1) return parts[0]
15
  // 否则，使用reduce方法将字符串数组中的每个字符串连成一个字符串，每个字符串之间用连字符(-)分隔
16
  return parts.reduce((acc, part) => {
17
    return `${acc}-${part.toLowerCase()}`
18
  })
19
}

1
export const title = (str: string | null | undefined): string => {
2
  if (!str) return ''
3
  return (
4
    str
5
      // 保留大小写和空格，并去除其他字符
6
      .split(/(?=[A-Z])|[\.\-\s_]/)
7
      // 使用map和filter方法过滤掉空字符串
8
      .map(s => s.trim())
9
      .filter(s => !!s)
10
      // 使用capitalize函数将每个单词的首字母大写
11
      .map(s => capitalize(s.toLowerCase()))
12
      // 使用join方法将剩余的字符连接成一个字符串
13
      .join(' ')
14
  )
15
}

1
export const template = (str: string, data: Record<string, any>, regex = /\{\{(.+?)\}\}/g) => {
2
  // 使用Array.from()方法将match数组转换为一个新的数组，并将其作为参数传递给reduce()方法。
3
  // 匹配字符串str中的占位符，并将它们存储在match数组中
4
  return (
5
    Array.from(str.matchAll(regex))
6
      // 遍历match数组
7
      .reduce((acc, match) => {
8
        // 对于每个匹配项，将传入data[match[1]] 替换当前 match[0]
9
        return acc.replace(match[0], data[match[1]])
10
      }, str)
11
  )
12
}

1
export const trim = (str: string | null | undefined, charsToTrim: string = ' ') => {
2
  // 空校验
3
  if (!str) return ''
4
  // 字符集处理：将charsToTrim转换为一个正则表达式可识别的字符集
5
  // 通过replace方法将所有非字母、数字和空格的字符替换为\\加相应字符
6
  const toTrim = charsToTrim.replace(/[\W]{1}/g, '\\$&')
7
  // 使用RegExp构造函数创建一个正则表达式对象，匹配：
8
  // 以 toTrim 开头 或者
9
  // 以 toTrim 结尾 的字符串
10
  // g 标志表示全局搜索
11
  const regex = new RegExp(`^[${toTrim}]+|[${toTrim}]+$`, 'g')
12
  // 使用replace方法将str中的匹配项替换为空字符串
13
  return str.replace(regex, '')
14
}