• Map 和 Set 是 ES6 新增的两个数据类型
  • 都是属于内置构造函数
  • 使用 new 的方式来实例化使用

Set

  • 使用方式就是和 new 连用 ```javascript const s = new Set() console.log(s)

/ Set(0) {} size: (…) proto: Set [[Entries]]: Array(0) length: 0 /

  2. - 就是一个数据集合
  3. - 我们可以在 new 的时候直接向内部添加数据
  4. ```javascript
  5. // 实例化的时候直接添加数据要以数组的形式添加
  6. const s = new Set([1, 2, 3, {}, function () {}, true, 'hwllo'])
  7. console.log(s)
  9. /*
  10.     Set(7) {1, 2, 3, {…}, ƒ, …}
  11.         size: (...)
  12.         __proto__: Set
  13.         [[Entries]]: Array(7)
  14.         0: 1
  15.         1: 2
  16.         2: 3
  17.         3: Object
  18.         4: function () {}
  19.         5: true
  20.         6: "hwllo"
  21.         length: 7
  22. */
  • 看上去是一个类似数组的数据结构，但是不是，就是 Set 数据结构

常用方法和属性

  • size ： 用来获取该数据结构中有多少数据的

    1. const s = new Set([1, 2, 3, {}, function () {}, true, 'hwllo'])
    2. console.log(s.size) // 7
    • 看上去是一个和数组数据类型差不多的数据结构，而且我们也看到了 length 属性
    • 但是不能使用，想要获取该数据类型中的成员数量，需要使用 size 属性

  • add : 用来向该数据类型中追加数据

    1. const s = new Set()
    2. s.add(0)
    3. s.add({})
    4. s.add(function () {})
    5. console.log(s.size) // 3
    • 这个方法就是向该数据类型中追加数据使用的
  • delete : 是删除该数据结构中的某一个数据 ```javascript const s = new Set() s.add(0) s.add({}) s.add(function () {})

s.delete(0)

console.log(s.size) // 2

  2. - `clear` ： 清空数据结构中的所有数据
  3. ```javascript
  4. const s = new Set()
  5. s.add(0)
  6. s.add({})
  7. s.add(function () {})
  9. s.clear()
  11. console.log(s.size) // 0
  • has ： 查询数据解构中有没有某一个数据 ```javascript const s = new Set() s.add(0) s.add({}) s.add(function () {})

console.log(s.has(0)) // true

  2. - `forEach` : 用来遍历 Set 数据结构的方法
  3. ```javascript
  4. const s = new Set()
  5. s.add(0)
  6. s.add({})
  7. s.add(function () {})
  9. s.forEach(item => {
  10.     console.log(item) // 0   {}   function () {}
  11. })
  • 方法介绍的差不多了，有一个问题出现了，那就是
  • 我们的方法要么是添加，要么是删除，要么是查询，没有获取
  • 因为要获取 Set 结构里面的数据需要借助一个 ... 展开运算符
  • 把他里面的东西都放到一个数组里面去，然后再获取 ```javascript const s = new Set([1, 2, 3, 4, 5, 6]) const a = […s] console.log(a) // (6) [1, 2, 3, 4, 5, 6]

console.log(a[0]) // 1 console.log([…s][0]) // 1

  2. - 又一个问题出现了，new 的时候需要以数组的形式传递
  3. - 然后获取的时候又要转成数组的形式获取
  4. - 那么我为什么不一开始就定义数组，要这个 Set 数据类型干什么
  5. - 这就不得不提到一个 Set 的特点
  6. - **Set 不允许存储重复的数据**
  7. ```javascript
  8. const s = new Set([1, 2, 3])
  10. s.add(4)  // 此时 size 是 4
  11. s.add(1)  // 此时 size 是 4
  12. s.add(2)  // 此时 size 是 4
  13. s.add(3)  // 此时 size 是 4

Map

  • 也是要和 new 连用
  • 是一个数据集合，是一个很类似于 对象 的数据集合 ```javascript const m = new Map() console.log(m)

/ Map(0) {} size: (…) proto: Map [[Entries]]: Array(0) length: 0 /

  2. - 我们的对象中不管存储什么，key 一定是一个字符串类型
  3. - 但是再 Map 里面，我们的 key 可以为任意数据类型
  4. - 我们也管 Map 叫做 （值 = 值 的数据类型）
  5. ```javascript
  6. const m = new Map([[{}, {}], [function () {}, function () {}], [true, 1]])
  7. console.log(m)
  9. /*
  10.     Map(3) {{…} => {…}, ƒ => ƒ, true => 1}
  11.         size: (...)
  12.         __proto__: Map
  13.         [[Entries]]: Array(3)
  14.         0: {Object => Object}
  15.             key: {}
  16.             value: {}
  17.         1: {function () {} => function () {}}
  18.             key: ƒ ()
  19.             value: ƒ ()
  20.         2: {true => 1}
  21.             key: true
  22.             value: 1
  23.         length: 3
  25. */

常用方法和属性

  • size ： 用来获取该数据类型中数据的个数

    1. const m = new Map([[{}, {}], [function () {}, function () {}], [true, 1]])
    2. console.log(m.size) // 3

  • delete : 用来删除该数据集合中的某一个数据 ```javascript const m = new Map([[{}, {}], [function () {}, function () {}], [true, 1]]) m.delete(true)

console.log(m.size) // 2

  2. - `set` : 用来向该数据集合中添加数据使用
  3. ```javascript
  4. const m = new Map()
  5. m.set({ name: 'Jack' }, { age: 18 })
  6. console.log(m.size) // 1
  • get : 用来获取该数据集合中的某一个数据 ```javascript const m = new Map()

m.set({ name: ‘Jack’ }, { age: 18 }) m.set(true, function () {}) console.log(m.get(true)) // function () {}

  2. - `clear` : 清除数据集合中的所有数据
  3. ```javascript
  4. const m = new Map()
  6. m.set({ name: 'Jack' }, { age: 18 })
  7. m.set(true, function () {})
  9. m.clear()
  11. console.log(m.size) // 0
  • has ： 用来判断数据集合中是否存在某一个数据 ```javascript const m = new Map()

m.set({ name: ‘Jack’ }, { age: 18 }) m.set(true, function () {})

console.log(m.has(true)) // true ```