• ES6介绍

    1：ES6声明变量

    1.变量var声明变量的问题 ES5

    1. 可以重复声明变量
    2. 可以先使用再声明
    3. 造成全局变量污染

    2.let声明变量特点 ES6

    1. 不能先使用再说明
    2. 不能重复定义一个变量
    3. 具有块级作用域

    3.const声明变量特点 ES6

    1. 不能先使用再说明
    2. 一旦声明必须赋值
    3. 赋值之后不能修改
    4. 具有块级作用域
    5. 声明变量，可以修改变量
    6. 声明常量不可修改恒改不变

    注意：const声明一个常量，这个常量是引用数据类型（对象，数组，函数....）,一旦赋值（引用地址不能修改），改的是值。

    2：Symbol（）

    用于表示一个独一无二的值，不能与其他数据类型进行运算

     

    438b83f3927b22b181ec9195bc083b10.png

    3：模板字符串

    1. var name="lzj"
    2. console.log(`我是${name}`)

    用法：`${}`

    4：解构

    1. var obj={
    2.   name:"ljz";
    3.   age:12;
    4. }
    5. const {name,age}=obj

    对象解构语法： let {变量，变量，变量}=对象，要和变量同名才可以解构。

    1. let arr=[10,11,23]
    2. let [a,b,c]=arr

    数组解构语法：let[变量，变量...]=arr。将数组中的值赋值给变量

    5：扩展运算符

    1. let arr =[10,11,12]
    2. console.log(...arr)

    扩展运算符：将数组或对象中的值一个一个拿出来。

    6：箭头函数

    1. function fn（a，b）{
    2.   return a+b
    3. }
    4. console.log(fn(1,3))
    1. var fn =function(){
    2.   console.log("我也很普通")
    3. }
    1. （function() {
    2.   console.log('1111')
    3. }
    4. ）()
    let fn =()=>{ console.log('1111') }

    箭头函数中，this指向外层作用域。

    7、箭头函数中的this

    箭头函数没有自己的作用域，即箭头函数 this 指向其外层作用域

    1. function People(name,age){
    2.     this.name=name;
    3.     this.age=age;
    4.     this.say = function () {
    5.         // console.log(this.name);
    6.         setTimeout(function () {
    7.             console.log(this.name);
    8.         },1000);
    9.     }
    10. }
    11. var p1 = new People("zhangsan", 15);
    12. p1.say();  // undefined
    13. ​
    14. ​
    15. function People2(name,age){
    16.     this.name=name;
    17.     this.age=age;
    18.     this.say = function(){
    19.         // console.log(this.name);
    20.         setTimeout(()=>{
    21.             console.log(this.name);
    22.         },1000);
    23.     }
    24. }
    25. var p2 = new People2("lisi", 15);
    26. p2.say();  //lisi
    27. ​
    28. ​
    29. ​
    30. ​
    31. //但如果创建的是字面量对象，不适合书写箭头函数
    32. let obj1 = {
    33.     name:"nodejs",
    34.     age:"11",
    35.     say:()=>{
    36.         console.log(this.name);   //this不指向obj
    37. };
    38. obj1.say();  // undefined

    在dom操作中使用箭头函数

    1. DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>Titletitle>
    6.     <style>
    7.         .box{
    8.             width: 200px;
    9.             height: 200px;
    10.             background-color: pink;
    11.         }
    12.     style>
    13. head>
    14. <body>
    15.     <div id="odiv" class="box">div>
    16.     <script>
    17.         var obj = document.getElementById("odiv");
    18.         obj.onclick = function(){
    19.             
    20.             // setTimeout(function(){
    21.             //     this.style.width="300px"   //修改不了
    22.             // },1000);
    23. ​
    24. ​
    25.             setTimeout(()=>{
    26.                 this.style.width="300px"   //修改成功
    27.             },1000);
    28.         }
    29.     script>
    30. body>
    31. html>

    八、面向对象(重点)

    一般面向对象的语言里面，都有类，实例对象这些概念。我们通过实例化类，得到实例对象。

    类：定义一个 类，需要使用 class 关键字，但是es5里面，使用构造函数（首字母大写）来实现的。

    继承：一般使用 extends 关键字来进行继承，但是在es5里面，也是没有extends继承，而是使用的prototype原型继承完成的。

    ES6之前的写法：

    1. // 用函数定义类
    2. function Animal(name){
    3.     this.name = name;
    4. }
    5. // 给类的实例定义方法
    6. Animal.prototype.showName = function(){
    7.     console.log(this.name);
    8. }
    9. // 给类定义静态方法
    10. Animal.eat = function(){
    11.     console.log('进食');
    12. }
    13. ​
    14. // 根据函数实例化对象
    15. var a = new Animal("Tom");
    16. // 调用对象的方法
    17. a.showName();
    18. // 调用类的静态方法
    19. Animal.eat();

    ES6的写法： （掌握）

    1. class Animal{
    2. ​
    3.     // 定义构造函数
    4.     constructor(name){
    5.         // console.log("constructor");
    6.         this.name = name
    7.     }
    8. ​
    9.     // 定义一个方法
    10.     showName(){
    11.         console.log(this.name);
    12.     }
    13. ​
    14.     //定义静态方法
    15.     static eat(){
    16.         console.log("吃---");
    17.     }
    18. }
    19. ​
    20. let obj = new Animal("Tom");
    21. ​
    22. obj.showName();
    23. Animal.eat();

    九、关于继承

    ES6之前的写法（仅做了解）

    1. function Animal(name){
    2.     this.name = name;
    3. }
    4. Animal.prototype.showName = function(){
    5.     console.log(this.name);
    6. }
    7. Animal.eat = function(){
    8.     console.log('进食');
    9. }
    10. ​
    11. // 定义子类
    12. function Mouse(name, color){ 
    13.     // 子类继承父类的属性 需要将 this 指向父类中的 name
    14.     Animal.call(this, name);  
    15.     this.color = color;
    16. }
    17. // 子类继承父类的方法
    18. Mouse.prototype = new Animal(); 
    19. // 给子类实例添加新方法 
    20. Mouse.prototype.showInfo = function(){
    21.     console.log(this.name, this.color);
    22. }
    23. ​
    24. var m = new Mouse('Jerry', 'gray');
    25. m.showName();
    26. m.showInfo();
    27. Animal.eat();

    ES6的写法：（掌握）

    1. class Animal{
    2. ​
    3.     // 定义构造函数
    4.     constructor(name){
    5.         // console.log("constructor");
    6.         this.name = name;
    7.     }
    8. ​
    9.     // 定义一个方法
    10.     showName(){
    11.         console.log(this.name);
    12.     }
    13. ​
    14.     //定义静态方法
    15.     static eat(){
    16.         console.log("吃---");
    17.     }
    18. }
    19. ​
    20. class Cat extends Animal{
    21. ​
    22. }
    23. ​
    24. let cat1 = new Cat("Tom");
    25. ​
    26. cat1.showName();
    27. Cat.eat();
    28. 继承中的子类constructor的写法：
    29.  
    30. 在ES6中使用继承时，constructor中必须调用super()方法,其本质是在调用父类的constructor方法。通过这样的方式来达到属性继承的效果
    31.  
    32. class Animal{
    33. ​
    34.     // 定义构造函数
    35.     constructor(name){
    36.         console.log("constructor");
    37.         this.name = name;
    38.         this.age = 0;
    39.         this.color = "white";
    40.     }
    41. ​
    42.     // 定义一个方法
    43.     showName(){
    44.         console.log(this.name);
    45.     }
    46. ​
    47.     //定义静态方法
    48.     static eat(){
    49.         console.log("吃---");
    50.     }
    51. }
    52. ​
    53. class Cat extends Animal{
    54.     //注意：在ES6中使用继承时，constructor中必须调用super()方法,其本质是在调用父类的constructor方法。通过这样的方式来达到属性继承的效果
    55.     constructor(name){
    56.         super(name);
    57.         // console.log("constructor");
    58.         this.color = "yellow";
    59.     }
    60.     
    61.     
    62.     //定义Cat类特有的方法
    63.     catchMouse(){
    64.         console.log("抓老鼠");
    65.     }
    66.     //重写父类方法
    67.     showName(){
    68.         console.log(this.name, "喵喵");
    69.     }
    70. }
    71. ​
    72. let cat1 = new Cat("Tom");
    73. console.log(cat1.color);
    74. console.log(cat1.age);
    75. console.log(cat1.name);
    76. cat1.catchMouse();
    77. cat1.showName();

    10、静态属性和静态方法

    Math.max(10, 20 30, 16) 把构造函数当成普通对象来调用某个方法，这个方法叫静态方法，如果是属性，我们就称它为静态属性。

    定义静态方法，再类中通过加static关键字来定义。

    关于静态属性，目前暂时没有关键字来定义，想要实现的话就在定义完类之后直接在类上添加属性，获取的时候通过类名来获取这个属性。

    1. class Animal{
    2. ​
    3.     // 定义构造函数
    4.     constructor(name){
    5.         // console.log("constructor");
    6.         this.name = name
    7.     }
    8. ​
    9.     // 定义一个方法
    10.     showName(){
    11.         console.log(this.name);
    12.     }
    13. ​
    14.     //定义静态方法，再类中通过加static关键字来定义
    15.     static eat(){
    16.         console.log("吃---");
    17.     }
    18. }
    19. ​
    20. let obj = new Animal("Tom");
    21. ​
    22. obj.showName();
    23. Animal.eat();
    24. // 关于静态属性，目前暂时没有关键字来定义，想要实现的话就在定义完类之后直接在类上添加属性，获取的时候通过类名来获取这个属性
    25. Animal.type = "动物";
    26. console.log(Animal.type);

     

    11、全局对象

    JavaScript 中有一个特殊的对象，称为全局对象（Global Object），它及其所有属性都可以在程序的任何地方访问，即全局变量。

    在浏览器 JavaScript 中，通常 window 是全局对象， 而 Node.js 中的全局对象是 global，所有全局变量（除了 global 本身以外）都是 global 对象的属性。

    后面看到所有的全局变量，例如 console，setTimeout 和 process 是 global 变量的成员。我们甚至可以向全局变量添加成员，使其在任何地方都可用。

    1. // 1. nodejs 里面没有 window全局对象，但是存在一个 gloabal 全局对象。之前使用 console. setTimeout 这些全局的函数都是 global 上面的属性
    2. ​
    3. // console.log(window);   // 报错 ReferenceError: window is not defined
    4. // console.log(global);
    5. ​
    6. ​
    7. // 2. nodejs 里面声明的变量，并不会被挂载带 global 全局对象
    8. let b = 20;
    9. console.log(global.b);  //undefined
    10. ​
    11. ​
    12. // 3. 可以向global添加成员，使其在任何地方都可用
    13. global.a = 10;
    14. console.log(a); //10
    15. ​
    16. // 4. 在nodejs执行js文件的过程中，里面也存在 this ，但是这个 this 和 global 并不是相等。
    17. console.log(global === this);  //false
    18. // 实际上，在 nodejs 里面的this代表的当前这个 js模块（暂且认为 this 代表当前这个js文件）

    12：promise对象

    一个promise对象有以下几种状态：

    1. pending:初始化状态
    2. fullfilled:成功状态
    3. rejected:失败状态。

    promise对象有以下两个特点：

    1.对象的状态不受外界影响。

    2.一旦状态改变，就不会再变。

    解决问题：回调地狱、ajax 请求和响应需要时间 顺序不可控 。目的 控制顺序。

    1. // 假装flag是状态
    2. let flag=false
    3. let p= new promise((resolve,reject)=>{
    4.   if(flag){
    5.     resolve("返回数据")
    6.   }else{
    7.     reject("抛出异常")
    8.   }
    9. }
    10.                    // .then()处理成功的回调   也就是resolve打包的数据
    11.                    // .catch()处理失败的回调   也就是reject暴露的异常
    12.  p.then(data=>{
    13.   console.log(data);
    14. }).catch(error=>{
    15.   
    16.     console.log(error);
    17.   })

    promise本身是同步的，.then()和.catch()是异步的

    promise的all和race方法

    1. let p1= new promise((resolve,reject)=>{
    2.    setTimeout(()=>{
    3.      resolve("成功"）
    4.    },3000)
    5. })
    6. let p2= new promise((resolve,reject)=>{
    7.    setTimeout(()=>{
    8.      // resolve("成功"）
    9.      reject("失败二")
    10.    },2000)
    11. })
    12. let p3= new promise((resolve,reject)=>{
    13.    setTimeout(()=>{
    14.      resolve("成功"）
    15.    },1000)
    16. })
    17. let p=Promise.all([p1,p2,p3]);
    18.  p.then(data=>{
    19.   console.log(data);
    20. }).catch(error=>{
    21.   
    22.     console.log(error);
    23.   })

    Promise.all([多个Promise对象]) 统一处理多个异步程序（定时器，时间可控）

    1：如果多个异步程序都是成功的状态，p的状态就是成功，多个异步程序的成功结果会打包成一个数组统一返回。

    2：但凡发现一个失败，最快得到的失败结果的直接返回

    1. let p1= new promise((resolve,reject)=>{
    2.    setTimeout(()=>{
    3.      resolve("成功"）
    4.    },3000)
    5. })
    6. let p2= new promise((resolve,reject)=>{
    7.    setTimeout(()=>{
    8.      // resolve("成功"）
    9.      reject("失败二")
    10.    },2000)
    11. })
    12. let p3= new promise((resolve,reject)=>{
    13.    setTimeout(()=>{
    14.      resolve("成功"）
    15.    },1000)
    16. })
    17. let p=Promise.all([p1,p2,p3]);
    18.  p.then(data=>{
    19.   console.log(data);
    20. }).catch(error=>{
    21.   
    22.     console.log(error);
    23.   })

    Promise.race()谁快返回谁。

    13：async和await

    1. async用来修饰函数，表示这是一个异步函数
    2. await 在异步函数中使用，表示同步代码（异步程序变成同步程序）
    1. async function getVal（）{
    2.  
    3. await p1.then(res=>console.log(res)）；
    4.   await p1.then(res=>console.log(res)）；
    5.   await p1.then(res=>console.log(res)）；
    6. }

    async/awiat的使用规则:

    async 表示这是一个async函数， await只能用在async函数里面，不能单独使用

    async 返回的是一个Promise对象，await就是等待这个promise的返回结果后，再继续执行

    await 等待的是一个Promise对象，后面必须跟一个Promise对象，但是不必写then()，直接就可以得到返回值

    14：新增数组方法

    ES6新增了许多有用的数组方法，下面是其中一些常用的方法：

    1. Array.from(): 将类数组对象或可迭代对象转换为真正的数组。
    2. Array.of(): 根据传入的参数创建一个新的数组。
    3. Array.prototype.find(): 返回满足条件的第一个元素。
    4. Array.prototype.findIndex(): 返回满足条件的第一个元素的索引。
    5. Array.prototype.includes(): 判断数组是否包含某个元素。
    6. Array.prototype.fill(): 用指定的值填充数组。
    7. Array.prototype.flat(): 将嵌套的数组扁平化。
    8. Array.prototype.flatMap(): 对数组中的每个元素执行映射函数后，再将结果扁平化为一个新数组。
    9. Array.prototype.keys(): 返回包含数组索引的新迭代器对象。
    10. Array.prototype.values(): 返回包含数组值的新迭代器对象。

    1.Array.from() 可接受3个参数（后两个参数可以没有）

    Array.from(arraylLike, MapFn, thisArg)

    1. arrayLike：第一个参数，指定一个类数组对象or可迭代对象（如果只有一个参数就是把形参转变成数组）
    2. MapFn(可选)：第二个参数，新数组中的每一个元素执行该回调函数
    3. thisArg(可选)：第三个参数，执行回调函数MapFn时的this对象
    4. 返回值：一个新数组实例

     

     

    fad08b905ad38db9184c67a9aa66a10f.png

    2：includes()方法 查看数组某个元素是否存在

     

    0df027eb9ac1a3a3053ef4f8a0368818.png

    3.Array.of构建数组

     

    34a12ad5f515160410f36f8a54155ac7.png

    4:forEach不改变原数组，若要改变需要配合index

    传入一个函数，函数参数依次为 value、index、arr

    • value：数组当前项的值（必填）
    • index：数组当前项的索引（可选）
    • arr：数组对象本身（可选，一般不选）

     

    7aa80a04f4ccb4e68d6ef930f6afddee.png

    5.map 一般用于取数组中某个值返回出来

     

    73794bf1f88f1865fb750979c02d470b.png

    map() 和 forEach() 的区别就是 map() 会返回一个新数组

    6.filter 筛选数组，返回筛选后的数组

    新方法中的元素是通过指定数组中符合条件的所有元素

    • value：数组当前的值
    • index ：数组当前的索引
    • arr：数组对象本身（一般省略不写）

     

    1097534f9b64350b8c0046bda1bacbdf.png

    7:every()依据判断条件，数组的元素是否全满足，若满足则返回ture

    callback的参数：

    value --当前索引的值
    index --索引

     

    6e2015efb4d4a2bacdd3f5fc706caebe.png

    8:some() 方法用于检测数组中的元素是否满足指定条件，通俗一点 查找数组中是否有满足条件的元素

     

    36331cedab000f708f505ec045e23807.png

    15：新增对象方法

    ES6新增了很多对象方法，这些方法使得对象的操作更加方便和灵活。以下是一些常用的ES6新增的对象方法：

    1. Object.assign()：用于将源对象的属性复制到目标对象中。
    2. Object.keys()：返回一个包含所有可枚举属性名称的数组。
    3. Object.values()：返回一个包含所有可枚举属性值的数组。
    4. Object.entries()：返回一个包含所有可枚举属性键值对的数组。
    5. Object.getOwnPropertyDescriptors()：返回一个对象的所有自身属性的描述符。
    6. Object.freeze()：冻结一个对象，使其属性不可修改。
    7. Object.seal()：密封一个对象，使其属性不可删除，但可修改。
    8. Object.is()：比较两个值是否相同，类似于严格相等运算符（===）。
    9. Object.setPrototypeOf()：设置一个对象的原型。
    10. Object.getOwnPropertySymbols()：返回一个包含所有Symbol类型属性的数组。

    1.Object.assign() 方法用于将所有可枚举属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。

    Object.assign(target, ...sources)

    参数：target--->目标对象

    source--->源对象

    返回值：target，即目标对象

     

    e1474b9967361efd1c7603a3e9917bdc.png

    有多个源对象情况也是和一个源对象一样的。没有同名的属性会直接复制到目标对象上，同名的属性后面的属性值会覆盖前面的同名属性值。

    2：Object.keys()：返回一个包含所有可枚举属性名称的数组。

    作用：遍历对象
    返回结果：返回对象中每一项key的数组

     

    344d6ebf531f9a191ad5ce477804dcdf.png

    3：Object.values()：返回一个包含所有可枚举属性值的数组。

    61bc93e48beec6f43948d90d5b3bb49e.png

    4:Object.entries()：返回一个包含所有可枚举属性键值对的数组。

     

    6d77d6c75a4111d84c1399512af71163.png

    16.Set和map

    Set

    add()

     

    ed96717be7ed814cde3e39eca677cc98.png

    delete()

     

    35765b67f4aac2a380424714172d9326.png

    has()判断指定值是否存在

     

    321d8ba3c5c1cba401359cc480f2ed5c.png

    clear（）清除所有值

     

    ed56fb598490af4f60f8e76e15c908f1.png

    for ...of由于Set只有键值没有键名，所以说keys和values返回值相同

     

    758740ca4eee7d0dd4888db4883023c0.png

     

    aab7c58c15f0ae11c453890e39ca5e63.png

    entries实现键值对

     

    7f653f0ce9444f76fd320b8ae34d341c.png

    利用Set实现数组去重

     

    3afde65f4eb2bec2952863bd79d26078.png

    set实现交集 A∩B

     

    12c46e4109c4338fe65ed07e370a512a.png

    实现并集A∪B

     

    ae1675c941d169c380716935e32a7d38.png

    实现差集A-B

     

    0d5367c615c4294da6649d7462a3e806.png

    1. // 主要用于数组去重，字符串去重
    2. // let set = new Set()
    3. // 1:add添加
    4. // set.add('ljz')
    5. // set.add('xzq')
    6. // set.add('hzd').add('plf')
    7. // console.log(set);
    8. // 2：delete删除
    9. // set.delete('plf')
    10. // console.log(set);
    11. //3:判断指定值是否存在has
    12. // console.log(set.has('plf'));
    13. // console.log(set.has('hzd'))
    14. // 4clear 清除所有值
    15. // set.clear()
    16. // console.log(set);
    17. // 遍历for...of
    18. // for (let i of set.keys()) {
    19.  
    20. //     console.log(i);
    21. // }
    22. // for (let i of set.values()) {
    23.  
    24. //     console.log(i);
    25. // }
    26. // 实现键值对
    27. // for (let i of set.entries()) {
    28.  
    29. //     console.log(i);
    30. // }
    31.  
    32. // Set实现数组去重
    33. // let arr = [1, 2, 3, 4, 2, 3, 1, 3, 6]
    34. // let set = new Set(arr);
    35. // let result = [...set]
    36. // console.log(result);
    37. // set实现交集
    38. let arr1 = [1, 2, 3, 4, 5, 6, 7]
    39. let arr2 = [2, 3, 4, 7]
    40. let set1 = new Set(arr1)
    41. let set2 = new Set(arr2)
    42. console.log(...set1);
    43. // let result = [...new Set(arr1)].filter(item => set.has(item))
    44. // console.log(result);
    45. // 实现并集
    46. // let result1 = [...new Set([...arr1, ...arr2])]
    47. // console.log(result1);
    48. // 实现差集A-B
    49. let result = [...set1].filter(item => !set2.has(item))
    50. console.log(result);
    51.

    Map集合

    类似于对象，也是键值对的集合，但是键的范围不局限于字符串，各种类型的值都可以当做键

    1.set（）给Map添加数据

     

    e1943a6846eb7fdf2d2b8d9f69cd4542.png

    2：get()获取某个key的值，返回key的值

     

    7c5d62069a48544fd87a3a1cedd1c1e5.png

    3：has监测是否存在某个key，返回布尔值存在：true；不存在：false

     

    cbe302dad32baf0ab7a2bedd703501e0.png

    4：delete（）删除某个key及其对应的value，返回布尔值

     

    1edf7e322b4f99c33f55e68a15346baf.png

    5：clear（）清除所有值

     

    01c5e0b1de353b155278e57054f5dc37.png

    6：for...of遍历

     

    5b6c007ccb2a72eca829418582e4ad2a.png

    7：keys():获取Map的所有key、

     

    49df9e6fddc6b41a1cc30ff948b918ae.png

    8：values（）获取Map的所有值

     

    b44a0561361eacfdadbf77048ff48046.png

    9：entries（）：获取Map所有成员

     

    0c8c64ac0b6474e382db9978729ea913.png

    10：转为数组

     

    37652a3bc55e8e89334d9f2840da53b8.png

    11：forEach遍历

     

    dfdd81b67cbea998f40d80d3e52c4985.png

    1. // 1:set()添加数据
    2. // let map = new Map()
    3. // map.set('name', '小王').set('age', 18);
    4. // console.log(map);
    5. // 2：get()获取某个key的值，返回key的值
    6. // console.log(map.get('name'));
    7. // 3:has监测是否存在某个key，返回布尔值存在：true；不存在：false
    8. // console.log(map.has('age'));
    9. // 4:delete（）删除某个key及其对应的value，返回布尔值
    10. // console.log(map.delete('age'));
    11. // console.log(map);
    12. // 5:clear（）清除所有值
    13. // console.log(map.clear());
    14. // console.log(map);
    15. // for...of遍历
    16. // map.set('syudy', function () {
    17. //     console.log('有在好好学习');
    18. // })
    19. // console.log(map);
    20.  
    21. // keys():获取Map的所有key、
    22. // for (let key of map.keys()) {
    23. //     console.log(key);
    24. // }
    25. // values（）获取Map的所有值
    26. // for (let value of map.values()) {
    27. //     console.log(value);
    28. // }
    29. // entries（）：获取Map所有成员
    30. // for (let item of map.entries()) {
    31. //     console.log(item);
    32. // }
    33.  
    34. // 转为数组
    35. const map = new Map([[1, 'one'], [2, 'tow'], [3, 'three']])
    36. // console.log([...map.keys()]);
    37. // console.log([...map.values()]);
    38. // console.log([...map.entries()]);
    39. // console.log([...map]);
    40.  
    41. // forEach遍历
    42. console.log(map);
    43. map.forEach((value, key, map) => {
    44.     console.log(value, key, map);
    45. })

    set和map是es6新增的集合类型。

    Set

    创建：可以用new set()进行创建。

    方法：add,添加一个集合到末尾；has判断集合中是否存在对应的数据。clear清空集合。set也可以用于去重，new set([]),原理主要根据Object.is进行判断。

    循环：for…of 或者 集合也可以用forEach进行循环，和循环数组的组别在于，forEach的第二个参数，因为set中不存在下标，所以第二个参数也是集合的元素。

    map:

    创建：new Map()

    用于存储多个键值对数据。在map出现之前使用对象存储键值对，但是有几个问题，键名只能是字符串，获取数据的数量不方便。键名容易和原型上的名称冲突。

    当描述一个整体，且属性不能随意添加删除时，适合用对象，当存储一些数据可以随意添加删除时可以用map。

    方法：可以用size或者键的数量。可以用set设置一个键值对，如果存在就修改它的值，不存在就添加。判断方法和set一样。delete用于删除指定的键值。

    遍历：遍历也可以用forEach和for of

     

     

  • 相关阅读:
    【Java SE】封装，面向对象三大特性之一
    Redis实战之Redisson使用技巧详解
    PTE 做题方法 Summarise Written Text and Write Essay
    惊帆JF141心率血氧模块简单使用（STM32标准库代码）
    使用达梦数据库的总结
    1. Gradle是什么，Gradle与Maven有什么不同
    区间DP 计数类DP 数位统计DP 状态压缩DP 树形DP 记忆化搜索
    为什么算法这么重要？四面字节拿offer后我终于明白了
    Linux项目自动化构建工具-make/Makefile
    ~/.bashrc配置文件说明
  • 原文地址：https://blog.csdn.net/m0_52704461/article/details/133779704