/**
* 我们拿到数据的一些常用功能 分组 排序 匹配 深拷贝 浅拷贝 树状图
*/
// 分组 思路通过循环来实现分组
let data = [
{ "name": "John", "Average": 15, "High": 10, "DtmStamp": 1358226000000 },
{ "name": "Jane", "Average": 16, "High": 92, "DtmStamp": 1358226000000 },
{ "name": "Jane", "Average": 17, "High": 45, "DtmStamp": 1358226000000 },
{ "name": "John", "Average": 18, "High": 87, "DtmStamp": 1358226000000 },
{ "name": "Jane", "Average": 15, "High": 10, "DtmStamp": 1358226060000 },
{ "name": "John", "Average": 16, "High": 87, "DtmStamp": 1358226060000 },
{ "name": "John", "Average": 17, "High": 45, "DtmStamp": 1358226060000 },
{ "name": "Jane", "Average": 18, "High": 92, "DtmStamp": 1358226060000 }
];
let dataTemp = []
let newData = []
data.forEach(item => {
dataTemp[item.name] = dataTemp[item.name] || [];
dataTemp[item.name].push(item);
})
console.log('格式一', dataTemp)
for (let key in dataTemp) {
let obj = {}
obj.date = key
obj.list = dataTemp[key]
newData.push(obj)
}
console.log('格式二', newData);
// 排序功能
console.log('正序排序后', data.sort((a, b) => a.High - b.High))
console.log('倒叙序排序后', data.sort((a, b) => a.High - b.High).reverse()) // 可以用倒叙功能进行排序
// 匹配功能 将具有相同信息的东西分配到一起 还可以用for循环来做
let newData1 = [
{
name: "Jane",
hobby: '拉粑粑'
},
{
name: "John",
hobby: '干饭'
}
]
data.map(item => {
newData1.map(ele => {
if (item.name === ele.name) {
let json = {
'hobby': ele.hobby
};
Object.assign(item, json)
return item
}
})
})
console.log('结果1', data)
/**
* 深浅拷贝 基本数据类型存储在栈中 引用数据类型值存储在堆中 地址值存储在栈中
* 修改变量的值不会影响原来的值 一般都是深拷贝 深拷贝就是不仅拷贝了指向同时开辟了新的内存空间
*/
let a = 1 // 内存中开辟一个空间
let b = a // 内存中又开辟了一个空间
b = 2
console.log(b) // 为什么不是1是2呢？因为开辟了新的空间 a,b 是独立的
/**
* 浅拷贝实现 可以直接创建对象将指针指向另外一个 也可以通过Object.assign()方法 Es6的扩展运算符... 数组的concat
* p1 Person {
* name: '小明',
* age: 18,
* address: { city: '重庆', school: '重庆大学' },
* arr: [ 1, 2, 3 ]
* }
* p1 Person {
* name: '小明',
* age: 18,
* address: { city: '四川成都', school: '重庆大学' },
* arr: [ 1, 2, 3 ]
* }
* 从结果来看浅拷贝在修改第一层的name时候没有修改成功 而修改其中的address中city修改成功了 说明浅拷贝只能拷贝对象的第一层 当对象中有对象时 还是会影响后一层
*/
class Person {
name = '小明';
age = 18;
address = {
city: '重庆',
school: '重庆大学'
}
arr = [1, 2, 3]
}
let p1 = new Person()
console.log('没有进行浅拷贝前的p1', p1)
let p3 = Object.assign({}, p1)
p3.name = "李佳伦"
p3.address.city = "四川成都"
console.log('进行了浅拷贝后的p1', p1)
// 数组concat 拷贝
let concatTest = [{
name: '1',
info: {
age: 18
}
}]
let ct = [].concat(concatTest)
ct[0].age = 20
console.log(concatTest[0].age)
/**
* 深拷贝 也就是全拷贝 怎么实现
* 1.浅拷贝加递归
* 2.深拷贝
* 3.Json.parse(Json.stringfy())
*/
var obj = {
color: 'red',
person: {
name: '谷底飞龙',
age: 28,
},
}
// 递归浅拷贝
function recursiveShallowCopy(obj) {
var copy = Array.isArray(obj) ? [] : {};
for (let p in obj) {
if (typeof obj[p] === 'object') {
// 对象类型，继续递归浅拷贝
copy[p] = recursiveShallowCopy(obj[p]);
} else {
copy[p] = obj[p];
}
}
return copy;
}
// 深拷贝
function deepCopy(obj) {
if (typeof obj === 'object' && obj !== null) {
// 如果是引用类型，进行递归浅拷贝
return recursiveShallowCopy(obj);
} else {
// 如果是基本类型，直接返回
return obj;
}
}
console.log(deepCopy(obj))
let newObj = JSON.parse(JSON.stringify(obj))
console.log('深拷贝前', obj)
newObj.person.age = 50
console.log('深拷贝后', obj) // 由此可见并没有发生什么变化
/**
* 树状图遍历 参考文献https://juejin.cn/post/6899267681959018510 树的应用相当广 我们的层级列表等等都可以用树来实现 所以必须要掌握他们的用法
* https://juejin.cn/post/6899267681959018510 这篇文章写的非常好 要详细的学习和理解
*
*/
let tree = [
{
id: '1',
title: '节点1',
children: [
{
id: '1-1',
title: '节点1-1'
},
{
id: '1-2',
title: '节点1-2'
}
]
},
{
id: '2',
title: '节点2',
children: [
{
id: '2-1',
title: '节点2-1'
}
]
}
]
// 广度优先
function treeForeach(tree, func) {
let node, list = [...tree]
while (node = list.shift()) {
func(node)
node.children && list.push(...node.children)
}
}
treeForeach(tree, node => { console.log(node.title) })
// 先序遍历
function treeForeach(tree, func) {
tree.forEach(data => {
func(data)
data.children && treeForeach(data.children, func) // 遍历子树
})
}
// 后续遍历
function treeForeach(tree, func) {
tree.forEach(data => {
data.children && treeForeach(data.children, func) // 遍历子树
func(data)
})
}
// 转化为列表
//递归实现
function treeToList(tree, result = [], level = 0) {
tree.forEach(node => {
result.push(node)
node.level = level + 1
node.children && treeToList(node.children, result, level + 1)
})
return result
}
// 循环实现
function treeToList(tree) {
let node, result = tree.map(node => (node.level = 1, node))
for (let i = 0; i < result.length; i++) {
if (!result[i].children) continue
let list = result[i].children.map(node => (node.level = result[i].level + 1, node))
result.splice(i + 1, 0, ...list)
}
return result
}