ES6Frist笔记

数据类型

USONB
undefined
String Symbol
object
null number
boolean

箭头函数
 如果只有一句话并且返回就是这个值 {}和return 都不用写
 

扩展运算符 

...就是把  ['x1','x2','x3'] 转为 'x1','x2','x3'

把数组转化为参数序列

同理 可以用来合并数组

const a = ['a','b']

const b = ['c','d']

const c = [...a,...b]  c = a.concat(b)

c的结果就是?["a", "b", "c", "d"]

同理 可以作为数组的克隆

const a = ['a','b']

const b = [...a] //如果有引用数据对象，那就是浅拷贝

同理 可以将伪数组转化为真正的数组

设 divs为为伪数组

通过 const turedivs = [...divs];

得到真数组  turedivs 

rest 参数 

用来代替arguments 
arguments 得到的是一个伪数组，也就是有索引读取没有数组特性 其实就是一个对象
rest得到的就是一个真数组，里面就是对应的参数值（提高了对参数的处理 如 filter some every map等）
rest 参数一定要放在最后

arguments

function a() 
{

console.log(arguments)

}

a('a','b','c') //得到一个arguments对象

/*
Arguments(3) ["a", "b", "c", callee: ?, Symbol(Symbol.iterator): ?]
0: "a"
1: "b"
2: "c"
callee: ? a()
length: 3
Symbol(Symbol.iterator): ? values()
__proto__: Object
*/

rest

function b(...args)//这个args 可以自定义，多个参数的话这个参数必须放最后
{

console.log(args);

}

b('a','b','c') //得到一个数组对象

/*
(3)?["a", "b", "c"]
0: "a"
1: "b"
2: "c"
*/

symbol
表示独一无二的值，类似字符串的数据类型

1 值唯一，用来解决命名冲突
2 不能与其他数据进行运运算
3 不能用 for... in来进行遍历 ，但是可以如果要读取到一个对象的 Symbol 属性，
可以通过Object.getOwnPropertySymbols()  {Object.getOwnPropertySymbols()方法的功能:返回对象中自有Symbol属性，原型链上属性不会被获取}
和 Reflect.ownKeys() 取到。

创建Symbol

let s = Symbol('adc')
let s1 = Symbol('adc')//成为函数
console.log（s） //Symbol(adc) 就是不给你看，其实是唯一的
console.log(s === s1)  //false 生成的都是唯一的所以不相等

还有一种
Symbol.for() 他会去全局找对应的这个名字的Symbol()，没找到再创建

let yellow = Symbol("Yellow");
let yellow1 = Symbol.for("Yellow");
yellow === yellow1;      // false
 
let yellow2 = Symbol.for("Yellow");
yellow1 === yellow2;     // true

遍历方法如下

  let s = {};
  let s1 = Symbol('k')
  s[s1] = "kk";
  console.log(Object.getOwnPropertySymbols(s))
  console.log(s[s1])
  console.log(Reflect.ownKeys(s))  
 
有一个方法Symbol.keyFor()

Symbol.keyFor() 返回一个已登记的 Symbol 类型值的 key ，用来检测该字符串参数作为名称的 Symbol 值是否已被登记。
let yellow1 = Symbol.for("Yellow");
Symbol.keyFor(yellow1);    // "Yellow" 就只有Symbol.for的可以被返回

Symbol 创建对象属性

第一种

let game = {
let methods = {
up: Symbol(),
down: Symbol()
}
game[methods.up] = ()=>
{
console.log("up方法")
}
game[methods.down] = ()=>
{
console.log("down方法")
}
}

第二种
 let game = {

[Symbol('up')] : ()=>
{
console.log("up方法")
}
[Symbol('down')] : ()=>
{
console.log("down方法")
}
}

迭代器

迭代器是一个统一接口，通过键为Symbol.iterator方法实现
迭代器用于遍历数据结构的指针

以下是可迭代的值:

Array
String
Map
Set
Dom元素（正在进行中）
我们将使用 for...of 循环

知识点
for ... in xx //返回的是那个序列号
for ... of xx //返回的是那个值

迭代过程
1 通过Symbol.iterator创建一个迭代器，并且指向第一个的位置
2 通过next方法指向下一个，next会返回  value 和 done两个属性
3 done 为 true就遍历结束了

const items = ["zero", "one", "two"];
const it = items[Symbol.iterator]();
 
it.next();
>{value: "zero", done: false}
it.next();
>{value: "one", done: false}
it.next();
>{value: "two", done: false}
it.next();
>{value: undefined, done: true}

数组自己就有iterator接口属性
其他要自己实现 Symbol.iterator 方法
实现方法如下
 const banji = {
    name: "终极一班",
    stus: [
      'aa',
      'bb',
      'cc',
      'dd'
    ],
    [Symbol.iterator]() {
      //索引变量
      let index = 0;
      return {
        next: () => {
          if (index < this.stus.length) {
            const result = { value: this.stus[index], done: false }
            //下标自增
            index++;
            //返回结果
            return result;
          } else {
            return { value: undefined, done: true }
          }

        }
      }
    }
  }
  for (let v of banji) {
    console.log(v)
  }

