练习

考试/原题/es6/letconst.md

@@ -0,0 +1,252 @@
+# let const 相关
+
+## 选择
+
+1. 下面代码执行结果为
+code:
+
+```
+{
+  let a = 0;
+  a++
+}
+console.log(a)
+```
+A.0  B. 1   C.01  D.报错
+答案 D
+解析 执行结果为 报错 ReferenceError: a is not defined； let声明的变量只在代码块内部有效   var 声明的变量是在全局有效
+
+
+2. 下面代码执行结果为 
+code:
+
+```
+{
+  let a = 0;
+  var b = 1;
+}
+console.log(a)
+console.log(b)
+
+
+```
+A. 0,1  B.报错，1  C.报错 空  D. 1 undefined
+
+答案 C
+解析  a是在代码块中用let声明的，只能在代码块内部访问，所以从代码块外面访问不到  然后console.log(a) 就会报错   报错会阻塞下面代码的执行 所以后面的console.log(b) 不执行
+
+
+3. 下面代码执行结果为
+code:
+
+```
+let a = 1;
+let a = 2;
+var b = 3;
+var b = 4;
+console.log(b)
+console.log(a)
+
+a  // Identifier 'a' has already been declared
+b  // 4
+
+```
+A.4,报错  B.4,1   C.1,4  D.4,2 
+
+答案  A
+解析  结果为报错Identifier 'a' has already been declared 意为 a变量已经声明过了
+let 声明变量时，只能声明一次 不能重复声明  var 声明变量 可以声明多次
+
+4. 下面代码的执行结果为
+code 
+
+```
+for (var i = 0; i < 10; i++) {
+  setTimeout(function(){
+    console.log(i);
+  })
+}
+
+```
+A. 0~9  B.10个0  C.什么也不输出  D.10个10
+
+答案 D
+解析
+变量 i 是用 var 声明的，在全局范围内有效，所以全局中只有一个变量 i, 每次循环时，setTimeout 定时器里面的 i 指的是全局变量 i ，而循环里的十个 setTimeout 是在循环结束后才执行，所以此时的 i 都是 10。
+
+5. 下面代码的执行结果为
+code:
+
+```
+for (let j = 0; j < 10; j++) {
+  setTimeout(function(){
+    console.log(j);
+  })
+}
+
+```
+A.10个0   B.0~9  C.什么也不输出  D.10个10
+答案 B
+解析
+变量 j 是用 let 声明的，当前的 j 只在本轮循环中有效，每次循环的 j 其实都是一个新的变量，所以 setTimeout 定时器里面的 j 其实是不同的变量，即最后输出 12345。（若每次循环的变量 j 都是重新声明的，如何知道前一个循环的值？这是因为 JavaScript 引擎内部会记住前一个循环的值）。
+
+6. 下面两段代码的执行结果为
+code
+
+```
+console.log(a);  //ReferenceError: a is not defined
+let a = "apple";
+
+```
+
+```
+console.log(b);  //undefined
+var b = "banana";
+
+```
+
+A. 报错  undefined   B. undefined banana  C.undefined undefined  D. apple banana 
+
+答案  A
+解析
+变量 b 用 var 声明存在变量提升，所以当脚本开始运行的时候，b 已经存在了，但是还没有赋值，所以会输出 undefined。
+
+变量 a 用 let 声明不存在变量提升，在声明变量 a 之前，a 不存在，所以会报错。
+
+
+7. 下面代码的执行结果为
+code
+```
+const PI = "3.1415926";
+PI=3.14
+console.log("PI")
+
+```
+A.PI   B.3.1415926  C. 报错 什么都不输出   D.3.14
+
+答案  C
+解析  const 声明一个只读变量，声明之后不允许改变
+
+8. 下面代码的执行结果为 
+code
+
+```
+const PI = "3.1415926";
+
+const MY_AGE; 
+console.log(MY_AGE)
+
+```
+
+A.MY_AGE   B.报错 什么都不输出  C.3.1415926    D.undefined
+
+答案 B
+解析  报错信息为  Uncaught SyntaxError: missing = in const declaration   
+const 声明一个只读变量，声明之后不允许改变。意味着，一旦声明必须初始化，否则会报错。
+
+
+9. 下面代码的执行结果为
+```
+var PI = "a";
+if(true){
+  console.log(PI);  
+  const PI = "3.1415926";
+}
+
+```
+A.a   B.PI  C.ReferenceError: PI is not defined  D.3.1415926
+
+答案 C
+解析
+ES6 明确规定，代码块内如果存在 let 或者 const，代码块会对这些命令声明的变量从块的开始就形成一个封闭作用域。代码块内，在声明变量 PI 之前使用它会报错。
+
+
+10. 下面代码的执行结果为
+
+```
+function test(){
+  for (let i=1;i<3;i++) {
+    console.log(i)
+  }
+  console.log(i)
+}
+
+```
+A.1,2  B.2,2  C.undefined undefined  D.报错
+ 
+答案  D
+解析  
+1、i 脱离了块作用域，let声明的变量只有在块作用域重用小 所以报错
+2、我们没有声明i调用的时候应该报undefined错误，这里报is not defined ，这是为什么呢？是因为es6默认（强制）开启了严格模式“use strict”，如果在es5中需要开启严格模式的话，在js文件的顶部加上“use strict”
+严格模式：变量未声明不能引用
+
+11.下面不属于ECMAScript规范的范围的是：（ ）
+
+A、数据类型
+
+B、语法
+
+C、DOM事件
+
+D、内置对象和函数的标准库
+答案：C
+
+解析：DOM事件不属于ECMAScript的部分；ECMAScript定义的内容：语法、类型、原型和继承、内置对象和函数的标准库。
+
+考点： ECMAScript定义规范的理解，来自《第一节：什么是ES6？新手该如何理解》的内容。
+
+12.下面不属于关键字let的特点的是：（ ）
+
+A、只在 let 命令所在的代码块内有效
+
+B、会产生变量提升现象
+
+C、同一个作用域，不能重复声明同一个变量
+
+D、不能在函数内部重新声明参数
+答案：B
+
+解析：使用var关键字才会产生变量提升的现象。关键字let不会产生变量提升现象，所以必须先声明定义后使用，否则程序抛出异常。
+
+考点：关键字let的使用注意事项，来自《第二节：ES6新增了let关键字，干嘛用的？》的内容。
+
+13.关于关键字const，下列说法错误的是：（）
+
+A、用于声明常量，声明后不可修改
+
+B、不会发生变量提升现象
+
+C、不能重复声明同一个变量
+
+D、可以先声明，不赋值。
+答案：D
+解析：声明后必须赋值，负责程序会抛出异常。
+
+
+
+# 简答题
+
+1. 说出至少5个ES6的新特性，并简述它们的作用。
+
+答案 1).let关键字，用于声明只在块级作用域起作用的变量
+2).const关键字，用于声明一个常量
+3).解构赋值，一种新的变量赋值方式。常用来交换变量值，提取函数返回值，设置默认值等
+4).for-of遍历，可用来遍历具有Iterator接口的数据结构(Array,String,Set,Map,arguments,NodeList等)
+5).Set结构，存储不重复的成员的集合
+6).Map结构，键名可以是任何类型的键值对集合
+7).Promise对象，更合理、规范地处理异步操作。
+8).Class类，定义类和更简便地实现类的继承。
+
+2. es5和es6的区别
+答案 ECMAScript5，即ES5，是ECMAScript的第五次修订，于2009年完成标准化ECMAScript6，即ES6，是ECMAScript的第六次修订，于2015年完成，也称ES2015ES6是继ES5之后的一次改进，相对于ES5更加简洁，提高了开发效率
+
+3. var、let、const之间的区别
+   
+答案 var声明变量可以重复声明，而let不可以重复声明
+var是不受限于块级的，而let是受限于块级
+var会与window相映射（会挂一个属性），而let不与window相映射
+var可以在声明的上面访问变量，而let有暂存死区，在声明的上面访问变量会报错
+const声明之后必须赋值，否则会报错
+const定义不可变的量，改变了就会报错
+const和let一样不会与window相映射、支持块级作用域、在声明的上面访问变量会报错
+

