JavascripObject

Object对象

• 对象中属性的顺序
• 删除属性
• 多词key
• 静态对象
• 使用参数为key
• 对象的简单声明
• 对象是否包含属性判断
• 对象的比较
• 浅拷贝与深拷贝
• 构造器
• 可选链
• Symbol类型

对象中属性的顺序

对象中的属性，如果数字类型的key，顺序则是按照数字排序。如果是，字符类型的key，则按照创建的顺序排序。

删除属性

let test = {
	name: 'test',
	age: 30
}
//删除对象中的属性
delete test.age;
//也可以删除不存在的属性，不会报错
delete test.gender;

多词key

//对象中使用多词作key
test['gen der'] = 'man'
//取值
let gender = test['gen der'];
//删除
delete test['gen der'];

静态对象

//const声明的对象中的属性可以修改，但是当person=····的时候会报错
const person = {
	name: '小明',
	age: '12'
}

使用参数为key

方括号中可以使用表达式

let key = 'name'
let person = {}
person[key] = '小明'
peison[key+'test'] = 'test'
//2.
let key = 'name'
let person = {
	[key]: '小明',
	[key+'test']: 'test'
}

对象的简单声明

let persion = {
	name,
	gender
}

对象是否包含属性判断

let person = {
	name: '小明',
	gender: 'man'
}
//1.当age存在并且保存的就是undefined时，会判断失误
person.age === undefined //不存在age属性，返回undefined
//2.
'age' in person //false
'name' in person //true
//3.
let key = 'name'
key in person //true

对象的比较

针对对象的比较，'==' 和 '===='结果是一样的。都是比较两个值得引用。

let a = {};
let b = a; // 拷贝引用
alert( a == b ); // true，都引用同一对象
alert( a === b ); // true

let a = {};
let b = {}; // 两个独立的对象
alert( a == b ); // false

浅拷贝与深拷贝

浅拷贝：仅拷贝对象的第一层。

深拷贝：拷贝对象的完整属性。

1. 浅拷贝

let src1 = {
	test1: 'a',
	test2: 'b'
}
let src2 = {
	test3: 'c',
	test4: 'd'
}
let src3 = {
	test5: 'd',
	src4: {
		test6: 'e'
	}
}
let dest = {}
//将src1 ,src2所有属性都copy到dest中。可以用来合并对象。当时同名属性会被覆盖
Object.assign(dest,[src1, src2, src3···])
//这个时候修改dest.src4.test6,也会修改src3.src4.test6的值

2. 深拷贝

//将对象中的对象都单独copy一份，递归
//解决方式
JSON.parse(JSON.stringify(dest));

构造器

构造器实质也是一个函数。

• 构造器，一般使用大驼峰命名
• 构造器中的属性使用this.XXX定义
• 构造器的使用通过new。普通函数直接使用
• 构造器仅当返回值是一个对象是才会有效。没有返回值或者返回值是对象以外时，返回自身对象
• 当有许多需要创建单个复杂对象的代码时，可以使用构造器

function Person(name,gender){
	this.name = name;
	this.gender = gender;
	this.eat(){
		//eat something
	}
	this.run(){
		//run
	}
}
let person = new Person('小明','男');
person.eat();
person.run();

可选链

写法：?. 或者 ?.() 或者?.[]

说明：用于解决访问嵌套对象属性报错的问题。判断符号前的属性是null或者undefined就返回undefined。

//反例
let person = {}
//ERROR
person.name.address
//undefined
person?.name?.addreess
//相当于
person !== undefined && person.name !== undefined && person.name.address

//ERROR  原因：?.仅生效符号前的对象，此时person不为undefined，所以person?.name正常，但是person?.name为undefined，所以person?.name.address会报错
person?.name.address

let user = null;
user?.eat();//不会报错，返回undefined
person.eat?.();//如果person.eat()存在则调用
user?.[1];//返回undefined

Symbol类型

Symbol值表示唯一的标识符，有点类似全局变量。具有唯一，隐藏的特性。可用于给插件添加自己的属性等。

隐藏性

Symbol 允许我们创建对象的“隐藏”属性，代码的任何其他部分都不能意外访问或重写这些属性。Symbol在for…in中会被跳过。

let id = Symbol('id');
let id2 = Symbol('id');

id == id2 //false

//全局Symbol,重点是Symbol.for('attribute')。只有通过Symbol.for()获取的两个同样的attribute才是同一个Symbol。
let key = Symbol('key');
let key1 = Symbol.for('key'); // 如果该 Symbol 不存在，则创建它
key === key1 //false
let key2 = Symbol.for('key');
key1 === key2 //true 

//通过Symbol.keyFor()获取Symbol中的内容
Symbol.keyFor(key);//key 返回变量key所表示的Symbol中的内容

Symbol使用场景

• “隐藏” 对象属性。 如果我们想要向“属于”另一个脚本或者库的对象添加一个属性，我们可以创建一个 Symbol 并使用它作为属性的键。Symbol 属性不会出现在 for…in 中，因此它不会意外地被与其他属性一起处理。并且，它不会被直接访问，因为另一个脚本没有我们的 symbol。因此，该属性将受到保护，防止被意外使用或重写。
• JavaScript 使用了许多系统 Symbol，这些 Symbol 可以作为 Symbol.* 访问。我们可以使用它们来改变一些内置行为。例如，Symbol.iterator、Symbol.toPrimitive