ES语法新特性
- let
// 声明变量
let a;
let b, c, d;
// 1. 变量不能重复声明
// 2. 块儿级作用域 全局,函数,eval
// 3.不存在变量提升(在未声明前使用变量 )
// 4.不影响作用域链
- const
const
// 1. 一定要赋初始值
const A
// 2. 一般常量使用大写(潜规则)
const a =100
// 3. 常量的值不能修改
// 4. 块儿作用域
// 5. 对于数组和对象的元素修改, 不算做对常量的修改, 不会报错
- 变量的解构赋值
1. 数组的解构
const F4=['小沈阳', '刘能','赵四','宋小宝']
let [xiao, liu, zhao, song] = F4
2. 对象的解构
const zhao = {
name: '赵本山',
age: '不详',
xiaopin: function (){
consloe.log('666')
}
};
let {name, age, xiaopin} = zhao
- 模板字符串
新的声明字符串的方式 `` '' ""
1. 声明
2. 内容中可以直接出现换行符 [ `` ]
3. 拼接变量
let lovest ='lol'
let out = `${lovest}老好了`
- 简化对象写法
ES6 允许在{}里直接写入变量和函数,作为对象的属性和方法
- 箭头函数
let ok = () =>{}
// 1. this是静态的, this 始终指向函数声明是所在作用域下的this 的值
// 2. 不能作为构造实例化对象
// 3. 不能使用arguments 变量
- 函数参数默认值
ES6 允许给函数参数赋值初始值
// 1. 形参初始值 具有默认值的参数,一般靠后
function add(a, b, c=10) {
return a+ b + c
}
let result = add(1, 2)
result = 13
// 2. 与解构赋值结合
- rest 参数
function data(...args){
console.log(args);
}
date('12','23','34')
// rest 参数必须放到参数最后
- 扩展运算符
... 扩展运算符能将 数组 转换为逗号分割的 序列参数
// 1. 数组的合并
const kuaizi = ['王','刘']
const mengnan = ['俊', '鑫']
// ES5
const daMengNan = kuaizi.concat(mengnan)
// ES6
const daMengNan = [...kuaizi, ...mengnan ]
// 2. 数组克隆
const kuaizi = ['王','刘']
const mengnan = [...kuaizi]
//3. 将伪数组转为真正的数组
const divs = document.querySelectorAll('div')
const divArr = [...divs]
- symbol
// 创建symbol
let s = symbol();
let s1 = symbol('猛男');
let s2 = symbol('猛男')
log (s1 === s2) >>>>false , symbol是一个标志
// symbol.for 创建
let s3 = symbol.for('猛男');
let s4 = symbol.for('猛男');
log (s3 === s4) >>>>true
// 不能与其他数据进行运算
- promise 读取文件
// 1. 引入 fs 模块
const fs = require('fs')
// 2. 调用方法读取文件
fs.readFile('./resources/xx.md', (err,data) =>{
// 如果错误 , 抛出错误
if(err) throw err;
// 如果没错, 输出内容
console.log(data.toString());
});
// 3. 使用Promise 封装
const P = new Promise(function(resolve, reject)){
fs.readFile('./resources/xx.md', (err,data) =>{
// 如果错误
if(err) reject(err);
// 如果成功
resolve(data);
});
});
p.then(function(value){
console.log(value.toString());
}, function(reason){
console.log('读取失败');
})
- set
let arr = [1,2,1,1,3,4,]
// 1.数组去重
let result = [...new Set(arr)]
// 2. 交集
let arr2 = [2,3]
let result = [...new Set(arr)].filter (item => {
let s2 = new Set(arr2);
if (s2.has(item)){
return true;
}else {
return false
}
});
let result = [...new Set(arr)].filter(item => new Set(arr2).has(item) )
// 3. 并集
let result = [...new Set([...arr,...arr2]) ]
// 4. 差集
let diff = [...new Set(arr)].filter(item => !(new Set(arr2).has(item)))
- map
// 声明 map
let m = new Map();
// 添加元素
m.set('name','酷毙');
m.set('change', function(){
console.log('我们可以改变你')
});
let key = {
school: '帅呆'
};
m.set(key, ['北京','上海','深圳'])
// size
console.log(m.size)
// 删除
m.delate()
// 清空
m.clear()
// 遍历
for (let v of m ){
console.log(v)
}
- 数值扩展
// 检测一个数值是否为有限数
Number.isFinite
// 检测一个数是否为NaN
Number.isNaN
// 字符串转数字
Number.parseInt
Number.parseFloat
// 是否为整数
Number.isInteger
// 将数字小数部分抹掉
Math.trunc
//判断到底是正数 负数 还是零
Math.sign
- 对象方法扩展
// 1. object.is 判断两个值是否完全相等
// 2. object.assign 对象的合并
object.assign(config1,config2) // 后面参数属性将前面覆盖
// 3. object.setPrototypeOf 设置原型对象
- 暴露语法
// 1. 分别暴露
export let school = 'school'
export function teach (){}
// 2. 统一暴露
let school = 'school'
function teach (){}
export {school, teach}
// 3. 默认暴露
export default{
school:'school'
change: function(){
console.log('awesome')
}
}
引用语法
// 1. 通用导入
import * as m1 from './xxx'
// 2. 解构赋值形式
import {school, teach} from 'xxxx'
import {school as xuexiao, teach} from 'xxxx' // 重名可以用 as 起别名
import { default as m3} from 'xxxx '
// 3. 简便形式 针对默认暴露
import m3 from 'xxxx'
- includes
// includes indexOf
const mingzhu = ['西游记','水浒传', '三国演义', '红楼梦']
// 判断
console.log(mingzhu.includes('西游记'))
====>> true
- Object.fromEntries()
// 通过 Object.fromEntries， 可以将 Map 转化为 Object:
const map = new Map([ ['foo', 'bar'], ['baz', 42] ]);
const obj = Object.fromEntries(map);
console.log(obj); // { foo: "bar", baz: 42 }
// 通过 Object.fromEntries， 可以将 Array 转化为 Object:
const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }
