chanjs 2.7.4 → 2.7.6

package/utils/time.js

@@ -1,89 +1,47 @@
 /**
- * 格式化时间戳为指定格式的字符串
- * @param {number|string|Date} timestamp - 时间戳、日期字符串或 Date 对象
- * @param {string} [format='YYYY-MM-DD HH:mm:ss'] - 输出格式
- * @returns {string} 格式化后的时间字符串
- * @description
- * 支持的格式占位符：
- * - YYYY: 四位年份
- * - MM: 两位月份（01-12）
- * - DD: 两位日期（01-31）
- * - HH: 两位小时（00-23）
- * - mm: 两位分钟（00-59）
- * - ss: 两位秒数（00-59）
- * @example
- * formatTime(1704067200000); // '2024-01-01 00:00:00'
- * formatTime(1704067200000, 'YYYY/MM/DD'); // '2024/01/01'
- * formatTime('2024-01-01', 'YYYY-MM-DD'); // '2024-01-01'
+ * 时间格式化工具
+ */
+const TIME_TOKENS = [
+  [/Y{2,4}/, 'getFullYear'],
+  [/M{2}/, 'getMonth', 1],
+  [/D{2}/, 'getDate'],
+  [/H{2}/, 'getHours'],
+  [/m{2}/, 'getMinutes'],
+  [/s{2}/, 'getSeconds'],
+];
+
+const pad = (n, len = 2) => String(n).padStart(len, "0");
+
+/**
+ * 格式化时间戳为指定格式
+ * @param {number|string|Date} timestamp 时间戳/日期字符串/Date 对象
+ * @param {string} [format='YYYY-MM-DD HH:mm:ss'] 输出格式
+ * @returns {string}
  */
 export function formatTime(timestamp, format = 'YYYY-MM-DD HH:mm:ss') {
-  try {
-    const date = new Date(timestamp);
-    if (isNaN(date.getTime())) {
-      return timestamp;
+  const date = new Date(timestamp);
+  if (isNaN(date.getTime())) return String(timestamp ?? '');
+  return format.replace(/Y{2,4}|M{2}|D{2}|H{2}|m{2}|s{2}/g, m => {
+    for (const [re, fn, off = 0] of TIME_TOKENS) {
+      if (re.test(m)) return pad(date[fn]() + off, m.length);
     }
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, '0');
-    const day = String(date.getDate()).padStart(2, '0');
-    const hours = String(date.getHours()).padStart(2, '0');
-    const minutes = String(date.getMinutes()).padStart(2, '0');
-    const seconds = String(date.getSeconds()).padStart(2, '0');
-
-    return format
-      .replace('YYYY', year)
-      .replace('MM', month)
-      .replace('DD', day)
-      .replace('HH', hours)
-      .replace('mm', minutes)
-      .replace('ss', seconds);
-  } catch (error) {
-    console.error('[formatTime] 格式化时间失败:', error, 'timestamp:', timestamp);
-    return timestamp;
-  }
+    return m;
+  });
 }
 
 /**
- * 格式化对象或数组中的日期字段
- * @param {Object|Array<Object>} data - 要处理的数据对象或数组
- * @param {Array<string>} [fields] - 需要格式化的字段名数组（可选，默认处理常用日期字段）
- * @returns {Object|Array<Object>} 处理后的数据
- * @description
- * 将对象或数组中指定的日期字段格式化为 'YYYY-MM-DD HH:mm:ss' 格式
- * 支持递归处理数组中的每个对象
- * 自动匹配下划线和驼峰格式的字段名（如 createdAt/created_at）
- * @example
- * const data = { id: 1, createdAt: 1704067200000, updatedAt: 1704067200000 };
- * const result = formatDateFields(data);
- * console.log(result);
- * // { id: 1, createdAt: '2024-01-01 00:00:00', updatedAt: '2024-01-01 00:00:00' }
- * 
- * const list = [
- *   { id: 1, createdAt: 1704067200000 },
- *   { id: 2, createdAt: 1704153600000 }
- * ];
- * const formatted = formatDateFields(list);
- * console.log(formatted);
- * // [
- * //   { id: 1, createdAt: '2024-01-01 00:00:00' },
- * //   { id: 2, createdAt: '2024-01-02 00:00:00' }
- * // ]
+ * 格式化对象/数组中的日期字段
+ * @param {Object|Array<Object>} data
+ * @param {string[]} fields 需要格式化的字段名数组
+ * @returns {Object|Array<Object>}
  */
 export function formatDateFields(data, fields) {
   if (!data || typeof data !== 'object') return data;
-
-  if (Array.isArray(data)) {
-    return data.map(item => formatDateFields(item, fields));
-  }
-
+  if (Array.isArray(data)) return data.map(item => formatDateFields(item, fields));
+  if (!Array.isArray(fields) || !fields.length) return data;
   const result = { ...data };
-  
-  const defaultFields = ['createdAt', 'updatedAt', 'created_at', 'updated_at'];
-  const targetFields = fields || defaultFields;
-  
-  for (const field of targetFields) {
-    if (result[field]) {
-      result[field] = formatTime(result[field]);
-    }
+  for (const field of fields) {
+    if (result[field]) result[field] = formatTime(result[field]);
   }
   return result;
 }

package/utils/tree.js

@@ -1,121 +1,129 @@
-/**
- * 树形结构工具函数
- * 提供数组转树形结构和路径查找功能
- */
+import logger from "./logger.js";
 
-/**
- * 默认最大递归深度，防止循环引用导致栈溢出
- */
-const DEFAULT_MAX_DEPTH = 20;
+/** 默认最大递归深度，防止循环引用栈溢出 */
+const MAX_DEPTH = 10;
 
 /**
- * 将扁平数组转换为树形结构
- * @param {Array<Object>} arr - 扁平化的数据数组
- * @param {number} [pid=0] - 父节点 ID，默认为 0
- * @param {Object} [opts] - 选项
- * @param {number} [opts.maxDepth=20] - 最大递归深度
- * @param {Set} [opts._visited] - 已访问节点 id 集合（防循环引用，内部用）
- * @param {number} [opts._depth=0] - 当前递归深度（内部用）
- * @returns {Array<Object>} 树形结构数组
- * @description
- * 递归构建树形结构，为每个节点添加 level 属性
- * 如果有子节点，则添加 children 属性
- *
- * 安全改进：
- * - maxDepth 限制递归深度，防止恶意数据导致栈溢出
- * - _visited 跟踪已访问的 id，遇到循环引用时立即终止
- * @example
- * const arr = [
- *   { id: 1, pid: 0, name: '根节点' },
- *   { id: 2, pid: 1, name: '子节点' },
- *   { id: 3, pid: 2, name: '孙节点' }
- * ];
- * const tree = tree(arr);
- * // 返回带有 children 和 level 的树形结构
+ * 扁平数组转树形结构（预建Map优化性能，支持自定义id/pid字段、防循环引用）
+ * @param {Array<Object>} list 扁平源数组
+ * @param {number|string} [rootPid=0] 根节点父ID
+ * @param {Object} [options={}] 配置项
+ * @param {number} [options.maxDepth=20] 最大递归深度
+ * @param {string} [options.idKey='id'] 节点唯一标识字段
+ * @param {string} [options.pidKey='pid'] 父ID字段
+ * @returns {Array<Object>} 树形节点数组，节点自带 children、level
  */
-export function tree(arr, pid = 0, opts = {}) {
-  const maxDepth = opts.maxDepth || DEFAULT_MAX_DEPTH;
-  const visited = opts._visited || new Set();
-  let depth = opts._depth || 0;
-
-  // 空数组 / 超过最大深度 / 循环引用检测
-  if (!Array.isArray(arr) || arr.length === 0) return [];
-  if (depth >= maxDepth) {
-    console.warn(`[tree] 已达到最大递归深度 ${maxDepth}，可能存在循环引用`);
-    return [];
+export function tree(list, rootPid = 0, options = {}) {
+  const {
+    maxDepth = MAX_DEPTH,
+    idKey = "id",
+    pidKey = "pid",
+  } = options;
+
+  // 基础校验
+  if (!Array.isArray(list) || list.length === 0) return [];
+
+  // 1. 一次性构建id映射，O(n)，避免递归重复遍历数组（核心性能优化）
+  const nodeMap = new Map();
+  const rootNodes = [];
+  const allNodes = [];
+
+  for (const item of list) {
+    const node = { ...item, children: [], level: 0 };
+    nodeMap.set(node[idKey], node);
+    allNodes.push(node);
   }
-  if (visited.has(pid)) {
-    console.warn(`[tree] 检测到循环引用，pid=${pid} 已访问过`);
-    return [];
+
+  // 2. 父子关联
+  for (const node of allNodes) {
+    const parentId = node[pidKey];
+    if (parentId === rootPid) {
+      rootNodes.push(node);
+      node.level = 1;
+      continue;
+    }
+    const parent = nodeMap.get(parentId);
+    if (parent) {
+      parent.children.push(node);
+    }
   }
-  visited.add(pid);
-
-  let result = [];
-  arr.forEach((item) => {
-    if (item.pid === pid) {
-      let children = tree(arr, item.id, { maxDepth, _visited: visited, _depth: depth + 1 });
-      if (children.length) {
-        item.children = children;
-      }
-      item.level = 1;
-      result.push(item);
+
+  // 3. 递归填充层级 + 循环引用深度拦截
+  const visitedIds = new Set();
+  function setLevel(node, depth = 1) {
+    if (depth > maxDepth) {
+      logger.warn(`[tree] 递归深度超限${maxDepth}，疑似循环引用，id:${node[idKey]}`);
+      return;
+    }
+    const nodeId = node[idKey];
+    if (visitedIds.has(nodeId)) {
+      logger.warn(`[tree] 检测循环引用 id:${nodeId}`);
+      return;
+    }
+    visitedIds.add(nodeId);
+    node.level = depth;
+    for (const child of node.children) {
+      setLevel(child, depth + 1);
     }
-  });
-  return result;
+  }
+
+  for (const root of rootNodes) {
+    setLevel(root, 1);
+    // 无孩子则删除空children字段，精简结构
+    if (root.children.length === 0) delete root.children;
+  }
+
+  return rootNodes;
 }
 
 /**
- * 根据 ID 查找节点路径
- * @param {number} id - 要查找的节点 ID
- * @param {Array<Object>} source - 数据源数组
- * @param {Object} [opts] - 选项
- * @param {number} [opts.maxDepth=20] - 最大递归深度
- * @returns {Array<Object>} 从根节点到目标节点的路径数组
- * @description
- * 递归查找指定 ID 的节点及其所有父节点
- * 为每个节点添加 path 属性，包含拼音路径
- *
- * 安全改进：
- * - maxDepth 限制递归深度，防止恶意数据导致栈溢出
- * - 用 visited 集合检测循环引用
- * @example
- * const arr = [
- *   { id: 1, pid: 0, pinyin: 'root' },
- *   { id: 2, pid: 1, pinyin: 'child' }
- * ];
- * const path = treeById(2, arr);
- * // 返回包含 root 和 child 节点的数组
+ * 根据节点ID向上追溯完整父级路径（通用版，剥离硬编码pinyin业务逻辑）
+ * @param {number|string} targetId 目标节点ID
+ * @param {Array<Object>} list 扁平源数组
+ * @param {Object} [options={}] 配置
+ * @param {number} [options.maxDepth=20] 最大追溯深度
+ * @param {string} [options.idKey='id'] id字段
+ * @param {string} [options.pidKey='pid'] 父ID字段
+ * @returns {Array<Object>} 路径数组 [根节点...父节点...目标节点]
  */
-export function treeById(id, source, opts = {}) {
-  const maxDepth = opts.maxDepth || DEFAULT_MAX_DEPTH;
-  const arr = [];
+export function treeById(targetId, list, options = {}) {
+  const {
+    maxDepth = MAX_DEPTH,
+    idKey = "id",
+    pidKey = "pid",
+  } = options;
+
+  if (!Array.isArray(list) || targetId == null) return [];
+
+  // 预构建Map加速查找
+  const nodeMap = new Map();
+  for (const item of list) {
+    nodeMap.set(item[idKey], item);
+  }
+
+  const path = [];
   const visited = new Set();
+  let currentId = targetId;
+  let depth = 0;
 
-  const findId = (id, source, depth = 0) => {
+  while (currentId != null && currentId !== 0) {
     if (depth >= maxDepth) {
-      console.warn(`[treeById] 已达到最大递归深度 ${maxDepth}，可能存在循环引用`);
-      return;
-    }
-    if (visited.has(id)) {
-      console.warn(`[treeById] 检测到循环引用，id=${id} 已访问过`);
-      return;
+      logger.warn(`[treeById] 追溯深度超限${maxDepth}，疑似循环引用 id:${currentId}`);
+      break;
     }
-    visited.add(id);
-    for (let i = 0, item; i < source.length; i++) {
-      item = source[i];
-      if (item.id == id) {
-        arr.unshift(item);
-        if (item.pid != 0) {
-          findId(item.pid, source, depth + 1);
-        }
-      }
+    if (visited.has(currentId)) {
+      logger.warn(`[treeById] 检测循环引用 id:${currentId}`);
+      break;
     }
-  };
-  findId(id, source);
-  const _path = [];
-  arr.forEach((item) => {
-    _path.push("/" + item.pinyin);
-    item.path = _path.join("");
-  });
-  return arr;
+    visited.add(currentId);
+
+    const node = nodeMap.get(currentId);
+    if (!node) break;
+
+    path.unshift({ ...node });
+    currentId = node[pidKey];
+    depth++;
+  }
+
+  return path;
 }