let arr1 = [3, 1, 5, 2, 3];
let arr2 = [2, 4, 1, 6, 5];

// 步骤拆解：
// 1. [...arr1, ...arr2] 合并两个数组
// 2. new Set(...) 自动去重（Set 中每个值只出现一次）
// 3. [...new Set(...)] 把 Set 转回数组
// 4. .sort((a, b) => a - b) 升序排列（不写回调函数会按字符串排序，数字会出错！）

let result = [...new Set([...arr1, ...arr2])].sort((a, b) => a - b);
console.log(result); // [1, 2, 3, 4, 5, 6]

let merged = arr1.concat(arr2);  // 合并
let unique = merged.filter((item, index) => merged.indexOf(item) === index); // 去重
let sorted = unique.sort((a, b) => a - b); // 升序
console.log(sorted); // [1, 2, 3, 4, 5, 6]

// ❌ 错误：不传回调，sort 按字符串排序
[10, 2, 1, 20].sort();        // [1, 10, 2, 20] ← 错误！

// ✅ 正确：传入比较函数
[10, 2, 1, 20].sort((a, b) => a - b);  // [1, 2, 10, 20] 升序
[10, 2, 1, 20].sort((a, b) => b - a);  // [20, 10, 2, 1] 降序

let arr = [{ name: '张三' }, { name: '李四' }];

// ❌ 浅拷贝：只复制引用，修改新数组会影响原数组！
let copy1 = arr;                     // 直接赋值
let copy2 = [...arr];                // 展开运算符（只是浅拷贝）
let copy3 = arr.slice();             // slice（只是浅拷贝）

copy2[0].name = '王五';
console.log(arr[0].name);  // '王五' ← 原数组被改了！

// ✅ 深拷贝：完全独立的副本，修改新数组不影响原数组

let original = [{ name: '张三', score: 88 }, { name: '李四', score: 95 }];

let deepCopy = JSON.parse(JSON.stringify(original));

deepCopy[0].name = '王五';
console.log(original[0].name);  // '张三' ← 原数组未被影响 ✅

function deepClone(obj) {
    // 基本类型直接返回
    if (obj === null || typeof obj !== 'object') return obj;

    // 处理数组
    if (Array.isArray(obj)) {
        return obj.map(item => deepClone(item));
    }

    // 处理普通对象
    let clone = {};
    for (let key in obj) {
        if (obj.hasOwnProperty(key)) {
            clone[key] = deepClone(obj[key]);  // 递归复制每个属性
        }
    }
    return clone;
}

let original = [{ name: '张三', scores: [88, 90, 95] }];
let copy = deepClone(original);
copy[0].scores.push(100);
console.log(original[0].scores);  // [88, 90, 95] ← 未受影响 ✅

let original = [{ name: '张三', date: new Date() }];

let copy = structuredClone(original);  // 浏览器原生 API，ES2022+

copy[0].name = '李四';
console.log(original[0].name);  // '张三' ← 未受影响 ✅
console.log(original[0].date instanceof Date);  // true ← Date 类型保留 ✅

// map() 对数组的每个元素执行函数，返回一个新数组
// 原数组不变，新数组长度 = 原数组长度

let newArr = arr.map((item, index) => {
    // item：当前元素
    // index：当前下标（可选）
    return 新元素;  // 返回值组成新数组
});

const scoreList = [
    { name: "张三", subject: "语文", score: 88 },
    { name: "李四", subject: "数学", score: 95 },
    { name: "王五", subject: "英语", score: 76 },
    { name: "赵六", subject: "计算机", score: 100 }
];

const result = scoreList.map(item => {
    // 根据分数判断等级
    let level;
    if (item.score >= 90) {
        level = '优秀';
    } else if (item.score >= 80) {
        level = '良好';
    } else if (item.score >= 60) {
        level = '及格';
    } else {
        level = '不及格';
    }

    // 返回新对象（包含原有字段 + 新的 level 字段）
    return {
        name: item.name,
        subject: item.subject,
        score: item.score,
        level: level
    };
});

console.log(result);
// [
//   { name: '张三', subject: '语文', score: 88, level: '良好' },
//   { name: '李四', subject: '数学', score: 95, level: '优秀' },
//   { name: '王五', subject: '英语', score: 76, level: '及格' },
//   { name: '赵六', subject: '计算机', score: 100, level: '优秀' }
// ]

const result = scoreList.map(({ name, subject, score }) => ({
    name,
    subject,
    score,
    level: score >= 90 ? '优秀'
         : score >= 80 ? '良好'
         : score >= 60 ? '及格'
         : '不及格'
}));

// reduce() 把数组"归并"成一个值
arr.reduce((accumulator, currentItem) => {
    return 新的累积值;
}, 初始值);

// accumulator：累积器（上一次回调的返回值，或初始值）
// currentItem：当前元素

let numbers = [1, 2, 3, 4, 5];

// 求和
let sum = numbers.reduce((acc, curr) => acc + curr, 0);
console.log(sum); // 15

// 求最大值
let max = numbers.reduce((acc, curr) => curr > acc ? curr : acc, 0);
console.log(max); // 5

