tools-for-js/lib/utils/string.js

基于babel构建的JavaScript前端工具库

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getStrLength = exports.fromCode = exports.encrypt = exports.decrypt = exports.checkPwdStrength = exports.checkCrypt = exports.checkCode = void 0;
exports.replacePath = replacePath;
exports.splitString = splitString;
exports.splitToFileName = splitToFileName;
exports.toCode = void 0;
var _random = require("./random");
var _common = require("./common");
var _utf8_encode = function _utf8_encode(string) {
  string = string ? string.toString() : '';
  string = string.replace(/\r\n/g, '\n');
  var utf_text = '';
  for (var n = 0; n < string.length; n++) {
    var c = string.charCodeAt(n);
    if (c < 128) {
      utf_text += String.fromCharCode(c);
    } else if (c > 127 && c < 2048) {
      utf_text += String.fromCharCode(c >> 6 | 192);
      utf_text += String.fromCharCode(c & 63 | 128);
    } else {
      utf_text += String.fromCharCode(c >> 12 | 224);
      utf_text += String.fromCharCode(c >> 6 & 63 | 128);
      utf_text += String.fromCharCode(c & 63 | 128);
    }
  }
  return utf_text;
};
var _utf8_decode = function _utf8_decode(utf_text) {
  utf_text = utf_text ? utf_text.toString() : '';
  var string = '';
  var i = 0;
  var c1 = 0;
  var c2 = 0;
  while (i < utf_text.length) {
    c1 = utf_text.charCodeAt(i);
    if (c1 < 128) {
      string += String.fromCharCode(c1);
      i++;
    } else if (c1 > 191 && c1 < 224) {
      c2 = utf_text.charCodeAt(i + 1);
      string += String.fromCharCode((c1 & 31) << 6 | c2 & 63);
      i += 2;
    } else {
      c2 = utf_text.charCodeAt(i + 1);
      var c3 = utf_text.charCodeAt(i + 2);
      string += String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
      i += 3;
    }
  }
  return string;
};

/*******
 * @description: 字符加密
 * @author: 琴时
 * @param {*} input
 * @param {String} key [盐值]
 * @param {Number} expires [有效期/毫秒|不传则永久有效]
 * @return {String} [''|null|undefined==>'']
 */
var encrypt = exports.encrypt = function encrypt(input, key, expires) {
  if ((0, _common.IsType)('Object', input) || (0, _common.IsType)('Array', input) || (0, _common.IsType)('Number', input)) {
    input = JSON.stringify(input);
  } else if (!input) return '';
  // 取65位字符
  var _keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
  var output = '';
  var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
  var i = 0;
  input = _utf8_encode(input);
  key = key || '';
  if (expires) {
    var et = Date.now() + Number(expires);
    input = "".concat(et, ":").concat(key, ":").concat(input);
  } else {
    input = "".concat((0, _random.randomCode)(6), ":").concat(key, ":").concat(input);
  }
  while (i < input.length) {
    chr1 = input.charCodeAt(i++);
    chr2 = input.charCodeAt(i++);
    chr3 = input.charCodeAt(i++);
    enc1 = chr1 >> 2;
    enc2 = (chr1 & 3) << 4 | chr2 >> 4;
    enc3 = (chr2 & 15) << 2 | chr3 >> 6;
    enc4 = chr3 & 63;
    if (isNaN(chr2)) {
      enc3 = enc4 = 64;
    } else if (isNaN(chr3)) {
      enc4 = 64;
    }
    output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
  }
  return output;
};

/*******
 * @description: 字符解密
 * @author: 琴时
 * @param {String} input
 * @param {String} key [盐值]
 * @return {String}
 */
