关于javascript:ES6七-Set-Map

245次阅读

共计 4443 个字符,预计需要花费 12 分钟才能阅读完成。

目录

  • Set 数据结构

    • 申明 Set
    • Set 办法

      • 存储数据
      • 删除数据
      • 清空数据
      • 查找数据
      • size 长度
      • 读取数据

        • get API & keys API & values API & entries API
        • forEach API
        • for-of API
      • 批改数据
    • 数组去重 ES6 能够用 Set 解决
  • Map 数据结构(字典类型)

    • 之前对象的键都是字符串,会出错?
    • map 的 key 能够是任意类型
    • 如果实例化一个 map 对象
    • Map 办法

      • 增加 / 编辑数据
      • 删除数据
      • 清空数据
      • 查找数据
      • Size 长度
      • 读取数据

        • get API & keys API & values API & entries API
        • forEach API
        • for-of API
    • Map 和 Object 的区别
  • WeakSet 和 WeakMap
  • ES6-ES10 学习幅员

Set 数据结构

ES6 除了能够应用 Object 存储数据,还能够应用 Set 存储数据

  1. Set 存储的成员是惟一的,不是反复的,如果有反复会主动过滤掉(用于数组去重,上面有解释)
  2. 能够链式调用 add、forEach、delete、clear、has、size、for-of

申明 Set

// 申明了一个 Set
let s = new Set()
// 申明并初始化数据,传入的参数是可遍历的对象,不只是数组
let s = new Set([1, 2, 3, 4])

Set 办法

存储数据

add API

let s = new Set()
s.add('hello')
s.add('goodbye')
console.log(s)
// Set(2) {"hello", "goodbye"}

// 能够应用简写模式,因为其返回的是以后对象
s.add('hello').add('goodbye')
console.log(s)
// Set(2) {"hello", "goodbye"}

// 遇到反复数据会进行过滤
s.add('hello').add('goodbye').add('hello')
console.log(s)
// Set(2) {"hello", "goodbye"}

删除数据

delete API

let s = new Set()
s.add('hello').add('goodbye')
console.log(s)
// Set(2) {"hello", "goodbye"}
s.delete('goodbye') // 删除胜利会返回一个 true
console.log(s)
// Set(1) {"hello"}

清空数据

clear API

let s = new Set()
s.add('hello').add('goodbye')
console.log(s)
// Set(2) {"hello", "goodbye"}
s.clear()
console.log(s)
// Set(0) {}

查找数据

has API

let s = new Set()
s.add('hello').add('goodbye')
console.log(s.has('hello'))
// true

size 长度

size Property

let s = new Set()
s.add('hello').add('goodbye')
console.log(s.size)
// 2

读取数据

keys API & values API & entries API
let s = new Set()
s.add('hello').add('goodbye')
// 返回键汇合,SetIterator 是遍历器
console.log(s.keys())
// SetIterator {"hello", "goodbye"}

// 返回值汇合
console.log(s.values())
// SetIterator {"hello", "goodbye"}

// 返回键值对汇合
console.log(s.entries())
// SetIterator{"hello" => "hello", "goodbye" => "goodbye"}
// Set 实质还是 Object,还是以键值对的模式存在。
forEach API
let s = new Set()
s.add('hello').add('goodbye')
s.forEach(item => {console.log(item)
})
for-of API
let s = new Set()
s.add('hello').add('goodbye')
for(let item if s) {console.log(item)
}

批改数据

目前没有提供批改的 API,对于批改须要先删除再增加

数组去重 ES6 能够用 Set 解决

const arr = [1,2,1,3,4,1]
const result = Array.from(new Set(arr)]
// [1, 2, 3, 4]
// or
const result = [... new Set(arr)]
// [1, 2, 3, 4]

Map 数据结构(字典类型)

之前对象的键都是字符串,会出错?

ES6 之前对象的键是一个字符串,会遇到上面的问题。键被间接 toString 了,那么咱们外面轻易传一个对象都能够拜访到值

const obj = {}
obj[true] = 'value'
obj[123] = 'value'
obj[{a: 1, b: 2}] = 'haha'

console.log(Reflect.ownKeys(obj)) // ['123', 'true', '[object Object]' ]

console.log(obj[{}]) // haha
console.log(obj['[object Object]']) // haha

map 的 key 能够是任意类型

上面的 key 是对象

