Es6 语法

已于 2023-05-25 17:05:18 修改
阅读量327 收藏
点赞数
文章标签： es6 javascript 开发语言
于 2023-05-25 16:53:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46214574/article/details/130869064
版权

Es6特性

1、块级作用域 => 关键字let，常量const

在Es6中通常用 var、let、const来声明，var 表示全局变量、let 表示局部变量、const 表示常量
特点
let 和 const 都是块级作用域，以 {} 代码块作为作用域范围，只能在代码块里面使用，不存在变量提升，只能先声明在使用，否则会报错。 在代码块内，在声明变量之前， 该变量都是不可用的。
const 声明的是一个只读的常量， 在声明时就需要赋值。 如果 const是一个对象

2、解构表达式

  • 数组解构 let arr = [1,2,3]; let [a,b,c] = arr
  • 对象解构 const{name:abc, age ,language} = person 其中name:abc 代表把name改名为abc
  • 字符串函数 str.startsWith();str.endsWith();str.includes();str.includes()
  • 字符串模板，··支持一个字符串定义为多行
  • 占位符功能 ${}
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        //数组解构
        let arr = [1,2,3];
        // // let a = arr[0];
        // // let b = arr[1];
        // // let c = arr[2];

        let [a,b,c] = arr;
        console.log(a,b,c)

        const person = {
            name: "jack",
            age: 21,
            language: ['java', 'js', 'css']
        }
        //         const name = person.name;
        //         const age = person.age;
        //         const language = person.language;

        //对象解构 // 把name属性变为abc，声明了abc、age、language三个变量
        const { name: abc, age, language } = person;
        console.log(abc, age, language)

        //4、字符串扩展
        let str = "hello.vue";
        console.log(str.startsWith("hello"));//true
        console.log(str.endsWith(".vue"));//true
        console.log(str.includes("e"));//true
        console.log(str.includes("hello"));//true

        //字符串模板 ``可以定义多行字符串
        let ss = `<div>
                    <span>hello world<span>
                </div>`;
        console.log(ss);
        
        function fun() {
            return "这是一个函数"
        }

        // 2、字符串插入变量和表达式。变量名写在 ${} 中，${} 中可以放入 JavaScript 表达式。
        let info = `我是${abc}，今年${age + 10}了, 我想说： ${fun()}`;
        console.log(info);

    </script>
</body>
</html>

3、函数优化

  • 支持函数形参默认值 function add(a, b = 1){}
  • 支持不定参数 function fun(…values){}
  • 支持箭头函数 var print = obj => console.log(obj);
  • 支持箭头函数+解析函数 var hello2 = ({name}) => console.log(“hello,” +name); hell2(person);
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>

    <script>
        //在ES6以前，我们无法给一个函数参数设置默认值，只能采用变通写法：
        function add(a, b) {
            // 判断b是否为空，为空就给默认值1
            b = b || 1;
            return a + b;
        }
        // 传一个参数
        console.log(add(10));


        //现在可以这么写：直接给参数写上默认值，没传就会自动使用默认值
        function add2(a, b = 1) {
            return a + b;
        }
        console.log(add2(20));


        //2）、不定参数
        function fun(...values) {
            console.log(values.length)
        }
        fun(1, 2)      //2
        fun(1, 2, 3, 4)  //4

        //3）、箭头函数。lambda
        //以前声明一个方法
        // var print = function (obj) {
        //     console.log(obj);
        // }
        var print = obj => console.log(obj);
        print("hello");

        var sum = function (a, b) {
            c = a + b;
            return a + c;
        }

        var sum2 = (a, b) => a + b;
        console.log(sum2(11, 12));

        var sum3 = (a, b) => {
            c = a + b;
            return a + c;
        }
        console.log(sum3(10, 20))


        const person = {
            name: "jack",
            age: 21,
            language: ['java', 'js', 'css']
        }

        function hello(person) {
            console.log("hello," + person.name)
        }

        //箭头函数+解构
        var hello2 = ({name}) => console.log("hello," +name);
        hello2(person);

    </script>
</body>
</html>

