js对象
在前面，我们有介绍过，在JavaScript中，数据类型整体上来讲可以分为两大类：简单数据类型 和复杂数据类型。
简单数据类型一共有6种，分别是我们前面介绍过的
string , number , boolean , null , undefined 以及本章将会介绍的 symbol
而复杂数据类型就只有1种
object
也就是我们本章将会向大家所介绍的对象。事实上，我们前面已经遇到过一些对象了。例如之前 所介绍过的数组就是一种对象，不过它是JavaScript语言中内置的对象。在本章中我们将学习到 如何自定义对象，以及一些其他的内置对象。
本章将学习如下内容：
・创建对象的方式
・访问对象属性的方式
・对象常用的属性和方法
・对象的嵌套与解构
- this关键字
・JSON对象
- Math对象
- Date对象
•正则表达式
6-1对象基础介绍
6-1-1 JS对象概述
JavaScript里面的对象就是一组键值对的集合。这些键一般由字符串构成，而值可以是任意数据 类型。比如字符串，数字，布尔，数组或者函数。一般来讲，如果一个键映射的是一个非函数的 值，我们将这个值称之为该对象的属性，而如果一个键映射的是一个函数的值，那么我们将其称 之为方法。
6-1-2创建对象
要创建一个对象，我们只需要输入一对大括号即可。这样我们就可以创建一个空的对象，如下:
let objName = {};
创建好对象以后，我们就可以给该对象添加相应的属性，例如这里我们给xiejie这个对象添加 相应的属性
let xiejie = {};
xiejie.name = "xiejie";
xiejie.age = 18;
xiejie.gender = "male";
xiejie.score = 100;
当然，和前面为大家介绍过的数组一样，我们可以在创建对象时就给对象添加好属性信息，如 下：
let xiejie = {
name : "xiejie",
age : 18,
gender : "male",
score : 100
};
可以看到，当我们创建包含属性的对象的时候，属性与属性之间是以逗号隔开的。这里我们可以 将属性名称之为键，属性对应的称之为值。所以，正如开头我们所介绍的那样，对象是由一个一 个键值对组成的。
6-1-3访问对象属性
访问对象的属性的方法有3种：点访问法，中括号访问法，symbol访问法
- 点访问法
我们可以通过一个点.来访问到对象的属性，如下：
let xiejie = {
name : "xiejie",
age : 18,
gender : "male",
score : 100
};
console.log(xiejie.name);//xiejie
console.log(xiejie.age);//18 console.log(xiejie.gender);//rnale
console.log(xiejie.score);//100
- 中括号访问法
第二种方法，是使用中括号法来访问对象的属性，如下：
let xiejie = {
name : "xiejie",
age : 18,
gender : "male",
score : 100
};
console.log(xiejie["name"]);//xiejie console.log(xiejie["age"]);//18
console.log(xiejie["gender"]);//male console.log(xiejie["score"]);//100
—般来讲，访问对象属性的时候使用点访问法的情况要多一些，那什么时候使用中括号访问方法 呢？当我们的属性名来自于变量的时候，这个时候中括号就要比点要灵活许多。来看下面的例 子：
let xiejie = {
name : "xiejie",
age : 18,
gender : "male",
score : 100
};
let str = "name"; console.log(xiejie[str]);//xiejie
既然讲到了对象属性的中括号访问法，那我们就顺带介绍一下伪数组对象的原理。前面给大家介 绍过的argument s就是一个伪数组对象。伪数组对象的原理就在于对象的键都是数字。如果属性 名是数字的话，通过中括号法来访问时可以不用添加引号，如下：
let obj = {
1 : "Bill",
2 : "Lucy",
3 : "David"
}
console.log(obj[1]);//Bill
console.log(obj[2]);//Lucy
console.log(obj[3]);//David
这样，就形成了给人感觉像是数组，但是并不是数组的伪数组对象。
- symbol访问法
在ES6之前，对象的属性名都只能是字符串。但是这样很容易造成属性名的冲突。比如我们使用 了一个别人提供的对象，然后我们想在这个对象的基础上进行一定的扩展，添加新的属性，这个 时候由于并不知道原来的对象里面包含哪些属性名，所以很容易就把别人的对象所具有的属性给 覆盖掉了。示例如下：
//假设person对象是从外部库引入的一个对象
let person = {
name : "xiejie"
}
console.log(person.name);//xiejie
person.name = "yajing"; console.log(person.name);//yajing
可以看到，这里两个name就产生了冲突，下面的name就把上面的name给覆盖掉了。
从ES6开始，新增了symbol这种数据类型，专门来解决这样的问题。创建symbol,需要使 用Symbol。函数，其语法如下：
let sym = Symbol(描述信息)；
示例：
let name = Symbol("这是一个名字");
console.log(name);//Symbol(这是一个名字) console.log(typeof name);//symbol
这里的描述信息是可选的，是对我们自己创建的symb。l的一个描述。接下来我们来用symb。l作 为对象的属性，示例如下：
let person = {
name : "xiejie"
}
let name = Symbol("这是一个名字");
person[name] = "yajing";
console.log(person.name);//xiejie console.log(person[name]);//yajing
可以看到，使用symbol来作为对象的属性，避免了同名的属性名发生冲突。
有些时候我们希望在不同的代码中共享一个symbol，那么这个时候可以使用Symbol.for()方法 来创建一个共享的symbol。ES6提供了一个可以随时访问的全局symb。l注册表。当我们使 用Symbol.for()方法注册一个symbo l的时候，系统会首先在全局表里面查找对应的参数的 symbol是否存在，如果存在，直接返回已经有的symbol,如果不存在，则在全局表里面创建一 个新的symbol
let obj = {};
let name = Symbol.for("test");
obj[name] = "xiejie";
let name2 = Symbol.for("test"); console.log(obj[name2]);//xiejie
如果使用Symbol.for()方法创建symbo l的时候没有传递任何参数，那么也会将undefined作为 全局表里面的键来进行注册，证明如下：
let obj = {};
let name = Symbol.for();
obj[name] = "xiejie";
let name2 = Symbol.for(undefined); console.log(obj[name2]);//xiejie
ES6里面还提供了 Symbol.keyFor()方法来查找一个symbo l的键是什么。但是需要注意的是， 该方法只能找到注册到全局表里面的symbol的键。如果是通过Symbol。方法创建的symbol,是 无法找到的。这其实也很好理解，通过Symbol()方法创建的symbo l都不存在有键。
let obj = {};
let name1 = Symbol("test1");
let name2 = Symbol.for("test2");
let i = Symbol.keyFor(namel);
let j = Symbol.keyFor(name2);
console.log(i);//udnefined console.log(j);//test2
前面有提到，如果一个对象的属性对应的是一个函数，那么这个函数被称之为对象的方法。访问 对象方法的方式和上面介绍的访问对象属性的方式是一样的，可以通过点访问法，中括号访问法 以及symbo l访问法来进行对象方法的调用。
let walk = Symbol("this is a test"); let person = {
name : "xiejie", walk : function(){ console.log("I'm walking");
},
[walk] : function(){ console.log("I'm walking,too");
}
}
person.walk();//I'rn walking person["walk"]();//I'm walking person[walk]();//I'm walking,too
6-1-4删除对象属性
对象的任何属性都可以通过delete运算符来从对象中删除。示例如下：
let person = {
name : "xiejie",
age : 18,
walk : function(){
console.log("I'm walking");
}
}
console.log(person.age);//』8
delete person.age;//删除age 这个属性
console.log(person.age);//undefined
person.walk();//I'm walking
delete person.walk; //删除walk方法 person.walk();//指错
//TypeError: person.walk is not a function
如果是删除的是属性，那么再次访问值为变为undefined，而如果删除的是方法，那么调用时会 直接报错
6-1-5对象常用属性和方法
1. in操作符
该操作符用于判断一个对象是否含有某一个属性，如果有返回true，没有返回false。需要注意的 是目前为止还无法判断对象的symb。l属性的包含情况，如果属性是symbol,那么会直接报错
let person = {
name : "xiejie",
age : 18,
walk : function(){
console.log("I'm walking");
}
}
let gender = Symbol("person's gender");
person[gender] = "male";
console.log("name" in person);//true console.log("age" in person);//true console.log([gender] in person);//灰错
//TypeError: Cannot convert a Symbol value to a string
但是需要注意，虽然上面给出了无法转换的错误，不过如果我们按照下面的方式来查看的话，是
会返回true的
let person = {
name : "xiejie",
age : 18,
walk : function(){
console.log("I'm walking");
}
}
let gender = Symbol("person's gender");
person[gender] = "male"; console.log("name" in person); // true console.log("age" in person); // true console.log(gender in person); // true
2. for..in
这个for..in我们在前面讲解遍历数组的时候已经见到过了。可以使用for..in来取出数组的键。除此 之外，我们还可以使用for..in来循环遍历一个对象的所有属性，示例如下：
let person = {
name : "xiejie",
age : 18,
walk : function(){
console.log("I'm walking");
}
}
for(let i in person){
console.log(i);
}
// name
// age
// walk
需要注意的是，使用for..in虽然说可以遍历出一个对象的所有的属性和方法(包括继承的，关于继 承后面会介绍)，但是无法遍历出用symbol来定义的属性，证明如下：
let person = {
name : "xiejie",
age : 18,
walk : function(){
console.log("I'm walking");
}
}
let gender = Symbol("person's gender");
person[gender] = "male";
for(let i in person){
console.log(i);
}
// name
// age
// walk
那么，这个时候可能有人会问了，那我如何才能遍历出一个对象的s ymbo l属性呢？这里介绍两种 方式。
第一种是使用Object.getOwnPropertySymbols()来返回一^对象所有的symbo l属性，如下：
let person = {
name : "xiejie",
age : 18,
walk : function(){
console.log("I'm walking");
}
}
let gender = Symbol("person's gender");
person[gender] = "male";
console.log(Object.getOwnPropertySymbols(person));
//[ Symbol(person's gender)]
除了上面的方法以外，ES6中还提供了一个叫做Reflect.ownkeys()方法。该方法可以遍历出 —个对象的所有类型的键名，包括字符串的键名以及symbo l键名
let person = { name : "xiejie",
age : 18,
walk : function(){
console.log("I'm walking");
}
}
let gender = Symbol("person's gender"); person[gender] = "male";
console.log(Reflect.ownKeys(person));
//[ 'name', 'age', 'walk', Symbol(person's gender)]
3. keys。，values。，entries。
前面在介绍遍历数组，集合以及映射的时候，有介绍过这3个方法，分别用于找出可迭代对象的 键，值，以及键和值。实际上，我们的对象也是属于可迭代对象的一种，所以也可以使用这3个 方法来找出对象的键和值
Object.keyO
let person = {
name : "xiejie",
age : 18,
walk : function(){
console.log("I'm walking");
}
}
let gender = Symbol("person's gender"); person[gender] = "male";
for(let i of Object.keys(person)){
console.log(i);
}
// name
// age
// walk
Object.valuesO
let person = { name : "xiejie", age : 18,
walk : function(){
console.log("I'm walking");
}
let gender = Symbol("person's gender"); person[gender] = "male";
for(let i of Object.values(person)){ console.log(i);
}
// xiejie
// 18
// [Function: walk]
Object.entriesO
let person = { name : "xiejie", age : 18,
walk : function(){
console.log("I'm walking");
}
}
let gender = Symbol("person's gender"); person[gender] = "male";
for(let i of Object.entries(person)){ console.log(i);
}
// [ 'name', 'xiejie' ]
// [ 'age', 18 ]
// [ 'walk', [Function: walk] ]
6-1-6嵌套对象
—个对象里面可以包含其他的对象，这个我们称之为对象的嵌套。示例如下:
let family = { xiejie : {
age : 18,
gender : "male"
},
song : {
age : 20,
gender : "female"
}
};
当我们访问嵌套对象里面的值的时候，和访问单个对象的方式是一样的。
let family = {
xiejie : {
age : 18, gender : "male"
},
song : {
age : 20, gender : "female"
}
};
console.log(family.xiejie.gender);//male 点访问法 console.log(family["song"]["age"]);//20 中括号访问法
对象的解构
在前面介绍解构的时候，我们有介绍过数组的解构。实际上对象我们也是可以将其解构的。解构 的方式也是和解构数组是类似的，示例如下：
let a = {name:"xiejie",age:18};
let b = {name:"song",age:20};
let {name:aName,age:aAge} = a; let {name:bName,age:bAge} = b; console.log(aName);//xiejie console.log(aAge);//18 console.log(bName);//song console.log(bAge);//20
当属性名和变量名一致的时候，可以进行简写，示例如下:
let a = {name:"xiejie",age:18};
let {name,age} = a;
console.log(name);//xiejie console.log(age);//18
和数组一样，同样可以解构嵌套的对象，如下：
let family = { xiejie : {
age : 18, gender : "male"
},
song : {
age : 20,
gender : "female"
}
};
let {xiejie,song} = family;
console.log(xiejie);//f age: 18, gender: 'male' } console.log(song);//f age: 20, gender: 'female' }
顺便一提的是，解构我们也是可以像函数一样设置一个默认值的，这里一起来看一下，如下:
let {name="xiejie",age} = {}; console.log(name);//xiejie console.log(age);//undefined
这里我们为name变量设置了一个默认值为xiejie，当我们解构一个空对象的时候，name变量的值 就使用了默认的xiejie这个值，而age这个变量由于没有设置默认值，所以值为undefined。
当然，既然叫做默认值，和函数一样，如果有解构的值传过来的话，肯定就是使用解构传过来的 值，如下：
let {name="xiejie",age} = {name:"song",age:10}; console.log(name);//song console.log(age);//10
6-1-7对象作为函数参数
对象字面量也可以作为函数的参数进行传递。这在有很多形式参数的时候非常有用，因为它允许 我们在调用函数时不用记住参数的顺序。
我们先来看一下我们一般函数调用的例子，如下：
let test = function(name,age){
console.log('我叫${name},我今年${age}岁');
}
test("xiejie", 18);//我叫xiejie,我今年 18岁 test(18,"xiejie");//我叫 18,我今年xiejie岁
可以看到，以前我们调用函数传递参数时，参数的顺序是必须要和形式参数的顺序一致的。否则 就会出现上面第2次调用函数的情况，输出不符合预期的结果。
当我们使用对象字面量来最为形式参数时，就可以不用按照定义函数时形式参数的顺序，只要名 字相同即可，如下：
let test = function({name,age}){
console.log('我叫${name},我今年${age}岁');
}
test({name:"xiejie",age:18});我今年 18 岁 test({age:18,name:"xiejie"});//^^AXiejie,我今年 18 岁
可以看到，只要参数名能对上号，位置是可以随意放置的。
和前面介绍函数的参数默认值一样，当对象字面量作为参数的时候，我们也可以为字面量的每一 项设置一个默认值，甚至我们还可以给整个对象字面量一个默认值，示例如下：
//给整个对象字面量一个默认值{ name:"BilT,age:20}
let test = function({name = "xiejie",age = 18} = {name:"Bill",age:20}){ console.log('我叫${name},我今年${age}岁');
}
test();//我叫Bill,我今年20岁
test({});//我叫xiejie,我今年 18岁 test({name:"yajing"});//我〃V/ajing,我今年 18 岁 test({age:1,name:"xizhi"});//我〃AXizhi,我今年 1 岁
这种技术被称之为命名参数，经常被用在函数有很多可选参数的时候。
6-1-8 this关键字
既然学习到了对象，那么有必要介绍一下this关键字。this ,翻译成中文就是这个的意思。 当我们在一个对象中使用this关键字时，该关键字就代表的是当前对象。来看下面的例子：
let person = {
name : 'xiejie',
age : 18,
intro : function(){
console.log(this);
// { name: 'xiejie', age: 18, intro: [Function: intro] } console.log('My name is ${this.name},I'm ${this.age} years old'); // My name is xiejie,I'm 18 years old
}
}
person.intro();
这里我们调用了 person对象的intro方法，里面涉及到了 this关键字。由于是在对象里面，所 以this指向当前对象，也就是person这个对象。所以this.name等价
于 person.name , this.age 等价于 person.age。
6-1-9命名空间(扩展)
当相同的变量和函数名被共享在同一作用域的时候，就会发生命名冲突。这看起来不太可能，但 是我们可以想象一下，随着时间的推移，我们已经写了很多的代码，可能不知不觉就重用了一个 变量名。如果是使用的其他开发者的代码库，这种问题就变得更加有可能。
解决命名冲突的方式，就是使用对象字面量来为一组相关函数创建一个命名空间。这样在调用这 些函数的时候需要先写上对象名，这里的对象名就充当了命名空间的角色。示例如下：
let myMaths = {
//求平方函数
square : function(x){
return x * x;
},
//传入数组求平均值函数
avg : function(arr){
let total = arr.reduce((a,b) => a + b);
return total / arr.length;
}
}
let arr = [1,2,3,4,5];
console.log(myMaths.avg(arr));//3
console.log(myMaths.square(5));//25
这里我们的myMaths就是我们的命名空间，这样就不用担心和其他人的变量或者函数名发生命 名冲突。
