【09】ES6:Set 和 Map 数据结构

一、Set

1、基本语法

定义

Set 是一系列无序、没有重复值的数据集合。数组是一系列有序(下标索引)的数据集合。

Set 本身是一个构造函数,用来生成 Set 数据结构。

const s = new Set()
[2, 3, 5, 4, 5, 2, 2].forEach(x => s.add(x))

for (let i of s) {
	console.log(i)
}
// 2 3 5 4 // Set 中不能有重复的成员

参数

Set 函数可以接受一个数组(或者具有 iterable 接口的其他数据结构)作为参数,用来初始化。

// 数组作为参数
const s = new Set([1, 2, 1])
console.log(s) // Set(2) { 1, 2 }

// 字符串作为参数
const s = new Set('hiii')
console.log(s) // Set(2) { 'h', 'i' }

// arguments 作为参数
function func() {
	console.log(new Set(arguments))
}
func(1, 2, 1) // Set(2) { 1, 2 }

// NodeList 作为参数
new Set(document.querySelectorAll('P'))

// Set 作为参数(这也是复制一个 Set 的方法)
const s = new Set([1, 2, 1])
console.log(new Set(s)) // Set(2) { 1, 2 }
console.log(s) // Set(2) { 1, 2 }

注意事项

Set 对重复值的判断基本遵循严格相等(===)。

但是对于 NaN 的判断与 === 不同,Set 中 NaN 等于 NaN 。

2、Set 实例的方法和属性

【Set 实例的属性】

属性 说明
Set.prototype.constructor 构造函数,默认就是 Set 函数。
Set.prototype.size 返回 Set 实例的成员总数。
const s = new Set()
s.add(0)
s.add(1).add(2).add(2).add(3)

s.size // 4

【Set 实例的方法】

操作方法(用于操作数据) 说明
Set.prototype.add(value) 添加某个值,返回 Set 结构本身。
Set.prototype.delete(value) 删除某个值,返回一个布尔值,表示删除是否成功。
Set.prototype.has(value) 返回一个布尔值,表示该值是否为Set的成员。
Set.prototype.clear() 清除所有成员,没有返回值。
const s = new Set()
s.add(0)
s.add(1).add(2).add(2).add(3) // 可以连写
s // Set(4) { 0, 1, 2, 3 }

s.has(1) // true
s.has(4) // false

s.delete(2)
s.delete(4) // 使用 delete 删除不存在的成员,什么都不会发生,也不会报错
s // Set(3) { 0, 1, 3 }

s.clear()
s // Set(0) {}
遍历方法(用于遍历成员) 说明
Set.prototype.keys() 返回键名的遍历器。
Set.prototype.values() 返回键值的遍历器。
Set.prototype.entries() 返回键值对的遍历器。
Set.prototype.forEach() 使用回调函数遍历每个成员。

keys 方法、values 方法、entries 方法返回的都是遍历器对象。 由于 Set 结构没有键名,只有键值,所以 keys 方法和 values 方法的行为完全一致。

Set 结构的实例与数组一样,也拥有 forEach 方法,用于对每个成员执行某种操作,没有返回值。

let set = new Set(['red', 'green', 'blue'])

for (let item of set.keys()) {
	console.log(item)
}
// red green blue

for (let item of set.values()) {
  console.log(item)
}
// red green blue

for (let item of set.entries()) {
  console.log(item)
}
// ['red', 'red'] ['green', 'green'] ['blue', 'blue']

let set = new Set([1, 4, 9])
set.forEach((value, key) => console.log(key + ' : ' + value))
// 1 : 1
// 4 : 4
// 9 : 9

Set 结构的实例默认可遍历,它的默认遍历器生成函数就是它的 values 方法。

这意味着,可以省略 values 方法,直接用 for...of 循环遍历 Set。

Set.prototype[Symbol.iterator] === Set.prototype.values // true

let set = new Set(['red', 'green', 'blue'])
for (let x of set) {
	console.log(x)
}
// red green blue

3、Set 的应用

数组去重

扩展运算符(...)内部使用 for...of 循环,所以也可以用于 Set 结构。

[...new Set(array)]

let arr = [3, 5, 2, 2, 5, 5]
let unique = [...new Set(arr)]
// [3, 5, 2]

Array.from() 方法可以将 Set 结构转为数组。

// Array.from 将类数组对象(array-like)和可遍历的对象(iterable)转换为真正的数组进行使用
function dedupe(array) {
	return Array.from(new Set(array))
}