4、对象优化

  • 可以获取map的键值对 Object.keys()、Object.values、Object.entries
  • Object.assgn(target,source1,source2) 合并source1, source2到target
  • 支持对象名声明简写 : 如果属性名和属性值的变量名相同可以省略
  • let someone = {…person} 去除person对象所有的属性拷贝到当前对象
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>
    <script>
        const person = {
            name: "jack",
            age: 21,
            language: ['java', 'js', 'css']
        }

        console.log(Object.keys(person));//["name", "age", "language"]
        console.log(Object.values(person));//["jack", 21, Array(3)]
        console.log(Object.entries(person));//[Array(2), Array(2), Array(2)]

        const target = { a: 1 };
        const source1 = { b: 2 };
        const source2 = { c: 3 };

        // 合并
        //{a:1,b:2,c:3}
        Object.assign(target, source1, source2);

        console.log(target);//["name", "age", "language"]

        //2）、声明对象简写
        const age = 23
        const name = "张三"
        const person1 = { age: age, name: name }
        // 等价于
        const person2 = { age, name }//声明对象简写
        console.log(person2);

        //3）、对象的函数属性简写
        let person3 = {
            name: "jack",
            // 以前：
            eat: function (food) {
                console.log(this.name + "在吃" + food);
            },
            //箭头函数this不能使用，要使用的话需要使用：对象.属性
            eat2: food => console.log(person3.name + "在吃" + food),
            eat3(food) {
                console.log(this.name + "在吃" + food);
            }
        }

        person3.eat("香蕉");
        person3.eat2("苹果")
        person3.eat3("橘子");

        //4）、对象拓展运算符

        // 1、拷贝对象（深拷贝）
        let p1 = { name: "Amy", age: 15 }
        let someone = { ...p1 }
        console.log(someone)  //{name: "Amy", age: 15}

        // 2、合并对象
        let age1 = { age: 15 }
        let name1 = { name: "Amy" }
        let p2 = { name: "zhangsan" }
        p2 = { ...age1, ...name1 }
        console.log(p2)
    </script>
</body>

</html>

5、map和reduce

  • arr.map() 接收一个函数，将arr中的所有元素用接收到的函数处理后放入新的数组
  • arr.reduce() 为数组中的每一个元素依次执行回调函数， 不包括数组中被删除或从未被赋值的元素
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>

    <!DOCTYPE html>
    <html lang="en">

    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>Document</title>
    </head>

    <body>


        <script>
            //数组中新增了map和reduce方法。
            //map()：接收一个函数，将原数组中的所有元素用这个函数处理后放入新数组返回。
            let arr = ['1', '20', '-5', '3'];

            //  arr = arr.map((item)=>{
            //     return item*2
            //  });
            arr = arr.map(item => item * 2);



            console.log(arr);
            //reduce() 为数组中的每一个元素依次执行回调函数，不包括数组中被删除或从未被赋值的元素，
            //[2, 40, -10, 6]
            //arr.reduce(callback,[initialValue])
            /**
             1、previousValue （上一次调用回调返回的值，或者是提供的初始值（initialValue））
        2、currentValue （数组中当前被处理的元素）
        3、index （当前元素在数组中的索引）
        4、array （调用 reduce 的数组）*/
            let result = arr.reduce((a, b) => {
                console.log("上一次处理后：" + a);
                console.log("当前正在处理：" + b);
                return a + b;
            }, 100);
            console.log(result)


        </script>
    </body>

    </html>

6、promise

  • 优化异步操作。封装ajax
  • 把Ajax封装到Promise中，赋值给let p
  • 在Ajax中成功使用resolve(data), 失败使用reject(err)
  • p.then().catch()
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
    <script src="https://cdn.bootcss.com/jquery/3.4.1/jquery.min.js"></script>
</head>

