随手总结 ----- 对象的操作

对象属性的增、删、改、查、判断

var obj = {}

// 对象属性的增加
obj.key1 = value1
obj['key2'] = value2

// 对象属性的读取
var x1 = obj.key1
var x2 = obj['key2']

// 对象属性的修改
obj.key1 = value3
obj['key2'] = value4

// 对象属性的删除
// delete 默认删除自身的属性，不删除__proto__上的
delete obj.key1
delete obj['key2']

// 判断该对象上是否有该属性
// 方法1 
// in即可判断自身属性，也可判断__proto__上的属性
console.log( key1 in obj ) // 有--true，没有--false
// 方法2  
// 对象名.hasOwnProperty('属性名')，只能判断自身的属性
console.log( obj.hasOwnProperty('key1') ) // 有--true，没有--false

// 冻结对象 
// Object.freeze( 对象名 )
var obj = {}
Object.freeze( obj )
obj.a = 1
console.log(obj) // {}
// const声明了一个常量，一旦声明，不能改变，
// 基本数据类型：值不能变，
// 引用数据类型：地址不可变

// 判断该对象是否为空
var obj1 = {}
var obj2 = { key:value }
// 方法1 
// JSON.stringify(对象名) 转为字符串
console.log(  JSON.stringify(obj1) == '{}' ) // true
console.log(  JSON.stringify(obj2) == '{}' ) // false
// 方法2
// Object.keys() 获取对象中所有属性并以数组形式表示
console.log (Object.keys(obj1).length == 0 ) // true
console.log (Object.keys(obj2).length == 0 ) // false
// 方法3
for (var key in obj1) {
    console.log('不空')
} // 不打印，''
for (var key in obj2) {
    console.log('不空')
} // 打印，'不空'
 
// Object.defineProperty()
// value和writable 不能与 get和set 共存
Object.defineProperty(obj, key, {
    value:value, // 设置value值
    writable:true/false, // 是否可修改，默认true
    configurable:true/false, // 是否可删除，默认true
    enumerable:true/false, // 是否可枚举，默认true
    get:function(){
        
        return value
    },
    set:function(newVal){
        
        return newValue
    }
})

// 对象解构
let person = { name: 'zhangsan', age: 20 }; 
let { name, age } = person;
console.log(name); // 'zhangsan' 
console.log(age); // 20
--------------------------------------
let {name: myName, age: myAge} = person; // myName myAge 属于别名
console.log(myName); // 'zhangsan' 
console.log(myAge); // 20

数据双向绑定原理

主要是通过 Object对象的defineProperty属性，重写data的set和get函数来实现的

数组解构

let [a, b, c] = [1, 2, 3];
 console.log(a)//1
 console.log(b)//2
 console.log(c)//3
//如果解构不成功，变量的值为undefined
let [d,e,f] = [1,2];//d=1,e=2 f=undefined
let [l,m,n,j,k] = "hello"; //字符串解构 
let [o,p,...q] = [1,2,3,4,5]; //q=[3,4,5];

深拷贝和浅拷贝

基本数据类型：都是深拷贝
引用数据类型：分深拷贝和浅拷贝

浅拷贝

// 只拷贝地址，不拷贝内容
var obj = {key:'value'}
var obj1 = obj
console.log(obj) // {key:'value'}
console.log(obj1) // {key:'value'}

obj.key = 'value1'
console.log(obj) // {key:'value1'}
console.log(obj1) // {key:'value1'}

obj1.key = 'value2'
console.log(obj) // {key:'value2'}
console.log(obj1) // {key:'value2'}

深拷贝

// 建立新地址，拷贝内容
var a = 1
var b = a
console.log(a) // 1
console.log(b) // 1

a = 2
console.log(a) // 2
console.log(b) // 1

b = 3
console.log(a) // 2
console.log(b) // 3
---------------------------------
// 方法1 循环赋值
var obj1 = {
    a:1,
    b:2
}
var obj2 = {}
for (var  key in obj1) {
    obj2[key] = obj1[key]
}
console.log(obj1) // { a:1, b:2 }
console.log(obj2) // { a:1, b:2 }

obj1.a = 3
obj1.b = 4
console.log(obj1) // { a:3, b:4 }
console.log(obj2) // { a:1, b:2 }

obj2.a = 5
obj2.b = 6
console.log(obj1) // { a:3, b:4 }
console.log(obj2) // { a:5, b:6 }
----------------------------------
var obj1 = {
    a:1,
    b:2,
    c:{
        d:3
    }
}
var obj2 = {}
function Obj(obj){
    for (var  key in obj) {
        if (obj[key] instanceof Object) {
            Obj(obj[key])
        } else {
            obj2[key] = obj[key]
        }
    }
    return obj2
}
console.log(Obj(obj1))