dedupe([1, 1, 2, 3]) // [1, 2, 3]

字符串去重

[...new Set(str)].join('')

[...new Set('ababbc')].join('') // 'abc'

存放 DOM 元素

 // 这里使用 Set 是因为我们不需要通过下标去访问,只需直接遍历即可
const s = new Set(document.querySelectorAll('p'))
s.forEach(function (elem) {
	elem.style.color = 'red'
})

遍历

数组的 mapfilter 方法也可以间接用于 Set 了。

let set = new Set([1, 2, 3])
set = new Set([...set].map(x => x * 2))
// 返回Set结构:{2, 4, 6}

let set = new Set([1, 2, 3, 4, 5])
set = new Set([...set].filter(x => (x % 2) == 0))
// 返回Set结构:{2, 4}

因此使用 Set 可以很容易地实现并集(Union)、交集(Intersect)和差集(Difference)。

let a = new Set([1, 2, 3])
let b = new Set([4, 3, 2])

// 并集
let union = new Set([...a, ...b])
// Set {1, 2, 3, 4}

// 交集
let intersect = new Set([...a].filter(x => b.has(x)))
// set {2, 3}

// (a 相对于 b 的)差集
let difference = new Set([...a].filter(x => !b.has(x)))
// Set {1}

二、Map

1、基本语法

定义

Map 可以理解为:“映射”。Map 和 对象 都是键值对的集合。

Map 和 对象 的区别:

对象一般用字符串当作 “键”(当然在书写时字符串键的引号可以去掉)。

Map 中的 “键” 可以是一切类型。

// 键 ——> 值,key ——> value
// 对象:
const person = {
	name: 'alex',
	age: 18
}

// Map:
const m = new Map()
m.set('name', 'alex')
m.set('age', 18)
console.log(m) // Map(2) { 'name' => 'alex', 'age' => 18 }

// Map 中的 “键” 可以是一切类型。
const m = new Map()
m.set(true, 'true')
m.set({}, 'object')
m.set(new Set([1, 2]), 'set')
m.set(undefined, 'undefined')
console.log(m)
/*
Map(4) {
  true => 'true',
  {} => 'object',
  Set(2) { 1, 2 } => 'set',
  undefined => 'undefined'
}
*/

参数

任何具有 Iterator 接口、且每个成员都是一个双元素的数组的数据结构都可以当作 Map 构造函数的参数

例如:二维数组、Set、Map 等

new Map([
	['name', 'alex'],
	['age', 18]
]) // Map(2) { 'name' => '张三', 'age' => 18 }

// 等价于
const items = [
	['name', 'alex'],
	['age', 18]
]
const map = new Map()
items.forEach(
	([key, value]) => map.set(key, value)
)
// Set
// Set 中也必须体现出键和值
const s = new Set([
	['name', 'alex'],
	['age', 18]
])
console.log(new Map(s)) // Map(2) { 'name' => 'alex', 'age' => 18 }
console.log(s) // Set(2) { [ 'name', 'alex' ], [ 'age', 18 ] }



// Map
const m = new Map([
	['name', 'alex'],
	['age', 18]
])
console.log(m) // Map(2) { 'name' => 'alex', 'age' => 18 }
const m2 = new Map(m) // Map 复制的方法
console.log(m2, m2 === m) // Map(2) { 'name' => 'alex', 'age' => 18 } false

注意事项

在 Set 中遇到重复的值直接去掉后者,而 Map 中遇到重复的键值则是后面的覆盖前面的。

基本遵循严格相等(===),Map 中 NaN 也是等于 NaN。

2、Map 实例的方法和属性

【Map实例的属性】

属性 说明
Map.prototype.constructor 构造函数,默认就是 Map 函数。
Map.prototype.size 返回 Map 实例的成员总数
const map = new Map()
map.set('foo', true)
map.set('bar', false)

map.size // 2

【Map实例的操作方法】

操作方法(用于操作数据) 说明
Map.prototype.set(key, value) 设置键名 key 对应的键值为 value,然后返回整个 Map 结构。
Map.prototype.get(key) 读取 key 对应的键值,如果找不到 key,返回 undefined。
Map.prototype.delete(key) 删除某个值,返回一个布尔值,表示删除是否成功。
Map.prototype.has(key) 返回一个布尔值,表示某个键是否在当前 Map 对象之中。
Map.prototype.clear() 清除所有成员,没有返回值。
const m = new Map()
m.set('edition', 6)        // 键是字符串
m.set(262, 'standard')     // 键是数值
m.set(undefined, 'nah')    // 键是 undefined
m.has('edition')     // true
m.has('years')       // false
m.has(262)           // true
m.has(undefined)     // true

