ES6

ECMAScript 6 入门教程

1、let、const，var的区别？
var：（在ES5中，全局变量和window属性是等价的，var、function声明的全局可以用window.访问）
1、可以先定义后赋值，可以用window.访问
2、存在变量提升，定义的变量提升成全局变量
注意：1、变量提升只会提升变量的定义，不会提升变量的赋值，一般会出现undefined的情况
2、js引擎是先获取到所有声明的变量然后再执行
3、没有块级作用域，会穿透作用域
4、var声明的变量能重复定义
let：（在ES6中，let、const不能用window.访问）
1、通过let定义的变量不能拿window.访问
2、let声明的变量不能重复定义
3、let没有变量提升
4、外部的作用域拿不到内部的变量，但内部的变量可以使用外部的变量。
5、暂时性死区：只要块级作用域内存在let命令，它所声明的变量就“绑定”（binding）这个区域，不再受外部全局变量的影响
const：（通过let、const定义的变量，只在对应所在的代码块内有效）
1、不可以修改，通过const定义的变量不能拿window.访问
2、不能先定义后赋值
3、常量指向的对象不能修改，但是可以修改对象内部的属性的值，可以对属性值进行修改和增加，但是不能重新赋值
（如果是引用类型的话，不能改变是内存地址，但是可以改变引用类型的属性值）

2、解构赋值？（就是从复杂的数据结构中，提取到需要的值）
注意：
1、左右两边的数据类型必须是一样的，右边是数组，左边也必须是数组，对象也是一样
2、如果结构失败的话会返回undefined
3、左边变量可以赋默认值，当右边的变量全等于undefined时候才可以赋默认值，如果是null的话赋值不生效
4、如果对一个已经声明的变量进行解构赋值，一定要在最外层包一个大括号
5、解构赋值的拷贝是浅拷贝，解构赋值拷贝的是这个值的引用，而不是这个值的副本

      1、数组解构：（arr可以是字符串、数组、对象）  { data }
    let arr = ['111','222']
                let ['first'，'second'] = arr;   //将数据拆解开，然后再一个个赋值
                console.log(first，secomd)    111 ，222
      2、对象解构：（变量必须与属性同名，才能取到正确的值，因为对象是无序的）
    let { foo, bar } = { foo: 'aaa', bar: 'bbb' };
    console.log(foo, bar )    'aaa',  'bbb' 
      3、字符串解构：（相当于把字符串拆解开）
    const [a, b, c, d, e] = 'hello';
    console.log(a,b,c,d,e); //h e l l o
      4、函数参数的解构：（有undefined的话才可以实现解构的默认值）

      用途：
1、可以交换变量
2、从函数返回多个值
3、提取JSON的参数值
4、函数参数设置默认值
5、通过import导入模块的时候 	const { SourceMapConsumer, SourceNode } = require("source-map");

3、 模板字符串（ ）
1、字符串中带参数变量的拼接
1、在ES5中，字符串拼接一般都用 + 号进行字符串拼接
2、在ES6中，可以用 来包含字符串，如果有变量的可以用 ${}来包含变量
注意：可以在模板字符串中嵌入变量，也可以在里面调用函数
2、可用模板字符串对字符串进行换行操作

4、字符串新增方法？
1、字符串新增了一些api （includes、startsWith、endsWith）
注意：ES5用indexOf判断一个字符串是否包含在另一个字符串中
1、includes 判断字符串是否包含某个字符，返回true、false s.includes(‘o’)
2、startsWith 判断字符串的开头是否含有某个字符
3、endsWith 判断字符串的结尾是否含有某个字符
2、repeat：表示将字符串重复几次 str.repeat(2)
3、trimStart()，trimEnd()：可以消除头部或者尾部的空格
4、replaceAll：可以替换全部的字符