var decrypt = exports.decrypt = function decrypt(input, key) {
  // 取65位字符
  var _keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
  var output = '';
  var chr1, chr2, chr3;
  var enc1, enc2, enc3, enc4;
  var i = 0;
  input = input ? input.toString() : '';
  input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
  while (i < input.length) {
    enc1 = _keyStr.indexOf(input.charAt(i++));
    enc2 = _keyStr.indexOf(input.charAt(i++));
    enc3 = _keyStr.indexOf(input.charAt(i++));
    enc4 = _keyStr.indexOf(input.charAt(i++));
    chr1 = enc1 << 2 | enc2 >> 4;
    chr2 = (enc2 & 15) << 4 | enc3 >> 2;
    chr3 = (enc3 & 3) << 6 | enc4;
    output = output + String.fromCharCode(chr1);
    if (enc3 != 64) {
      output = output + String.fromCharCode(chr2);
    }
    if (enc4 != 64) {
      output = output + String.fromCharCode(chr3);
    }
  }
  output = _utf8_decode(output);
  key = key || ''; // 盐值
  var symbol = ":".concat(key, ":"); // 盐字段切割符号
  output = output.split(symbol);
  if (output.length === 1) return '';
  if (output[0] > 6 && /^\d+$/.test(output[0])) {
    var nt = Date.now();
    if (nt > output[0]) return '';
  }
  return output[1] || '';
};

/*******
 * @description: 校验加密字符
 * @author: 琴时
 * @param {*} input [明文]
 * @param {String} crypt [密文]
 * @param {*} key [盐值]
 * @return {Boolean}
 */
var checkCrypt = exports.checkCrypt = function checkCrypt(input, crypt, key) {
  if ((0, _common.IsType)('Object', input) || (0, _common.IsType)('Array', input) || (0, _common.IsType)('Number', input)) {
    input = JSON.stringify(input);
  }
  return input === decrypt(crypt, key);
};

/*******
 * @description: GBK字符集实际长度计算
 * @author: 琴时
 * @param {String} str
 * @return {Number}
 */
var getStrLength = exports.getStrLength = function getStrLength(str) {
  str = str.toString();
  var realLength = 0;
  var len = str.length;
  var charCode = -1;
  for (var i = 0; i < len; i++) {
    charCode = str.charCodeAt(i);
    if (charCode >= 0 && charCode <= 128) {
      realLength += 1;
    } else {
      // 如果是中文则长度加2
      realLength += 2;
    }
  }
  return realLength;
};

/*******
 * @description: 密码强度校验
 * @author: 琴时
 * @param {String} value
 * @return {Number} [0:小于6位不合格，1:弱，2: 中，3:强]
 */
var checkPwdStrength = exports.checkPwdStrength = function checkPwdStrength(value) {
  if (value === undefined || value === null) {
    return 0;
  }
  var strongRegex = new RegExp('^(?=.{8,})(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*\\W).*$', 'g');
  var mediumRegex = new RegExp('^(?=.{7,})(((?=.*[A-Z])(?=.*[a-z]))|((?=.*[A-Z])(?=.*[0-9]))|((?=.*[a-z])(?=.*[0-9]))).*$', 'g');
  var enoughRegex = new RegExp('(?=.{6,}).*', 'g');
  var strong = 1;
  if (enoughRegex.test(value) == false) {
    //密码小于六位的时候
    strong = 0;
  } else if (strongRegex.test(value)) {
    //密码为八位及以上并且字母数字特殊字符三项都包括,强度最强
    strong = 3;
  } else if (mediumRegex.test(value)) {
    //密码为七位及以上并且字母、数字、特殊字符三项中有两项，强度是中等
    strong = 2;
  }
  return strong;
};

/*******
 * @description: 按指定长度分段字符串
 * @author: 琴时
 * @param {String} str
 * @param {Number} num
 * @return {Array}
 */
function splitString(str, num) {
  var reg = /^[0-9]*[1-9][0-9]*$/;
  if (str == null || str == undefined || !reg.test(num)) return [];
  var array = [];
  var len = str.length;
  for (var i = 0; i < len / num; i++) {
    if ((i + 1) * num > len) {
      array.push(str.substring(i * num, len));
    } else {
      array.push(str.substring(i * num, (i + 1) * num));
    }
  }
  return array;
}