考试/原题/es6/promise.md

@@ -0,0 +1,127 @@
+#promise
+
+## 填空
+下面的打印结果是什么
+```
+const promise = new Promise((resolve, reject) => {
+  console.log(1)
+  resolve()
+  console.log(2)
+})
+promise.then(() => {
+  console.log(3)
+})
+console.log(4)
+
+```
+答案  1 2 4 3
+
+
+下面打印结果是什么
+
+```
+const promise = new Promise((resolve, reject) => {
+  //resolve('success1')
+ 
+  resolve('success2')
+  reject('error)
+})
+
+promise
+  .then((res) => {
+    console.log('then: ', res)
+  })
+  .catch((err) => {
+    console.log('catch: ', err)
+  })
+
+```
+答案 then: success1
+
+下面打印结果是什么
+
+```
+
+Promise.resolve(1)
+  .then((res) => {
+    console.log(res)
+    return 2
+  })
+  .catch((err) => {
+    return 3
+  })
+  .then((res) => {
+    console.log(res)
+  })
+
+```
+
+答案 1 2
+
+下面打印结果是
+
+```
+
+let a = 1;
+const promise = new Promise((resolve, reject) => {
+  setTimeout(() => {
+    console.log('once')
+    console.log(a)
+    resolve(a++)
+  }, 1000)
+})
+
+const start = Date.now()
+promise.then((res) => {
+  console.log(res)
+})
+promise.then((res) => {
+  console.log(res)
+})
+
+```
+答案
+    once
+    1
+    1
+
+下面代码打印结果是
+
+```
+async function asyncFn() {
+    return 'hello world';
+}
+console.log(asyncFn())
+
+```
+答案：
+    Promise {<resolved>: "hello world"}
+
+
+下面代码打印结果是
+```
+
+async function asyncFn() {
+   	return 1;
+}
+asyncFn()
+.then(res => {
+    console.log(res);
+})
+
+```
+答案 1
+
+下面写法是否正确
+
+```
+let a = new Promise((res)=>{
+	console.log(1)
+	res(1)
+})
+function name(){
+	let a = await a;
+}
+
+```
+答案 错误