5、数值新增的方法？
1、Number.isNaN()：用来检查一个值是否为NaN，是的话返回true
2、将全局方法parseInt()、parseFloat()移植到Number对象上了 ------ Number.parseInt()
3、Number.isInteger()：用来判断一个数值是否为整数
4、Math.trunc(11.2)：用于去除一个数的小数部分，返回整数部分 ----- 11
5、Math.sign()：用来判断一个数到底是正数、负数、还是零

6、函数扩展？
1、函数中的参数是默认声明的，所以不能在函数内部再次声明。
2、函数参数可以配合解构赋值进行使用
3、函数有单独的作用域
4、rest参数（形式为…变量名）：用于获取函数的多余参数，将多余的参数放入数组中
注意，rest 参数之后不能再有其他参数（即只能是最后一个参数），否则会报错。
5、箭头函数可以与解构赋值结合使用
6、什么是尾调用？-------就是指某个函数的最后一步是调用另一个函数。
7、什么是尾递归？-------就是在尾调用自身，就称为尾递归（不会发生栈溢出（或者层层递归造成的超时），相对节省内存）
8、try…catch：catch代码块后面可能不需要使用参数，就不用写了

7、箭头函数：const func = （参数列表1，参数列表2）=> {}
注意：1、当参数列表只有1个的时候可以省略括号 const func = 参数列表1 => {}
2、返回值可以不用写return，直接返回 const mul = (n1,n2) => n1 + n2; console.log(mul(10,10));
3、this的使用（箭头函数需要注意作用域）
1、箭头函数本身是没有this的，它是向外层的作用域，一层层查找，直到有this的定义
2、箭头函数中的this是固定的
3、this指向函数定义生效时候所在的对象。
4、箭头函数不能当做构造函数使用，不能对箭头函数使用new关键字
因为箭头函数没有new.target(是用来检测函数是否被当做构造函数使用，他会返回一个指向构造函数的引用)
6、箭头函数没有prototype属性
8、因为箭头函数没有this，所有不能通过call，apply，bind修改this的指向
9、箭头函数返回值为一个对象时，你需要用小括号括起你想返回的对象。
注意：1、对象中的方法 不适用于使用箭头函数，因为对象没有作用域，导致箭头函数中的this指向全局，如果是普通函数的话就会指向这个对象

8、扩展运算符（…）：相当于 rest 参数的逆运算
1、 将一个数组转为用逗号分隔的参数序列 。--------- 常用于展开数组
应用：
1、 进行深拷贝数组：const a1 = [1, 2]; const a2 = […a1]; ------ES5用concat进行深拷贝数组
2、 用于数组合并： var arr = [1,2,3,4]; var brr = [11,22,33,44]; console.log([…arr,…brr])
2、 用于字符串转数组： var z = ‘zjw’ console.log([…z])
3、 用于数组转对象： var z = [‘1’,‘20’,’-5’,‘3’]; console.log({…z})

9、数组扩展？
1、Array.from()：可以将类数组对象或者可遍历的对象转为真正的数组。（包括 ES6 新增的数据结构 Set 和 Map）
类数组对象：键从0开始，而且键是一个字符串 ------ { ‘0’: ‘a’};
2、Array.of()： 用于将一组值，转换为数组 。（如果没有参数的话返回空数组）
Array.of(3, 11, 8) // [3,11,8]
3、copyWithin()：将数组中指定位置的成员复制到其他位置
4、find（function()）：只返回一个值，找到条件正确的值（只关注满足条件的第一个值，直接返回，如果没有符合的返回undefined）
[1, 4, -5, 10].find((n) => n < 0) -5
5、findIndex（function()： 返回满足条件的值的索引值
[1, 4, -5, 10].find((n) => n < 0) 2
6、includes() ：用来判断数组中是否包含某个给定的值
7、flat()：用于将嵌套的数组拉平，变成一维数组
[1, 2, [3, 4]].flat() // [1, 2, 3, 4]
8、arr.every()：所有内部对象返回是true返回的就是true
9、arr.some()：所有内部对象只要有一个是true返回的就是true
注意：
1、forEach：不支持break和continue

