1.ES6中的面向对象的类

1.1、定义类

在ES5中,我们写一个类,通常是这么写的

  1. function Person(name,age){
  2. this.name = name;
  3. this.age = age;
  4. }
  5. /**
  6. * es5中的模拟面向对象的类的方法 写法1
  7. Person.prototype.showName = function(){
  8. return "名字为:"+this.name;
  9. }
  10. Person.prototype.showAge = function(){
  11. return "年龄为:"+this.age;
  12. }*/
  13.  
  14. /**
  15. * es5中的模拟面向对象的类的方法 写法2
  16. *
  17. */
  18. Object.assign(Person.prototype,{
  19. showName(){
  20. return "名字为:"+this.name;
  21. },
  22. showAge(){
  23. return "年龄为:"+this.age;
  24. }
  25. });
  26. var p1 = new Person('tom',18);
  27. console.log(p1.showName());//名字为:tom
  28. console.log(p1.showAge());//年龄为:18

在ES6中,我们可以这样写

  1. //ES6中的类(类名大小写都可以,推荐使用规范按照首字母大写)
  2. class Person{
  3. constructor(name,age){//构造方法(函数),每new一个新对象,自动执行
  4. // console.log(`构造函数执行了,${name},${age}`);//构造函数执行了,Lucy,18
  5. this.name = name;
  6. this.age = age;
  7. }
  8. showName(){
  9. return `名字为:${this.name}`;
  10. }
  11. showAge(){
  12. return `年龄为:${this.age}`;
  13. }
  14. }
  15. let p1 = new Person('Lucy',18);
  16. console.log(p1.showName(),p1.showAge());//名字为:Lucy 年龄为:18
  1. //ES6中的类(赋给一个变量或常量,类名大小写都可以,推荐使用规范首字母大写)
  2. const Person = class{
  3. constructor(name,age){//构造方法(函数),每new一个新对象,自动执行
  4. // console.log(`构造函数执行了,${name},${age}`);//构造函数执行了,Lucy,18
  5. this.name = name;
  6. this.age = age;
  7. }
  8. showName(){
  9. return `名字为:${this.name}`;
  10. }
  11. showAge(){
  12. return `年龄为:${this.age}`;
  13. }
  14. }
  15. let p1 = new Person('Lucy',18);
  16. console.log(p1.showName(),p1.showAge());//名字为:Lucy 年龄为:18

注意:

1).ES6里面Class没有提升(例如ES5中的函数有提升到顶部的作用)

2).ES6中的this,首先来看一下ES5中矫正this的几个方法

(2.1) fn.call(this指向谁,args1,args2...);

(2.2) fn.apply(this指向谁,[args1,args2...]);

(2.3) fn.bind();(React中经常会用到)

其中,(2.1) fn.call和(2.2) fn.apply都会在矫正this的时候,方法(函数)会调用一次

  1. class Person{
  2. constructor(){
  3. this.name = 'jason';
  4. this.showName = this.showName.bind(this);//矫正this
  5. }
  6. showName(){
  7. console.log('this:',this);//this: Person {name: "jason", showName: function}
  8. return `名字为:${this.name}`;
  9. }
  10. }
  11. let p1 = new Person();
  12. let {showName} = p1;
  13. console.log(showName());//名字为:jason

1.2、类里面的取值函数(getter)和存值函数(setter):

  1. class Person{
  2. constructor(name){
  3. this.name = name;
  4. }
  5. get aaa(){
  6. return `获取aaa的名字,值为${this.name}`;
  7. }
  8. set aaa(val){
  9. console.log(`设置aaa的名字,值为${val}`);
  10. }
  11. }
  12. let p1 = new Person('jack');
  13. console.log(p1.aaa);//获取aaa的名字,值为jack
  14. p1.aaa = 'luke';//设置aaa的名字,值为luke

1.3、类里面的静态方法(就是类身上的方法)

  1. class Person{
  2. constructor(){
  3.  
  4. }
  5. showName(){
  6. return '这是showName方法';
  7. }
  8. static aaa(){
  9. return '这是静态方法';
  10. }
  11. }
  12. let p1 = new Person();
  13. console.log(p1.showName());//这是showName方法
  14. console.log(Person.aaa());//这是静态方法

1.4、类里面的继承

先来回顾一下ES6之前的继承写法

1.原型链继承

  1. //父类
  2. Animal.prototype.eat = function(food) {
  3. console.log(this.name + '正在吃' + food);
  4. }
  5. function Animal(name) {
  6. this.color = ['green','red','blue'];
  7. this.name = name || 'animal';
  8. this.sleep = function() {
  9. console.log(this.name + "正在睡觉")
  10. }
  11. }

原型链继承核心: 将父类的实例作为子类的原型。

  1. //子类
  2. function Cat(name) {
  3. this.name = name
  4. this.color = ['green','red','blue'];//引用类型值,,所有实例会共享这个属性。
  5. }
  6. Cat.prototype = new Animal();
  7. var cat = new Cat('cat');
  8. console.log(cat.name);
  9. console.log(cat.eat('fish'));
  10. console.log(cat instanceof Animal);
  11. console.log(cat.sleep());

缺点:

