形参默认值
形参的默认值:当不传入参数的时候使用形参的默认值(undefined)
function Point(x = 0, y = 0){
        this.x = x;
        this.y = y;
    }
    let point1 = new Point();
    console.log(point1);

Promise对象

Promise对象: 代表了未来某个将要发生的事件(通常是一个异步操作)

有了promise对象, 可以将异步操作以同步的流程表达出来, 避免了层层嵌套的回调函数(俗称'回调地狱')
ES6的Promise是一个构造函数, 用来生成promise对象的实例




使用promise基本步骤(2步):


创建promise对象
*调用promise的then()


promise对象的3个状态


pending: 初始化状态
fullfilled: 成功状态
rejected: 失败状态


promise对象的3个状态


pending: 初始化状态
fullfilled: 成功状态
rejected: 失败状态


应用:


使用promise实现超时处理
使用promise封装处理ajax请求
练习网页新闻评论

// 定义获取新闻的功能函数
    function getNews(url){
        let promise = new Promise((resolve, reject) => {
            // 状态：初始化
            // 执行异步任务
            // 创建xmlHttp实例对象
            let xmlHttp = new XMLHttpRequest();
            console.log(xmlHttp.readyState);
            //绑定readyState监听
            xmlHttp.onreadystatechange = function(){
                if(xmlHttp.readyState === 4){
                    if(xmlHttp.status == 200){//请求成功
                        // console.log(xmlHttp.responseText);
                        //修改状态
                        resolve(xmlHttp.responseText);//修改promise的状态为成功的状态
                    }else{//请求失败
                        reject('暂时没有新闻内容');
                    }
                }
            };
            // open设置请求的方式以及url
            xmlHttp.open('GET', url);
            // 发送
            xmlHttp.send();
        })
        return promise;
    }
    getNews('http://localhost:30001/news?id=2')
    //成功和失败
        .then((data) => {
            console.log(data);
            // console.log(typeof data);
            // 准备获取评论内容的url
            let commentsUrl = JSON.parse(data).commentsUrl;
            let url = 'http://localhost:3000' + commentsUrl;
            // 发送请求获取评论内容
            return getNews(url);
        }, (error) => {
            console.log(error);
        })
        .then((data) => {
            console.log(data);
        }, () => {
        });

async函数
async函数(源自ES2017)
概念： 真正意义上去解决异步回调的问题，同步流程表达异步操作
本质： Generator的语法糖
语法：
async function foo(){
await 异步操作;
await 异步操作；
}
特点：
1、不需要像Generator去调用next方法，遇到await等待，当前的异步操作完成就往下执行
2、返回的总是Promise对象，可以用then方法进行下一步操作
3、async取代Generator函数的星号*，await取代Generator的yield
4、语意上更为明确，使用简单，经临床验证，暂时没有任何副作用
class

通过class定义类/实现类的继承
在类中通过constructor定义构造方法
通过new来创建类的实例
通过extends来实现类的继承
通过super调用父类的构造方法
重写从父类中继承的一般方法

//定义一个人物的类
    class Person{
        // 类的构造方法
        constructor(name, age){
            this.name = name;
            this.age = age;
        }
        // 类的一般方法
        showName(){
            console.log('调用父类的方法');
            console.log(this.name, this.age);
        }
    }
    let person = new Person('kobe', 40);
    console.log(person);
    // person.showName();
    // 子类
    class StarPerson extends Person{
        constructor(name, age, salary){
            super(name, age);
            this.salary = salary;
        }
        // class StarPerson extends Person{
        //  constructor(){
        //      super()//调用父类的构造方法            -
        
        //  }
        // }
        // 父类的方法重写
        showName(){
            console.log('调用子类的方法');
            console.log(this.name, this.age, this.salary);
        }
    }
    let sp = new StarPerson('wade', 36, 152450000);
    console.log(sp);
    sp.showName();

字符串扩展

includes(str) : 判断是否包含指定的字符串
startsWith(str) : 判断是否以指定字符串开头
endsWith(str) : 判断是否以指定字符串结尾
repeat(count) : 重复指定次数

let str = 'asdfohsvckxnlck';
    console.log(str.includes('t'));
    console.log(str.includes('a'));
    console.log(str.startsWith('a'));
    console.log(str.endsWith('k'));
    console.log(str.repeat(5));

数值扩展
二进制与八进制数值表示法: 二进制用0b, 八进制用0o

Number.isFinite(i) : 判断是否是有限大的数
Number.isNaN(i) : 判断是否是NaN
Number.isInteger(i) : 判断是否是整数
Number.parseInt(str) : 将字符串转换为对应的数值
Math.trunc(i) : 直接去除小数部分

console.log(0b1010);//10
    console.log(0o56);//46
    console.log(Number.isFinite(123));//true
    console.log(Number.isFinite(Infinity));//flase
    console.log(Number.isNaN(NaN));//true
    console.log(Number.isInteger(123));//true
    console.log(Number.isInteger(123.456));//false
    console.log(Number.isInteger(123.0));//true
    console.log(Number.parseInt('123abc456'));//123
    console.log(Number.parseInt('a123abc456'));//NaN
    console.log(Math.trunc('123.123'));//123

数组扩展
. Array.from(v) : 将伪数组对象或可遍历对象转换为真数组

Array.of(v1, v2, v3) : 将一系列值转换成数组
find(function(value, index, arr){return true}) : 找出第一个满足条件返回true的元素
findIndex(function(value, index, arr){return true}) : 找出第一个满足条件返回true的元素下标

let btns = document.getElementsByTagName('button');
    Array.from(btns).forEach(function(item, index){
        console.log(item);
    })
    let arr = Array.of(1, 4, 'abc', true);
    console.log(arr);
    let arr2 = [2,3,4,2,5,7,3,6,5];
    let result = arr2.find(function(item, index){
        return item > 4;
    });
    console.log(result);//5
    result = arr2.findIndex(function(item, index){
        return item > 4;
    });
    console.log(result);//4

对象扩展

Object.is(v1, v2)


判断2个数据是否完全相等,以字符串形式来判断


Object.assign(target, source1, source2..)


将源对象的属性复制到目标对象上


直接操作 proto 属性  隐式原型
let obj2 = {};
obj2.proto = obj1;

console.log(0 == -0);//true
    console.log(NaN == NaN);//false
    console.log(Object.is(0, -0));//false
    console.log(Object.is(NaN, NaN));//true
    let obj = {};
    let obj1 = {username:'iverson', age:43};
    let obj2 = {sex: '男'};
    Object.assign(obj, obj1, obj2);
    console.log(obj);
    let obj3 = {};
    let obj4 = {money: 5000000};
    obj3.__proto__ = obj4;//相当与obj4是obj3的父类 所以obj3可以使用obj4的东西
    console.log(obj3);
    console.log(obj3.money);

ES7


指数运算符(幂): **
Array.prototype.includes(value) : 判断数组中是否包含指定value

console.log (2 ** 3);//8

let arr = [1,4,5,6,"abc"];
console.log(arr.includes("a"));//false
console.log(arr.includes("abc"));//true
console.log(arr.includes(4));//true