10、数组函数：
1、map：接收一个函数，将原数组中的所有元素，通过这个函数处理后放入新的数组，会返回一个新的数组，不会改原数组
let newArr = arr.map(s => parseInt(s))
注意：（映射----------对原数组进行一些操作，不会改变元素的数量）
1、函数内部必须有返回值，如果没有的话就是undefined
2、原数组的元素有几个，返回的新数组中就会有几个元素
3、经过map函数会将原数组中所有的元素进行处理一遍，会返回一个新的数组
4、新数组中的元素为原数组元素调用回调函数处理以后的值
5、map() 方法按照原数组的元素顺序依次处理元素
2、reduce：返回一个新的数组，对原数组中所有的元素进行汇总的操作，
第一个参数代表回调参数，第二个参数代表的是初始值为0（选填）
arr.reduce((a, b) => a + b)
3、filter 过滤器，会检查原数组中所有符合条件的的所有元素存入一个新的数组
注意：（过滤----------对原数组进行一些操作，可能会改变元素的数量）
1、返回一个新数组，会检查原数组中所有符合条件的的所有元素
2、第一个参数是回调函数，n代表的是每个数字
3、这个回调函数必须返回一个布尔值,当返回的是true时，自动将回调的n加入到新的数组中，当是false时，内部会过滤掉这次的n
4、回调操作完成会自动创建新的数组，接收即可
let newNums = num.filter(function (n) { //第一次的n等于10，进行判断n是否小于100，是true，存入到新数组里面
return n < 100;
})

11、对象的扩展？
1、对象的简洁表示法（属性名和属性值相同的情况下可以省略属性名）
2、对象的属性名可以用中括号包装属性名（可以在中括号中包含变量）
3、对象的每个属性都有一个描述对象，用来控制该属性的行为（Object.getOwnPropertyDescriptor(obj, ‘foo’)）
注意：
可以获取到数据劫持中的那几个属性：
1、enumerable：当为true的时候当前属性就是属于可遍历的，Object.assign，Object.keys都用到
为true的时候就是可枚举的属性
为false的时候就是不可枚举的属性
2、writable
3、configurable
4、链判断运算符：（?.）
如果想要读取对象内部的某个属性，往往需要判断一下该对象是否存在
5、Null值判断：（??）
当一个对象的属性值如果是null或者undefined的时候，给这个属性值赋默认值。
ES5处理方式：通过（||）赋默认值，但是如果属性值是空字符串、false、0的话也会给属性值赋上默认值
ES2020处理（??）：它的行为类似||，但是只有运算符左侧的值为null或undefined时，才会返回右侧的值
注意：因为优先级的问题，和其他逻辑运算符一块使用的时候需要加小括号来声明优先级

12、对象新增的方法？
1、Object.is()：用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致
2、Object.assign()：用于对象的合并，将源对象的所有可枚举属性（enumerable可枚举性），复制到目标对象
注意：
1、由于undefined和null无法转成对象，所以如果它们作为参数，就会报错。
2、如果合并的两个对象中属性名有重复的，处理方式是替换
3、 没有目标对象的时候属于浅拷贝--------Object.assign(a)
有目标对象的时候属于深拷贝-----------Object.assign({}，a)
-------------------------------------------------------------------------------
当对象中只有一级属性，没有二级属性的时候，此方法为深拷贝，
但是对象中有对象的时候，此方法，在二级属性以后就是浅拷贝
举例：
var obj = {
name: ‘zjw’, //属于深拷贝
age: 18, //属于深拷贝
like: {
item: ‘play’ //属于浅拷贝
}
}
var newObj = Object.assign({},obj)
// obj.name = ‘zzc’ //属于深拷贝
obj.like.item = ‘comp’ //属于浅拷贝
console.log(obj);
console.log(newObj);
用途：
1、为对象添加属性（ Object.assign(this, {x, y}) ）
2、为对象添加方法
3、克隆对象
4、合并多个对象
3、JavaScript 语言的对象继承是通过原型链实现的。ES6 提供了更多原型对象的操作方法
1、__proto__属性：用来读取或设置当前对象的原型对象（prototype）
4、Object.keys()：获取到当前对象中所有可遍历的键名，然后包装成一个数组返回。供for…of循环使用
5、Object.values()：获取到当前对象中所有可遍历的键值，然后包装成一个数组返回。供for…of循环使用
6、Object.entries()：将一个对象，返回成一个二维数组
7、Object.fromEntries()：将一个二维数组，返回成一个对象