但是,原型链式继承并没有实现代码的复用,一些共同的属性:如name,在子类中还是得重新写一遍(即同一套代码还是得重新写)。

再者,cat继承了Animal实例的所有属性和方法,这些方法并不都是我们需要的,也就是过多的继承了没有用的属性。且如果原型中包含引用类型值,那么所有的实例会共享这个属性。

2.构造函数继承

  1. function Person(name,age,sex){
  2. this.name = name;
  3. this.age = age;
  4. this.sex = sex;
  5. }
  6. function Student(name,age,sex){
  7. Person.call(this,name,age,sex);
  8. this.grade = grade;
  9. }
  10. let student = new Student;

优点:

  • 构造函数模式继承实现了代码的复用

缺点:

  • 不能继承借用的构造函数的原型,只能借用构造函数本身的属性和方法
  • 每次构造函数都要多走一个函数

3.组合继承

  1. // 父类
  2. function Person(name){
  3. this.name = name;
  4. }
  5. Person.prototype.showName = function(){
  6. return `名字是:${this.name}`
  7. };
  8. // 子类
  9. function Student(name,age){
  10. Person.call(this,name);//继承属性,在创建实例时第二次调用Person
  11. this.age = age;
  12. }
  13. Student.prototype = new Person();//继承方法,第一次调用Person
  14. Student.prototype.constructor = Student;//矫正constructor
  15. Student.prototype.sayName = function(){
  16. return '年龄是:'+this.age;
  17. }
  18. // 调用
  19. var stu1 = new Student('jack',20);
  20. console.log(stu1.name);//jack
  21. console.log(stu1.showName);//function (){return `名字是:${this.name}`}
  22. console.log(stu1.showName());//名字是:jack
  23. console.log(stu1.sayName());//年龄是:20

缺点:

  • 父类构造函数被调用2次,子类实例的属性存在两份,一份在原型上,一份在实例属性上。造成内存的浪费。

4.寄生组合式继承

寄生组合式继承是对组合继承的进一步优化。我们先看一下为什么要写这个语句。

  1. SubType.prototype = new SuperType();

我们无非是想让SubType继承SuperType的原型。但是我们为什么不直接写成这样呢?

  1. SubType.prototype = SuperType.prototype

这样写确实可以实现子类对象对父类对象原型的继承。但是这样写的话:所有继承该父类的子类对象的原型都指向同一个了。也就是说SubType不能有自己的原型了。这显然不是我们想要的。

既然不能直接继承,那可不可以间接继承SuperType.prototype呢。这就是最终的解决方案:寄生组合式继承

我们让一个函数去指向SuperType.prototype,然后让SubType.prototype指向这个函数产生的对象不就可以了嘛。

  1. function inherit(Target,Origin) {//实现寄生组合式继承的核心函数
  2. function F() {};
  3. F.prototype = Origin.prototype; //F()的原型指向的是Origin
  4. Target.prototype = new F(); //Target的原型指向的是F()
  5. Target.prototype.constructor = Target;
  6. SubType.prototype.__proto__ == SuperType.prototype
  7. }
  8.  
  9. function SuperType(name) {
  10. this.name = name;
  11. this.colors = ['red','blue','pink'];
  12. }
  13. SuperType.prototype.sayName = function() {
  14. console.log(this.name);
  15. }
  16. function SubType(name,age) {
  17. //继承属性
  18. SuperType.call(this,name);//在创建实例时第二次调用SuperType
  19. this.age = age;
  20. }
  21.  
  22. inherit(SubType,SuperType);//实现寄生组合式继承

我们再来看一下实现寄生组合式继承的核心函数。F函数其实是通用的,我们没必要每次进入inherit函数时都声明一遍。所以我们可以用闭包的形式来写:

  1. var inherit = (function () {
  2. var F = function () {};
  3. return function (Target , Origin) {
  4. F.prototype = Origin.prototype;//F()的原型指向的是Origin
  5. Target.prototype = new F();//Target的原型指向的是F()
  6. Target.prototype.constructor = Target;
  7. Target.prototype.uber = Origin.prototype;
  8. SubType.prototype.__proto__ == SuperType.prototype
  9. }
  10. })()

再来看看ES6继承的写法,相比前面就优雅了许多,代码量也会少很多!!!

  1. /* ES6继承 */
  2. // 父类
  3. class Person{
  4. constructor(name){
  5. this.name = name;
  6. }
  7. showName(){
  8. return `名字为:${this.name}`;
  9. }
  10. }
  11. // 子类
  12. class Student extends Person{
  13.  
  14. }
  15. // 调用
  16. var stu1 = new Student('jack');
  17. console.log(stu1.showName());//名字为:jack

子类在自己的身上加方法:

  1. /* ES6继承 */
  2. // 父类
  3. class Person{
  4. constructor(name){
  5. this.name = name;
  6. }
  7. showName(){
  8. return `名字为:${this.name}`;
  9. }
  10. }
  11. // 子类
  12. class Student extends Person{
  13. constructor(name,skill){
  14. super(name);//子类的构造函数必须有super(),相当于执行一次父级的构造函数
  15. this.skill = skill;
  16. }
  17. showSkill(){
  18. return `他的名字是${this.name},他的特长是${this.skill}`;
  19. }
  20. }
  21. // 调用
  22. var stu1 = new Student('jack','跳舞');
  23. console.log(stu1.showSkill());//他的名字是jack,他的特长是跳舞