<body>

    <script>
        //1、查出当前用户信息
        //2、按照当前用户的id查出他的课程
        //3、按照当前课程id查出分数
        // $.ajax({
        //     url: "mock/user.json",
        //     success(data) {
        //         console.log("查询用户：", data);
        //         $.ajax({
        //             url: `mock/user_corse_${data.id}.json`,
        //             success(data) {
        //                 console.log("查询到课程：", data);
        //                 $.ajax({
        //                     url: `mock/corse_score_${data.id}.json`,
        //                     success(data) {
        //                         console.log("查询到分数：", data);
        //                     },
        //                     error(error) {
        //                         console.log("出现异常了：" + error);
        //                     }
        //                 });
        //             },
        //             error(error) {
        //                 console.log("出现异常了：" + error);
        //             }
        //         });
        //     },
        //     error(error) {
        //         console.log("出现异常了：" + error);
        //     }
        // });


        //1、Promise可以封装异步操作
        // let p = new Promise((resolve, reject) => {
        //     //1、异步操作
        //     $.ajax({
        //         url: "mock/user.json",
        //         success: function (data) {
        //             console.log("查询用户成功:", data)
        //             resolve(data);
        //         },
        //         error: function (err) {
        //             reject(err);
        //         }
        //     });
        // });

        // p.then((obj) => {
        //     return new Promise((resolve, reject) => {
        //         $.ajax({
        //             url: `mock/user_corse_${obj.id}.json`,
        //             success: function (data) {
        //                 console.log("查询用户课程成功:", data)
        //                 resolve(data);
        //             },
        //             error: function (err) {
        //                 reject(err)
        //             }
        //         });
        //     })
        // }).then((data) => {
        //     console.log("上一步的结果", data)
        //     $.ajax({
        //         url: `mock/corse_score_${data.id}.json`,
        //         success: function (data) {
        //             console.log("查询课程得分成功:", data)
        //         },
        //         error: function (err) {
        //         }
        //     });
        // })

        function get(url, data) {
            return new Promise((resolve, reject) => {
                $.ajax({
                    url: url,
                    data: data,
                    success: function (data) {
                        resolve(data);
                    },
                    error: function (err) {
                        reject(err)
                    }
                })
            });
        }

        get("mock/user.json")
            .then((data) => {
                console.log("用户查询成功~~~:", data)
                return get(`mock/user_corse_${data.id}.json`);
            })
            .then((data) => {
                console.log("课程查询成功~~~:", data)
                return get(`mock/corse_score_${data.id}.json`);
            })
            .then((data)=>{
                console.log("课程成绩查询成功~~~:", data)
            })
            .catch((err)=>{
                console.log("出现异常",err)
            });

    </script>
</body>

</html>

7、模块化

  • export用于规定模块的对外接口,export不仅可以导出对象，一切JS变量都可以导出。比如：基本类型变量、函数、数组、对象
  • import用于导入其他模块提供的功能
// user.js

var name = "jack"
var age = 21
function add(a,b){
    return a + b;
}
// 导出变量和函数
export {name,age,add}

---------------------------------------------------------------
// hello.js
    
// 导出后可以重命名
export default {
    sum(a, b) {
        return a + b;
    }
}


--------------------------------------------------------------
// main.js

import abc from "./hello.js"
import {name,add} from "./user.js"

