前端常用方法

1.求两个时间的时间差：

function getTimeInterval(start: Date, end: Date): number {
  return Math.abs(end.getTime() - start.getTime());
}

2.数组对象组装成一棵树：

interface TreeNode {
  id: number;
  name: string;
  children?: TreeNode[];
}

function buildTree(nodes: { id: number; name: string; parentId: number }[]) {
  const map = new Map<number, TreeNode>();
  const roots: TreeNode[] = [];

  nodes.forEach((node) => {
    const { id, name, parentId } = node;
    const treeNode: TreeNode = { id, name };

    if (parentId === 0) {
      roots.push(treeNode);
    } else {
      const parent = map.get(parentId);
      if (parent) {
        if (!parent.children) {
          parent.children = [];
        }
        parent.children.push(treeNode);
      }
    }

    map.set(id, treeNode);
  });

  return roots;
}

3.数组对象按照某个字段分组：

function groupByField(arr: any[], field: string) {
  return arr.reduce((acc, obj) => {
    const key = obj[field];
    if (!acc[key]) {
      acc[key] = [];
    }
    acc[key].push(obj);
    return acc;
  }, {});
}

4.数组对象按照某个字段排序：

const sortedArray = array.sort((a, b) => a.fieldName - b.fieldName);

5.两个数组求并集：

function union(arr1: any[], arr2: any[]): any[] {
  return Array.from(new Set([...arr1, ...arr2]));
}

6.两个数组求交集：

function intersection(arr1: any[], arr2: any[]) {
  return arr1.filter(item => arr2.includes(item));
}

7.两个数组求差集：

function difference(arr1: any[], arr2: any[]): any[] {
  return arr1.filter(item => !arr2.includes(item));
}

8.根据某个属性获取数组对象中对应对象：

function getObjectByProperty(data: any[], property: string, value: any) {
  return data.find(obj => obj[property] === value);
}

9.根据某个属性获取数组对象中对应对象的位置：

function getPositionByProperty(data: any[], property: string, value: any) {
  return data.findIndex(obj => obj[property] === value);
}

10.树扁平化：

function flattenTree(data: any[], childrenKey: string = 'children') {
  let result: any[] = [];
  data.forEach(item => {
    result.push(item);
    if (item[childrenKey]) {
      result = result.concat(flattenTree(item[childrenKey], childrenKey));
      delete item[childrenKey];
    }
  });
  return result;
}

11.数组扁平化：

function flattenArray(data: any[]) {
  let result: any[] = [];
  data.forEach(item => {
    if (Array.isArray(item)) {
      result = result.concat(flattenArray(item));
    } else {
      result.push(item);
    }
  });
  return result;
}