如果子类的方法和父类的方法同名,然后想调用父类的方法,自己子类的方法也要执行,可以这么写

  1. /* ES6继承 */
  2. // 父类
  3. class Person{
  4. constructor(name){
  5. this.name = name;
  6. }
  7. showName(){
  8. console.log('父类的showName');
  9. return `名字为:${this.name}`;
  10. }
  11. }
  12. // 子类
  13. class Student extends Person{
  14. constructor(name,skill){
  15. super(name);//子类的构造函数必须有super(),相当于执行一次父级的构造函数
  16. this.skill = skill;
  17. }
  18. showName(){
  19. super.showName();//执行父类的方法
  20. /* 这里写子类自己的要做的事 */
  21. console.log('子类的showName');
  22. }
  23. showSkill(){
  24. return `他的名字是${this.name},他的特长是${this.skill}`;
  25. }
  26. }
  27. // 调用
  28. var stu1 = new Student('jack','跳舞');
  29. console.log(stu1.showName());//父类的showName 子类的showName

2.Symbol和Generator

2.1Symbol:ES6新增的一种数据类型

定义方法:let Symbol = Symbol('aaa');

注意:

(1)Symbol不能当new来使用

(2)Symbol()返回是一个唯一值

(3)Symbol是一个单独数据类型,就叫symbol的基本类型

(4)如果Symbol作为key,用for in循环,出不来

  1. let symbol = Symbol('Jack');
  2. let json = {
  3. a:'apple',
  4. b:'banana',
  5. [symbol]:'aaa'
  6. }
  7. console.log(json[symbol]);//aaa
  8. // 遍历json
  9. for(let key in json){
  10. console.log(key);//a b
  11. }

2.2Generator生成器函数:解决异步,深度嵌套的问题

语法:

  1. function * show(){
  2.  
  3. }
  4. function* show(){
  5.  
  6. }
  7. function *show(){
  8.  
  9. }

定义&调用:

  1. function * gen(){//在函数名前面使用*号定义一个
  2. yield 'hello';
  3. yield 'javascript';
  4. return 'generator函数';
  5. }
  6. let g1 = gen();
  7. console.log(g1.next());//Object {value: "hello", done: false}
  8. console.log(g1.next());//Object {value: "javascript", done: false}
  9. console.log(g1.next());//Object {value: "generator函数", done: true}
  10. console.log(g1.next());//Object {value: undefined, done: true}

遍历generator函数:

  1. function * gen(){//在函数名前面使用*号定义一个
  2. yield 'hello';
  3. yield 'javascript';
  4. yield 'world';
  5. return 'generator函数';
  6. }
  7. let g1 = gen();
  8. /*遍历generator函数(注意:return的东西不会被遍历出来)*/
  9. // 1.用for...of遍历
  10. for(let val of g1){
  11. console.log(val);//hello javascript world
  12. }
  13. // 2.使用解构
  14. let [a,b,c,d] = gen();
  15. console.log(a,b,c,d);//hello javascript world undefined
  16. // 3.使用扩展(三个点)运算符
  17. let [f,...g] = gen();
  18. console.log(f,g);//hello ["javascript", "world"]
  19.  
  20. let [...newArr] = gen();
  21. console.log(newArr);//["hello", "javascript", "world"]
  22. //4.使用Array.from函数
  23. console.log(Array.from(gen()));//["hello", "javascript", "world"]

关于异步的解决方案:

(1)回调函数

(2)事件监听

(3)发布/订阅

(4)Promise对象

(5)Generator函数

(6)Async/Await

3.async、await函数:解决异步问题

定义:在函数前面加async,函数内部加await,后面的代码会等待前面的代码先执行

语法:

  1. async function fn(){//表示异步,这个函数里面有异步的任务
  2. let result=await;//表示后面结果需要等待
  3. }

使用(例如读取文件):

(1)promise写法:

  1. const fs = require('fs');
  2.  
  3. // 用fs封装一个promise
  4. const readFile = function(fileName){
  5. return new Promise((resolve,reject)=>{
  6. fs.readFile(fileName,(err,data)=>{
  7. if(err) reject(err);
  8. resolve(data);
  9. })
  10. })
  11. }
  12.  
  13. // promise
  14. readFile('data/1.txt').then(res=>{
  15. console.log(res.toString());
  16. return readFile('data/2.txt');
  17. }).then(res=>{
  18. console.log(res.toString());
  19. });

(2)generator写法:

  1. const fs = require('fs');
  2.  
  3. // 用fs封装一个promise
  4. const readFile = function(fileName){
  5. return new Promise((resolve,reject)=>{
  6. fs.readFile(fileName,(err,data)=>{
  7. if(err) reject(err);
  8. resolve(data);
  9. })
  10. })
  11. }
  12.  
  13. // generator
  14. function * gen(){
  15. yield readFile('data/1.txt');
  16. yield readFile('data/2.txt');
  17. }
  18. let g1 = gen();
  19. g1.next().value.then(res=>{
  20. console.log(res.toString());
  21. return g1.next().value;
  22. }).then(res=>{
  23. console.log(res.toString());
  24. return g1.next().value;
  25. });

