文本加密

/**
 * 替换字符串中指定前缀和后缀之间的内容为 *
 * @param str - 要进行替换的字符串
 * @param options - 替换选项对象，包含前缀和后缀，默认为 { prefix: "关于", suffix: "纪要" }
 * @param options.prefix - 前缀，默认为 "关于"
 * @param options.suffix - 后缀，默认为 "纪要"
 * @returns 替换后的字符串
 */
export function replaceBetween(
  str: string,
  options: { prefix?: string; suffix?: string } = { prefix: '关于', suffix: '纪要' }
): string {
  const { prefix = '关于', suffix = '纪要' } = options
  const regex = new RegExp(`${prefix}(.*?)${suffix}`)
  const match = regex.exec(str)
  if (match) {
    const replaceStr = match[1].replace(/./g, '*')
    return str.replace(regex, `${prefix}${replaceStr}${suffix}`)
  } else {
    return str
  }
}

// 普通人名,去除两边空格  strList:string=>arr []=>str string
export function replaceName(nameStr: string) {
  if (!nameStr) return `*`
  const nameList = nameStr.split(',')
  // console.log('nameList :>> ', nameList)
  const _replaceChars = (str: string) => {
    if (str.length === 2) {
      return str[0] + '*'
    } else if (str.length === 3) {
      return str[0] + '*' + '*'
    } else {
      return str[0] + '*'.repeat(str.length - 1)
    }
  }
  return nameList.map((v: string) => _replaceChars(v.trim())).join()
}
// 暴力加密： 长度为2则最后一位为*，大于2则仅保留头尾中间全部为*  究极大招

export function encryptStr(nameStr: string) {
  if (nameStr.length === 1) return nameStr
  if (nameStr.length === 2) return nameStr[0] + '*'
  return nameStr[0] + '*'.repeat(nameStr.length - 2) + nameStr[nameStr.length - 1]
}

/**
 * 将文本中特定关键词前面的指定数量的字符替换为指定的字符串。
 * @param text - 待处理的文本。
 * @param options - 选项对象，包括 keyword、replaceCount 和 replacement 字段。
 *      mismatchList: 当文本不符合keyword，但是又须将指定词替换为*时使用，如：将`福州`两字替换为**
 * @param isNeedMismatchList - 是否确认mismatchList默认true，若为false，则当文本不符keyword会原文输出
 * @returns 处理后的文本。
 */
export function replacePrefix(
  text: string,
  options?: {
    keyword?: string
    replaceCount?: number
    replacement?: string
    mismatchList?: string[]
  },
  isNeedMismatchList: boolean = true
): string {
  // 默认选项
  const defaultOptions = {
    keyword: '(省|市|县|区|同志|任期|乡|镇|村|及|街道)',
    replaceCount: 2,
    replacement: '*',
    mismatchList: ['福州']
  }
  // 合并选项
  const { keyword, replaceCount, replacement, mismatchList } = { ...defaultOptions, ...options }
  let resultStr = text

  // 构造正则表达式模式
  const pattern = new RegExp(`(.{${replaceCount}})(${keyword})(?:(?!\\2).)*?`, 'g')

  if (pattern.test(text)) {
    // 替换匹配的部分
    const replacedText = resultStr.replace(pattern, (match, p1, p2) => {
      return replacement.repeat(replaceCount) + p2
    })
    resultStr = replacedText
  }
  // 如果文本中不存在匹配模式，
  // 如果文本中有`福州`,则替换为**
  // 否则直接返回原始文本
  if (!mismatchList.includes(resultStr) && isNeedMismatchList) {
    //有匹配词
    const regex = new RegExp(mismatchList.join('|'), 'g')
    let match
    while ((match = regex.exec(resultStr)) !== null) {
      const stars = replacement.repeat(match[0].length)
      resultStr = resultStr.replace(match[0], stars)
    }
    return resultStr
  }
  return resultStr
}

以上。