ES6 Definir e mapear estruturas de dados

Definir estrutura de dados

É semelhante a um array, mas os valores dos membros são todos únicos e não há valores duplicados.

const mySet = new Set([1,2,1,2,1,2])
[...mySet] // [1,2]
mySet.size  // 2  数据结构的长度，没有length属性

Set pode ser entendido como um método de desduplicação de dados.

Propriedades e métodos de definir instâncias

Set.prototype.constructor: Construtor, o padrão é a função Set.
Set.prototype.size: retorna o número total de membros da instância Set
Set.prototype.add(value): Adiciona um valor e retorna a própria estrutura Set.
Set.prototype.delete(value): Exclua um valor e retorne um valor booleano indicando se a exclusão foi bem-sucedida.
Set.prototype.has(value): Retorna um valor booleano indicando se o valor é membro de Set.
Set.prototype.clear(): Limpa todos os membros, sem valor de retorno.

mySet.add(3).add(4).add(2); 
[...mySet] // [1,2,3,4]
mySet.size // 4

mySet.has(1) // true
mySet.has(5) // false

mySet.delete(2,3);
[...mySet] // [1,4]

O método Array.from pode converter a estrutura Set em uma matriz.

const myArr = Array.from(mySet); // [1,4]

Encapsular um método para desduplicar uma matriz

function dedupe(arr){
    
    
  return Array.from(new Set(array));
}
dedupe([1,1,1,2,2,3]) // [1,2,3]

Instâncias da estrutura Set possuem quatro métodos de passagem que podem ser usados para percorrer membros.

Set.prototype.keys(): retorna um percursor de nomes de chaves
Set.prototype.values(): retorna um percursor de valores-chave
Set.prototype.entries(): retorna um percursor de pares chave-valor
Set.prototype.forEach(): use a função callback para percorrer cada membro

chaves(), valores(), entradas()

let set = new Set ([4,3,9,6]);

for(let item of set.keys()){
    
    
  console.log(item);
}
// 4, 3, 9, 6

for(let item of set.values()){
    
    
  console.log(item)
}
// 4, 3, 9, 6

for(let item of set.entries()){
    
    
  console.log(item);
}
//[4,4] [3,3] [9,9] [6,6]

forEach() , map() , filter()
forEach() executa algum tipo de operação em cada membro e não tem valor de retorno.

set.forEach((val,key)=>{
    
    console.log(key + ':' + val)});
// 4 : 4, 3 : 3, 9 : 9, 6 : 6

Os métodos map e filter de arrays também podem ser usados indiretamente para Set, e a união, interseção e diferença de dados podem ser facilmente realizadas.

let x = new Set ([2, 3, 4]);
let y = new Set ([4, 3, 1]);

let union = new Set([...x,...y]);
[...union]  // [2, 3, 4, 1] 并集

let intersect = new Set([...x].filter(el => y.has(el)));
[...intersect] // [3, 4] 交集

let difference = new Set([...x].filter(el => !y.has(el)));
[...difference] // [2, 1] 差集

Estrutura de dados do mapa

É semelhante ao objeto, mas o escopo de "chave" não será limitado a string.

let myMap = new Map();
let obj = {
    
    val : 'good'};
let arr = [1, 2, 3];

set() get() has() delete() tamanho clear()

myMap.set(obj,'hello').set(arr,'world');
myMap.get(obj); // 'hello'
myMap.delete(obj) // true
myMap.has(obj) // false

myMap.size // 1
myMap.clear()
myMap.size // 0

A estrutura Map fornece nativamente três funções de gerador de percursor e um método de percurso.

Map.prototype.keys(): retorna um percursor de nomes de chaves.
Map.prototype.values(): Retorna um iterador para valores-chave.
Map.prototype.entries(): retorna um transversal para todos os membros.
Map.prototype.forEach(): percorre todos os membros do mapa.

let map = new Map([
  ['ADC', 'Uzi'],
  ['MID', 'Knight'],
  ['TOP', 'The Shy']
]);

for(let key of map.keys()){
    
    
 	console.log(key);
}
// 'ADC', 'MID', 'TOP'

for(let value of map.values()){
    
    
  console.log(value);
}
// 'Uzi', 'Knight', 'The Shy'

for(let item of map.entries()){
    
    
  console.log(item[0],item[1])
}
//  'ADC' : 'Uzi', 'MID' : 'Knight', 'TOP' : 'The Shy'

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

Combinado com o método map e o método filter do array, a travessia e a filtragem de Map podem ser realizadas (semelhante ao uso de map e filter em Set)

Converter array em mapa com outras estruturas de dados

let map = new Map([
  ['ADC', 'Uzi'],
  ['MID', 'Knight'],
  ['TOP', 'The Shy']
]);

Mapear para matriz

Use o operador de propagação (…)

[...map] 
// [ ['ADC', 'Uzi'], ['MID', 'Knight'], ['TOP', 'The Shy'] ]

Mapear para objeto

function strMapToObject(value){
    
    
  let obj = Object.create(null);
  for(let [key,val] of value){
    
    
    obj[key] = val;
  }
  return obj;
}
strMapToObject(map);
// { ADC: 'Uzi', MID: 'Knight', TOP: 'The Shy' }

Objeto a mapear

Object.entries() itera sobre objetos

let obj = {
    
    x: 1, y: 2};
let toMap = new Map(Object.entries(obj));

// 或者是
function objectToMap(value){
    
    
  let toMap = new Map();
  for (let key of Object.keys(value)){
    
    
    toMap.set(k,obj[k]);
  }
  return toMap;
}
objectToMap(obj); // Map{"x": 1, "y": 2}

Mapear para JSON

function mapToJson(value){
    
    
	return JSON.stringify([...value]);
}
let json = mapToJson(map); // {"ADC": "Uzi", "MID": "Knight", "TOP": "The Shy"}

Converter JSON para mapa

function jsonToMap(json){
    
    
  return objectToMap(JSON.parse(value));
}
jsonToMap(); // Map {'ADC' => "Uzi", 'MID' => "Knight", 'TOP' => "The Shy"}