(3)async、await写法:

  1. // 用async、await做一个文件读取
  2. const fs = require('fs');
  3.  
  4. // 用fs封装一个promise
  5. const readFile = function(fileName){
  6. return new Promise((resolve,reject)=>{
  7. fs.readFile(fileName,(err,data)=>{
  8. if(err) reject(err);
  9. resolve(data);
  10. })
  11. })
  12. }
  13.  
  14. // async
  15. async function fn(){//表示异步,函数内有异步任务
  16. let f1 = await readFile('data/1.txt');//表示后面的结果需要等待
  17. console.log(f1.toString());
  18. let f2 = await readFile('data/2.txt');
  19. console.log(f2.toString());
  20. }
  21. fn();

async、await特点:

1.await只能放在async函数中

2.相比generator语法更强

3.await后面可以是promise对象,也可以是数字、字符串、布尔类型

4.async函数返回的是一个promise对象

5.只要await语句后面Promise状态变为reject,那么整个async函数会中断执行

如何解决async函数中抛出错误,影响后续代码执行?

1.使用try{}catch(e){}语法

  1. async function fn(){
  2. try{
  3. await Promise.reject('出现问题了');
  4. }catch(e){
  5.  
  6. }
  7. let a = await Promise.resolve('successs');
  8. console.log(a);
  9. }
  10. fn().then(res=>{
  11. console.log(res);
  12. }).catch(err=>{
  13. console.log(err);
  14. });
  15. // 结果
  16. // success undefined

2.promise本身的catch

  1. async function fn(){
  2. let [a,b] = await Promise.all([
  3. readFile('data/1.txt'),
  4. readFile('data/2.txt')
  5. ]);
  6. console.log(a.toString());
  7. console.log(b.toString());
  8. }
  9. fn();

4.Set和WeakSet

4.1、Set数据结构:类似数组,但里面不能有重复值。new Set([]),存储数组

用法:

  1. // Set数据结构
  2. let setArr = new Set(['a','b','a']);
  3. console.log(setArr);//Set(2) {"a", "b"}

方法:

(1)add()方法:向Set数据结构中添加元素

  1. // Set数据结构--add()方法:向数组中添加元素
  2. let setArr = new Set();
  3. setArr.add('aaa');
  4. setArr.add('bbb');
  5. setArr.add('aaa');
  6. console.log(setArr);//Set(2) {"aaa", "bbb"}
  7. // add()方法链式添加
  8. let setArr = new Set().add('aaa').add('bbb').add('aaa');
  9. console.log(setArr);//Set(2) {"aaa", "bbb", "ccc"}

(2)delete()方法:删除Set数据结构中的某一项

  1. let setArr = new Set();
  2. setArr.add('aaa');
  3. setArr.add('bbb');
  4. setArr.add('ccc');
  5. console.log(setArr);//Set(2) {"aaa", "bbb","ccc"}
  6. // Set数据结构--delete()方法:删除Set数据结构中的某一项
  7. setArr.delete('bbb');
  8. console.log(setArr);//Set(2) {"aaa", "ccc"}

(3)clear()方法:删除Set数据结构中的所有项

  1. // Set数据结构--add()方法:向Set数据结构中添加元素
  2. let setArr = new Set();
  3. setArr.add('aaa');
  4. setArr.add('bbb');
  5. setArr.add('ccc');
  6. // Set数据结构--clear()方法:删除Set数据结构中的所有项
  7. setArr.clear();
  8. console.log(setArr);//Set(0) {}

(4)has()方法:检测Set数据结构中的是否某一项,返回布尔值

  1. let setArr = new Set();
  2. setArr.add('aaa');
  3. setArr.add('bbb');
  4. setArr.add('ccc');
  5. // Set数据结构--has()方法:检测Set数据结构中的是否某一项,返回布尔值
  6. console.log(setArr.has('bbba'));//false

(5)size属性:查看Set数据结构有多少个元素

  1. let setArr = new Set();
  2. setArr.add('aaa');
  3. setArr.add('bbb');
  4. setArr.add('ccc');
  5. // Set数据结构--size属性:查看Set数据结构有多少个元素
  6. console.log(setArr.size);//

(6)循环Set数据结构(注:Set数据结构的key和value是相同的)

  1. for(let val of setArr){//默认循环的是values()
  2. console.log(val);//aaa bbb ccc
  3. }
  4. console.log('-------');
  5. for(let val of setArr.keys()){
  6. console.log(val);//aaa bbb ccc
  7. }
  8. console.log('-------');
  9. for(let val of setArr.values()){
  10. console.log(val);//aaa bbb ccc
  11. }
  12. for(let item of setArr.entries()){
  13. console.log(item);//["aaa", "aaa"] ["bbb", "bbb"] ["ccc", "ccc"]
  14. }
  15. for(let [k,v] of setArr.entries()){
  16. console.log(k,v);//aaa aaa bbb bbb ccc ccc
  17. }
  18. setArr.forEach((val,index)=>{
  19. console.log(val,index);//aaa aaa bbb bbb ccc ccc
  20. });

利用Set做数组的去重:

方法1

  1. let arr = [1,2,3,4,5,6,3,4,5,3,2];
  2. let newArr = [...new Set(arr)];//这里数组去重返回的是一个数组的浅拷贝
  3. arr.push(9,8,7,7,8);
  4. console.log(arr);//[1, 2, 3, 4, 5, 6, 3, 4, 5, 3, 2, 9, 8, 7, 7, 8]
  5. console.log(newArr);//[1, 2, 3, 4, 5, 6]

方法2

  1. let arr2 = [1,2,3,4,5,6,3,4,5,3,2];
  2. let newArr2 = new Set();
  3. arr2.map(x=>newArr2.add(x));
  4. let resArr2 = [...newArr2];
  5. console.log(resArr2);[1, 2, 3, 4, 5, 6]

4.2、WeakSet数据结构:类似数组对象,但里面不能有重复值。new WeakSet({}),存储对象

注意:

1.WeakSet初始化定义时,不能在里面存值。

2.WeakSet里面的add()方法只能存json对象,如果存字符串、数字等会报错!

定义:

  1. let set = new WeakSet();//WeakSet初始化定义时,不能在里面存值。
  2. let json = {
  3. a:1,
  4. b:2
  5. };
  6. let json2 = {
  7. a:'asp',
  8. b:2
  9. };
  10. set.add(json);
  11. set.add(json2);//add()方法只能存json对象,如果存字符串、数字等会报错!
  12. //set.add(true);//Invalid value used in weak set
  13. console.log(set);//WeakSet {Object {a: "asp", b: 2}, Object {a: 1, b: 2}}

方法:Set数据结构提供的方法除了size属性和clear()方法没有,别的都有。(例如:add()、has()、delete())

5.Map和WeakMap

5.1Map数据结构:类似json,但是json的键(key)只能是字符串,而map的key可以是任意类型

使用:

  1. // Map使用
  2. let map = new Map();
  3. map.set(key,value);

方法:

  1. // Map使用
  2. let map = new Map();
  3. let json = {
  4. a:1,
  5. b:2
  6. }
  7.  
  8. // map.set(key,value);//设置一个值
  9.  
  10. map.set('abc','123');
  11. map.set(json,'aaa');
  12. map.set('a',json);
  13. console.log(map);//Map(3) {"abc" => "123", Object {a: 1, b: 2} => "aaa", "a" => Object {a: 1, b: 2}}
  14.  
  15. // map.get(key);//获取一个值
  16.  
  17. console.log(map.get(json));//aaa
  18. console.log(map.get('a'));//Object {a: 1, b: 2}
  19.  
  20. // map.delete(key);//删除某一项
  21.  
  22. map.delete('abc');
  23. console.log(map);//Map(2) { Object {a: 1, b: 2} => "aaa", "a" => Object {a: 1, b: 2}}
  24.  
  25. // map.has(key);//查找某一项,返回布尔值
  26.  
  27. console.log(map.has('abc'));//false
  28.  
  29. // map.clear();//删除所有项
  30.  
  31. map.clear();
  32. console.log(map);//Map(0) {}

循环map数据结构:

  1. let map = new Map();
  2. let json = {
  3. a:1,
  4. b:2
  5. }
  6. map.set('abc','123');
  7. map.set(json,'aaa');
  8. map.set('a',json);
  9. // 循环map
  10. for(let [key,value] of map){//默认entries
  11. console.log(key,value);
  12. /*abc 123
  13. Object {a: 1, b: 2} "aaa"
  14. Object {a: 1, b: 2}*/
  15. }
  16. for(let key of map.keys()){}
  17. for(let value of map.values()){}
  18. for(let [key,value] of map.entries()){}
  19. map.forEach((value,key)=>{
  20. console.log(key,value);
  21. /*abc 123
  22. Object {a: 1, b: 2} "aaa"
  23. Object {a: 1, b: 2}*/
  24. });

5.1WeakMap数据结构:类似json,但是json的键(key)只能是字符串,而WeakMap的key只能是对象

使用:

  1. // WeakMap使用
  2. let wmap = new WeakMap();
  3. let json = {
  4. a:1,
  5. b:2
  6. }
  7. wmap.set(json,'123');
  8. console.log(wmap);//WeakMap {Object {a: 1, b: 2} => "123"}

总结:

1.Set  里面是数组,不能重复,没有key(下标),没有get方法

2.Map 对json功能增强,key可以是任意类型值

6.数字变化和Math新增的东西

6.1数字变化(数值变化)

1.进制:

  1. // 二进制:(binary)
  2. let a = 0b010101;
  3. console.log(a);//
  4. // 八进制:(Octal)
  5. let b = 0o652;
  6. console.log(b);//
  7. // 十六进制:(Hexadecimal)
  8. let c = 0xabc;
  9. console.log(c);//

