es6的新特性
概述：es6对应数组 字符串 对象及函数以及循环,值类型，修饰符等都有加强（es6以后的内容都称为es6的内容）
<script type='module'></script> //部分浏览器不解析es6时需书写 编译器会自动将所有type=module的代码编译为ES5，然后再交给浏览器执行。
数组的增强
find 查找
findIndex 查找下标
var li = Array.from(lis).find(function(li){
return li.innerText == '5'
}) //找到对应匹配的元素
console.log(li);
//findIndex 查找对应的元素的下标 返回第一个找到的元素下标
var index = Array.from(lis).findIndex(function(li,index,arr){
return li.innerText == '5'
})
console.log(index);
静态方法（使用类名.）
Array.of() 将一组数据转为数组
Array.from() 将伪数组转为数组
var array = Array.of(1,2,3,4,5)
console.log(array);
//具备某些数组的特性的对象称为伪数组 arguments NodeList HTMLCollection等
var lis = document.querySelectorAll('li')
// 伪数组是不具备数组的函数的
Array.from(lis).forEach(function(li){
console.log(li.innerText);
})
字符的增强
includes 是否包含 （包含返回true 不包含返回false）
startsWith 是否以这个字符串开头 （是返回true 不是返回false）
endsWith 是否以这个字符串结尾 （是返回true 不是返回false）
repeat 重复多次的去平铺对应的字符串
// indexOf的基础上增强
//是否包含 includes
console.log('abc'.includes('a')); //true
//endsWith 是否以这个字符串结尾
console.log('abc'.endsWith('abc'));//true
console.log('abc'.endsWith('c'));//true
//startsWith 是否以这个字符串开头
console.log('abc'.startsWith('a'));//true
console.log('abc'.startsWith('abc'));//true
//平铺 repeat 平铺的次数 重复多次的写个字符串
console.log('abc'.repeat(3));//将abc写3次
变量修饰符（增强）
var 关键词修饰的变量是伪全局变量（进行变量提升）
let 关键词 块状作用域 （变量名不能重复声明 避免变量名污染）
1. 不允许重复声明
2. 不存在预解析
3. 在大括号中声明的变量只能在大括号中使用，如if、for的大括号中声明的变量
const 关键词 常量（常量不可变 ）
1. 不允许重复声明
2. 不允许重新赋值（可以给对象中新增属性）
3. 声明的时候必须赋值
4. 不存在预解析
5. 在大括号中声明的变量只能在大括号中使用，如if、for的大括号中声明的变量
var btns = document.querySelectorAll('button')
// var 关键词声明的伪全局作用域
for(var i=0;i<btns.length;i++){
btns[i].onclick = function(){ //当前的事件是异步操作
console.log(i); //3 异步比同步晚执行 var关键词修饰的变量是伪全局变量
}
}
// let 块级作用域 只在当前的代码块内有用
for(let i=0;i<btns.length;i++){
btns[i].onclick = function(){
console.log(i);
}
}
// let 在同一作用域优点不能重复命名
let a = 10
// let a = 20 报错 不能重复声明
// 当你省略了对应的修饰符 默认就是以var关键词修饰
// const关键词 声明常量 他同样具备块级作用域 const定义的变量的不能重新赋值
// 声明的时候 必须要赋值
const a = 10
// a = 20 错误的 因为const修饰的变量不允许更改
// const b 错误的 必须要赋值
// es6 不是所有浏览器都可以直接解析的 不建议写源码的时候用let const (babel.js 解析es高版本的内容 把变成低版本的)
新增的值类型
旧有值类型
number , String , boolean , null , undefined
新增的类型
symbol 独一无二的值 bigInt 大的整型
//如果去声明一个Symbol
var v = Symbol() //独一无二的值
var s = Symbol('这个值很重要') //里面的参数是一个说明
var s1 = Symbol('这个值很重要') //里面的参数是一个说明
console.log(v);
console.log(s == s1); //false 因为symbol是一个独一无二的值
console.log(s.description);//获取里面的详情信息 当前这个详情是一个只读属性 description
v.description = 'hello' //没用 他是个只读属性
//key是独一无二 当作对象的key值
var obj = {v:'hello'}
console.log(obj.v); //hello
//bigInt 大的整型(存储number存不了的数据) 实现的方式 字符串传入实现
// 传入字符串
var str = '123456789123456789'
console.log( Number(str)); //123456789123456780
var bigNumber = BigInt(str) //123456789123456789n
console.log(bigNumber);
检测数据类型
之前使用typeof检测数据类型，但这种方式只能检测基本数据类型。在判断数组或对象的时候不能准确判断。有一个比较长的方法，可以检测所有数据类型：
Object.prototype.toString.call(被检测的数据类型)
例如
console.log(Object.prototype.toString.call(123))//[object Number]
console.log(Object.prototype.toString.call('abc'));
console.log(Object.prototype.toString.call(true));
console.log(Object.prototype.toString.call(undefined));
console.log(Object.prototype.toString.call(null));
console.log(Object.prototype.toString.call([]));
console.log(Object.prototype.toString.call({}));
console.log(Object.prototype.toString.call(function(){}));
console.log(Object.prototype.toString.call(/^abc$/));
console.log(Object.prototype.toString.call(new Date()));
对象的增强
静态方法
is方法 Object.is() 判断俩个对象是否是一个（true或者false）
// NaN
console.log(NaN == NaN);//false
//Object.is 主要解决NaN和NaN的问题
console.log(Object.is(NaN,NaN));//true NaN是值类型(常量)地址一样
console.log(Object.is({},{}));//false {}对象 比对地址
Object.assign 将后面对象合并当前前面 返回的是合并的对象
var obj = {sex:'男'}
//assign 目标对象 来源对象 将后面的合并到前面 返回一个对象 会影响之前的对象
var res = Object.assign(obj,{name:'张三',age:18})
console.log(obj); //{sex: '男', name: '张三', age: 18}
console.log(res); //{sex: '男', name: '张三', age: 18}
console.log(Object.is(obj,res));//true 浅拷贝( Object.assign)
函数增强
箭头函数
// //箭头函数一般都是匿名函数
// var hello = function(){ //之前的写法
// }
//箭头函数的写法 ()形参 {}代码块 把function省略了 加了个=>
var hello = ()=>{
console.log('hello')
}
//调用
hello()
箭头函数的简化
-
如果只有一个参数 可以省略()
// 简化 如果只有一个参数可以省略() var say = username => { console.log(username); } say('jack') -
如果只有一句代码的话 可以省略{}
//当你只有一句代码的时候 {} 可以省略 var world = username => console.log(username) world('hello') -
如果只有一句代码 且你需要返回数据情况下 可以省略对应的 retrun
//当你只有一句代码的时候 且你需要返回值 那么return可以被省略(此时花括号必须省略，不然并不能省略return) var getUserName = username => username+'hello' var value = getUserName('张三') console.log(value); //张三hello //数组的forEach方法 [1,2,3].forEach(value=>console.log(value)) // 数组的reduce方法 var sum = [1,2,3].reduce((pre,current)=>pre+current) console.log(sum);
箭头函数的特性
- 箭头函数里面没有this（根据作用域链向上查找对应的this）
// this谁调用 this指向谁 是在对应的普通函数的情况下
// document.querySelector('button').onclick = function(){
// console.log(this);//指向当前按钮
// }
//箭头函数
document.querySelector('button').onclick = ()=>{
console.log(this); //箭头函数里面没有this 根据作用域链的情况 向上找 window
}
var hello = ()=>{
console.log(this);
}
hello.call({age:18}) // 作用域链 向上找window
默认参数
function fn(agr1=value,arg2=value2){
}
// 初始化一个对象 默认值
function initObj(name,age=18,sex='男'){
return {
name,age,sex
}
}
console.log(initObj('jack'));//没有传参会使用默认值 {name: 'jack', age: 18, sex: '男'}
console.log(initObj('jack',19,'女'));//传了参会覆盖默认值 {name: 'jack', age: 19, sex: '女'}
对象里面内容的简化
属性的简化
当你的属性值是一个变量的情况下，以及你向使用你的变量作为key的名，这个时候可以省略key
var age = 18
var username = 'jack'
//简化 使用变量做键的名 {age:age,username:username}
var obj = {age,username}
函数的简写（只能在对象中简写）
var obj = {
say:function(){
console.log('hello')
}
}
obj.say()
//简写 省略:和function
var obj = {
say(){
console.log('hello')
}
}
obj.say()
循环的加强
- for in 是用于遍历对象的 遍历的是对象的里面key 他也可以遍历数组（数组也是对象）
- for of 是用于遍历数组的 遍历的是数组里面的value 他不可以遍历对象（只有实现了迭代器的对象才可以被遍历 必须具备length或者size属性）
如果要使用对应的for of来遍历对象的话 怎么办！！
Object的几个方法（静态方法） 可以用来实现对应的遍历
keys 拿到所有的key
values 拿到所有的值
entries 拿到所有的键值对
var obj = {age:18,name:'jack',sex:'男'}
//keys 获取所有的key 作为一个迭代对象
var k = Object.keys(obj)
console.log(k);
//values 获取所有的value
var v = Object.values(obj)
//entries 获取所有的key-value对
var e = Object.entries(obj)
新增的对应的迭代器类型（实现了迭代器）
set 元素不重复的一个集合（去重）
set声明
无参
var set = new Set() //空的集合
将数组作为参数传递
var arr = [1,1,2,2,3,3]
var set = new Set(arr) //传入数组
console.log(set) //1 2 3
相关的方法（增删改查）
add 添加
delete 删除
clear 清空
keys 获取key
values 获取值
entries 获取键值对象
forEach 遍历（三个参数分别是value,key,set）
has 判断是否存在 （返回的是boolean类型）
属性
size 获取对应的长度
//无参的形式
var set = new Set()
//添加 add append push...
set.add(1)
set.add(2)
set.add(1)
//获取对应的set的长度 size
console.log(set.size);//2
//删除方法 delete remove
set.delete(1) //删除1这个value值
//删除所有 清空
// set.clear()
//获取元素
var key = set.keys() //获取所有key 值既是key 又是值
var value = set.values() //获取所有的值
var kv = set.entries() //获取所有的键值对
console.log(kv);
console.log(key);
console.log(value);
//set里面有一个forEach方法
// 第一个是值 第二个key 第三个是遍历的set
set.forEach((v,k,set)=>{
console.log(v);
})
//has 判断是否存在 返回true和false
console.log(set.has(2));//true
WeakSet 内容存储对应的set（只能存储对象 但并不能完成去重）
var weakset = new WeakSet()
weakset.add({username:"张三"})
weakset.add({username:"张三"})
weakset.add({username:"张三"})
console.log(weakset);//里面还是存在3个
map 基于set和array之上构建的一个集合
map的声明
var map = new Map() //无参
var arr = [[1,2],[3,4]]
var map = new Map(arr) //通过二维数组构建的
map对应的方法
get 通过key来获取value
set 存入一个key-value
delete 通过key来删除
clear 清空所有
keys 获取所有的key values 获取所有的值 entries 获取所有的键值对
has 判断当前key是否存在
forEach 遍历
var map = new Map() //空的map
var arr = [[1,2],[3,4]]
var map = new Map(arr) //通过二维数组构建的
console.log(map);
//map对应的方法 增删改查
// 查询 get
console.log(map.get(1)); //通过key来获取value
// 添加的方法 set 传入key和value
map.set('hello','张三')
//属性 size属性
console.log( map.size);
//删除的方法 通过key来删除
map.delete(3)
//重新设置就是修改
map.set(1,'埃里克多')
//获取key 获取value 获取键值对
console.log(map.keys());
console.log(map.values());
console.log(map.entries());
//清空所有
map.clear()
//forEach value key map
map.forEach((value,key,map)=>{
console.log(value);
})
//has 判断是存在
console.log(map.has('hello'));
weakMap基于weakSet上面构建map 也就是他的key是对象 只能是对象
解构
解除构造
var obj = {username:'jack',password:'123'}
// obj.username
// obj.password
//解构来取 (通过key来解构对应的obj) {key} = {key:123}
var {password,username} = obj
console.log(username);
console.log(password);
//快速提取对象里面数据
var {age} = {age:18}
console.log(age);
//解构取数组里面的内容 按照位置来取对应的值
var [o,p] = ['a','b']
console.log(o);
// 快速读取值
var {sex} = {username:'jack',password:"123",age:'18',sex:"女"}
console.log(sex);
扩展运算符
... 打开数组拿出里面的内容
//扩展运算符
var arr = [1,3,5]
var arr1 = [2,4,6]
console.log(...arr); //解除数组的包装 把他暴露出来 1 3 5
//如果你的方法里面需要,隔开他会默认给你加上一个,
console.log( 'abc'.concat(1,2,3,4,5)); //abc12345
console.log( 'abc'.concat(...arr,...arr1)); //默认加上, abc135246
Class （类）
他是用于对象构建的 （类只是一个构建对象的容器 ）调用这个class要使用new关键词
//类名首字母必须大写
class Person{
constructor(){ //构造器
//this必须在构造器里面使用
this.age = 18 //类的属性
this.sayHello = function(){ //类的方法
console.log('hello')
}
}
}
//构建对象
var person = new Person()
console.log(person.age); //18
person.sayHello() //hello
//类名首字母必须大写 class不能被重复定义
class Person1{
//constrctor调用 new的过程 每一次new 里面的内容都会重新声明
constructor(age=18,name='jack'){ //构造器
//this必须在构造器里面使用 this是指向实例化的对象
this.age = age //类的属性
this.name = name
this.sayHello = function(){ //类的方法
console.log('hello')
}
}
run(){//在函数里面可以访问对应的this
console.log(this.name+'跑');
}
}
//使用new 调用的对应构造器的时候 就是在实例化的过程 而产生的对象被称为实例化对象
var person = new Person1(18,'jack')
console.log(person); // age:18 name:jack sayHello:fn
var person1 = new Person1()
console.log(person1);
person1.run()
console.log( person1.sayHello == person.sayHello);//false
console.log( person1.run == person.run);//true
注意事项
- class 修饰的类 类名首字母必须大写
- class 不允许重复声明
- class 里面this只能存在于constructor（构造器）里面
- class 里面this指向当前实例化对象
- 在实例化的过程 new的过程的 调用的constructor函数 跟其他函数无关（所以当前在constructor都会重新声明一次）
extends关键词
extends 用于继承 他会拥有父类所有的非私有的属性及方法
class Person{
constructor(){
this.age = 18
}
run(){
console.log('跑');
}
}
//extends 关键词声明以后 在对应的constructor里面想要使用this 必须先写super()
class Son extends Person{
constructor(){
super()//指向父类Person的构造器constructor
this.name = 'jack'
}
}
var son = new Son()
console.log(son);//获取不到run的
注意事项
- 在子类构造里面如果想要使用this 必须先要使用super()
- super指向父类的构造器
- 子类无法获取构造器之外的函数