// 计算每个订单的商品总金额，添加 totalAmount 属性
const ordersWithTotal = orders.map(order => {
    // 用 reduce 累加 items 中每个商品的金额
    const totalAmount = order.items.reduce((sum, item) => {
        // 商品金额 = 单价 × 数量 × (1 - 折扣)
        const itemAmount = item.unitprice * item.quantity * (1 - item.discount);
        return sum + itemAmount;
    }, 0);  // 初始值为 0

    // 返回原订单对象 + totalAmount 字段
    return {
        ...order,            // 展开原订单的所有字段
        totalAmount: parseFloat(totalAmount.toFixed(2))  // 保留两位小数
    };
});

// 第一个订单的计算过程：
// 商品1：35.50 × 100 × (1 - 0.03) = 35.50 × 100 × 0.97 = 3443.50
// 商品2：20.00 × 50 × (1 - 0.00)  = 20.00 × 50 × 1.00  = 1000.00
// totalAmount = 3443.50 + 1000.00 = 4443.50

// 假设已有 customers 数组和 orders 数组

// 第一步：建立客户 ID 到客户信息的映射表
// 方便后续快速通过 customerid 找到客户名称，不需要每次遍历
const customerMap = {};
customers.forEach(customer => {
    customerMap[customer.customerid.trim()] = customer;
    // 注意：customerid 可能有空格，trim() 去掉首尾空格
});

// customerMap 结构：
// {
//   'AHDTSM': { customerid: 'AHDTSM', companyname: '顶天商贸有限公司', ... },
//   'AHPPSP': { customerid: 'AHPPSP', companyname: '盼盼食品有限公司', ... },
//   ...
// }

// 第二步：遍历订单，按客户统计2018年的销售额和订单数
const customerStats = {};

orders.forEach(order => {
    // 筛选2018年的订单
    const year = new Date(order.orderdate).getFullYear();
    if (year !== 2018) return;  // 不是2018年，跳过

    const cid = order.customerid.trim();  // 去掉空格

    // 如果该客户还没有统计记录，初始化
    if (!customerStats[cid]) {
        customerStats[cid] = {
            customerid: cid,
            companyname: customerMap[cid]?.companyname || '未知客户',
            orderCount: 0,    // 订单数量
            totalSales: 0,    // 总销售额
        };
    }

    // 累加订单数量
    customerStats[cid].orderCount += 1;

    // 累加该订单的销售额（items 中每项的金额）
    order.items.forEach(item => {
        customerStats[cid].totalSales +=
            item.unitprice * item.quantity * (1 - item.discount);
    });
});

// 第三步：转成数组，按订单数量降序排列，取前10
const top10 = Object.values(customerStats)
    .sort((a, b) => b.orderCount - a.orderCount)  // 按订单数量降序
    .slice(0, 10)                                   // 取前10个
    .map((item, index) => ({
        rank: index + 1,                            // 名次
        customerid: item.customerid,
        companyname: item.companyname,
        orderCount: item.orderCount,
        totalSales: parseFloat(item.totalSales.toFixed(2))
    }));

console.log(top10);

const obj = { a: 1, b: 2, c: 3 };
Object.values(obj);  // [1, 2, 3] ← 把对象的所有值转成数组
Object.keys(obj);    // ['a', 'b', 'c'] ← 把对象的所有键转成数组
Object.entries(obj); // [['a',1], ['b',2], ['c',3]] ← 键值对数组

/**
 * 在树中找到指定 parentId 的节点，并插入新子节点
 * @param {Array} tree - 树形数组
 * @param {string} parentId - 目标父节点的 ID
 * @param {Object} newNode - 要插入的新节点（包含 id、text 等基本信息）
 * @returns {boolean} - 是否插入成功
 */
function insertNode(tree, parentId, newNode) {
    for (let node of tree) {
        if (node.id === parentId) {
            // 找到了父节点，准备插入

            // 1. 计算新节点的层级 = 父节点层级 + 1
            newNode.level = node.level + 1;

            // 2. 计算新节点的祖先路径 = 父节点祖先 + 父节点ID + '#'
            newNode.ancestor = node.ancestor + node.id + '#';

            // 3. 设置新节点的父节点ID
            newNode.parentnodeid = node.id;

            // 4. 新节点默认没有子节点
            newNode.isparentflag = 0;
            if (!newNode.children) newNode.children = [];

            // 5. 父节点现在有子节点了，更新 isparentflag
            node.isparentflag = 1;

            // 6. 确保父节点的 children 数组存在
            if (!node.children) node.children = [];

            // 7. 插入新节点
            node.children.push(newNode);

            return true; // 插入成功
        }

        // 没找到，递归在子节点里找
        if (node.children && node.children.length > 0) {
            let found = insertNode(node.children, parentId, newNode);
            if (found) return true;  // 子树里找到并插入了，停止递归
        }
    }
    return false; // 没找到父节点
}

// 使用示例：
let tree = [
    {
        id: 'A', text: '饮料', level: 1, ancestor: '',
        isparentflag: 1, parentnodeid: '',
        children: [
            { id: 'A1', text: '非酒精饮料', level: 2, ancestor: 'A#', isparentflag: 0, parentnodeid: 'A', children: [] }
        ]
    }
];

let newNode = { id: 'A1-1', text: '矿泉水' };
insertNode(tree, 'A1', newNode);

// 结果：newNode 被插入到 A1 节点下
// newNode = {
//   id: 'A1-1',
//   text: '矿泉水',
//   level: 3,          ← 自动计算
//   ancestor: 'A#A1#', ← 自动计算
//   parentnodeid: 'A1',← 自动设置
//   isparentflag: 0,   ← 新节点没有子节点
//   children: []
// }
// A1 节点的 isparentflag 也被更新为 1