2.数值判断

  1. // 数字变化
  2. let a = 12;
  3. // Number.isNaN:判断是否为NaN
  4. console.log(Number.isNaN(a));//false
  5. // Number.isFinite:判断是否是数字
  6. let b = 'aaa';
  7. console.log(Number.isFinite(b));//fasle
  8. // Number.isInteger:判断是否是整数
  9. let c = 12.12;
  10. console.log(Number.isInteger(c));//false
  11. console.log(Number.isInteger(a));//true
  12. // Number.parseInt():将一个数据转换成整数
  13. console.log(Number.parseInt(2.5));
  14. // Number.parseFloat():将一个数据转换成浮点数
  15. console.log(Number.parseFloat("13.5526"));//13.5526
  16. // Number.isSafeInteger():判断是否是安全整数
  17. /* 安全整数:-(2^53-1)到(2^53-1) */
  18. console.log(Number.isSafeInteger(-(2**53)));//false
  19. console.log(Number.isSafeInteger(-(2**53-1)));//true
  20. console.log(Number.isSafeInteger((2**53)));//false
  21. console.log(Number.isSafeInteger((2**53-1)));//true
  22. // Number.MAX_SAFE_INTEGER:最大安全整数
  23. console.log(Number.MAX_SAFE_INTEGER);//
  24. // Number.MIN_SAFE_INTEGER:最小安全整数
  25. console.log(Number.MIN_SAFE_INTEGER);//-9007199254740991

6.2Math新增的东西

  1. // Math新增的东西
  2. // Math.trunc():截取数字整数部分
  3. console.log(Math.trunc(4.6));//
  4. // Math.sign():判断一个数是正数、负数、0
  5. console.log(Math.sign(-5));//-1
  6. console.log(Math.sign(5));//
  7. console.log(Math.sign(0));//
  8. console.log(Math.sign(-0));//-0
  9. console.log(Math.sign('abc'));//NaN
  10. // Math.cbrt():计算一个数的立方根
  11. console.log(Math.cbrt(27));//
  12. // ...等等

7.ES2018(ES9)新增的东西

7.1命名捕获(用于正则匹配)

语法:(?<名字>)

以前写正则,要把捕获到的数据赋给变量,都是这么写的

  1. let today = "2019-05-03";
  2. let reg = /(\d{4})-(\d{2})-(\d{2})/;
  3. let dateArr = today.match(reg);
  4. let [full,year,month,day,...more] = dateArr;
  5. console.log(year,month,day);//2019 05 03

现在,我们可以这么写:

  1. let today = "2019-05-03";
  2. let reg = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;//建议在Chrome浏览器下测试,别的浏览器可能会报错。
  3. let {year,month,day} = today.match(reg).groups;
  4. console.log(year,month,day);//2019 05 03

7.2反向引用命名捕获

1.反向引用以前写法:

(1)\1 \2(字符串写法)    (2)$1 $2(str.replace()方法写法)

语法:\k<名字>

如果要匹配和前面组相同的多个,可以这么写

  1. // 匹配:"monday-monday"
  2. // let reg = /^(?<m>monday)-\k<m>$/;
  3. // let str = 'a-a';
  4. // let str2 = 'm-m';
  5. // let str3 = 'monday-monday';
  6. // console.log(reg.test(str));//false
  7. // console.log(reg.test(str2));//false
  8. // console.log(reg.test(str3));//true
  9.  
  10. // 匹配:"monday-monday-monday"
  11. let reg = /^(?<m>monday)-\k<m>-\1$/;//或者let reg = /^(?<m>monday)-\k<m>-\k<m>$/;
  12. let str = 'a-a';
  13. let str2 = 'm-m';
  14. let str3 = 'monday-monday';
  15. let str4 = 'monday-monday-monday';
  16. console.log(reg.test(str));//false
  17. console.log(reg.test(str2));//false
  18. console.log(reg.test(str3));//false
  19. console.log(reg.test(str4));//true

2.替换:$<名字>

例如:正则转换日期格式:

  1. let str = '2019-05-03';
  2. let reg = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
  3.  
  4. let str1 = str.replace(reg,'$<day>/$<month>/$<year>');
  5. console.log(str);//2019-05-03
  6. console.log(str1);//03/05/2019

结合回调函数:

  1. let str = '2019-05-03';
  2. let reg = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
  3.  
  4. let str1 = str.replace(reg,(...args)=>{
  5. // console.log(args);
  6. let {year,month,day} = args[args.length-1];
  7. return `${day}/${month}/${year}`;
  8. });
  9. console.log(str1);//03/05/2019

7.3dotAll模式(用s)来表示:匹配任意东西

之前,如果用正则匹配任意东西,用‘.’来匹配,但不包括\n,所以之前如果匹配\n之类的东西,是这么写的

  1. let reg = /^\w+.\w+$/m;//注:在结尾处加m表示多行模式
  2. let str = 'turn-\noff';
  3. console.log(reg.test(str));//true

但是如果匹配一些别的文字,比如换行符’\n‘,会匹配失败

  1. let reg = /^\w+.\w+$/m;
  2. let str = 'turn\noff';
  3. console.log(reg.test(str));//false

现在可以用dotAll模式来匹配(结尾处加s即可):

  1. let reg = /^\w+.\w+$/s;//加s表示为dotAll模式
  2. let str = 'turn\noff';
  3. console.log(reg.test(str));//true

7.3标签函数

定义:和定义普通函数一样

  1. function fn(){
  2.  
  3. }