13、Symbol？（属于原始数据类型，表示独一无二的值，创建之后不可以改变，
因为ES5 的对象属性名都是字符串，这容易造成属性名的冲突，所以常用于定义对象的唯一属性名。）
1、不能用new来修饰成对象，也可以用于解决全局变量命名冲突的问题
let sy = Symbol(‘name’)-----可通过传参数定义一个描述
console.log(obj[sy]);
2、Symbol 值不能与其他类型的值进行运算，会报错
3、Symbol 值可以转为布尔值和字符串，但是不能转为数值。
4、Symbol.prototype.description：用于获取Symbol的描述
let name = Symbol(‘cname’)
console.log(name.description);
5、Symbol 作为属性名，当遍历对象的时候，该属性不会出现在for…in、for…of循环中，
也不会被Object.keys()、Object.getOwnPropertyNames()、JSON.stringify()返回
6、Symbol.for()：重复使用同一个 Symbol 值
7、Symbol.keyFor() ：返回一个已登记的 Symbol 类型值的key。

14、Set数据结构？（Set类似于数组，但是它里面存储的成员值总是唯一的）
1、Set是一种新的数据结构，但是本身是个构造函数，使用 new 关键字和 Set 构造函数可以创建一个空集合，可以通过add，has对集合进行操作
2、Set也可以将函数，对象作为键
3、Set创建的集合，也会提供一个迭代器( Iterator)，但是它是通过values()获取这个迭代器

  例子： let a = new Set()
let arr = [1,2,3,5,7,6,5,2]
arr.forEach(e => {
    a.add(e)   ------------add方法表示向Set结构中加入成员，但是不会添加重复的值
})
console.log(a);  //[1,2,3,5,7,6]
  注意：
           1、通过Set创建出来的值是唯一的，没有重复的值，如果值重复之后会把重复的值过滤掉，
           2、a.add（value）：添加某个值，返回 Set 结构本身
           3、a.delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
           4、a.has(value)：返回一个布尔值，表示该值是否为Set的成员
           5、a.clear()：清除所有成员，没有返回值
           6、a.keys()：获取成员键名
           7、a.values()：获取成员键值
           8、a.size：获取成员个数
  用途：
           1、数组去重（扩展运算符和 Set 结构相结合，就可以去除数组的重复成员，也可以用map，filter）
   let array = [1,2,3,5,7,6,5,2]
   console.log([...new Set(array)]);  //需要用扩展运算符转换为普通的数组
           2、字符串去重
   [...new Set('ababbc')].join('')  //通过扩展运算符转为数组，然后再数组分隔为字符串

15、WeakSet和Set的区别？
1、WeakSet 的成员只能是对象，而不能是其他类型的值。
2、WeakSet 中的对象都是弱引用

16、Map数据结构？（Map类似于对象，传统对象的键名只能是字符串，但是Map中的“键”的范围不限于字符串，可以是各种类型的值（包括对象）都可以当作键）
1、Map提供了一种新的集合类型，通过new实例化一个Map构造函数可以创建一个空映射，可以通过set，get对映射进行操作
2、传统的Object 结构提供了“字符串—值”的对应，Map 结构提供了“值—值”的对应
3、Map创建出来的实例，可以提供一个迭代器(Iterator)，可以通过entries()获取这个迭代器

   例子：
const m = new Map();
const o = {p: 'Hello World'};
		