考试/原题/es6/setmap.md

@@ -0,0 +1,218 @@
+# setmap
+## 选择
+1. 下面哪个不是set的方法
+A.add  B.delete  C.has  D.get
+答案 D
+ 
+2. 下面代码执行的结果为
+
+```
+let set = new Set([1, 2, 3, 4, 4]);
+set.add(5)
+set.add(6)
+set.add(5)
+console.log(set.size)
+ 
+```
+A.8  B.5  C.6  D. 4
+答案  C
+
+3. 下面代码执行的结果为
+
+```
+let set = new Set([1, 2, 3, 4, 4]);
+set.set(5)
+set.add(6)
+set.add(5)
+console.log(set.size)
+ 
+```
+A.报错  B.5  C.6  D. 4
+答案  A
+
+4. 下面代码执行的结果为
+
+```
+var mySet = new Set([1, 2, 3, 4, 4]);
+console.log([...mySet]);
+
+ 
+```
+A.[1, 2, 3, 4, 4]  B.[1, 2, 3, 4]   C.[[1, 2, 3, 4, 4]]  D.[]
+答案 B
+
+
+5. 下面代码的执行结果为
+
+```
+var myMap = new Map();
+var keyObj = {}, 
+ 
+myMap.set(keyObj, "和键 keyObj 关联的值");
+console.log(myMap.get(keyObj)); 
+console.log(myMap.get({}));
+
+```
+A."和键 keyObj 关联的值" {}   B.报错 什么都不出  C.undefined  null D."和键 keyObj 关联的值"  undefined 
+答案 D
+解析
+ 因为 keyObj !== {}
+
+6. 下面代码的执行结果为
+```
+var myMap = new Map();
+var keyFunc = function () {}, // 函数
+ 
+myMap.set(keyFunc, "和键 keyFunc 关联的值");
+ 
+console.log(myMap.get(keyFunc)); // "和键 keyFunc 关联的值"
+console.log(myMap.get(function() {})) // undefined, 因为 keyFunc !== function () {}
+ 
+```
+A."和键 keyFunc 关联的值" "和键 keyFunc 关联的值" B.报错 什么也不出   
+C."和键keyFunc 关联的值"  undefined   D.undefined undefined
+
+答案 C
+
+7. 下面代码的执行结果为
+
+```
+var myMap = new Map();
+myMap.set(NaN, "not a number");
+ 
+console.log(myMap.get(NaN)); // "not a number"
+ 
+var otherNaN = Number("foo");
+console.log(myMap.get(otherNaN)); // "not a number"
+
+```
+A. 
+8.
+## 填空
+1. 下面代码执行后 size的值打印出来是
+
+```
+let s = new Set();
+s.add([1]);
+s.add([1]);
+console.log(s.size);
+
+```
+
+答案 2
+解析：
+这个问题类似于问这个：
+
+let a = [1];
+let b = [1];
+console.log(a === b); // false
+
+简单的说就是a和b是两个数组，两个引用对象，怎么可能相等呢？所以对于set来说，这俩不重复，所以是2！
+
+1. 下面代码执行后 con的值打印出来是
+答案 undefined
+解析 因为set的时候用的数组[1]和get的时候用的数组[1]是分别两个不同的数组，只不过它们元素都是1。它们是分别定义的两个数组，并不是同一个值。
+```
+let map = new Map();
+map.set([1],"ES6系列");
+let con = map.get([1]);
+console.log(con);
+
+```
+
+3. 用      声明一个set结构
+答案 new Set
+
+
+4. 通过           可以实现对set结构中元素的遍历
+   
+答案  for of   foreach
+
+
+
+4. 下面代码执行的结果为
+
+```
+
+var first = new Map([[1, 'one'], [2, 'two'], [3, 'three'],]);
+var second = new Map([[1, 'uno'], [2, 'dos']]);
+var merged = new Map([...first, ...second]);
+console.log(merged)
+ 
+```
+答案   { 1 → "uno", 2 → "dos", 3 → "three" }
+解析  合并两个 Map 对象时，如果有重复的键值，则后面的会覆盖前面的，对应值即 uno，dos， three
+
+
+4. 下面代码执行的结果为
+
+```
+
+var myMap = new Map();
+var keyString = "a string"; 
+ 
+myMap.set(keyString, "和键'a string'关联的值");
+ 
+var jieguo = myMap.get(keyString);    // "和键'a string'关联的值"
+var jieguo1 = myMap.get("a string");  
+console.log(jieguo,jieguo1)
+ 
+```
+答案 和键'a string'关联的值 和键'a string'关联的值  
+
+
+
+map 遍历生成函数及其作用
+答案 
+    Map.prototype.keys()：返回键名的遍历器。
+    Map.prototype.values()：返回键值的遍历器。
+    Map.prototype.entries()：返回所有成员的遍历器。
+    Map.prototype.forEach()：遍历 Map 的所有成员。
+
+
+
+
+## 简答题
+1. maps和objects的区别
+答案 
+     一个 Object 的键只能是字符串或者 Symbols，但一个 Map 的键可以是任意值。
+    Map 中的键值是有序的（FIFO 原则），而添加到对象中的键则不是。
+    Map 的键值对个数可以从 size 属性获取，而 Object 的键值对个数只能手动计算。
+    Object 都有自己的原型，原型链上的键名有可能和你自己在对象上的设置的键名产生冲突。
+
+
+2. WeakSet和Set的区别
+答案
+   
+WeakSet的成员只能是对象，而不能是其他类型的值
+WeakSet中的对象都是弱引用，即垃圾回收机制不考虑WeakSet对该对象的引用，也就是说，如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于WeakSet之中。这个特点意味着，无法引用WeakSet的成员，因此WeakSet是不可遍历的。
+
+
+3. set 和 map的区别 
+答案  Set是一种类似数组的集合类型，它与数组不同的是，不允许存在重复数据；常用操作方法有：add,delete,has,clear等；遍历使用forEach；
+
+Map是一种类似对象的集合类型，它与对象不同的是，key可以接受对象类型，常用的操作方法有：set,get,has,delete等；遍历使用forEach
+
+
+
+4. 定义一个函数 将传入的数组元素去重后返回（可以写多种方法）
+详见 https://segmentfault.com/a/1190000016418021?utm_source=tag-
+
+
+
+5. 用 foreach 和 for of  分别遍历下面这个set
+var myMap=new Map()
+myMap.set(0, "zero");
+myMap.set(1, "one");
+
+
+
+var first = new Map([[1, 'one'], [2, 'two'], [3, 'three'],]);
+var second = new Map([[1, 'uno'], [2, 'dos']]);
+var merged = new Map([...first, ...second]);
+
+
+6.module、import
+
+
+