调用:

  1. fn();//这样调用就是普通函数
  2. fn`aaa`;//标签函数的调用

Demo:

  1. function fn(args){
  2. return args[0].toUpperCase();//将第一个参数转为大写
  3. }
  4. console.log(fn`panda`);//调用标签函数

7.4Proxy代理(扩展或增强对象的一些功能)

作用:比如vue中的拦截,预警、上报、扩展功能、统计、增强对象等等;proxy是设计模式的一种,叫做代理模式。

语法:new Proxy(target,handler),target为被代理的对象,handler对代理的对象做什么操作

  1. let obj = {//此对象不暴露给外部
  2. name:'jack'
  3. };
  4. let newObj = new Proxy(obj,{//此对象是暴露给外部的obj
  5. get(target,property){
  6. // console.log(target,property);
  7. // 在访问属性之前做一些操作
  8. console.log(`您访问了${property}属性`);
  9. return target[property];
  10. }
  11. }
  12. );
  13. console.log(newObj.name);//您访问了name属性 jack

proxy对象的get(target,property):简单封装创建DOM元素的方法:

  1. /* 使用proxy对象简单封装创建DOM元素的方法 */
  2. const DOM = new Proxy({},{
  3. get(target,property){
  4. // console.log(target,property);
  5. return function(attr={},...children){
  6. // console.log(attr,children);
  7. let el = document.createElement(property);
  8. for(key of Object.keys(attr)){
  9. el.setAttribute(key,attr[key]);
  10. }
  11. for(child of Object.values(children)){
  12. if(typeof child == 'string'){
  13. child = document.createTextNode(child);
  14. }
  15. el.appendChild(child);
  16. }
  17. return el;
  18. }
  19. }
  20. });
  21. let oDiv = DOM.div(
  22. {id:'div1'},'我是div','哈哈哈',
  23. DOM.a({href:'http://www.baidu.com'},'访问百度'),
  24. DOM.ul({},
  25. DOM.li({},'1111'),
  26. DOM.li({},'2222'),
  27. DOM.li({},'3333'),
  28. DOM.li({},'4444')
  29. )
  30. );
  31. window.onload = function(){
  32. document.body.appendChild(oDiv);
  33. }

proxy对象的set(target,prop,value):检测设置年龄是否达到要求

  1. let obj = new Proxy({},{
  2. set(target,prop,value){
  3. // console.log(target,prop,value);
  4. if(prop == 'age'){
  5. if(!Number.isInteger(value)){
  6. throw new TypeError('年龄必须为整数');
  7. }
  8. if(value>200){
  9. throw new RangeError('年龄超标了,必须小于200岁');
  10. }
  11. }
  12. target[prop]=value;
  13. }
  14. });
  15. obj.a = 123;
  16. obj.name = 'pilot';
  17. console.log(obj);
  18. obj.age = 201;

proxy对象的deleteProperty(target,property):删除对象属性之前,显示提示信息

  1. let json = {
  2. a:1,
  3. b:2
  4. }
  5. let newJson = new Proxy(json,{
  6. deleteProperty(target,property){
  7. console.log(`您要删除${property}属性`);
  8. delete target[property];
  9. }
  10. });
  11. delete newJson.a;
  12. console.log(newJson);

proxy对象的has(target,property):

  1. let json = {
  2. a:1,
  3. b:2
  4. }
  5. let newJson = new Proxy(json,{
  6. has(target,property){
  7. console.log(`判断是否存在调用has方法`);
  8. return property in target;
  9. }
  10. });
  11. console.log('a' in newJson);//true
  12. console.log(newJson);

proxy对象的apply():

  1. function fn(){
  2. return '我是一个函数';
  3. }
  4. let newFn = new Proxy(fn,{
  5. apply(){
  6. return '函数么?';
  7. }
  8. });
  9. console.log(newFn());

apply结合reflect()来使用:

  1. function sum(a,b){
  2. return a+b;
  3. }
  4. let newSum = new Proxy(sum,{
  5. apply(target,context,args){
  6. // console.log(target,context,args);
  7. //console.log(...arguments);
  8. // return Reflect.apply(...arguments);//8
  9. return Reflect.apply(...arguments)**2;//
  10. }
  11. });
  12. console.log(newSum(3,5));

7.5Reflect反射:类似fn.call()、fn.apply()

定义:Reflect.apply(调用的函数,this指向,参数数组)

调用:

  1. // console.log(Math.ceil(5.2));//6
  2. let res = Reflect.apply(Math.ceil,null,[6.8]);
  3. console.log(res);//

检测对象的某一项属性是否存在:

  1. console.log(Reflect.has(Object,'assign'));//true

删除对象的某一项属性:

  1. let json = {a:1,b:2};
  2. Reflect.deleteProperty(json,'a');
  3. console.log(json);//{b: 2}

---------------------END---------------------

到这也就全部都完了,ES6以及ESNext的一些东西,下面附上其他俩个部分的地址,感谢观看!

javascript的ES6学习总结(第一部分)

javascript的ES6学习总结(第二部分)