m.set(o, 'content')
m.get(o)  // "content"
   注意：
1、Map创建出来的键不能重复，如果键重复之后会把重复的过滤掉
2、m.set（key，value）：设置键名和键值
3、m.get（key）：获取键值
  用途：
           1、Map 转为数组（Map 转为数组最方便的方法，就是使用扩展运算符（...））	 
           2、Map 转为对象（如果所有 Map 的键都是字符串，它可以无损地转为对象。）	 

17、WeakMap和Map的区别？
1、WeakMap只接受对象作为键名（null除外），不接受其他类型的值作为键名。
2、WeakMap的键名所指向的对象，不计入垃圾回收机制

18、Proxy？（俗称拦截器，在访问或者修改目标对象之前架设一层“拦截”，外界对该对象的访问，都必须先通过这层拦截）
------------ （ES6 为了操作对象而提供的新 API）
1、ES6 原生提供 Proxy 构造函数，用来生成 Proxy 实例
var proxy = new Proxy(target, handler); -----（目标对象，用于定义拦截行为的对象）
2、Proxy的实例方法？
1、get：用于拦截某个属性的读取操作
2、set：用来拦截某个属性的赋值操作
3、this 问题
注意：
1、在 Proxy 代理的情况下，目标对象内部的this关键字会指向 Proxy 代理

19、Reflect？
------------ （ES6 为了操作对象而提供的新 API）

