ES6简单语法

let关键字

1. 作用:

• 与var类似, 用于声明一个变量

2. 特点:

• 在块作用域内有效
• 不能重复声明
• 不会预处理, 不存在变量提升

3. 应用:

• 循环遍历加监听
• 使用let取代var是趋势

<script type="text/javascript">
    // console.log(username);
    let username = 'kobe';
    // let username = 'wade';
    // console.log(username);
    let btns = document.getElementsByTagName('button');
    for (let i = 0; i < btns.length; i++) {
        var btn = btns[i];
        /*var无法获取正确的索引*/
        btn.onclick = function(){
            alert(i);
        }
        /*闭包的方式解决
        (function(i){
            btn.onclick = function(){
                alert(i);
            }
        })(i);*/
    }
</script>

const关键字

1. 作用:

• 定义一个常量

2. 特点:

• 不能修改
• 其它特点同let

3. 应用:

• 保存不用改变的数据

<script type="text/javascript">
    const KEY = 'NBA';
    KEY = 'CBA';
    console.log(KEY);
</script>

变量的解构赋值

1. 理解:

• 从对象或数组中提取数据, 并赋值给变量(多个)

2. 对象的解构赋值
   let {n, a} = {n:'tom', a:12}
3. 数组的解构赋值
   let [a,b] = [1, 'hello'];
4. 用途

• 给多个形参赋值

<script type="text/javascript">
    let obj = {username: 'kobe', age: 40};
    // let username = obj.username;
    // let age = obj.age;
    // let {username, age} = obj;
    // console.log(username, age);
    // let {age} = obj;
    // console.log(age);
    let arr = [1,3,5,'abc',true];
    // let [a,b,c,d,e] = arr;
    // console.log(a,b,c,d,e);
    let [,,a,b] = arr;
    console.log(a,b);
    /*function foo(obj){
        console.log(obj.username, obj.age);
    }*/
    function foo({username, age}){//{username, age} = obj;
        console.log(username, age);
    }
    foo(obj);
</script>

模板字符串

1. 模板字符串 : 简化字符串的拼接

• 模板字符串必须用 `` 包含
• 变化的部分使用${xxx}定义

<script type="text/javascript">
    let obj = {username: 'kobe', age: 40};
    let str = '我的名字叫：' + obj.username + '，我的年龄：' + obj.age;
    console.log(str);
    str = `我的名字叫：${obj.username}，我的年龄：${obj.age}`;
    console.log(str);
</script>

简化的对象写法

简化的对象写法

• 省略同名的属性值
• 省略方法的function
• 例如:

let x = 1;
let y = 2;
let point = {
x,
y,
setX (x) {this.x = x}
};

<script type="text/javascript">
    let username = 'kobe';
    let age = 40;
    let obj = {
        username,//同名的属性可以省略不写
        age,
        getName(){//可以省略函数的function
            return this.username;
        }
    };
    console.log(obj);
    console.log(obj.getName());
</script>

箭头函数

• 作用: 定义匿名函数
• 基本语法:
  • 没有参数: () => console.log('xxxx')
  • 一个参数: i => i+2
  • 大于一个参数: (i,j) => i+j
  • 函数体不用大括号: 默认返回结果
  • 函数体如果有多个语句, 需要用{}包围，若有需要返回的内容，需要手动返回
• 使用场景: 多用来定义回调函数
• 箭头函数的特点：
  1、简洁
  2、箭头函数没有自己的this，箭头函数的this不是调用的时候决定的，而是在定义的时候所处的对象就是它的this
  3、扩展理解： 箭头函数的this看外层的是否有函数，
  如果有，外层函数的this就是内部箭头函数的this，
  如果没有，则this是window。