javascript的ES6学习总结(第三部分)的更多相关文章

  1. javascript的ES6学习总结(第二部分)

    1.数组循环 介绍数组循环之前,先回顾一下ES5数组的循环 (1)数组遍历(代替普通的for):arr.forEach(callback(val,index,arr){todo}) //val是数组的 ...

  2. javascript的ES6学习总结(第一部分)

    ES6(ESNext学习总结——第一部分) ES6, 全称 ECMAScript 6.0 ,是 JavaScript 的下一个版本标准,2015.06 发版. ECMA每年6月份,发布一个版本 201 ...

  3. ES6学习笔记(三):教你用js面向对象思维来实现 tab栏增删改查功能

    前两篇文章主要介绍了类和对象.类的继承,如果想了解更多理论请查阅<ES6学习笔记(一):轻松搞懂面向对象编程.类和对象>.<ES6学习笔记(二):教你玩转类的继承和类的对象>, ...

  4. Javascript oop深入学习笔记(三)--javascript中类的实现

    一.类的实现机制 在javascript中可以使用function关键字来定义一个类.在函数内通过this指针引用的变量或则方法都会成为类的成员. function classDemo(){ var ...

  5. ES6学习笔记(三)

    ES6加强了对Unicode的支持,并且扩展了字符串对象. 1.字符的Unicode表示法 JavaScript允许采用\uxxxx形式表示一个字符,其中"xxxx"表示字符的码点 ...

  6. JavaScript高级程序设计---学习笔记(三)

    函数表达式 定义函数的方式有两种:一种是函数声明,另一种是函数表达式. 关于函数声明,它的一个重要特征就是函数声明提升,意思是在执行代码之前会先读取函数声明所以可以把函数声明放在调用它的语句后面. 而 ...

  7. ES6学习笔记(三):与迭代相关的新东东

    Symbol 概念 Symbol:一种新的原始数据类型,表示独一无二的值. 注意:Symbol函数的参数只是表示对当前Symbol值的描述,因此相同参数的Symbol函数的返回值是不相等的. // 没 ...

  8. JavaScript高级程序设计学习笔记第三章--基本概念

    一.标识符: 1.区分大小写 2.命名规则: 第一个字符必须是一个字母.下划线(_)或一个美元符号($) 其他字符可以是字母.下划线.美元符号或数字 标识符中的字母也可以包含扩展的 ASCII 或 U ...

  9. ES6学习笔记(三)字符串的扩展

    ES6 加强了对 Unicode 的支持,并且扩展了字符串对象. 1.字符的Unicode表示法 JavaScript 允许采用\uxxxx形式表示一个字符,其中xxxx表示字符的 Unicode 码 ...

随机推荐

  1. python之turtle画蚊香

    原理:利用turtle绘制圆形,并使圆半径逐步增加 代码如下: import turtle turtle.pensize(30) for i in range(30): turtle.circle(i ...

  2. win10 下安装zookeeper+Kafka 的详细步骤(2)

    Win10 下要使用Kafka需要经过以下三个步骤: 1.安装JDK(需要安装依赖java JDK) 2.安装zookeeper(资源协调,分配管理) 3.使用Kafka开发 ============ ...

  3. EasyCode实现数据库到Swagger全自动化

    简介 EasyCode是基于IntelliJ IDEA开发的代码生成插件,通过自定义生成模板可以完成定制化的 Mapper Service Controller 生成,结合数据库 Comment还可以 ...

  4. 使用Cap解决.Netcore分布式事务

    一.什么是Cap    CAP 是一个基于 .NET Standard 的 C# 库,它是一种处理分布式事务的解决方案,同样具有 EventBus 的功能,它具有轻量级.易使用.高性能等特点. 在我们 ...

  5. day20191106

    笔记: 一.#{}和${}的区别是什么 1)#{}是预编译处理,${}是字符串替换.2)Mybatis 在处理#{}时,会将 sql 中的#{}替换为?号,调用 PreparedStatement 的 ...

  6. Netty学习——protoc的新手使用流程

    Netty学习——protoc的新手使用流程 关于学习的内容笔记,记下来的东西等于又过了一次脑子,记录的更深刻一些. 1. 使用IDEA创建.proto文件,软件会提示你安装相应的语法插件 安装成功之 ...

  7. 用launchscreen.storyboard适配启动图方法(二)

    背景 之前有写一篇实现方式比较简单的随笔用launchscreen.storyboard适配启动图方法,顺便在评论区提了一下用autolayout适配启动图的思路,现把思路和流程记录下来. 思路 整体 ...

  8. 洛谷 题解 P1842 【奶牛玩杂技】

    本蒟蒻又双叒叕被爆踩辣! Solution: 我们先看数据,50000,那么O(n)或者O(n log(n))是可以过的,非严格O(n * sqrt(n))要卡卡常,说不定也可以过. 那么什么算法可以 ...

  9. luogu P1168 中位数 |树状数组+二分

    题目描述 给出一个长度为NN的非负整数序列A_i,对于所有1 ≤ k ≤ (N + 1) / 21≤k≤(N+1)/2,输出A_1, A_3, -, A_2k - 1的中位数.即前1,3,5,-个数的 ...

  10. dubbo 订阅 RPC 服务

    Dubbo 订阅 RPC 服务 建立消费者者项目 pom.xml <?xml version="1.0" encoding="UTF-8"?> &l ...