CmsWing源码分析（2）全局功能函数（一）

最新推荐文章于 2024-03-26 09:37:20 发布

措字侠

最新推荐文章于 2024-03-26 09:37:20 发布

阅读量259

点赞数

文章标签： javascript

本文链接：https://blog.csdn.net/KINOKKO/article/details/121320400

版权

这篇博客详细分析了JavaScript中用于全局功能的函数，包括IP地址与数字之间的转换、密码的加密处理、数组去重与查重、排序算法、时间格式化以及内容格式化等实用技巧。文章还介绍了获取子集分类的方法，对于网站建设和数据处理具有很高的参考价值。

摘要由CSDN通过智能技术生成

2021SC@SDUSC

本次博客主要分析引导文件夹中的全局可用的功能函数

此部分内容极长，因此决定分次分析global.js文件

IP与数字的转换

作为建站系统，必然需要连接网络，接受、发送使用者的IP地址

_ip2int和_int2iP分别是用于IP转数字和数字转IP的函数

IP地址的格式为四个数字中间分别用“ .”分隔

global._ip2int = function(ip) {
  var num = 0;
  ip = ip.split('.');
  num = Number(ip[0]) * 256 * 256 * 256 + Number(ip[1]) * 256 * 256 + Number(ip[2]) * 256 + Number(ip[3]);
  num = num >>> 0;
  return num;
};

则IP转数字就需要先去掉间隔符，再乘上对应位数

数字转IP则相反，先分出位数，再加上间隔符

global._int2iP = function(num) {
  var str;
  var tt = new Array();
  tt[0] = (num >>> 24) >>> 0;
  tt[1] = ((num << 8) >>> 24) >>> 0;
  tt[2] = (num << 16) >>> 24;
  tt[3] = (num << 24) >>> 24;
  str = String(tt[0]) + '.' + String(tt[1]) + '.' + String(tt[2]) + '.' + String(tt[3]);
  return str;
};

密码加密

对于有用户登陆需求的网站，密码加密十分重要

不过这边似乎只是简单地为密码首尾加上了一些字符

global.encryptPassword = function(password, md5encoded) {
  md5encoded = md5encoded || false;
  password = md5encoded ? password : think.md5(password);
  return think.md5(think.md5('www.cmswing.com') + password + think.md5('Arterli'));
};

其中，md5是在think-helper中出现的加密函数

function md5(str) {
  return crypto.createHash('md5').update(str + '', 'utf8').digest('hex');
}
exports.md5 = md5;

数组去重与查重

很多地方都很有用的数组去重

global.unique = function(arr) {
 return Array.from(new Set(arr));
};

很暴力地把array转换为set再转换为array

查重，很常用的功能

global.in_array = function(stringToSearch, arrayToSearch) {
  for (let s = 0; s < arrayToSearch.length; s++) {
    const thisEntry = arrayToSearch[s].toString();
    if (thisEntry == stringToSearch) {
      return true;
    }
  }
  return false;
};

排序函数

function sort_node(v, w) {
  return v['sort'] - w['sort'];
}
function sort_node1(v, w) {
  return w['sort'] - v['sort'];
}

时间格式化

由于需要存储很多数据，时间作为重要的参数需要被传递，对于获取到的系统时间，需要做出格式化操作

global.times = function(d, sec) {
  var time;
  var date = new Date(d);
  var y = date.getFullYear();
  var M = date.getMonth() + 1;
  M = M < 10 ? '0' + M : M;
  var d = date.getDate();
  d = d < 10 ? '0' + d : d;
  var h = date.getHours();
  h = h < 10 ? '0' + h : h;
  var m = date.getMinutes();
  m = m < 10 ? '0' + m : m;
  var s = date.getSeconds();
  s = s < 10 ? '0' + s : s;
  if (sec) {
    time = y + '-' + M + '-' + d + ' ' + h + ':' + m + ':' + s;
  } else {
    time = y + '-' + M + '-' + d + ' ' + h + ':' + m;
  }

  return time;
};

内容格式化

为防止空格造成不必要的格式错误，可以对内容进行两端去空格化

global.trim = function(str) {
  return str.replace(/(^\s*)|(\s*$)/g, '');
};

获取子集分类

首先获取所有子集

要获取所有子集，首先遍历一遍所有结点

通过PID判断，当其拥有父级时，将其深度设为零，在children这个子集中加入此节点

否则将其加入末端子集

在传入的参数sn中，sn默认为0，此时children进行倒序排序

否则，进行正序排序

然后再用二叉树遍历的方法对children进行同级排序，获得当前子节点列表

得到未在前序操作栈内弹出的节点后，对结果集进行清空，然后使用差不多的有序树非递归前序遍历方法，最后得到子集分类

global.get_children = function(nodes, parent, sn = 0) {
  // console.log(11);
  var children = [];
  var last = [];
  /* 未访问的节点 */
  /*
     * 获取根分类列表。
     * 创建一个虚拟父级分类亦可
     **/
  var node = null;
  for (var i in nodes) {
    node = nodes[i];
    if (node['pid'] == parent) {
      node['deep'] = 0;
      children.push(node);
    } else {
      last.push(node);
    }
  }
  if (sn == 0) {
    children.sort(sort_node);
  } else {
    children.sort(sort_node1);
  }

  /* 同级排序 */
  var jumper = 0;
  var stack = children.slice(0);
  /* easy clone */

  while (stack.length > 0 &&
  /* just in case */ jumper++ < 1000) {
    var shift_node = stack.shift();
    var list = [];
    /* 当前子节点列表 */
    var last_static = last.slice(0);
    last = [];
    for (var i in last_static) {
      node = last_static[i];
      if (node['pid'] == shift_node['id']) {
        node['deep'] = shift_node['deep'] + 1;
        list.push(node);
      } else {
        last.push(node);
      }
    }
    if (sn == 0) {
      list.sort(sort_node);
    } else {
      list.sort(sort_node1);
    }

    for (var i in list) {
      node = list[i];
      stack.push(node);
      children.push(node);
    }
  }
  /*
     * 有序树非递归前序遍历
     *
     * */
  var stack = [];
  /* 前序操作栈 - 分类编号 */
  var top = null;
  /* 操作栈顶 */
  var tree = children.slice(0);
  /* 未在前序操作栈内弹出的节点 */
  var has_child = false;
  /* 是否有子节点，如无子节点则弹出栈顶 */
  var children = [];
  /* 清空结果集 */
  var jumper = 0;
  last = [];
  /* 未遍历的节点 */
  var current = null;
  /* 当前节点 */
  stack.push(parent);
  /* 建立根节点 */

  while (stack.length > 0) {
    if (jumper++ > 1000) {
      break;
    }
    top = stack[stack.length - 1];
    has_child = false;
    last = [];

    for (var i in tree) {
      current = tree[i];
      if (current['pid'] == top) {
        top = current['id'];
        stack.push(top);
        children.push(current);
        has_child = true;
      } else {
        last.push(current);
      }
    }
    tree = last.slice(0);
    if (!has_child) {
      stack.pop();
      top = stack[stack.length - 1];
    }
  }
  return children;
};