const m = new Map()

const tom = {name: 'xm'}

m.set(tom, 90)

console.log(m) // Map {{ name: 'xm'} => 90 }
console.log(m.get(tom)) // 90

上面的 key 是数字,也能够是函数

let map = new Map()
map.set(1, 'value-2')
let o = function () {console.log('o')
}
map.set(o, 4)
console.log(map)
// Map(2) {1 => "value-2", ƒ => 4} ƒ示意一个函数 function
console.log(map.get(o))
// 4

如果实例化一个 map 对象

// 申明了一个 Map
let map = new Map()
// 申明并初始化数据,传入的参数是可遍历的对象
// 然而对其可遍历的元素有条件限度,必须要用 key
let map = new Map([1, 2, 3])
// 报错 Iterator value 1 is not an entry object 不是一个字典模式

// 正确写法
// 对于外层数据满足可遍历对象,内层数组是外层对象的一个元素,后面 1 是 key,前面 2 是 value,同样后面的 3 是 key,前面的 4 是 value
let map = new Map([[1, 2]], [3, 4])
console.log(map)
// Map(2) {1 => 2, 3 => 4}
// 区别:map 外面的 key 能够是任意值,set 外面的元素能够是任意值

Map 办法

map 办法有 set、delete、has、clear、size、forEach、for-of

增加 / 编辑数据

set API ——(增加的是能够批改的)

let map = new Map()
map.set(1, 2)
map.set(3, 4)
console.log(map)
// Map(2) {1 => 2, 3 => 4}
map.set(1, 2).set(3, 4)
console.log(map)
// Map(2) {1 => 2, 3 => 4}
map.set(1, 3)
console.log(map)
// Map(2) {1 => 3, 3 => 4}

删除数据

delete API ——(删除索引值)

let map = new Map()
map.set(1, 2).set(3, 4)
// Map(2) {1 => 2, 3 => 4}
map.delete(1)
console.log(map)
// Map(1) {3 => 4}

清空数据

clear API

let map = new Map()
map.set(1, 2).set(3, 4)
// Map(2) {1 => 2, 3 => 4}
map.clear()
console.log(map)
// Map(0) {}

查找数据

has API ——(查找索引值)

let map = new Map()
map.set(1, 2).set(3, 4)
console.log(map.has(1))
// true

Size 长度

size Property

let map = new Map()
map.set(1, 2).set(3, 4)
console.log(map.size)
// 2

读取数据

数据的程序是依据初始化的程序统一的

get API & keys API & values API & entries API
let map = new Map()
map.set(1, 2).set(3, 4)
console.log(map.get(1))
// 2
console.log(map.keys())
// MapIterator {1, 3}
console.log(map.values())
// MapIterator {2, 4}
console.log(map.entries())
// MapIterator {1 => 2, 3 => 4}
forEach API
let map = new Map()
map.set(1, 'value-2').set(3, 'value-4')
map.forEach((value, key) => {console.log(value, key)
})
// value-2 1
// value-4 3
for-of API
let map = new Map()
map.set(1, 'value-2').set(3, 'value-4')
// map 是一个可遍历对象,[key, value]和之前定义的数据结构是统一的
for (let [key, value] of map) {console.log(key, value)
}
// 1 "value-2"
// 3 "value-4"

Map 和 Object 的区别

下面的区别之外:

Map 和 Object 的区别 Map Object
键的类型 Map 的键能够是任意值,包含函数、对象、根本类型 Object 的键只能是字符串和 Symbols
键的程序 Map 中的键值是 有序 对象的键是无序的,<br/>- Object 如果是整数或者整数类型的字符串,则依照从小到大的程序进行排列,其余的数据结构依照输出的顺序排列。<br/>- Object 如果外面有整数还有其余数据类型,整数放在最后面
键值对的统计 你能够通过 size 属性间接获取一个 Map 的键值对个数 Object 只能进行手动计算
键值对的遍历 Map 可间接进行迭代,而 Object 的迭代须要获取它的键数组 Object 的遍历办法没有 Map 多
性能 Map 在波及频繁增删键值对的场景下会有性能劣势

WeakSet 和 WeakMap

不罕用、API 都一样

WeakSet 和 Set 的区别:

  • 存储的数据只能是对象

WeakMap 和 Map 的区别:

  • 只能承受对象类型的 key

学习幅员

正文完
 0