<script type="text/javascript">
    /*let fun= function(){
        console.log('我是函数');
    }*/
    /*
    let fun = () => console.log('我是箭头函数');
    fun();
    //形参的情况
    //1、没有形参的时候
    let fun1 = () => console.log('我是箭头函数');
    fun1();
    //2、只有一个形参的时候()可以省略
    let fun2 = a => console.log(a);
    fun2('aaa');
    //3、两个及两个以上的形参的时候()不能省略
    let fun3 = (x, y) => console.log(x, y);
    fun3(25, 36);
    //函数体的情况
    //1、函数体只有一条语句或者是表达式的时候{}可以省略-->会自动返回语句执行的结果，或者是表达式的结果
    // let fun4 = (x,y) => {return x + y};
    let fun4 = (x,y) => x + y;
    console.log(fun4(24, 36));
    //2、函数体不止一条语句或者表达式的情况
    let fun5 = (x, y) => {
        console.log(x, y);
        return x + y;
    }
    console.log(fun5(35, 49));
    */
    let btn1 = document.getElementById('btn1');
    let btn2 = document.getElementById('btn2');
    btn1.onclick = function(){
        alert(this);
        console.log(this);
    }
    btn2.onclick = () => {
        alert(this);
    }
    let obj = {
        name: '箭头函数',
        getName: () => {
            btn2.onclick = () => {
                console.log(this);
            }
        }
    }
    // 本质是 obj.getName = () => {};
    obj.getName();
</script>

3点运算符

• 用途

1. rest(可变)参数
   • 用来取代arguments 但比 arguments 灵活,只能是最后部分形参参数

    function fun(...values) {
        console.log(arguments);
        arguments.forEach(function (item, index) {
            console.log(item, index);
        });
        console.log(values);
        values.forEach(function (item, index) {
            console.log(item, index);
        })
    }
    fun(1,2,3);

2. 扩展运算符
   let arr1 = [1,3,5];
   let arr2 = [2,...arr1,6];
   arr2.push(...arr1);

<script type="text/javascript">
    function foo(a, ...value){
        console.log(arguments);
        // arguments.callee();
        console.log(value);
        /*arguments.forEach(function(item, index){
            console.log(item, index);
        })*/
        value.forEach(function(item, index){
            console.log(item, index);
        })
    }
    foo(2, 65, 33, 44);
    let arr = [1,6];
    let arr1 = [2,3,4,5];
    arr = [1, ...arr1, 6];
    console.log(arr);
    console.log(...arr);
</script>

形参默认值

• 形参的默认值----当不传入参数的时候默认使用形参里的默认值

    function Point(x = 1,y = 2) {
        this.x = x;
        this.y = y;
    }

<script type="text/javascript">
    //定义一个点的坐标的构造函数
    function Point(x = 0, y = 0){
        this.x = x;
        this.y = y;
    }
    let point = new Point(23, 35);
    console.log(point);
    let point1 = new Point();
    console.log(point1);
</script>

Promise对象

1. 理解:

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

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

• 创建promise对象
  let promise = new Promise((resolve, reject) => {
  //初始化promise状态为 pending
  //执行异步操作
  if(异步操作成功) {
  resolve(value);//修改promise的状态为fullfilled
  } else {
  reject(errMsg);//修改promise的状态为rejected
  }
  })
• 调用promise的then()
  promise.then(function(
  result => console.log(result),
  errorMsg => alert(errorMsg)
  ))

3. promise对象的3个状态

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

4. 应用:

• 使用promise实现超时处理
• 使用promise封装处理ajax请求
  let request = new XMLHttpRequest();
  request.onreadystatechange = function () {
  }
  request.responseType = 'json';
  request.open("GET", url);
  request.send();

<script type="text/javascript">
    /*
    //创建promise对象
    let promise = new Promise((resolve, reject) => {
        //初始化promise状态：pending（初始化）
        console.log('111');
        //执行异步操作，通常是发送ajax请求、开启定时器
        setTimeout(() => {
            console.log('333');
            //根据异步任务的返回结果，去修改promise的状态
            //异步任务执行成功
            // resolve('哈哈');//修改promise的状态为fullfilled（成功状态）
            //异步任务执行失败
            reject('555');//修改promise的状态为rejected（失败状态）
        }, 2000);
    })
    console.log('222');
    promise
        .then((data) => {//成功的回调
            console.log(data, '成功了~~~');
        }, (error) => {//失败的回调
            console.log(error, '失败了~~~');
        });
    */
    // 定义获取新闻的功能函数
    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);
        }, () => {
        });
</script>