ESnext '下一代 js’语言
任何人都可以向 标准委员会 (TC39), 要求更改语言标准
提案变成标准，经历5个阶段
Stage 0 展示阶段
Stage 1 征求意见阶段
Stage 2 草案阶段
Stage 3 候选阶段
Stage 4 定案阶段(标准)
babel
https://github.com/tc39/ecma262
react， vue, angularJs， angular
chrome, 对新的语法支持，速度还挺猛
ES6环境:
webpack3.x
Traceur
let&const
关于定义(声明)变量:
之前: var a=12;
let a=12
作用域:
全局
函数作用域
let 相当于之前的 var
const 常量， 定义好了不能改变
let注意:
1. 没有预解析，不存在变量提升
在代码块内，只要let定义变量，在之前使用，都是报错
先定义完，在使用
2. 同一个作用域里， 不能重复定义变量，但是在不同作用域内可以重复定义
3. for循环，for循环里面是父级作用域，里面又一个
块级作用域:
{
//块级作用域
}
{{{{let a = 12}}}}
if(){xx}
for(){}
while(){}
const实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址所保存的数据不得改动。对于简单类型的数据（数值、字符串、布尔值），值就保存在变量指向的那个内存地址，因此等同于常量。但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，保存的只是一个指向实际数据的指针，const只能保证这个指针是固定的（即总是指向另一个固定的地址），至于它指向的数据结构是不是可变的，就完全不能控制了。因此，将一个对象声明为常量必须非常小心。
const: 特性和let一样
const定义变量不能修改
const定义完变量，必须有值，不能后赋值，不能修改
Object.freeze(对象)：是此对象不可修改
const config={
host:
username:
password:
version:
}
建议:
以后 就用 let 不要在使用var
const http = require('http');
======================================
解构赋值:
ES6 允许按照一定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构
* 非常有用，特别在做数据交互 ajax
let [a,b,c] =[12,5, 6];
注意: 左右两边，结构格式要保持一致
json:
let {name,age, job} = {
name:'Strive',
age:18,
job:'码畜'
};
let {name:n,age:g, job:a} = json;
解构时候可以给默认值：
let [a,b, c="默认值"] = ['aaa','bbb'];
let a = 12;
let b = 5;
import {a,b,c} from './mod'
======================================
字符串模板:
`` 字符串模板：
优点: 可以随意换行
${变量名字}
字符串连接，要死人的。
let name ='Strive';
let age = 18;
let str = `这个人叫${name}, 年龄是 ${age}岁`;
关于字符串一些东西:
字符串查找:
str.indexOf(要找的东西) 返回索引(位置) ，没找到返回-1
str.includes(要找的东西) 返回值 true/false
判断浏览器: includes
http://www.xxx.xx
字符串是否以谁开头:
str.startsWith(检测东西)
检测地址
字符串是否以谁结尾:
str.endsWith(检测东西)
.png
重复字符串:
str.repeat(次数);
填充字符串:
str.padStart(整个字符串长度, 填充东西) 往前填充
str.padEnd(整个字符串长度, 填充东西) 往后填充
str.padStart(str.length+padStr.length, padStr)
============================================
函数变化:
1. 函数默认参数
function show({x=0,y=0}={}){
console.log(x,y);
}
show()
2. 函数参数默认已经定义了，不能再使用let，const声明
function show(a=18){
let a = 101; //错误
console.log(a);
}
show()
扩展运算符(…)、Rest运算符:
...
展开数组
... :
[1,2,3,4] -> ... [1,2,3,4] -> 1,2,3,4,5
...:
1,2,3,4,5 -> ...1,2,3,4,5 -> [1,2,3,4,5]
剩余参数: 必须放到最后
箭头函数:
? =>
let show = () => 1;
() => return东西
() =>{
语句
return
}
注意:
1. this问题, 定义函数所在的对象，不在是运行时所在的对象
2. 箭头函数里面没有arguments, 用 ‘...’
3. 箭头函数不能当构造函数
箭头函数有几个使用注意点。
（1）函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。
（2）不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。
（3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。
（4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数。
上面四点中，第一点尤其值得注意。this对象的指向是可变的，但是在箭头函数中，它是固定的。
function foo() {
setTimeout(() => {
console.log('id:', this.id);
}, 100);
}
var id = 21;
foo.call({ id: 42 });
// id: 42
上面代码中，setTimeout的参数是一个箭头函数，这个箭头函数的定义生效是在foo函数生成时，而它的真正执行要等到 100 毫秒后。如果是普通函数，执行时this应该指向全局对象window，这时应该输出21。但是，箭头函数导致this总是指向函数定义生效时所在的对象（本例是{id: 42}），所以输出的是42。
箭头函数可以让setTimeout里面的this，绑定定义时所在的作用域，而不是指向运行时所在的作用域。下面是另一个例子。
function Timer() {
this.s1 = 0;
this.s2 = 0;
// 箭头函数
setInterval(() => this.s1++, 1000);
// 普通函数
setInterval(function () {
this.s2++;
}, 1000);
}
var timer = new Timer();
setTimeout(() => console.log('s1: ', timer.s1), 3100);
setTimeout(() => console.log('s2: ', timer.s2), 3100);
// s1: 3
// s2: 0
上面代码中，Timer函数内部设置了两个定时器，分别使用了箭头函数和普通函数。前者的this绑定定义时所在的作用域（即Timer函数），后者的this指向运行时所在的作用域（即全局对象）。所以，3100 毫秒之后，timer.s1被更新了 3 次，而timer.s2一次都没更新。
尾调用、尾递归
递归非常耗费内存，因为需要同时保存成千上百个调用帧，很容易发生“栈溢出”错误（stack overflow）。但对于尾递归来说，由于只存在一个调用帧，所以永远不会发生“栈溢出”错误。
function factorial(n) {
if (n === 1) return 1;
return n * factorial(n - 1);
}
factorial(5) // 120
上面代码是一个阶乘函数，计算n的阶乘，最多需要保存n个调用记录，复杂度 O(n) 。
如果改写成尾递归，只保留一个调用记录，复杂度 O(1) 。
function factorial(n, total) {
if (n === 1) return total;
return factorial(n - 1, n * total);
}
factorial(5, 1) // 120
“尾调用优化”对递归操作意义重大，所以一些函数式编程语言将其写入了语言规格。ES6 亦是如此，第一次明确规定，所有 ECMAScript 的实现，都必须部署“尾调用优化”。这就是说，ES6 中只要使用尾递归，就不会发生栈溢出（或者层层递归造成的超时），相对节省内存。
数组:
ES5里面新增一些东西
循环:
1. for
for(let i=0; i<arr.length; i++)
2. while
arr.forEach() // 代替普通for
arr.forEach(function(val, index, arr){
console.log(val, index, arr);
});
arr.map() // 非常有用，做数据交互 "映射"
正常情况下，需要配合return，返回是一个新的数组
若是没有return，相当于forEach
注意：平时只要用map，一定是要有return
重新整理数据结构:
[{title:'aaa'}] -> [{t:'aaaa'}]
arr.filter(): 过滤，过滤一些不合格“元素”， 如果回调函数返回true，就留下来
arr.some(): 类似查找, 数组里面某一个元素符合条件，返回true
arr.every(): 数组里面所有的元素都要符合条件，才返回true
其实他们可以接收两个参数:
arr.forEach/map...(循环回调函数, this指向谁);
------------------------------------------
上面的回调函数中都是三个参数，而下面两个就不一样了 (val, index, arr)
------------------------------------------
reduce()、reduceRight()方法使用指定的函数将数组元素进行组合，生成单个值。这在函数时编程中是常见的操作，也可称为 注入 或 折叠 。
两个参数：第一个：回调函数：又称为化简函数，任务是用某种方法将两个值组合或化简为一个值，并返回化简后的值。(prevOperateResult,current,index,arr)
第二个：(可选)传递给函数的初始值
arr.reduce() //从左往右
求数组的和、阶乘
eg：
var a=[1,2,3,4,5]
var sum = a.reduce(function(x,y){return x+y},0)//数组求和
var product = a.reduce(function(x,y){return x*y},1)//数组求积
var max = a.reduce(function(x,y){return (x>y)?x:y})//求最大值
arr.reduceRight() //从右往左
------------------------------------------------------------
ES6新增
ES2017新增一个运算符:
幂
旧：Math.pow(2,3):2的3次方
新增：2 ** 3 (两个*)
for…of…：
ES6 提供三个新的方法——entries()，keys()和values()——用于遍历数组。它们都返回一个遍历器对象（详见《Iterator》一章），可以用for...of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历
arr.keys() 数组下标
arr.entries() 数组某一项
let arr = ['apple','banana','orange','tomato'];
// 遍历数组
for(let val of arr){
console.log(val);
}
// 遍历下标
for(let index of arr.keys()){
console.log(index);
}
// 遍历下标+值：[0:'apple']、[1:'banana']...
for(let item of arr.entries()){
console.log(item);
}
// 解构赋值
for(let [key, val] of arr.entries()){
console.log(key,val);
}
======================
扩展运算符:
…
let arr =[1,2,3];
let arr2 = [...arr];
let arr2 = Array.from(arr);
Array.from:
作用: 把类数组(获取一组元素、arguments…) 对象转成数组
个人观点： 具备 length这个东西，就靠谱
Array.of(): 把一组值，转成数组
let arr = Array.of(‘apple’,‘banana’,‘orange’);
console.log(arr);
arr.find(): 查找，找出第一个符合条件的数组成员，如果没有找到，返回undefined
let arr = [23,900,101,80,100];
let res = arr.find((val, index, arr) =>{
return val>1000;
});
console.log(res);
arr.findIndex(): 找的是位置， 没找到返回-1
arr.fill() 填充
arr.fill(填充的东西, 开始位置, 结束位置);
在ES2016里面新增:
arr.indexOf()
arr.includes//返回一个布尔值，表示某个数组是否包含给定的值
str.includes返回一个布尔值，表示某个数组是否包含给定的值
============================================
对象:
对象扩展及新增方法
对象简介语法(相当有用)
对象简介语法(相当有用):
let json ={
a:1,
b:2,
showA:function(){
return this.a;
}
showB:function(){
return this.b;
}
}
//属性的简洁表示法
let json ={
a,
b,
showA(){ //个人建议: 一定注意，不要用箭头函数
},
showB(){
}
}
new Vuex.Store({
state,
mutation,
types,
actions
});
new Vue({
router,
App,
vuex
})
Object.is(): 用来比较两个值是否相等
Object.is('a','a');
比较两个东西相等:
==
===
Object.is(NaN, NaN);//相等
Object.is(+0, -0);//不相等
Object.assign(): 用来合并对象
let 新的对象 = Object.assign(目标对象, source1, srouce2…)
function ajax(options){ //用户传
let defaults={
type:'get',
header:
data:{}
....
};
let json = Object.assign({}, defaults, options);
.....
}
用途:
1. 复制一个对象或数组
2. 合并参数
ES2017引入:
Object.keys()
Object.entries();
Object.values();
let {keys, values, entries} = Object;let {keys, values, entries} = Object;
对象身上: 计划在ES2018引入
…
let json = {a:3, b:4};
let json2 = {...json};
属性名表达式：
ES6中定义对象属性时，允许字面量定义使用和标识符定义对象时，一样的表达式定义属性。
let lastWord = 'last word';
const a = {
'first word': 'hello',
[lastWord]: 'world'//表达式定义属性
};
a['first word'] // "hello"
a[lastWord] // "world"
a['last word'] // "world"
方法的name属性：
函数的name属性，返回函数名。对象方法也是函数，因此也有name属性。
super关键字：
我们知道，this关键字总是指向函数所在的当前对象，ES6 又新增了另一个类似的关键字super，指向当前对象的原型对象。
Object.fromEntries():
Object.fromEntries()方法是Object.entries()的逆操作，用于将一个键值对数组转为对象。
Object.fromEntries([
['foo', 'bar'],
['baz', 42]
])
// { foo: "bar", baz: 42 }
==================================================
Promise: 承诺，许诺
作用: 解决异步回调问题
传统方式，大部分用回调函数，事件
ajax(url,{ //获取token
ajax(url,()=>{ //获取用户信息
ajax(url, ()=>{
//获取用户相关新闻
})
})
})
语法:
let promise = new Promise(function(resolve, reject){
//resolve, 成功调用
//reject 失败调用
});
promise.then(res=>{
}, err=>{
})
promise.catch(err=>{})
本人用法:
new Promise().then(res=>{
}).catch(err=>{
})
Promise.resolve('aa') : 将现有的东西，转成一个promise对象， resolve状态，成功状态
等价于:
new Promise(resolve =>{
resolve('aaa')
});
Promise.reject('aaa'): 将现有的东西，转成一个promise对象，reject状态，失败状态
等价于:
new Promise((resolve, reject) =>{
reject('aaa')
});
√ Promise.all([p1, p2, p3]): 把promise打包，扔到一个数组里面，打包完还是一个promise对象
必须确保，所有的promise对象，都是resolve状态，都是成功状态
Promise.race([p1, p2, p3]): 只要有一个成功，就返回
用户登录 -> 用户信息
补充：
=========================================
模块化:
js不支持模块化
ruby require
python import
在ES6之前，社区制定一套模块规范:
Commonjs 主要服务端 nodeJs require('http')
AMD requireJs, curlJs
CMD seaJs
ES6出来，同意服务端和客户端模块规范:
import {xx} ddd
Math.pow()
Math.abs()
import {pow, abs} from 'Math' 我自己瞎想
模块化：
注意： 需要放到服务器环境
a). 如何定义模块？
export 东西
export const a =12;
export{
a as aaa,
b as banana
}
b). 如何使用?
import
import './modules/1.js';
import {a as a, banana, c} from './modules/2.js'
import * as modTwo from './modules/2.js';
使用模块:
<script type="module"></script>
import: 特点
a). import 可以是相对路径，也可以是绝对路径
import 'https://code.jquery.com/jquery-3.3.1.js';
b). import模块只会导入一次，无论你引入多少次
c). import './modules/1.js'; 如果这么用，相当于引入文件
d). 有提升效果，import会自动提升到顶部，首先执行
e). 导出去模块内容，如果里面有定时器更改或其他更改了模块内容，外面也会改动，不想Common规范缓存
import() 类似node里面require， 可以动态引入, 默认import语法不能写到if之类里面
返回值，是个promise对象
import('./modules/1.js').then(res=>{
console.log(res.a+res.b);
});
优点:
1. 按需加载
2. 可以写if中
3. 路径也可以动态
Promise.all([])
Promise.all([
import('./modules/1.js'),
import('./modules/2.js')
]).then(([mod1,mod2])=>{
console.log(mod1);
console.log(mod2);
})
export default的不需要用{}接受
export 的需要用{}接受
export default 12;
export const cc=12;
export const dd=5;
=============================
<script?type="module">
????????import?a,{cc,dd}?from?'./modules/3.js';
????????console.log(a,?cc,?dd);
????</script>
ES2017加 async await:
‘use strict’ 以后默认就是严格模式
程序中类
ES6
面向对象 ，类
属性
方法
函数模拟
人: Person
属性: name
展示名字: showName
Person.prototype.showName
ES5之前：
function Person(){
this.name=‘aaa’;
}
Person.prototype.showName=function(){}
ES6中变形:
class Person{
constructor(name){
this.name = 'aaa';
}
showName(){
}
}
--------------------------
const Person = class{}
------------------------------
let a = 'strive';
let b = 'method';
class Person{
[a+b](){
}
}
let aaa=‘aaa’;
let bbb=‘ddd’;
let json={
[aaa+bbb]:‘welcome 51mmr.net’
}
注意：
- ES6里面class没有提升功能，在ES5，用函数模拟可以，默认函数提升
- ES6里面this 比之前轻松多了
矫正this:
1. fn.call(this指向谁, args1, args2…)
2. fn.apply(this指向谁, [args1, args2…])
? 以上两个立即调用
- fn.bind()不立即调用
class里面取值函数(getter), 存值函数(setter)
class Person{
constructor(){
}
get aaa(){
return `aaa的属性`;
}
set aaa(val){
console.log(`设置aaa属性，值为:${val}`);
}
}
let p1 = new Person();
p1.aaa='123';
console.log(p1.aaa);
静态方法: 就是类身上方法
class Person{
constructor(){
}
showName(){
return '这是showName方法';
}
static aaa(){
return '这是静态方法';
}
}
let p1 = new Person();
console.log(p1.showName());
console.log(Person.aaa());
static aaa(){
}
父类.aaa();
继承
之前:
Person
Student
现在: extends
class Student extends Person{
}
组合继承：父类.call(this)：继承属性
? 子类.prototype = new 父类():继承父类原型共享方法
super：
第一种情况，super作为函数调用时，代表父类的构造函数。ES6 要求，子类的构造函数必须执行一次super函数。
class A {}
class B extends A {
constructor() {
super();
}
}
第二种情况，super作为对象时，在普通方法中，指向父类的原型对象；在静态方法中，指向父类。
class A {
p() {
return 2;
}
}
class B extends A {
constructor() {
super();
console.log(super.p()); // 2
}
}
let b = new B();
========================================
//父类
class Person{
constructor(name){
this.name = name;
}
showName(){
console.log('父类showName');
return `名字为: ${this.name}`;
}
}
//子类
class Student extends Person{
constructor(name,skill){
super(name);
this.skill = skill;
}
showName(){
super.showName(); //父级的方法执行
//TODO 做子级事情
console.log('子类里的showName');
}
showSkill(){
return `哥们儿的技能为: ${this.skill}`;
}
}
数据类型:
number、string、boolean、Object、undefined、function
用typeof检测出来数据类型:
symbol
new Number(12)
new String()
new Array()
symbol 使用情况一般
定义：
let syml = Symbol(‘aaa’);
注意:
1. Symbol 不能new
2. Symbol() 返回是一个唯一值
坊间传说, 做一个key，定义一些唯一或者私有一些东
3. symbol是一个单独数据类型，就叫 symbol, 基本类型
let symbol = Symbol('Strive');
let symbolnum = Symbol(111)
let symbolboolean = Symbol(true)
let json ={
a:'apple',
b:'banana',
[symbol]:'aaa',
[symbolnum]:111,
};
console.log(symbol)
console.log(symbolnum)
console.log(symbolboolean)
console.log(json[symbolnum]);
4. 如果symbol作为key，用for in循环，出不来，其他的能循环出来
json -> for in
箭头函数
() =>{}
generator(发电机)函数
生成器
解决异步深度嵌套的问题， async
语法:
function * show(){
yield
}
function* show(){
}
function *show(){
}
yield：生产、产出
yield表达式就是暂停标志。
定义：
function * gen(){
yield 'welcome';
yield 'to';
return '牧码人';
}
调用:
let g1 = gen();
g1.next(); // {value:'welcome', done:false}
g1.next(); // {value:'to', done:false}
g1.next(); // {value:'牧码人', done:true}
上述调用，手动调用，麻烦
for … of 自动遍历 generator
function * gen(){
yield 'welcome';
yield 'to';
return '牧码人';
}
let g1 = gen();
for(let val of g1){
console.log(val);
}
return的东西，它不会遍历
generator不仅可以配合 for … of …
还可以:
-
解构赋值:
let [a, …b] = gen();//解构的是yield对应的值 function * gen(){ yield 'welcome'; yield 'to'; yield '51mmr.net'; return '牧码人'; } //let [a,b,c] = gen(); let [a, ...b] = gen(); console.log(a, b); -
扩展运算符
‘…’
console.log(…gen());//welcome to 51mmr.net
3. Array.from()
console.log(Array.from(gen()));
generator结合 axios数据请求：
异步: 不连续，上一个操作没有执行完，下一个操作照样开始
同步: 连续执行，上一个操作没有执行完，下一个没法开始
关于异步，解决方案：
a). 回调函数
b). 事件监听
c). 发布/订阅
d). Promise对象
co…
ES2017,规定 async
nodeJs
读取文件 fs.readFile
1. promise
2. genrator
3. async
async function fn(){ //表示异步，这个函数里面有异步任务
let result = await xxx //表示后面结果需要等待
}
//async
async function fn(){
let f1 = await readFile('data/a.txt');
console.log(f1.toString());
let f2 = await readFile('data/b.txt');
console.log(f2.toString());
let f3 = await readFile('data/c.txt');
console.log(f3.toString());
}
fn();
async特点:
1. await只能放到async函数中
2. 相比genrator语义化更强
3. await后面可以是promise对象，也可以数字、字符串、布尔
4. async函数返回是一个promise对象
5. 只要await语句后面Promise状态变成 reject, 那么整个async函数会中断执行
如何解决async函数中抛出错误，影响后续代码:
a).
try{
}catch(e){
}
b). promise本身catch
个人建议大家:
try{
let f1 = await readFile(‘data/a.txt’);
let f3 = await readFile(‘data/c.txt’);
let f2 = await readFile(‘data/b.txt’);
}catch(e){}
async await
set
数据结构
数组
json， 二叉树…
set数据结构:
类似数组，但是里面不能有重复值
let arr = [‘a’,‘b’,‘a’];
let arr = new Array();
set用法:
let setArr = new Set([‘a’,‘b’]);
setArr.add('a'); 往setArr里面添加一项
setArr.delete('b'); 删除一项
setArr.has('a') 判断setArr里面有没有此值
setArr.size 个数
setArr.clear(); 清空
for…of…
循环:item：在set里是key和value都是a、b、c、d
a). for(let item of setArr){ //默认是values()
console.log(item);
}//a、b、c、d
b). for(let item of setArr.keys()){console.log(item);}//a、b、c、d
c). for(let item of setArr.values()){}//a、b、c、d
d). for(let [k,v] of setArr.entries()){}
//["a","a"]、["b","b"]、["c","c"]、["d","d"]、
e). setArr.forEach((value,index) =>{
console.log(value, index);
});
let setArr = new Set().add(‘a’).add(‘b’).add(‘c’);
数组去重:
let arr = [1,2,3,4,5,6,7,6,5,4,3,2,1,2,3,4,4];
let newArr = […new Set(arr)];
console.log(newArr);
set数据结构变成数组:
[…set]
想让set使用数组的，map循环和filter:
let arr = [{},{}];
new Set([]); 存储数组， 这种写法对;new Set({}):错。但是可以写成set.add({})
new WeakSet({}) 存储json，这种写法不靠谱
WeakSet没有size，也没有clear()
有， add(), has(), delete()
确认，初始往里面添加东西，是不行的。最好用add添加
总结: new Set()
let json ={
p1:1,
b:2
};
map:
? 类似 json, 但是json的键(key)只能是字符串
map的key可以是任意类型
使用:
let map = new Map();
map.set(key,value); 设置一个值
map.get(key) 获取一个值
map.delete(key) 删除一项
map.has(key) 判断有没有
map.clear() 清空
map.siza Map结构的成员总数
循环:
for(let [key,value] of map){}
for(let key of map.keys()){}
for(let value of map.values()){}
for(let [k,v] of map.entries()){}
map.forEach((value, key) =>{
console.log(value, key);
})
WeakMap(): key只能是对象
总结：
Set 里面是数组，不重复，没有key，没有get方法
Map 对json功能增强，key可以是任意类型值
数字(数值)变化:
Number
二进制: (Binary)
let a = 0b010101;
八进制: (Octal)
let a = 0o666;
十六进制:
#ccc
-------------------------------------------
Nunber()、parseInt()、 parseFloat()
-------------------------------------------
Number.isNaN(NaN) -> true
Number.isFinite(a) 判断是不是数字 √
Number.isInteger(a) 判断数字是不是整数 √
-------------------------------------------
Number.parseInt();
Number.parseFloat();
安全整数:
2**3：二的三次方
安全整数: -(2^53-1) 到 (2^53-1), 包含-(2^53-1) 和(2^53-1)
Number.isSafeInteger(a);
Number.MAX_SAFE_INTEGER 最大安全整数
Number.MIN_SAFE_INTEGER 最小安全整数
Math:
Math.abs()：返回绝对值
Math.sqrt()：返回数的平方根
Math.sin()：返回数的正弦
Math.trunc() 截取，只保留整数部分
Math.trunc(4.5) -> 4
Math.trunc(4.9) -> 4
Math.sign(-5) 判断一个数到底是正数、负数、0
Math.sign(-5) -> -1
Math.sign(5) -> 1
Math.sign(0) -> 0
Math.sign(-0) -> -0
其他值，返回 NaN
Math.cbrt() 计算一个数立方根
Math.cbrt(27) -> 3
.......
ES2018(ES9):
1. 命名捕获
语法: (?<名字>)
let str = '2018-03-20';
let reg = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
let {year, month ,day} = str.match(reg).groups;
console.log(year, month, day);
反向引用:
\1 \2 $1 $2
反向引用命名捕获:
语法: \k<名字>
let reg = /^(?<Strive>welcome)-\k<Strive>$/;
匹配: ‘welcome-welcome’
-------------------------------------------------
let reg = /^(?<Strive>welcome)-\k<Strive>-\1$/;
匹配: 'welcome-welcome-welcome'
替换:
$<名字>
let reg = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
str = str.replace(reg,'$<day>/$<month>/$<year>');
console.log(str);
----------------------------------------
str = str.replace(reg, (...args)=>{
//console.log(args)
let {year, month, day} = args[args.length-1];
return `${day}/${month}/${year}`;
});
console.log(str);
2. dotAll 模式 s
之前 '.' 在正则里表示匹配任意东西， 但是不包括 \n
let reg = /\w+/gims;
3. 标签函数
function fn(){
}
fn() //这样调用就是普通函数
fn`aaa` //标签函数使用
-----------------------------------
function fn(args){
return args[0].toUpperCase();
}
console.log(fn`welcome`);