工具函数

数组

• 普通一维数组 转 树形结构数据

/**
 * 普通一维数组 转 树形结构数据
 * @param {Array} data 普通一维数组
 * @param {Object} opt 属性对照
 * @param {Function} format 数据格式化
 */
function transformToTree(data, opt, format) {
    let defaultOpt = {
        id: 'id',
        parentId: 'parentId',
        children: 'children'
    };
    opt = Object.assign({}, defaultOpt, (opt || {}));
    // 获取根节点数据；parentId不存在或者null、undefined、''；则为根节点
    let parentData = data.filter(item => !item[opt.parentId] || item[opt.parentId] === '');
    // 获取子节点数据；不是根节点，都视为子节点
    let childrenData = data.filter(item => !(!item[opt.parentId] || item[opt.parentId] === ''));
    function recursionFn(parentData, childrenData) {
        parentData.forEach(parent => {
            childrenData.forEach((child, index) => {
                // 这个判断成立，接着递归；不成立结束递归
                if (parent[opt.id] === child[opt.parentId]) {
                    let item = child;
                    if (typeof format === 'function') {
                        item = format(child);
                    } 
                    (parent[opt.children] instanceof Array) ? parent[opt.children].push(item) : parent[opt.children] = [item];
                    let copyData = JSON.parse(JSON.stringify(childrenData));
                    copyData.splice(index, 1);
                    // 已当前数据为父节点，看看有没有数据是它的子节点
                    recursionFn([child], copyData);
                }
            });
        });
    }
    return parentData;
}

• 树形结构数据 转 一维数组

/**
 * 树形结构数据 转 一维数组
 * @param {Array} data 树形结构数据
 * @param {Object} opt 属性对照
 * @param {Function} format 数据格式化
 */
function transformToArray(data, opt, format) {
    let defaultOpt = {
        id: 'id',
        parentId: 'parentId',
        children: 'children'
    };
    opt = Object.assign({}, defaultOpt, (opt || {}));

    let arr = [];
    function recursionFn(data) {
        data.forEach(item => {
            if (typeof format === 'function') {
                item = format(item);
            } 
            arr.push(item);
            // 这个判断成立，接着递归；不成立结束递归 
            if (item[opt.children] instanceof Array && item[opt.children].length) {
                recursionFn(item[opt.children]);
            }
        });
    }
    recursionFn(data);
    return arr;
}

• uint8Array转String

function Uint8ArrayToString(fileData){
  var dataString = "";
  for (var i = 0; i < fileData.length; i++) {
    dataString += String.fromCharCode(fileData[i]);
  }
 
  return dataString
}

• String转uint8Array

function stringToUint8Array(str){
  var arr = [];
  for (var i = 0, j = str.length; i < j; ++i) {
    arr.push(str.charCodeAt(i));
  }
 
  var tmpUint8Array = new Uint8Array(arr);
  return tmpUint8Array
}

• int转byte[]

function intTobytes2(n) {
  var bytes = [];
 
  for (var i = 0; i < 2; i++) {
    bytes[i] = n >> (8 - i * 8);
 
  }
  return bytes;
}

• string转ArrayBuffer

function str2ab(str) {
  var buf = new ArrayBuffer(str.length * 2); // 每个字符占用2个字节
  var bufView = new Uint16Array(buf);
  for (var i = 0, strLen = str.length; i < strLen; i++) {
    bufView[i] = str.charCodeAt(i);
  }
  return buf;
}

• ArrayBuffer转String

function ab2str(buf) {
  return String.fromCharCode.apply(null, new Uint8Array(buf));
}

function ab2str(u,f) {
   var b = new Blob([u]);
   var r = new FileReader();
    r.readAsText(b, 'utf-8');
    r.onload = function (){if(f)f.call(null,r.result)}
}

正则校验

邮箱地址

// 无子域名邮箱
var reg = /^([A-z0-9_-]+)@([A-z0-9_-]+)+(\.([A-z0-9_-]+))+$/g;
// 多级子域名邮箱
var reg = /^([A-z0-9_-]+)(\.?([A-z0-9_-]+))+@([A-z0-9_-]+)+(\.([A-z0-9_-]+))+$/g;