考试/原题/es6/解构赋值.md

@@ -0,0 +1,153 @@
+# 解构赋值
+
+## 选择
+1. 下面代码执行后 a,b,c的值分别是
+
+```
+let [a, b, c] = [1, 2, 3];
+
+```
+A.1,2,3  B.2,3,1  C.未定义  D.undefined  undefined  undefined 
+
+答案 A
+解析  在解构中，有下面两部分参与：
+    解构的源，解构赋值表达式的右边部分。
+    解构的目标，解构赋值表达式的左边部分。
+
+2. 下面代码执行后 a,b,c的值分别是
+code 
+
+```
+let [a, [[b], c]] = [4, [[5], 6]];
+
+```  
+A.4 [5] 6   B.[4, [[5], 6]]  undefined undefined C.4,5,6  D. 4,[[5], 6]
+
+答案 C
+
+3. 下面代码执行后 a,b的值分别是
+code
+
+```
+let [a, , b] = [1, 2, 3];
+
+```
+A.1,2  B.1,3  C.2,3  D.1,3
+
+答案   D
+
+4. 下面代码执行后 a,b的值分别是
+CODE
+
+```
+let [a = 1, b] = []; // a = 1, b = undefined
+```
+
+A.1 undefined  B. 1 报错  C.[]  D. undefined  undefined
+
+答案 A
+
+5. 下面代码执行后  a b的值分别是
+code 
+```
+let [a, ...b] = [1, 2, 3];
+
+```
+
+A. 1;  2,3  B. 1;[1,2,3]  C.1,[2,3]  D.1,[]
+
+答案  C
+ 
+6. 下面代码执行后  a,b,c,e,d的值分别是
+code
+
+```
+let [a, b, c, d, e] = 'hello';
+
+``` 
+A h,e,l,l,o  B.h,e,l,o,l   C. 所有的都是undefined  D. 所有的都是空数组
+
+答案 B
+
+7. 下面代码执行后  a的值为
+code
+
+```
+let [a = 2] = [undefined]; // a = 2
+
+```
+A.2  B.undefined  C.[]   D.报错
+
+答案 A
+
+8. 下面代码执行后foo,bar 的值分别是
+code
+
+```
+let { foo, bar } = { foo: 'aaa', bar: 'bbb' };
+
+```
+A. foo bar  B.aaa,bbb  C.foo bbb  D.aaa bar
+
+答案 B
+
+9. 下面代码执行后foo 的值为
+code
+
+```
+let { baz : foo } = { baz : 'ddd' };
+
+```
+A. baz  B.foo  C.ddd  D.undefiend
+
+答案  C
+
+10. 下面代码执行后X 的值为
+code
+
+```
+let obj = {p: ['hello', {y: 'world'}] };
+let {p: [x, {  }] } = obj;
+
+```
+
+A.hello   B.world   C.p    D.obj
+
+答案 A
+
+11. 下面代码执行后x,y 的值分别为
+code
+
+```
+let obj = {p: [{y: 'world'}] };
+let {p: [{ y }, x ] } = obj
+
+```
+
+A.undefined  undefined  B. obj world  C. 报错  obj   D.undefined world 
+
+答案 D
+
+
+12. 下面代码执行后a,b,rest 的值分别为
+code
+
+```
+let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40};
+
+```
+
+A. 10  20  30,40   B.10  20  [30,40]   C.  10  20  []   D.undefined  undefined [] 
+
+答案  B
+
+
+13. 下面代码执行后aa,bb 的值分别为
+code
+
+```
+let {a: aa = 10, b: bb = 5} = {a: 3};
+
+```
+
+A. 3  5   B.10  5   C. 3  undefined   D. 报错