abc.sum(1,2);
console.log(name);
add(1,3);
小小阿封
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
es6语法
weixin_43963309的博客
03-23 88
在开发项目过程中，会遇到很多es6的语法，但是对某些语法使用不熟练，比如结构赋值，async await等。 仔细阅读了阮大佬的es6入门指导后，会逐步对自己不熟悉的部分进行总结。 结构赋值 数组的结构赋值 数组的结构赋值是按顺序赋值的 [a,b,c] = [1,2,3] console.log(a,b,c) [b,a,c] = [1,2,3] console.log(a,b,c) // 12...
ES6基本语法
ttttsuki的博客
06-13 2万+
ES6 一、let、const let：ES6中新增的用于声明变量的关键字 let声明的变量只在所处于的块级有效{} 不存在变量提升 暂时性死区 const：声明量，常量就是值（内存地址）不能变化的量 具有块级作用域 声明常量时必须赋值 常量赋值后，值不能修改 二、解构赋值 ES6中允许从数组中提取值，按照对应位置，对变量赋值，对象也可以实现解构。 对象解构 三、箭头函数 ES6中新增的定义函数的方式 ()=>{} 在箭头函数中，如果函数体中只有一句代码，并且代码的执行结果就是函数的返回值，
ES6中常用语法
mengsandy的专栏
01-10 5331
ECMAScript 6.0（也可以称为ECMAScript2015），ECMAScript 6.0简称 ES6，是 JavaScript 语言的标准。 出来的时间已经很久了，但是我们在工作中，有时候也不会使用。今天我们就来介绍一下。 1、块级作用域（let、const） 块级作用域，就是有{}括号中可用范围，不像之前var定义的变量都是函数作用域。 let定义的变量可以改变值，const定义的都是静态变量，不可以修改的。但是像数组，只对数据进行push操作的话，也可以定义成const的。 2、模版字符串
[最完整的前端学习手册]——ES6语法
weixin_48683052的博客
08-12 4113
5、有this关键字的不能被解构，会出现指向丢失（当解构的对象方法内部有this关键字参与，该方法不能进行解构，如果强行进行解构，在赋值后，调用时，会导致内部的this指向window）。可以按照数组，对象的形式进行解构赋值操作；​ rest参数，形式为“...变量名”，用于获取函数的多余参数，可以用rest参数取代arguments对象的使用。let定义的变量，只能在块作用域里访问，不能跨块访问，也不能跨函数访问。1. var定义的变量，**没有块的概念，可以跨块访问**, 不能跨函数访问。......
ES6语法详解+面试必备
weixin_47194802的博客
01-12 2903
/ 传统函数定义// 箭头函数定义。
ES6语法
m0_73442777的博客
06-11 1890
本文将介绍 ECMAScript 2015（简称 ES6）的一些核心特性和改进。ES6 是 JavaScript 的一项重要更新，为开发者提供了许多新的语法和功能，以提升开发效率和代码可读性。本文将深入探讨 ES6 中的箭头函数、模板字符串、解构赋值、类和模块化等重要特性。
ie11兼容es6语法资源包
03-08
1、引入browser.min.js，使用es6语法的script标签加 type="text/babel" 2、引入browser-polyfill.min.js，兼容promise语法
webstorm和.vue中es6语法报错的解决方法
12-09
1.webstorm中es6语法报错，解决方法： 打开 Settings => Languages & Frameworks => Javascript 把 Javascript Language version 改为 ECMAScript 6 这样做所有的.js文件中es6不再报错，但是.vue文件中es6语法依然...
解决node终端下运行js文件不支持ES6语法
12-20
最近写一些简单的测试代码时，为了方便直接在node终端执行发现有些ES6语法不支持，记录一下解决方式 现象 新建class.js文件后添加如下代码 // constructer class Person { constructor(name,age,sex) { this.name...
利用babel将es6语法转es5的简单示例
11-30
Babel是一个广泛使用的转码器，可以将ES6代码转为ES5代码，从而在现有环境执行。 这意味着，你可以现在就用ES6编写程序，而不用担心现有环境是否支持。 本文讲解需预装node和npm。大家可以参考这篇文章：//...
ES6基本全部语法
热门推荐
qq_40322724的博客
02-21 4万+
一,变量声明： let声明变量： 1.变量不可重复声明， let star = '罗志祥' let star = '小猪' 结果报错 2.块级作用域， { let girl = '周扬青' } 在大括号内的都属于作用域内 3.不存在变量提升 4.不影响作用域链 const声明常量： const SCHOOL = ‘学校’;一般习惯把常量全用大写字母 1.一定要赋初始值 2.一般常量使用大写（潜规则） 3.常量值不能修改 4.块级作用域 5.对数组和对象的元素修改，不算对常量的修改，不会报错 变量的结构.
ES5 ES6基础知识
henucm的博客
04-17 1012
ES5语法 数组方法 迭代(遍历)方法：forEach()、map()、filter()、some()、every()； array.forEach(function(currentValue, index, arr)) // currentValue：数组当前项的值 index：数组当前项的索引 arr：数组对象本身 var arr = [1,2,3]; var sum=0; arr.fo...
ES6语法大全
wozxy7831的博客
01-02 827
一、推荐在函数中使用 let 定义变量。 二、const 用来声明一个常量 (值类似值不能改变，引用类型地址不能改变)。 备注 let 和 const 只在最近的一个块中（花括号中）有效 1.ES6中可以使用 => 作为函数表达形式 var foo = function(){return 1;}; //等价于 let foo = () => 1; 2.class ES6中增加了类的概念...
【JavaScript高级篇】ES6
BMG-Princess
12-08 1581
目录 1、ES6语法：let和const 2、ES6变量赋值 3、ES6箭头函数 4、Promise构造函数 5、新增的实例方法：includes() ，startsWith() ，endsWith() 6、repeat() 7、padStart() padEnd() 8、rest参数（形式为“…变量名”） 9、扩展运算符（…） 10、字符串新增的方法 1、ES6语法：let和const 好处： let用来声明变量，类似于var，但是所声明的变量，只在let命令所在的代码块内有效
ECMAScript6介绍及环境搭建
最新发布
2401_85124347的博客
06-24 373
解构赋值可以方便地将一组参数与变量名对应起来。// 参数是一组有次序的值// 参数是一组无次序的值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值