生成器（generator）

是一种返回迭代器的函数，用来实现异步编程
在function后面加个 * 如 function * a(){}
第一次调用就要用.next() 不然不顶用
然后可以在里面加 yield 就相当于暂停 每加一下next() 
就多执行一下 
  function* a() {
    yield '第一步'
    console.log('这是个生成器函数!!!');
    yield '第二步'
    console.log('这个是第二步的结果');
    yield '第三步'
    console.log('这个是第三步的结果');
  }
  // let aa = a();
  // aa.next();
  // a().next();
  // a().next();
  // a().next();
  //next()里面也可以传参数，作为上一个yield的返回值
  for (let g of a()) {
    console.log(g);
  }

Promise

1、主要用于异步计算
2、可以将异步操作队列化，按照期望的顺序执行，返回符合预期的结果
3、可以在对象之间传递和操作promise，帮助我们处理队列

这一个主要就是实例，自己去看

然后就是 基本结构 

const p =new Promise(function(resolve,reject){
    // //成功调用 resolve
      // resolve(data);

    // //失败调用reject
      // let err = '数据读取失败'
      // reject(err)
});

p.then(value =>{
   console.log(value);
}),function(reason){
  console.log(reason)
}

Set集合

const set = new Set([1, 1, 2, 2, 3, 3]);

特点
1、Set 集合不会添加重复的成员。
2、Set 构造函数可以接受所有可迭代对象作为参数。

size属性：返回Set 集合的成员总数。
add(value) 方法：添加某个值，返回 Set 集合本身。
delete(value) 方法：删除某个值，返回一个布尔值，表示删除是否成功。
has(value) 方法：返回一个布尔值，表示该值是否为Set的成员。
clear() 方法：清除所有成员，没有返回值。

可以用for..of

  const arr = [1, 2, 2, 2, 3, 3, 4, 5, 6, 6];
  let arrs = new Array(...new Set(arr));
  console.log(arrs);

  const brr = [1, 2, 9, 8, 7, 6];

  //求交集
  let crrs = new Array(...new Set(arr)).filter(item => {
    return new Set(brr).has(item)
  }
  )

  // let crrs = [...new Set(arr)].filter(item => 
  //   new Set(brr).has(item)
  // )
  console.log("并集+", crrs)

  //求并集

  let drrs = [...new Set([...arr, ...brr])];
  console.log("并集+", drrs)
  
  
  
Map使用

Map 类似与对象,就是一个键值对集合，但是他键不只局限于字符串
也可以是对象之类的，也实现了iterator接口你懂的

API接口

1 size 返回函数个数
2 set 增加一个新元素，返回当前map
3 get 返回键值对象的键值
4 has 检测Map中 是否包含某个键值，放回Boolean值
5 clear 清空集合，返回 undefined

Class类对象

class 的本质是 function。是一个语法糖

   //构造方法，名字不能改
    constructor(brand, price) {}
    //定义个方法 
    call() {
      console.log("我可以打电话！！！");
    }

TIps 函数的对象不属于实例的对象（ps 属于类不属于实例对象）BUT 原型里面的会遗传

super get set  和JAVA不能说毫无关系，简直一模一样

数值扩展

0 Number.EPSILON 是 JavaScript表示的最小精度，他是一个数字你懂吧
怎么用呢 就是比较
function numbersequal(a,b){  
        return Math.abs(a-b)<Number.EPSILON;
    }

Number.isFinite 检测一个数是否是有限数
Number.isNaN 检测数值是否是NaN
Number.parseInt Number.parseFloat
字符串转数字 会删掉非数字的东西
Number.isInteger 是否为整数

Math.trunc 去掉小数
Math.sign 判断是正数负数还是零

对象方法扩张Object

Object.is 判断两个值是不是完全相等
   
Object.assign(a,b) 对象的合并，后面覆盖前面

Object.setPrototypeOf 设置原型对象
Object.getPrototypeOf 获取原型对象 
①所有引用类型都有一个__proto__(隐式原型)属性，属性值是一个普通的对象
②所有函数都有一个prototype(原型)属性，属性值是一个普通的对象
③所有引用类型的__proto__属性指向它构造函数的prototype

模块化

export //模块暴露
在js文件里面暴露一些东西
三种方式
在定义的前面直接加 export let school="sgg"
在最后统一暴露 export{school}
直接一开始圈住所有 
export default{
school:"sgg"
}

import
1 import* as xx from "xxx/xxx.js"   //通用导入
2 import {school as xx,teach} from "xxx/xxx.js" //解构赋值形式
// 对于上面第三种 特殊写法 而且必须取别名 
 import  {default as m3} from "xxx/xxx.js" 

3 import m3 from  from "xxx/xxx.js" //简便形式 针对默认暴露
说白了就是针对上面第三种那种