/*******
 * @description: 将路径中的反斜杠字符 \ 替换为斜杠 /
 * @author: 琴时
 * @param {*} path
 * @return {*}
 */
function replacePath(path) {
  return path.replace(/\\/g, '/');
}

/*******
 * @description: 切割/获取文件名
 * @author: 琴时
 * @param {*} path
 * @return {*}
 */
function splitToFileName(path) {
  path = replacePath(path || '');
  var lastIndex = path.lastIndexOf('/');
  if (lastIndex === -1) return path;
  return path.substring(lastIndex + 1);
}

/*******
 * @description: Unicode加密方式
 * @author: 琴时
 * @param {String|Number} params
 * @return {String}
 */
var toCode = exports.toCode = function toCode(params) {
  params = params ? params.toString() : ''; //避免参数不是字符串
  /* 定义密钥 */
  var num = '0123456789';
  var lower = 'abcdefghijklmnopqrstuvwxyz';
  var capital = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  var character = num + lower + capital; //构建秘钥数组
  var len = character.length; //秘钥长度

  /**
   * 定义临时变量
   * unicodeValue:最终加密值
   */
  var unicodeValue = '';
  /* 遍历待加密字符串 */
  for (var i = 0; i < params.length; i++) {
    var b = params.charCodeAt(i); //逐个提取每个字符，并获取Unicode编码值
    var b1 = b % len; //第一轮求余数
    b = (b - b1) / len; //求最大倍数
    var b2 = b % len; //第二轮求余数
    b = (b - b2) / len; //求最大倍数
    var b3 = b % len; //第三轮求余数
    unicodeValue += character[b3] + character[b2] + character[b1]; //根据余数值映射到密钥中对应下标位置的字符
  }
  return unicodeValue; //返回这些映射的字符(加密后)
};

/*******
 * @description:Unicode解密方式
 * @author: 琴时
 * @param {String} params
 * @return {String}
 */
var fromCode = exports.fromCode = function fromCode(params) {
  params = params ? params.toString() : ''; //避免参数不是字符串
  /* 定义密钥 */
  var num = '0123456789';
  var lower = 'abcdefghijklmnopqrstuvwxyz';
  var capital = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  var character = num + lower + capital; //构建秘钥数组
  var len = character.length; //秘钥长度
  var result = '';
  var b = 0;
  //计算加密字符串包含的字符数，创建一个x位的数组
  var x = Math.ceil(params.length / 3);
  var arr = new Array(x);
  for (var i = 0; i < arr.length; i++) {
    //以数组的长度循环次数，遍历加密字符串
    var b1 = character.indexOf(params.charAt(b)); //截取周期内第d个字符串，计算在密钥中的索引值
    b++;
    var b2 = character.indexOf(params.charAt(b)); //截取周期内第d个字符串，计算在密钥中的索引值
    b++;
    var b3 = character.indexOf(params.charAt(b)); //截取周期内第d个字符串，计算在密钥中的索引值
    b++;
    arr[i] = b1 * len * len + b2 * len + b3; //利用索引值，反推被加密字符的Unicode编码值
  }
  // 将数组转换成字符串连接起来
  // let str1 = arr.join(',')
  //用fromCharCode()算出字符串
  // result = eval('String.fromCharCode(' + str1 + ')')
  result = String.fromCharCode.apply(String, arr);
  return result; //返回被解密的字符串
};

/*******
 * @description: 校验数据是否一致
 * @author: 琴时
 * @param {String} arg1 [未加密]
 * @param {String} arg2 [已加密]
 * @return {boolean} 返回校验结果<布尔值>
 */
var checkCode = exports.checkCode = function checkCode(arg1, arg2) {
  arg1 = arg1 ? arg1.toString() : '';
  return arg1 === fromCode(arg2);
};