// set 方法返回的是当前的 Map 对象,因此可以采用链式写法。
let map = new Map()
  .set(1, 'a')
  .set(2, 'b')
  .set(3, 'c')


const m = new Map()
const hello = function() {console.log('hello');}
m.set(hello, 'Hello ES6!') // 键是函数
m.get(hello)  // Hello ES6!


const m = new Map();
m.set(undefined, 'nah')
m.has(undefined)     // true
m.delete(undefined)
m.has(undefined)       // false

let map = new Map()
map.set('foo', true)
map.set('bar', false)
map.size // 2
map.clear()
map.size // 0

【Map实例的遍历方法】

遍历方法(用于遍历成员) 说明
Map.prototype.keys() 返回键名的遍历器。
Map.prototype.values() 返回键值的遍历器。
Map.prototype.entries() 返回所有成员的遍历器。
Map.prototype.forEach() 遍历 Map 的所有成员。

需要特别注意的是,Map 的遍历顺序就是插入顺序。

const map = new Map([
	['F', 'no'],
	['T',  'yes']
])


for (let key of map.keys()) {
	console.log(key)
}
// F T


for (let value of map.values()) {
	console.log(value)
}
// no yes


for (let item of map.entries()) {
	console.log(item[0], item[1])
}
// F no   T yes

// 或者
for (let [key, value] of map.entries()) {
	console.log(key, value)
}
// F no   T yes


map.forEach(function(value, key, map) {
	console.log(value, key, map)
})
// no F Map(2) {'F' => 'no', 'T' => 'yes'}
// yes T Map(2) {'F' => 'no', 'T' => 'yes'}

Map 结构的默认遍历器接口(Symbol.iterator属性),就是 entries 方法。 这意味着,可以省略 entries 方法。

map[Symbol.iterator] === map.entrie // true

// 等同于使用 map.entries()
for (let [key, value] of map) {
	console.log(key, value)
}
// F no   T yes

3、与其他数据结构的互相转换

Map 转为数组

const map = new Map()
	.set(true, 7)
	.set({foo: 3}, ['abc'])

[...map.keys()] // [ true,  { foo: 3 } ]
[...map.values()] // [ 7, [ 'abc' ] ]
[...map.entries()] // [ [ true, 7 ], [ { foo: 3 }, [ 'abc' ] ] ]
[...map] // [ [ true, 7 ], [ { foo: 3 }, [ 'abc' ] ] ]

// 转为数组后,数组的 map 和 filter 方法也可以间接用于 Map

数组 转为 Map

new Map([
	[true, 7],
	[{foo: 3}, ['abc']]
]) 
// Map { true => 7, Object {foo: 3} => ['abc'] }

Map 转为对象

如果所有 Map 的键都是字符串,它可以无损地转为对象。

如果有非字符串的键名,那么这个键名会被转成字符串,再作为对象的键名。

function strMapToObj(strMap) {
	let obj = Object.create(null)
	for (let [k, v] of strMap) {
		obj[k] = v
	}
	return obj
}

const myMap = new Map()
	.set('yes', true)
	.set('no', false)
strMapToObj(myMap) // { yes: true, no: false }

对象转为 Map

let obj = { a: 1, b: 2 }
let map = new Map(Object.entries(obj))

// 自己封装实现
function objToStrMap(obj) {
	let strMap = new Map()
	for (let k of Object.keys(obj)) {
		strMap.set(k, obj[k])
	}
	return strMap
}

objToStrMap({yes: true, no: false}) // Map {yes => true, no => false}

4、应用

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p>1</p>
<p>2</p>
<p>3</p>
<script>
	const [p1, p2, p3] = document.querySelectorAll('p')
    const m = new Map([
        [p1, {
            color: 'red',
            backgroundColor: 'yellow',
            fontSize: '40px'
        }],
        [p2, {
            color: 'green',
            backgroundColor: 'pink',
            fontSize: '40px'
        }],
        [p3, {
            color: 'blue',
            backgroundColor: 'orange',
            fontSize: '40px'
        }]
    ]);
    m.forEach((propObj, elem) => {
        for (const p in propObj) {
            elem.style[p] = propObj[p];
        }
    })	// 由于不需要改变 this 指向,所以可以使用箭头函数
</script>
</body>
</html>

你可能感兴趣的:(ES,es6,数据结构,前端)