fenzhi-utils/globalMethods/CustomString/CustomHideStrGeneral.js

分值前端项目的js函数库

import { CustomGetTypeOf } from '../CustomPublic/CustomGetTypeOf.js';

/**
 * 判断一个数组是否是正序的二维数组
 * @param {*} arr
 * @returns {boolean}
 */
function IsAscendingOrderArr(arr = []) {
  if (!arr.length) return false;
  let flag = true;
  arr.forEach((item) => {
    let flag_01 = CustomGetTypeOf(item[0]) === 'number';
    let flag_02 = CustomGetTypeOf(item[1]) === 'number';
    let flag_03 = Number.isInteger(item[0]) && item[0] > -1;
    let flag_04 = Number.isInteger(item[1]) && item[1] > -1;
    let flag_05 = item[0] <= item[1];
    if (!(flag_01 && flag_02 && flag_03 && flag_04 && flag_05)) {
      flag = false;
    }
  });
  return flag;
}

/**
 * 判断是否一维数字数组
 * @param {array} arr
 * @returns {boolean}
 */
function OnedimensionalNumberArray(arr = []) {
  if (!arr.length) return false;
  let flag = true;
  arr.forEach((item) => {
    let flag_01 = CustomGetTypeOf(item) === 'number';
    let flag_02 = Number.isInteger(item); // 判断是否是整数
    let flag_03 = item > -1;
    if (!(flag_01 && flag_02 && flag_03)) {
      flag = false;
    }
  });
  return flag;
}

/**
 * 字符串处理的通用函数
 * @param {string} processStr -- 传入的字符串
 * @param {number,array} param_1
 * @param {nunber,string} param_2
 * @param {nunber} param_3
 * @returns {string}
 */
/*
// 动态替换索引位置的字符
CustomHideStrGeneral('abcdefghijklmn',[0,1,4,5,6],'x');// '$$cd$$$hijklmn'
// 替换连续位置的字符
CustomHideStrGeneral('abcdefghijklmn',1,5,'x');// 'a$$$$$ghijklmn'
// 替换分段索引位置的字符
CustomHideStrGeneral('abcdefghijklmn',[[0,2],[4,6]],'x');// '$$$d$$$hijklmn'
 */
export function CustomHideStrGeneral(
  processStr = '',
  param_1, //[3,5]
  param_2 = '*',
  param_3 = '*'
) {
  try {
    if (CustomGetTypeOf(processStr) !== 'string') {
      throw new Error('请传入字符串');
    }
    if (!processStr.length) {
      return processStr;
    }

    if (CustomGetTypeOf(param_1) === 'array') {
      if (OnedimensionalNumberArray(param_1)) {
        // 纯一维数字数组
        return processStr.split('').reduce((prev, item, index) => {
          return (prev += param_1.includes(index) ? param_2 : item);
        }, '');
      } else if (IsAscendingOrderArr(param_1)) {
        // 纯二维数字数组
        param_1.forEach((item_01) => {
          processStr = processStr.split('').reduce((prev, item_02, index) => {
            return (prev +=
              item_01[0] <= index && index <= item_01[1] ? param_2 : item_02);
          }, '');
        });
        return processStr;
      } else {
        throw new Error('请检查数组格式');
      }
    } else if (CustomGetTypeOf(param_1) === 'number') {
      let flag_01 = Number.isInteger(param_1); // 判断是否是整数
      let flag_02 = Number.isInteger(param_2); // 判断是否是整数
      if (CustomGetTypeOf(param_2) === 'number' && flag_01 && flag_02) {
        if (param_1 > param_2) {
          throw new Error('字符串截取开始位置不能大于结束位置');
        }
        param_1 = param_1 > 0 ? param_1 : 0;
        param_2 = param_2 > processStr.length ? processStr.length : param_2;
        return processStr.split('').reduce((prev, item, index) => {
          return (prev +=
            param_1 <= index && index <= param_2 ? param_3 : item);
        }, '');
      } else {
        throw new Error('第二个参数、第三个参数需为非负整数');
      }
    } else {
      return processStr;
    }
  } catch (err) {
    console.log(err);
  }
}