map 和 set
set更像是包含元素不能有重复的array；map更像是key可以是任意类型的object
object的键只能是string类型，但是map的键可以是任意类型
set
Set.prototype.add(value)：向Set中添加一个新元素。Set.prototype.has(value)：判断Set中是否存在指定的元素，返回布尔值。Set.prototype.delete(value)：从Set中删除指定的元素，删除成功返回true，否则返回false。Set.prototype.clear()：清空Set中的所有元素。Set.prototype.size：返回Set中元素的个数。Set.prototype.entries()：返回一个包含Set中所有元素的键值对的迭代器对象。Set.prototype.keys()：返回一个包含Set中所有元素键（值）的迭代器对象。Set.prototype.values()：返回一个包含Set中所有元素值的迭代器对象。Set.prototype.forEach(callbackFn[, thisArg])：遍历Set中的所有元素，对每个元素执行回调函数。Set.prototype[Symbol.iterator]()：返回一个迭代器对象，可以用于遍历Set中的所有元素。
这些API可以通过Set对象的实例进行调用。例如：
const set = new Set();
set.add('apple');
set.add('banana');
set.add('orange');
console.log(set.size); // 输出: 3
console.log(set.has('apple')); // 输出: true
set.delete('banana');
console.log(set.size); // 输出: 2
set.forEach((value) => {
console.log(value);
});
// 输出:
// apple
// orange
map
Map.prototype.set(key, value)：向Map中添加一个键值对。Map.prototype.get(key)：根据指定的键获取对应的值。Map.prototype.has(key)：判断Map中是否存在指定的键，返回布尔值。Map.prototype.delete(key)：根据指定的键删除对应的键值对，删除成功返回true，否则返回false。Map.prototype.clear()：清空Map中的所有键值对。Map.prototype.size：返回Map中键值对的个数。Map.prototype.entries()：返回一个包含Map中所有键值对的迭代器对象。Map.prototype.keys()：返回一个包含Map中所有键的迭代器对象。Map.prototype.values()：返回一个包含Map中所有值的迭代器对象。Map.prototype.forEach(callbackFn[, thisArg])：遍历Map中的所有键值对，对每个键值对执行回调函数。
这些API可以通过Map对象的实例进行调用。例如：
const map = new Map();
map.set('apple', 10);
map.set('banana', 5);
map.set('orange', 8);
console.log(map.size); // 输出: 3
console.log(map.get('apple')); // 输出: 10
map.delete('banana');
console.log(map.size); // 输出: 2
map.forEach((value, key) => {
console.log(key, value);
});
// 输出:
// apple 10
// orange 8
空值合并操作符
Unicode字节码的获取与转换
扁平数组转树
单循环
相当于先向roots中放入顶级节点，然后在顶级节点的children中追加子节点。
// 定义一个扁平的节点数组，每个节点包含 id、parentId 和 name 属性
// id 是节点的唯一标识，parentId 是其父节点的 id，null 表示该节点是根节点
const nodes = [
{ id: 1, parentId: null, name: 'Root' },
{ id: 2, parentId: 1, name: 'Child 1' },
{ id: 3, parentId: 1, name: 'Child 2' },
{ id: 4, parentId: 2, name: 'Grandchild 1' },
{ id: 5, parentId: 2, name: 'Grandchild 2' },
{ id: 6, parentId: 3, name: 'Grandchild 3' },
{ id: 7, parentId: 3, name: 'Grandchild 4' },
{ id: 8, parentId: 2, name: 'Grandchild 5' },
{ id: 9, parentId: 5, name: 'Great-grandchild 1' },
];
/**
* 将扁平的节点数组转换为树形结构
* @param {Array} nodes - 扁平的节点数组，每个节点包含 id 和 parentId 属性
* @returns {Array} - 转换后的树形结构数组，数组元素为根节点
*/
function flatToTree(nodes) {
// 创建一个空对象 dict，用于存储每个节点及其对应的树形结构
// 键为节点的 id，值为节点对象，并且包含一个 children 数组用于存储子节点
const dict = {};
// 创建一个空数组 roots，用于存储根节点
const roots = [];
// 第一步：将所有节点存入 dict 中，并为每个节点初始化 children 数组
for (const node of nodes) {
// 解构赋值获取当前节点的 id
const { id } = node;
// 将当前节点存储到 dict 中，并为其添加一个空的 children 数组
// 这样做是为了确保后续操作时可以直接访问每个节点的 children 属性
dict[id] = { ...node, children: [] };
}
console.log(JSON.stringify(dict))
// 第二步：根据节点的 parentId 构建树结构
for (const node of nodes) {
// 解构赋值获取当前节点的 id 和 parentId
const { id, parentId } = node;
// 如果 parentId 为 null，说明该节点是根节点
if (parentId === null) {
// 将该节点添加到 roots 数组中
roots.push(dict[id]);
} else {
// 如果 dict 中还没有该父节点的记录，则为其初始化一个包含空 children 数组的对象
if (!dict[parentId]) {
dict[parentId] = { children: [] };
}
// 将当前节点添加到其父节点的 children 数组中
dict[parentId].children.push(dict[id]);
}
}
// 返回根节点数组，即转换后的树形结构
return roots;
}
// 调用 flatToTree 函数将扁平节点数组转换为树形结构
const tree = flatToTree(nodes);
// 打印转换后的树形结构
console.log(JSON.stringify(tree));
双循环
let flag = [{ id: 1, name: 'zs', pid: 0 }, { id: 2, name: 'ls', pid: 1 }, { id: 3, name: 'ww', pid: 1 },{id:4,name:'同软',pid:0}]
flag.map(item => item.children = [])
for (let i = 0; i < flag.length; ) {
if (flag[i].pid != 0) {
let index = flag.findIndex(item => item.id = flag[i].pid)
flag[index].children.push(flag[i])
flag.splice(i,1)
i--
}
i++
}
