JS知识点

用于循环的foreach和map有什么区别

用过那些es6相关知识点

let var const的区别

对于promise的怎么样理解的

promise的构造函数是同步执行还是异步执行, then方法呢?

用于循环的foreach和map有什么区别

forEach(): 针对每一个元素执行提供的函数。
map(): 创建一个新的数组，其中每一个元素由调用数组中的每一个元素执行提供的函数得来。


forEach()方法不会返回执行结果，而是undefined。

也就是说，forEach()会修改原来的数组。而map()方法会得到一个新的数组并返回。

用过那些es6相关知识点

 let、const 
 
 箭头函数
 
 函数参数默认值
 
 扩展运算符[...]
 
 new Set
 
 ES6 允许声明在对象字面量时使用简写语法
 
 结构赋值
 
 模板字符串
 
 for...of VS for...in
 
 Map
 
 Class
 
 Symbol
 
 Promises

Map

ES6 中新的数据结构集。事实上每个对象都可以看作是一个 Map。

var myMap = new Map();

var keyString = "a string",
    keyObj = {},
    keyFunc = function () {};

// 设置值
myMap.set(keyString, "value 与 'a string' 关联");
myMap.set(keyObj, "value 与 keyObj 关联");
myMap.set(keyFunc, "value 与 keyFunc 关联");

myMap.size; // 3

// 获取值
myMap.get(keyString); // "value 与 'a string' 关联"
myMap.get(keyObj); // "value 与 keyObj 关联"

Set

Set 对象是一组不重复的值，重复的值将被忽略，值类型可以是原始类型和引用类型, Set是ES6新的数据结构，类似数组，但成员的值是唯一的，没有重复的值。

const mySet1 = new Set()

mySet1.add(1)           // Set [ 1 ]
mySet1.add(5)           // Set [ 1, 5 ]
mySet1.add(5)           // Set [ 1, 5 ]
mySet1.add('some text') // Set [ 1, 5, 'some text' ]
const o = {a: 1, b: 2}
mySet1.add(o)

mySet1.add({a: 1, b: 2})   // o is referencing a different object, so this is okay

mySet1.has(1)              // true
mySet1.has(3)              // false, since 3 has not been added to the set
mySet1.has(5)              // true
mySet1.has(Math.sqrt(25))  // true
mySet1.has('Some Text'.toLowerCase()) // true
mySet1.has(o)       // true

mySet1.size         // 5

mySet1.delete(5)    // removes 5 from the set
mySet1.has(5)       // false, 5 has been removed

mySet1.size         // 4, since we just removed one value

console.log(mySet1)
// logs Set(4) [ 1, "some text", {…}, {…} ] in Firefox
// logs Set(4) { 1, "some text", {…}, {…} } in Chrome

Class

ES6 中有 class 语法。值得注意是，这里的 class 不是新的对象继承模型，它只是原型链的语法糖表现形式。

class Task {
  constructor() {
    console.log("task instantiated!");
  }

  showId() {
    console.log(23);
  }

  static loadAll() {
    console.log("Loading all tasks..");
  }
}

console.log(typeof Task); // function
let task = new Task(); // "task instantiated!"
task.showId(); // 23
Task.loadAll(); // "Loading all tasks.."

Promise

ES6 对 Promise 有了原生的支持，一个 Promise 是一个等待被异步执行的对象，当它执行完成后，其状态会变成 resolved 或者 rejected。

var p = new Promise(function(resolve, reject) {
  if (/* condition */) {
    // fulfilled successfully
    resolve(/* value */);
  } else {
    // error, rejected
    reject(/* reason */);
  }
});

// 每一个 Promise 都有一个 .then 方法，这个方法接受两个参数，第一个是处理 resolved 状态的回调，一个是处理 rejected 状态的回调

let var const的区别

1. var声明的变量会挂载在window上，而let和const声明的变量不会
2. ar声明变量存在变量提升，let和const不存在变量提升
3. let和const声明形成块作用域
4. 同一作用域下const不能声明同名变量，而var可以

const
- 一旦声明必须赋值,不能使用null占位。
- 声明后不能再修改
- 如果声明的是复合类型数据，可以修改其属性

对于promise是怎么理解的

1、Promise是一个构造函数，可以通过 new Promise()得到一个 Promise 的实例；

2、在 Promise 上，有两个函数，分别叫做 resolve（成功之后的回调函数） 和 reject（失败之后的回调函数） ；

3、在 Promise 构造函数的 Prototype 属性上，有一个 .then() 方法，也就说，只要是 Promise 构造函数创建的实例，都可以访问到这个  .then() 方法 ；

4、Promise 表示一个 异步操作；每当我们 new 一个 Promise 的实例，这个实例，就表示一个具体的异步操作；

5.、既然 Promise 创建的实例，是一个异步操作，那么，这个 异步操作的结果，只能有两种状态：

状态1： 异步执行成功了，需要在内部调用 成功的回调函数 resolve 把结果返回给调用者；
状态2： 异步执行失败了，需要在内部调用 失败的回调函数 reject 把结果返回给调用者；
6、由于 Promise 的实例，是一个异步操作，所以，内部拿到 操作的结果后，无法使用 return 把操作的结果返回给调用者； 这时候，只能使用回调函数的形式，来将成功 或 失败的结果，返回给调用者；

7、我们可以在 new 出来的 Promise 实例上，调用 .then() 方法，【预先】为 这个 Promise 异步操作，指定成功（resolve） 和 失败（reject） 回调函数；

promise的构造函数是同步执行还是异步执行，它的then方法呢？

promise构造函数是同步执行的，then方法是异步执行的。