0
0

【前端】--- ES6上篇（带你深入了解ES6语法）

前言：ECMAScript是 JavaScript 的标准化版本，由 ECMA 国际组织制定。ECMAScript 定义了 JavaScript 的语法、类型、语句、关键字、保留字等。

ES6 是 ECMAScript 的第六个版本，于 2015 年发布，引入了许多重要的新特性，使 JavaScript 更加现代化。

变量声明：

作用域有块作用域，函数作用域，全局作用域，其中全局作用域>函数作用域>块作用域

**let和var的区别 (ES6使用let更加严谨）： **

let声明:

使用 let 声明的变量仅在其定义的块（用 { } 包围的代码块）内有效。这意味着变量在块外不可访问。

  1. {
  2.     let x = 10;
  3.     console.log(x); // 输出 10
  4. }
  5. console.log(x); // ReferenceError: x is not defined
var声明:

使用 var 声明的变量的作用范围是整个函数体。如果在函数外部声明，变量将是全局的。

  1. function myFunction() {
  2.     var x = 10; // 函数作用域
  3.     console.log(x); // 输出 10
  4. }
  5. myFunction();
  6. console.log(x); // ReferenceError: x is not defined
const声明:

** const:声明常量的 特点和语法 与let相同的。能改变的是变量，常量不能够改变**

  1.   1.常量不允许修改值。
  3.   2.常量必须赋初始值。
  5.   3.const与let相同 同样有块作用域(没有预解析，变量提升
  7.   4.const定义的引用类型值内容可以修改。
  1.    const PI = 3.1415926;
  2.    // PI=3.14; //报错，1.常量不允许修改值
  3.    // const numA; //2.常量必须赋初始值。
  4.    // numA= 10;
  6.    const obj = { a: 1 };
  7.    console.log(obj);
  8.    obj.a = 20; // 不报错，没有修改到内存地址
  9.    obj = { b: 1 };// 报错，修改内存地址了。console.log(obj);
  10.    //如果存储的是一个数值，存的就是一个值
  11.    //如果存储的是一个对象，存的就是一个内存地址

解构（数组，对象，字符串）：

数组解构：
  1. 解构: 左边一种结构，右边一种结构，左右一一对应
  3. 1.完全解构
  5. 2.不完全解构(部分解构)
  7. 3.忽略方式解构
  9. 4.嵌套解构
  11. 5.剩余运算符方式解构Ig
  13. 6.解构默认值
  15. 7.使用场景
  17. 场景1:使用解构方式实现两数交换
  19. 场景2:使用函数返回值

** 1.完全解构：**

  1.       //1.完全解构
  2.       let a, b;
  3.       [a, b] = [1, 2];
  4.       console.log(a, b);

** 2.不完全解构(部分解构)**

  1.       //2.不完全解构(部分解构)
  2.       let [a] = [1, 2, 3];
  3.       console.log(a);
  4.       let [b, c] = [1];
  5.       console.log(b, c);//如果解构不成功，变量值就默认等于undefined

** 3.忽略方式解构**

  1.       //3.忽略方式解构
  2.       let [, , a] = [1, 2, 3];
  3.       console.log(a);

4.嵌套解构

  1.       //4.嵌套解构
  2.       let [a, b, [c]] = ["a", "b", ["c"]];
  3.       console.log(a, b, c);

5.剩余运算符方式解构

  1.       //5，剩余运算符方式解构
  2.       let [a, ...b] = [1, 2, 3, 4, 5, 6, 7];
  3.       console.log(a, b);//a只取第一个，剩下的都赋值给b

6.解构默认值

  1.       //6.解构默认值
  2.       let [a, b = 100] = [90];
  3.       console.log(a, b);//如果设置了默认值，当没有第二个参数值时就取默认值180

场景1:使用解构方式实现两数交换

  1.       let a = 10;
  2.       b = 20;
  3.       [a, b] = [b, a];
  4.       console.log(a, b);

场景2:使用函数返回值

  1.       //使用场景二：使用函数返回值
  2.       function fu() {
  3.         return [1, 2, 3]
  4.       }
  5.       let res = fu()
  6.       console.log(res[0], res[1], res[2])
  8.       let [a, b, c] = fu()
  9.       console.log(a, b, c)
对象解构：
  1. 数组解构和对象解构的不同:
  3. 数组解构是按照顺序一一解构
  5. 对象解构与顺序无关，根据属性名和变量名进行比较
  7. 1.完全解构
  9. 2. 部分解构
  11. 3.解构之后重命名
  13. 4.剩余运算符对象解构 - 浅指贝
  15. 5。对象默认值
  17. 6.使用场景: 场景1: 函数返回值

** 1.完全解构**

  1.       //1.完全解构
  2.       let obj = {
  3.         name: 'zhangsna',
  4.         age: 20
  5.       }
  6.       let { age, name } = obj;
  7.       console.log(name, age);

** 2. 部分解构**

  1.       //2.部分解构
  2.       let obj = { name: 'zhangsan', age: 20 };
  3.       let { age } = obj;
  4.       console.log(age);
  5.       let { address, name } = obj;
  6.       console.l0g(address, name);//如果没有匹配到则变量undefined
  1. **3.解构之后重命名**
  1.       //3.解构之后重命名(匹配的属性名:变最名
  2.       let obj = { name: 'zhangsan', age: 20 };
  3.       let { name: myname, age: myage } = obj;
  4.       console.log(myname, myage);
  1. **4.剩余运算符对象解构 - 浅指贝**
  1.       //4。剩余运算符对象解构-浅拷贝...
  2.       let obj = { name: 'zhangsan', age: 20, address: '大河区' };
  3.       let { name, ...rest } = obj;
  4.       console.log(name, rest);

** 5.对象默认值**

  1.       //5。对象默认值
  2.       let obj = { name: 'zhangsan', age: 20, address: '天河区' };
  3.       let { name, img = 'aaa.png' } = obj;
  4.       console.log(name, img);

** 6.使用场景: 场景1: 函数返回值**

  1.       //场景1:函数返回值
  2.       function fn() {
  3.         return {
  4.           name: 'zhangsan', age: 20, address: '天河区'
  5.         }
  6.       }
  7.       let res = fn();//之前不解构方式
  8.       console.log(res.name, res.age, res.address);//解构方式
  9.       let { name, age, address } = res;
  10.       console.log(name, agP, address);
字符串解构：

字符串解构很简单，就是将字符解构出来赋给变量

  1.     let str = 'ababa'
  2.     let [a, b, c, d] = str
  3.     console.log(a, b, c, d) //a b a b
  5.     let { length } = str
  6.     console.log(length)//5

对象扩展：

  1. 对象扩展
  3. 1.属性和方法的简洁表达方式
  5. 2.属性如果对象属性名和接收的变量名相同可以直接用变量名作为性名方法 方法名(){)
  7. 3.0bject.assign()用于对象合井
  9. 4.0bject.is()方法 比较两个值是否严格相等
  11. 5.遍历对象的方法（键，值，键值对） 以及将对像转为map对象的方法

1.属性和方法的简洁表达方式,键值对的命名和方法的命名

  1. const name = "xiaoming";
  2.       let vue = {
  3.         name,//等同于name:xiaoming
  4.         data() {
  5.           console.log("我是data-fn")
  6.         }
  7.         //等同于
  8.         // data:function(){
  9.         //   console.log("我是data-fn"))
  10.         // }
  11.       }

2.动态属性名：在对象字面量中，使用方括号 [ ] 语法可以动态地计算属性名。这意味着你可以通过表达式来生成属性名。动态方法名：在对象字面量中，方法名同样可以使用动态计算的方式。

  1. //2.表达式方式的属性名和方法名
  2.       let obj = {
  3.         ['my' + 'name']: 'zhangsan',
  4.         ["say" + "Hi"]() {
  5.           console.log("sayHi...")
  6.         }
  7.       }
  9.       let nameobj = {}
  10.       console.log(obj);
  11.       obj.sayHi();
  12.       //后面写项目时，对象的属性可能是动态添加进去。并需要动态获取出来let nameobj{};
  13.       let arr = ["zhangsan", "lisi", "wangwu"];
  14.       //{"zhangsan1":"zhangsan","lisi2":"lisi"}
  15.       for (let i = 0; i < arr.length; i++) {
  16.         console.log(arr[i]);
  17.         nameobj[arr[i] + (i + 1)] = arr[i];
  18.       }
  19.       console.log(nameobj);
  20.       // lisi2: "lisi"
  21.       // wangwu3: "wangwu"
  22.       // zhangsan1: "zhangsan"
  24.       for (let i = 0; i < arr.length; i++) {
  25.         console.log(nameobj[arr[i] + (i + 1)])
  26.         // zhangsan
  27.         // lisi
  28.         // wangwu
  29.       };

3.0bject.assign()用于对象合井

  1.     //1.0bect.assign()用于对象合并
  2.     //注意点:如果不希望更改源对象，第一个参数可以给一个}
  3.     //合井时如果存在相同属性，后面对象的会覆盖前面对象属性值
  4.     let a = { name: 'zhangsan', width: 100 };
  5.     let b = { age: 20, width: 200 };
  6.     let ret = Object.assign({}, a, b);
  7.     console.log(ret);
  8.     console.log(a, b);

** 4.0bject.is()方法 比较两个值是否严格相等**

  1.     //2.0bject.is()方法   比较两个值是否严格相等
  2.     console.log(1 == 1);//true
  3.     console.l0g("1" == 1);//true
  4.     console.log("1" === 1);//false
  6.     console.log(object.is(1, 1)); //true
  7.     console.log(object.is("1", 1));//false
  8.     console.log(Object.is({}, {}))//false

** 5.遍历对象的方法（键，值，键值对） 以及将对像转为map对象的方法**

  1.     let obj = {
  2.       name: '11',
  3.       age: 22
  4.     }
  6.     //遍历值
  7.     console.log(Object.values(obj))
  8.     //遍历键值对
  9.     console.log(Object.entries(obj))
  10.     //遍历键
  11.     console.log(Object.keys(obj))
  13.     //将对象转换成map
  14.     let map = new Map(Object.entries(obj))
  15.     console.log(map)

数组扩展：

  1. 1.扩展运算符...
  3. 解构。数组合并
  5. 2.find(callback) 查找，找出第一个符合条件的数组成员
  7. 3.findIndex(callback)
  9. 4.Array.of()
  11. 5.Array.from(obj)将对象转换为真正的数组
  13. 6.数组includes()方法
  15. 7.at()方法通过下标访问数组
  1. **1.扩展运算符...      解构。数组合并**
  1.       //1。扩展运算符...
  2.       let arr1 = ["a", "b", "c"]
  3.       // let arr2 = arr1.concat();
  4.       let arr2 = [...arrl]
  5.       arr1.push("d")
  6.       console.log(arr1, arr2);
  8.       let arr3 = ["x", "y", "z"];
  9.       let arr4 = [...arr1, ...arr3];
  10.       console.log(arr4);

** 2.find(callback) 查找，找出第一个符合条件的数组成员**

  1.       // 2.find(callback) 查找，找出第一个符合条件的数组成员
  2.       let arr1 = [1, 2, 3, 4, 5, 6];
  3.       let result = arrl.find(function (item) {
  4.         return item > 3; 1
  5.       })
  6.       console.log("result", result);

** 3.findIndex(callback)**

  1.       //3.findIndex(callback)查找。找出第一个符合条件的数组成员对应的索引
  2.       let arr1 = [1, 2, 3, 4, 5, 6];
  3.       let result = arr1.findIndex(function (item) {
  4.         return item > 3;
  5.       })
  6.       console.log("result2", result);

** 4.Array.of()**

  1.       //4.Array.of()将一组值转换为数组 (了解)
  2.       console.log(Array.of(1, 2, 3))
  3.       console.log(Array.of(99))
  5.       let arr = Array(5)
  6.       console.log(arr);//[empty]*5

** 5.Array.from(obj)将对象转换为真正的数组**

  1.       //5.Array.from(obj[,fn])将对象转换成真正的数组
  2.       //获取到的dom对象集合并不是真正数组
  3.       //arguments 也不是真正数组
  4.       //转换条件:需要是可遍历的对象，需要有索引以及length属性
  5.       function fn() {
  6.         console.log("arguments:", arguments);
  7.         //arguments.forEach(function()())//报供arguments.forEach is not a function
  8.         Array.from(arguments).forEach(function (item) {
  9.           console.log(item);
  10.         })
  11.       }
  12.       fn("zhangsan", "lisi")
  13.       console.log(["zhangsan"])
  14.       let obj = { 0: "zhangsan", 1: "lisi", length: 2 }
  15.       console.log(Array.from(obj));

** 6.数组includes()方法 **

  1.     //数组的includes方法
  2.     let arr = [1, 2, 34, 5, 33]
  3.     console.log(arr.includes(33))

** 7.at()方法通过下标访问数组**

  1.     let arr = [12, 3, 3, 2, 56, 5]
  3.     //正数  与之前数组访问下标相同
  4.     //负数  从后往前进行查找
  5.     console.log(arr.at(1))
  6.     console.log(arr.at(-1))//5

字符串扩展：

  1. 字符串新增的方法
  3. 1.**includes**()  判断是否包含 返回true /false
  5. 2.**startswith**() 判断字符串是否是在原字符串的头部 返回true / false
  7.  3.**endsWith**()判断字符串是否是在原字符串的结尾返回true  / false
  9. 4.**repeat() **将字符串重复n次 返回重复后的新字符事
  11. 5.**padStart**() **padEnd**() 字符串填充
  13. 6.字符替换 **replace**() 和 **replaceAll**()
  15. 7.优化代码的兼容性所以将**trimleft**()更新了**trimstart**() **trimright**()更新了**trimend**()

** 1.includes() 判断是否包含 返回true /false**

  1.       let str = "hello world"
  2.       console.log(str.includes(h));//true
  3.       console.log(str.includes(yy));//false

** 2.startswith() 判断字符串是否是在原字符串的头部 返回true / false**

  1.       let str = "hello world"
  2.       console.log(str.startsWith(h));//true
  3.       console.log(str.startswith(e));//false

** 3.endsWith()判断字符串是否是在原字符串的结尾返回true / false**

  1.       let str = "hello world"
  2.       console.log(str.endsWith('world'));//true
  3.       console.log(str.endsWith('hello'));//false

** 4.repeat() 将字符串重复n次 返回重复后的新字符事**

  1.       let str = "hello world"
  2.       console.log(str.repeat(3));//hello worldhello worldhello world

5.padStart() padEnd() 字符串填充

  1.       let str = 'addsfsaf'
  2.       //str.padstart(目标长度，[，填充字符串])
  3.       let s = str.padStart(10)
  4.       let s1 = str.padStart(10, '2')
  6.       console.log(s1)  //22addsfsaf
  8.       let str = 'addsfsaf'
  9.       //str.padstart(目标长度，[，填充字符串])
  10.       let s = str.padEnd(10)
  11.       let s1 = str.padEnd(10, '2')
  13.       console.log(s1) //addsfsaf22

6.字符替换 replace() 和 replaceAll()

  1.       //替换所有
  2.       let s = "aflsdjflsefel"
  3.       console.log(s.replaceAll('s', 'a'))
  4.       //替换第一个
  5.       let s = "aflsdjflsefel"
  6.       console.log(s.replace('s', 'a'))

到这里就结束了，感谢大家的观看╮(￣▽￣")╭

标签： javascript es6 开发语言
本文转载自: https://blog.csdn.net/2301_81253185/article/details/142069958
版权归原作者 心.c 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【前端】--- ES6上篇（带你深入了解ES6语法）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。