Es6 语法

已于 2023-05-25 17:05:18 修改
阅读量320 收藏
点赞数
文章标签： 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
    评论
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语法依然...
ES6中常用语法
mengsandy的专栏
01-10 5327
ECMAScript 6.0（也可以称为ECMAScript2015），ECMAScript 6.0简称 ES6，是 JavaScript 语言的标准。 出来的时间已经很久了，但是我们在工作中，有时候也不会使用。今天我们就来介绍一下。 1、块级作用域（let、const） 块级作用域，就是有{}括号中可用范围，不像之前var定义的变量都是函数作用域。 let定义的变量可以改变值，const定义的都是静态变量，不可以修改的。但是像数组，只对数据进行push操作的话，也可以定义成const的。 2、模版字符串
ES6语法
最新发布
m0_73442777的博客
06-11 1864
本文将介绍 ECMAScript 2015（简称 ES6）的一些核心特性和改进。ES6 是 JavaScript 的一项重要更新，为开发者提供了许多新的语法和功能，以提升开发效率和代码可读性。本文将深入探讨 ES6 中的箭头函数、模板字符串、解构赋值、类和模块化等重要特性。
ES6基本语法
See_Star的博客
11-26 2234
文章目录一、ES6基本语法二、let声明变量三、const声明常量四、解构赋值4.1 数组解构4.2 对象解构五、 模板字符串5.1 定义多行字符串5.2 字符串插入变量和表达式5.3 字符串中调用函数六、声明对象简写七、定义方法简写八、对象拓展运算符8.1 拷贝对象(深拷贝)8.2 合并对象九、函数的默认参数十、函数的不定参数十一、箭头函数十二、Promise十三、模块化13.1 传统的模块化13.2 ES6的模块化 一、ES6基本语法 ES标准中不包含 DOM 和 BOM的定义，只涵盖基本数据类型、关键
ES6语法大全
wozxy7831的博客
01-02 825
一、推荐在函数中使用 let 定义变量。 二、const 用来声明一个常量 (值类似值不能改变，引用类型地址不能改变)。 备注 let 和 const 只在最近的一个块中（花括号中）有效 1.ES6中可以使用 => 作为函数表达形式 var foo = function(){return 1;}; //等价于 let foo = () => 1; 2.class ES6中增加了类的概念...
【JavaScript高级篇】ES6
BMG-Princess
12-08 1477
目录 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命令所在的代码块内有效
es6语法
01-07
3.ES6 允许使用“箭头”（=>）定义函数。 场景：用于替换匿名函数 e.target.value 每次触发DOM事件时会产生一个事件对象（也称event对象），此处的参数e接收事件对象。 e.target表示该DOM元素，然后在获取其相应的...
解决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 语法教程
国内某知名游戏公司小菜鸡工程师
06-28 5161
学好 ES 标准规范，就是学好前端
前端介绍之ES6 语法指南
liuerchong的博客
07-24 5155
ES6 语法指南 后端项目搭建完毕，接下来就是前端页面了。不过在这之前需要一些准备工作。我们需要学习ES6的语法标准。 什么是ES6？就是ECMAScript第6版标准。 4.1.什么是ECMAScript？ 来看下前端的发展历程： web1.0时代： 最初的网页以HTML为主，是纯静态的网页。网页是只读的，信息流只能从服务的到客户端单向流通。开发人员也只关心页面的样式和内容即可。 web2.0时代： 1995年，网景工程师Brendan Eich 花了10天时间设计了Ja
ES6 语法
weixin_41909678的博客
07-30 336
ES6新特性
ECMAScript6
m0_46337171的博客
01-06 150
目录前言1.ECMAScript6 简介1.1 ECMAScript 和 JavaScript 的关系1.2 ES6 与 ECMAScript 2015 的关系2.搭建前端环境2.1 Node 环境2.1.1 什么是Node.js2.2 NPM环境2.2.1 什么是NPM3. ES6基本语法3.1 let声明变量3.2 const声明常量3.3 解构赋值3.3.1 数组解构3.3.2 对象解构3.4 模板字符串3.4.1 定义多行字符串3.4.2 字符串插入变量和表达式3.4.3 字符串中调用函数3.5 声
C#中的数组
凯歌技术控团队
02-24 5632
声明并且初始化数组 class Demo { //初始化数组的3种方式 static void Main() { //第一种 int[] a = new int[10]; a[0] = 1; a[1] = 2; a[3] = 3; ...
JavaScript复习总结
wzp123wzp的博客
09-08 427
js复习总结
JS中let用法
热门推荐
chenmo2001的博客
06-07 2万+
let

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值