20、Promise（是一个对象也是一个构造函数，Promise使得异步流程可以写成同步流程，相比以前的回调函数更强大。）
概念：1、是一个异步操作的解决方案，用于对异步操作进行处理（网络请求），相当于异步操作和回调函数的中介
2、通过new一个构造函数会返回一个promise实例，这个实例对象上有一个then方法，用来指定回调函数。
（当进行网络请求的时候，会开启异步的任务，异步会处理网络请求，js的代码还会继续往下执行，
当网络请求回来数据的时候，会执行一个回调函数，在回调函数里面就可以拿到网络请求到的所有数据）
1、Promise构造函数需要接收一个函数作为参数，而且该函数的两个参数resolve、reject也必须是函数
2、当调用resolve函数的时候，就会回调到.then函数中， resolve(‘2222’) .then((data)
3、当调用reject函数的时候，就会回调到.catch函数中， reject(‘error message’) .catch((err)
4、promise有三种状态（sync：同步，async：异步）
1、pending：等待状态 （在new Promise的时候会返回一个等待的状态，就会发送异步的时候，比如说正在进行网络请求的时候，等待响应）
2、fulfill：满足状态 （当我们调用resolve函数，就会进行回调then函数）
3、reject：拒绝状态 （当我们调用reject函数，就会进行回调catch函数）
4、finally()：最后执行的
5、promise.all()：（可以支持多个并发请求）当这两个异步操作都完成之后，再执行then，相当于如果需要两个请求都完成之后再执行，可以包装两个异步请求，
回调之后的.then返回的结果显示的数据是一个数组。。。。。
Promise.all([
this.$chat.getUserInfo(this.$chat.user_id),
this.$chat.getUserInfo(this.target_userid)
]).then(res => {
console.log(res);
})
6、是一个构造函数，原型上有then、catch等方法，可以通过该构造函数生成promise的实例

21、Iterator（遍历器对象） 和 for…of 循环？
1、Iterator是一种统一的接口机制，用来处理所有不同的数据结构。它是一种接口，为各种不同的数据结构提供统一的访问机制
注意：
1、任何数据结构只要部署 Iterator 接口，就可以完成遍历操作
2、当使用for…of循环遍历某种数据结构时，该循环会自动去寻找 Iterator 接口。
3、只要是一种数据结构部署了 Iterator 接口，我们就称这种数据结构是“可遍历的”
4、一个数据结构只要部署了Symbol.iterator属性，就被视为具有 iterator 接口，就可以用for…of循环遍历它的成员

  Iterator的作用？
        1、为各种数据结构，提供一个统一的、简便的访问接口
        2、使得数据结构的成员能够按某种次序排列
        3、ES6 创造了一种新的遍历命令for...of循环，Iterator 接口主要供for...of消费

  Iterator 的遍历过程？（next方法用来移动指针）
        1、创建一个指针对象，指向当前数据结构的起始位置。也就是说，遍历器对象本质上，就是一个指针对象
        2、第一次调用指针对象的next方法，可以将指针指向数据结构的第一个成员
        3、不断调用指针对象的next方法，直到它指向数据结构的结束位置
        注意：
               1、每一次调用next方法，都会返回数据结构的当前成员的信息，value属性是当前成员的值，done属性是一个布尔值，表示遍历是否结束

   原生具备 Iterator 接口的数据结构？
       1、Array----------------------因为Array原生就部署了Symbol.iterator属性
       2、Set，Map
       3、String
          注意：
               1、Object是不具备的 Iterator 接口的数据结构
                    （是因为对象的哪个属性先遍历，哪个属性后遍历是不确定的，需要开发者手动指定，没有Symbol.iterator属性）

22、Generator函数？（是 ES6 提供的一种异步编程解决方案，用内部的yield可以暂停执行的函数，通过next()方法执行函数）
1、Generator是一个状态机，封装了多个内部状态，返回一个遍历器对象，返回的遍历器对象可以依次遍历Generator 内部的每一个状态
2、如果函数内部没有yield的话，就相当于是一个暂缓执行函数，因为普通函数调用会立即执行，Generator函数调用的话不会立即执行，而是需要调用next方法执行

        和普通函数的区别？
            1、function关键字和函数名中间有个*号 
            2、函数内部用yield来定义不同的内部状态 
            3、调用函数之后不会立即执行，因为返回的遍历器对象（Iterator 接口），所以需要调用next()方法执行
        
        yield的作用？
            1、因为返回的是一个遍历器对象，必须调用next才会遍历下一个内部状态，
                 所以用yield其实就是提供了一种可以暂停执行的函数。yield表达式就是暂停标志。

       return 和 yield的区别？ 
            1、yield可以在函数内部存在多个，但是return只能存在一次。
            2、遇到yield函数会暂停执行，但是return不可以

       用途？
            1、Generator 可以暂停函数执行，返回任意表达式的值。这种特点使得 Generator 有多种应用场景。
            2、利用 Generator 函数，可以在任意对象上部署 Iterator 接口。

23、async/await？（是Generator函数的语法糖，相当于是 *号替换成axync，yield替换成await，实际上将Generator 函数和自动执行器，包装在一个函数里）
async：
1、async返回是Promise对象，可以用.then方法添加回调函数，遇到await就会等待，等await获取到结果之后，再执行函数体后面语句
2、async中return返回的值，就会成为then方法中回调函数中的参数。
3、async中内部抛出错误，就会被Promise变成reject状态，抛出的错误会被catch捕获，可以用（throw new Error(‘出错了’)；）抛错误
4、async返回的Pormise对象，它的Pormise状态必须等到内部所有的await执行完毕才会发生改变（或者遇到return或者抛出错误才会改变状态）
----------------意思就是只有async内部的异步操作执行完毕之后，才会执行then方法的回调

   await：
        1、await一般后面跟的是Promise对象，会返回该对象的结果，如果不是Promise对象，就直接返回值
        2、async中只要有一个await返回的Promise是reject状态，整个函数在当前的await处终止执行，整个async的状态就是reject
        3、多个await一块执行影响效率，因为只有一个await执行完毕才会执行下一个，可以用Pormise.all同时触发
             （let [foo, bar] = await Promise.all([getFoo(), getBar()]);）

  await抛出错误之后怎么不影响后面代码运行？
        1、将await放入到try..catch..中，多个await都可放入里面
        2、在当前await返回的Promise对象中跟一个catch方法，用于捕获await抛出的错误

  async比Generator的优点？
        1、Generator函数不能自动执行，需要co模块充当执行器，而async跟普通函数调用一样
        2、async返回的是Promise，而Generator函数返回的遍历器对象，还需要用next方法执行
        3、语义明确

24、Class？（是对象的模板，类的本身还是函数，而且类的本身指向的是构造函数(constructor),通过new来生成实例对象）
1、通过类new生成多个实例对象，它们是相等的，因为生成的实例对象共享同一个原型对象，所有它们的__proto__属性是相等的。
2、在类的内部，可以使用get和set对属性值进行拦截操作
3、大多数浏览器的 ES5 实现之中，每一个对象都有__proto__属性，指向对应的构造函数的prototype属性

 constructor()：----------构造函数
       1、constructor()是构造方法，通过new生成对象的时候自动调用constructor方法，而构造函数的内部会默认返回实例对象，就是返回this
       2、constructor(){ } 来声明一个构造函数（在创建类的时候，构造函数用于初始化数据创建对象，赋初始值）
       3、在ES5期间，如果使用类的话，就需要生成构造函数，然后去原型上添加方法，再通过new关键字实例化之后可以使用

 类的继承？--------Class通过extend实现继承，而ES5是通过原型链进行继承。
       1、在继承类中super代表的是父类的构造函数，用于新建父类的this对象
       2、子类必须在构造函数中调用super，否则新建实例会报错。
                （因为子类的this对象，必须先通过父类的构造函数进行塑造，从而得到和父类相同的实例属性和方法）
       注意：
             1、如果子类不调用super方法，子类就得不到this对象 
             2、只有先调用super才能使用this，因为只有super才能调用父类实例

 注意：
       1、ES5中用原型声明的类，会存在引用类型的问题（从一个变量向另一个变量复制引用类型的值，复制的其实是指针，所以两个变量都指向同一个对象）
                 而ES6中用class声明的类最主要的就是解决了引用类型的问题，
                 如果修改实例中对象中的某一个属性，那么所有实例中的属性都会跟着修改。
       2、对象实例可以访问原型中的值，但不能重写原型中的值 （由new出来的对象就叫做实例）
       3、如果对象实例中定义了和原型重名的属性，那么该属性就会屏蔽原型中的那个属性，但并不会重写。

25、Module模块加载？（import/export）
ES5：CommonJS用于加载服务器，AMD用于加载浏览器。
两者都属于运行时加载，意思就是整体加载模块，加载所有的方法，然后生成一个对象，根据需要从对象中提取方法

  ES6：import(导入)/export(导出)。
          属于编译时加载，意思就是只加载需要的方法，不用加载所有的方法，其他的不用加载

  export：
         1、将内容当做一个模块，通过export命令对外部输出变量、函数、类都可以，配合解构一起使用
         2、可以通过as关键字对输出的变量进行重命名
         3、export命令规定的是对外的接口，必须与模块内部的变量建立一一对应关系
         4、export导出的值是动态的，CommonJS导出的值是缓存的
         注意：
             exprot default：
                   设置当前文件的默认输出，而导入的时候可以任意设置名字进行使用，而且不在需要用花括号{}来包裹
  import：
         1、通过{}将导出的接口名称相同，也可以通过as关键字对输入的变量重命名，
         2、只读，不可以修改
         注意：
             整体加载（*）：
                   用星号（*）来指定一个对象，所有输出值都加载在这个对象上面，然后通过as设置别名，用对象的方式来使用

   ES6 模块输出 和 CommonJS的区别？
        1、CommonJS 模块输出的是一个值的拷贝，ES6 模块输出的是值的引用
        2、CommonJS 模块是运行时加载，ES6 模块是编译时输出接口
        3、CommonJS 模块的require()是同步加载模块，ES6 模块的import命令是异步加载，有一个独立的模块依赖的解析阶段。

   用途？
        1、按需加载，不用加载全部，提高运行速度 
        2、条件加载，可以配合if语句进行加载