Object.assign()是什么 let和const的区别 es6中...运算符 JSON.stringify() JSON.parse()

Object.assign()拷贝

当对象中只有一级属性，没有二级属性的时候，此方法为深拷贝，但是对象中有对象的时候，此方法在二级属性以后就是浅拷贝

Object.assign()方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象，它将返回目标对象

1.Object.assign(tartget,…sources) // （target：目标对象sources:源对象（可多个））
例子：

const obj1={
    a:1,
    b:2,
    c:3
}
const obj2=Object.assign({c:4,d:5},obj1)
console.log(obj1)//{a:1,b:2,c:3}
console.log(obj2)//{c:3,d:5,a:1,b:2}

注意：1.如果目标对象中的属性和原对象有相同的键，则属性被源对象中的属性覆盖。

​ 2.Object.assign方法只会拷贝源对象自身的并且可枚举的属性到目标对象，

Object.assign()对象的深拷贝

针对深拷贝，因为Object.assign()拷贝的是属性值，假如源对象的属性值是一个对象的引用，那么它也只指向那个引用。

let object1={a:0,b:{c:0}};
let object2=Object.assign({},object1);
console.log(JSON.stringify(object2))//{"a":0,"b":{"c":0}}

object1.a=1;
console.log(JSON.stringify(object1));//{"a":1,"b":{"c":0}}
console.log(JSON.stringify(object2));//{"a":0,"b":{"c":0}}

object2.a=1;
console.log(JSON.stringify(object1));//{"a":1,"b":{"c":0}}
console.log(JSON.stringify(object2));//{"a":2,"b":{"c":0}}

object2.b.c = 3; 
console.log(JSON.stringify(object1)); // { a: 1, b: { c: 3}} 
console.log(JSON.stringify(object2)); // { a: 2, b: { c: 3}} 
最后一次赋值的时候，b是值是对象的引用，只要修改任意一个，其他的也会受影响

// Deep Clone （深拷贝）
obj1 = { a: 0 , b: { c: 0}}; 
let obj3 = JSON.parse(JSON.stringify(obj1)); 
obj1.a = 4; 
obj1.b.c = 4; 
console.log(JSON.stringify(obj3)); // { a: 0, b: { c: 0}}

合并相同属性的对象

const o1 = { a: 1, b: 1, c: 1 };
const o2 = { b: 2, c: 2 };
const o3 = { c: 3 };

const obj = Object.assign({}, o1, o2, o3);
console.log(obj); // { a: 1, b: 2, c: 3 }
1.属性被后续参数中具有相同属性的其他对象覆盖。
2.目标对象的属性与源对象的属性相同，源的会覆盖目标的属性

使用递归的方式实现深拷贝

function _deepClone(source) {
  let target;
  if (typeof source === 'object') {
    target = Array.isArray(source) ? [] : {}
    for (let key in source) {
      if (source.hasOwnProperty(key)) {
        if (typeof source[key] !== 'object') {
          target[key] = source[key]
        } else {
          target[key] = _deepClone(source[key])
        }
      }
    }
  } else {
    target = source
  }
  return target
}

使用js实现深拷贝

function deepClone(a){
    let _data=JSON.stringify(a);
    dataClone=JSON.parse(_data)
    return dataClone;
}

let 和const的区别？

const和let的作用域都是块级作用域，都是在作用域内有效。

let声明的变量可以改变，值和类型都可以改变，没有限制。

const声明的变量不能改变值，const一单声明变量，就必须初始化，不能留到以后赋值。

const a;//报错，一旦声明变量，应该立即赋值
const b=2;
b=3;//报错，因为定义常量之后不能重新赋值

对于复合类型的变量，如数组和对象，变量名不指向数据，而是指向数据所在的地址。const命令只是保证变量名指向的地址不变，并不保证该地址的数据不变，所以将一个对象声明为常量必须非常小心。

const aa = [];
aa = [1,2,3] //出错，因为变量aa指向的地址不能发生改变，应始终指向[]所在的地址！！！[1,2,3]与[]不是同一个地址
//不会报错，因为aa指向的地址不变，改变的只是内部数据
const aa = [];
aa[0] = 1
aa[1] = 2
aa[2] = 3

1. …为展开运算符

   let a = [1,2,3];
   let b = [0, ...a, 4]; // [0,1,2,3,4]
    
   let obj = { a: 1, b: 2 };
   let obj2 = { ...obj, c: 3 }; // { a:1, b:2, c:3 }
   let obj3 = { ...obj, a: 3 }; // { a:3, b:2 }
   

2. …为剩余操作符

   let a = [1,2,3];
   let [b, ...c] = a;
   b; // 1
   c; // [2,3]
   
   // 也可以
   let a = [1,2,3];
   let [b, ...[c,d,e]] = a;
   b; // 1
   c; // 2
   d; // 3
   e; // undefined
   
   // 也可以
   function test(a, ...rest){
     console.log(a); // 1
     console.log(rest); // [2,3]
   }
   test(1,2,3)
   
   
   

JSON.stringify()方法用于将javascript值转换成JSON字符串

JSON语法规则：

• 数据为键值对
• 数据由都好分隔
• 大括号保存对象
• 方括号保存数据

//eg:一个名称对应一个值

"name":"Runoob"

//JSON 对象保存在大括号内。
//就像在 JavaScript 中, 对象可以保存多个 键/值 对：

{"name":"Runoob", "url":"www.runoob.com"}
//JSON数组json数组保存在中括号内
"sites":[
    {"name":"Runoob", "url":"www.runoob.com"}, 
    {"name":"Google", "url":"www.google.com"},
    {"name":"Taobao", "url":"www.taobao.com"}
]

JSON.parse()将JSON字符串转为javascript对象

var text = '{ "sites" : [' +
'{ "name":"Runoob" , "url":"www.runoob.com" },' +
'{ "name":"Google" , "url":"www.google.com" },' +
'{ "name":"Taobao" , "url":"www.taobao.com" } ]}';

var obj=JSON.parse(text);
console.log(obj)//{sites:Array(3)}  
// 0:{name:"Runoob",url:"www.runoob.com"}
// 1:{name:"Goole",url:"www.Goole.com"}
 //2:{name:"Taobao",url:"www.Taobao.com"}