关于javascript:JavaScript中集合引用类型就这么点东西

Object

创立形式：

let obj={};// 举荐此办法(代码少)
或
let obj new Object();

拜访对象属性的办法:

let obj={name:"lly",sex:"Man"}
obj.name//lly 通常应用此办法
或
obj["name"]//lly

对于 Object 更全面，更深层次的学习，作者会独自开篇。

Array

• 创立形式：

  let arr=[];// 增加子元素
  let arr1=new Array();// 能够指定数组长度，或者间接增加子元素（如果是数字指定数组长度，其余类型增加子元素）//Array 静态方法:
  1.Array.from()// 将类数组构造转换为数组实例
  // 场景 1：（字符串会被拆分为单字符数组）Array.from("1234567890")// ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
  // 场景 2：（汇合和映射转换为一个新数组）const m = new Map().set(1, 2).set(7,8); 
  const s = new Set().add(1).add(2).add(3).add(4); 
  Array.from(m); // [[1, 2], [7, 8]] 
  Array.from(s); // [1, 2, 3, 4]
  // 场景 3：（现有数组执行浅复制）let arr1=[1, 2, 3, 4]
  let arr2=Array.from(arr1)
  arr1===arr2//false
  // 场景 4：(能够应用任何可迭代对象)
   *[Symbol.iterator]() { 
   yield 1; 
   yield 2; 
   yield 3; 
   yield 4; 
   } 
  }; 
  console.log(Array.from(iter)); // [1, 2, 3, 4]
  // 场景 5：（arguments 对象能够被轻松地转换为数组）function getArgsArray() {return Array.from(arguments); 
  } 
  console.log(getArgsArray(1, 2, 3, 4)); // [1, 2, 3, 4]
  // 场景 6：（转换带有必要属性的自定义对象）const arrayLikeObject = { 
   0: 1, 
   1: 2, 
   2: 3, 
   3: 4, 
   length: 4 
  }; 
  console.log(Array.from(arrayLikeObject)); // [1, 2, 3, 4]
  //from()承受三个参数参数一对应的是解决的对象参数二对应的是映射函数参数参数三对应的是指定映射函数中 this 的值
  let arr=[0,1,2,3]
  let arrNew=Array.from(arr,function(x){return x**this.exponent},{exponent:3})//[0,1,8,27]
  2.Array.of()// 用于将一组参数转换为数组实例等价 Array.prototype.slice.call(arguments)
  Array.of(1,2,3,4,5,6)//[1,2,3,4,5,6]
  Array.of(unedfined)//[unedfined]

• 数组空位：

  let arr=[,,]
  console.log(arr.length)//2
  for(let i of arr){console.log(i)//unedfined,unedfined}    
  // 留神！！！！！// 防止应用数组空位。如果的确须要空位，则能够显式地用 undefined 值代替。

• 数组索引

  let  arr=["A","B","C","D"]
  arr[0]//A
  arr[arr.length-1]//D

• 检测数组

• value instanceof Array
  let arr=[];
  console.log(arr instanceof Array)//true
  2.Array.isArray()
  Array.isArray(arr)//true
  3.Object.prototype.toString.call(value)
  Object.prototype.toString.call(arr)//[object Array]

• 迭代器办法

  // 拜访 Array 的办法：xx.keys()// 数组索引;
  xx.values()// 数组元素;
  xx.entriess()// 索引 / 值对;
  let arr=["A","B","C"];
  Array.from(arr.keys())// [0, 1, 2]
  Array.from(arr.values())//["A", "B", "C"]
  Array.from(arr.entries())//[[0, "A"][1, "B"][2, "C"]]

• 复制和填充办法

  // 以下办法须要指定既有数组实例上的一个范畴，蕴含开始索引，不蕴含完结索引不扭转数组的大小
  // 批量复制办法 copyWithin, 依照指定范畴浅复制数组中的局部内容，而后将它们插入到指定索引开始的地位。let ints, reset = () => ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
  reset(); 
  // 从 ints 中复制索引 0 开始的内容，插入到索引 5 开始的地位
  // 在源索引或指标索引达到数组边界时进行
  ints.copyWithin(5); 
  console.log(ints); // [0, 1, 2, 3, 4, 0, 1, 2, 3, 4] 
  reset(); 
  // 从 ints 中复制索引 5 开始的内容，插入到索引 0 开始的地位
  ints.copyWithin(0, 5); 
  console.log(ints); // [5, 6, 7, 8, 9, 5, 6, 7, 8, 9] 
  reset(); 
  // 从 ints 中复制索引 0 开始到索引 3 完结的内容
  // 插入到索引 4 开始的地位
  ints.copyWithin(4, 0, 3); 
  alert(ints); // [0, 1, 2, 3, 0, 1, 2, 7, 8, 9] 
  reset(); 
  // JavaScript 引擎在插值前会残缺复制范畴内的值
  // 因而复制期间不存在重写的危险
  ints.copyWithin(2, 0, 6); 
  alert(ints); // [0, 1, 0, 1, 2, 3, 4, 5, 8, 9] 
  reset(); 
  // 反对负索引值，与 fill()绝对于数组开端计算正向索引的过程是一样的
  ints.copyWithin(-4, -7, -3); 
  alert(ints); // [0, 1, 2, 3, 4, 5, 3, 4, 5, 6] 
  //copyWithin 静默疏忽超出数组边界、零长度及方向相同的索引范畴：let ints,  reset = () => ints = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
  reset(); 
  // 索引过低，疏忽
  ints.copyWithin(1, -15, -12); 
  alert(ints); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
  reset() 
  // 索引过高，疏忽
  ints.copyWithin(1, 12, 15); 
  alert(ints); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
  reset(); 
  // 索引反向，疏忽
  ints.copyWithin(2, 4, 2); 
  alert(ints); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; 
  reset(); 
  // 索引局部可用，复制、填充可用局部
  ints.copyWithin(4, 7, 10) 
  alert(ints); // [0, 1, 2, 3, 7, 8, 9, 7, 8, 9];
  // 填充数组办法 fill，能够向一个已有的数组中插入全副或局部雷同的值。开始索引用于指定开始填充的地位，它是可选的。如果不提供完结索引，则始终填充到数组开端。负值索引从数组开端开始计算。const zeroes = [0, 0, 0, 0, 0]; 
  // 用 5 填充整个数组
  zeroes.fill(5); 
  console.log(zeroes); // [5, 5, 5, 5, 5] 
  zeroes.fill(0); // 重置
  // 用 6 填充索引大于等于 3 的元素
  zeroes.fill(6, 3); 
  console.log(zeroes); // [0, 0, 0, 6, 6] 
  zeroes.fill(0); // 重置
  // 用 7 填充索引大于等于 1 且小于 3 的元素
  zeroes.fill(7, 1, 3); 
  console.log(zeroes); // [0, 7, 7, 0, 0]; 
  zeroes.fill(0); // 重置
  // 用 8 填充索引大于等于 1 且小于 4 的元素
  // (-4 + zeroes.length = 1) 
  // (-1 + zeroes.length = 4) 
  zeroes.fill(8, -4, -1); 
  console.log(zeroes); // [0, 8, 8, 8, 0];
  //fill 静默疏忽超出数组边界、零长度及方向相同的索引范畴：const zeroes = [0, 0, 0, 0, 0]; 
  // 索引过低，疏忽
  zeroes.fill(1, -10, -6); 
  console.log(zeroes); // [0, 0, 0, 0, 0] 
  // 索引过高，疏忽
  zeroes.fill(1, 10, 15); 
  console.log(zeroes); // [0, 0, 0, 0, 0] 
  // 索引反向，疏忽
  zeroes.fill(2, 4, 2); 
  console.log(zeroes); // [0, 0, 0, 0, 0] 
  // 索引局部可用，填充可用局部
  zeroes.fill(4, 3, 10) 
  console.log(zeroes); // [0, 0, 0, 4, 4]

• 转换方法

  toLocaleString()// toString()和 valueOf()雷同的后果
  toString()// 每个值的等效字符串拼接而成的一个逗号分隔的字符串
  valueOf()// 数组自身;
  let arr=["A","B","C"];
  arr.toString()//A,B,C
  arr.valueOf()//["A","B","C"]
  arr.toLocaleString()//A,B,C
  // 批改数组宰割符 join("要应用宰割符")
  arr.join('~')//A~B~C
  // 留神!!!! 如果数组中某一项是 null 或 undefined，则在 join()、toLocaleString()、toString()和 valueOf()返回的后果中会以空字符串示意。

• 栈办法

  // 办法批改原来的数组
  1.push()// 在数组后增加元素承受任意个值
  2.pop()// 获取数组最初一个元素
  let arr=[1,2,3]
  arr.push(4,5)
  console.log(arr)//[1,2,3,4,5]
  arr.pop()//5
  console.log(arr)//[1,2,3,4]

• 队列办法

  // 办法批改原来的数组
  1.shift()// 获取数组第一元素
  2.unshift()// 在数组第一个元素前增加元素
  let arr=[1,2,3]
  console.log(arr.shift())//1
  arr.unshift(0,1)
  console.log(arr)//[0,1,2,3]

• 排序办法

  1.reverse()// 反向排序
  2.sort()// 升序排列可承受一个比拟函数
  let arr=[1,12,3,0,7,18,5]
  arr.reverse();//[5,18,7,0,3,12,1]
  function compare(value1, value2) {if (value1 < value2) {return -1;} else if (value1 > value2) {return 1;} else {return 0;} 
        }
    arr.sort(compare);
    console.log(arr);//[0, 1, 3, 5, 7, 12, 18]

• 操作方法

  1.concat()// 复制原来数组在此基础之上增加元素，不扭转原来数组，能够承受任意参数
  let arr=[0,1,2]
  let arr1=arr.concat('4',[5,6])
  arr//[0,1,2]
  arr1//[0,1,2,"4",5,6]
  对于数组会拉平
  2.slice()// 截取承受一个或两个参数示意起始索引和完结索引, 不扭转原有数组参数能够承受负值，（以数组长度加上对应的负值为索引地位）let arr=[0,1,2,3,4,5,6,7,8,9]
  arr.slice(1)//[1,2,3,4,5,6,7,8,9]
  arr.slice(0,4)//[0,1,2,3]
  arr.slice(-5,-2)//[5,6,7]

• 删除，参数阐明：参数 1 索引起始地位，参数 2 要删除的元素数
  arr.splice(0,3)//[0,1,2]
  arr//[3,4,5,6,7,8,9]
• 插入，参数阐明：参数 1 索引地位，参数 2 删除元素个数，参数 3 + 要查入的元素
  arr.splice(0,2,”name”,”sex”,”age”)//[0,1]
  arr//[“name”, “sex”, “age”, 2, 3, 4, 5, 6, 7, 8, 9]

• 替换，参数阐明：参数 1 索引地位，参数 2 删除元素个数，参数 3 + 要查入的元素
  arr.splice(0,1,’name’)//[0]
  arr//[“name”,1,2, 3, 4, 5, 6, 7, 8, 9]

• 搜寻和地位办法

• indexOf()// 从前搜寻元素，查问到返回元素索引，没查问到返回 -1，能够承受一个或两个参数，参数 1 要查问的元素，参数 2 查问开始的索引
  let arr=[‘A’,’B’,’C’,’D’,’E’]
  arr.indexOf(3)//-1
  arr.indexOf(‘E’)//4
  arr.indexOf(“C”,1)// 2 从索引 1 开始查问元素 ’C’
• lastIndexOf()// 同 indexOf 用法雷同不同是从数组开端开始查问
• includes()// 同 indexOf 用法雷同返回后果为 true 和 false
  2. 按断言函数搜寻
• find((element, index, array)=>{})//element：以后元素 index：以后元素的索引 array：数组 查问后就不在搜寻
  let arrObj=[{name:”lly”,sex:”man”,age:”18″},{name:”ly”,sex:”woman”,age:”18″}]
  arr.find((element, index, array)=>{
  element// 以后元素
  index// 以后元素的索引
  array// 数组
  })// 返回查问到元素

• findIndex()// 同 find 用法雷同返回查问到的元素的索引

• 迭代办法

  // 以下办法不扭转原数组
  every()：// 对数组每一项都运行传入的函数，如果对每一项函数都返回 true，则这个办法返, 回 true。let arr=[2,4,6,8,10]
  arr.every((item,index,array)=>{return item>=2})//true
  filter()：// 对数组每一项都运行传入的函数，函数返回 true 的项会组成数组之后返回。arr.filter((item,index,array)=>{return item>2)})//[4,6,8,10]
  forEach()：// 对数组每一项都运行传入的函数，没有返回值。arr.forEach((item,index,array)=>{console.log(item*=10)//20,40,60,80,100
  })
  map()：// 对数组每一项都运行传入的函数，返回由每次函数调用的后果形成的数组。arr.map((item,index,array)=>{item*=10})
  some()：// 对数组每一项都运行传入的函数，如果有一项函数返回 true，则这个办法返回 true。

• 归并办法

  1.reduce((prev, cur, index, array) => prev + cur)) => {});// 参数阐明：上一个归并值、以后项、以后项的索引和数
  组自身
  let arr=[0,1,2,3,4,5,6,7,8,9]
  arr.reduce((prev, cur, index, array) =>{console.log(prev, cur, index, array)
  // 过程
  //0 1 1 (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  //1 2 2 (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  //3 3 3 (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  //6 4 4 (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  //10 5 5 (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  //15 6 6 (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  //21 7 7 (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  //28 8 8 (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  //36 9 9 (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  return   prev + cur
  })
  2.reduceRight()// 和 reduce 雷同只是归并的方向不同此办法从数组尾部开始

  定型数组

  Typed Array 是 ECMAScript 新增的构造, 为了晋升向原生库传输数据的效率而产生，（一种非凡的蕴含数值类型的数组），定型数组的架构分为缓冲和视图两局部, 缓冲通过 ArrayBuffer 对象来实现，视图次要用来读和写缓冲区的内容, 视图次要蕴含 TypedArray 和 DataView()。
  TypedArray 蕴含：

• Uint8Array，Uint16Array，Uint32Array —— 用于 8 位、16 位和 32 位无符号整数。
• Uint8ClampedArray —— 用于 8 位整数，在赋值时便“固定”其值。
• Int8Array，Int16Array，Int32Array —— 用于有符号整数（能够为正数）。
• Float32Array，Float64Array —— 用于 32 位和 64 位的有符号浮点数。

留神：不要把类型化数组与失常数组混同，因为在类型数组上调用 Array.isArray() 会返回false。此外，并不是所有可用于失常数组的办法都能被类型化数组所反对（如 push 和 pop）

历史

因为浏览器疾速倒退，为了满足运行简单的 3D 应用程序需要，浏览器厂商开发一套 JavaScript API，从而充分利用 3D 图形 API 和 GPU 减速，以便在 <canvas> 元素上渲染简单的图形，起初欧朋浏览器专一于 2D 和 3D 计算机图形子集，写出 WebGL, 晚期版本因为 JavaScript 数组与原生数组之间不匹配，所以呈现了性能问题。为了解决性能问题 Mozilla 实现了 CanvasFloatArray，最初变成了 Float32Array，也就是定型数组的第一个类型

ArrayBuffer

ArrayBuffer 是所有定型数组及视图援用的根本单位。ArrayBuffer()是一个一般的 JavaScript 构造函数，可用于在内存中调配特定数量的字节空间。ArrayBuffer 一经创立就不能再调整大小，能够应用 slice()复制其全副或局部到一个新实例中

// 创立
let buf=new ArrayBuffer(32)// 内存中调配 32 个字节
buf.byteLength//32 查看字节数
let buf1=buf.slice(0,16)
buf1.byteLength//16

ArrayBuffer 某种程度上相似于 C++ 的 malloc()，但也有几个显著的区别。

• malloc()在调配失败时会返回一个 null 指针。ArrayBuffer 在调配失败时会抛出谬误。
• malloc()能够利用虚拟内存，因而最大可调配尺寸只受可寻址零碎内存限度。ArrayBuffer 调配的内存不能超过 Number.MAX_SAFE_INTEGER（2^53^  1）字节。
• malloc()调用胜利不会初始化理论的地址。申明 ArrayBuffer 则会将所有二进制位初始化为 0。
• 通过 malloc()调配的堆内存除非调用 free()或程序退出，否则零碎不能再应用。而通过申明 ArrayBuffer 调配的堆内存能够被当成垃圾回收，不必手动开释。
  不能通过对 ArrayBuffer 的援用就能读取或写入其内容，要读取或写入须要通过视图，视图有不同的类型，但援用的都是 ArrayBuffer 中存储的二进制数据。

DataView

DataView 读写 ArrayBuffer 的视图，专为文件 I / O 和网络 I / O 设计，反对对缓冲数据的高度管制，但相比于其余类型的视图性能也差一些。DataView 对缓冲内容没有任何预设，也不能迭代。

let buf=new ArrayBuffer(32);
let dv=new DataView(buf,byteOffset,byteLength);// 能够承受三个参数别离是已知 buf，缓冲区开始地位，ArrayBuffer 的内存
dv.byteOffset // 0 ArrayBuffer 缓冲开始地位
dv.byteLength// 32 ArrayBuffer 的内存
dv.buffer === buf // true

DataView 读取缓冲须要的组件

• 首先是要读或写的字节偏移量。能够看成 DataView 中的某种“地址”。
• DataView 应该应用 ElementType 来实现 JavaScript 的 Number 类型到缓冲内二进制格局的转换。
• 最初是内存中值的字节序。默认为大端字节序。
• ElementType

DataView 裸露了 get 和 set 办法, 这些办法应用 byteOffset（字节偏移
量）定位要读取或写入值的地位，类型能够互相转换。

2. 字节序

计算系统维护的一种字节程序的约定，DataView 只反对两种约定：大端字节序（网络字节序）和小端字节序，大端字节序中最高无效位保留在第一个字节，而最低无效位保留在最初一个字节，小端字节序中最低无效位保留在第一个字节，最高无效位保留在最初一个字节

3. 边界情景

• DataView 实现读、写操作的前提是必须有短缺的缓冲区，否则就会抛出 RangeError
• DataView 在写入缓冲里会尽最大致力把一个值转换为适当的类型，后备为 0。如果无奈转换，则抛出谬误

定型数组

定型数组是 ArrayBuffer 的视图，用来读写缓存区的内容。

定型数组次要有：

定型数组办法：

1. 定型数组行为（操作符、办法和属性）

2. 合并、复制和批改定型数组

3. 下溢和上溢

定型数组中值的下溢和上溢不会影响到其余索引，但依然须要思考数组的元素应该是什么类型。定型数组对于能够存储的每个索引只承受一个相干位，而不思考它们对理论数值的影响。

// 长度为 2 的有符号整数数组
// 每个索引保留一个二补数模式的有符号整数
// 范畴是 -128（-1 * 2^7）~127（2^7 - 1）const ints = new Int8Array(2); 
// 长度为 2 的无符号整数数组
// 每个索引保留一个无符号整数
// 范畴是 0~255（2^7 - 1）const unsignedInts = new Uint8Array(2); 
// 上溢的位不会影响相邻索引
// 索引只取最低无效位上的 8 位
unsignedInts[1] = 256; // 0x100 
console.log(unsignedInts); // [0, 0] 
unsignedInts[1] = 511; // 0x1FF 
console.log(unsignedInts); // [0, 255] 
// 下溢的位会被转换为其无符号的等价值
// 0xFF 是以二补数模式示意的 -1（截取到 8 位）, 
// 但 255 是一个无符号整数
unsignedInts[1] = -1 // 0xFF (truncated to 8 bits) 
console.log(unsignedInts); // [0, 255] 
// 上溢主动变成二补数模式
// 0x80 是无符号整数的 128，是二补数模式的 -128 
ints[1] = 128; // 0x80 
console.log(ints); // [0, -128] 
// 下溢主动变成二补数模式
// 0xFF 是无符号整数的 255，是二补数模式的 -1 
ints[1] = 255; // 0xFF 
console.log(ints); // [0, -1]
// 不容许任何方向溢出。超出最大值 255 的值会被向下舍入为 255，而小于最小值 0 的值会被向上舍入为 0。const clampedInts = new Uint8ClampedArray([-1, 0, 255, 256]); 
console.log(clampedInts); // [0, 0, 255, 255]

Map

映射，一种汇合类型，为 JavaScript 提供真正的键值存储机制

应用形式：

//**Map 对象能够应用 JavaScript 中所有的数据类型作为键
// 创立
let m = new Map();
// 增加
m.set("key1",1).set("key2",2)
// 查问
m.has("key1")// 蕴含 true 不蕴含 false
m.get("key")// 返回键值
m.size// 键值对的个数
// 删除
m.delete("key1")// 删除指定的键值对
m.clear()// 清空所有的键值对

程序和迭代

let m=new Map([[key1,1],[key2,2],[key3,3]])
m.entries===m[Symbol.iterator]//true
m.entries()//MapIterator {"key1" => 1, "key2" => 2, "key3" => 3}
[...m]//[["key1", 1], ["key2", 2], ["key3", 3]]

// 能够通过 for ...of 办法实现迭代
for(let i of obj){
  //obj 是 m
  console.log(i)//["key1", 1], ["key2", 2], ["key3", 3]
  //obj 是 m.entries()
  console.log(i)//[["key1", 1], ["key2", 2], ["key3", 3]]
  //obj 是 m[Symbol.iterator]()
  console.log(i)//["key1", 1], ["key2", 2], ["key3", 3]
}
m.forEach((value,key)=>{
    value//1,2,3
    key//"key1","key2","key3"
})
m.keys()//MapIterator {"key1", "key2", "key3"}
m.values()//MapIterator {1, 2, 3}
// 键和值在迭代器遍历时是能够批改的，但映射外部的援用则无奈批改
let m1=new Map([["name":"lly"]])
for(let key of m1.keys()){
   key="name1"
   console.log(key)//name1
   console.log(m1.get("name"))//lly
  }

开发中对于 Object 和 Map 应用的抉择

1. 内存占用
给定内存 Map 比 Object 存储的键值大 50%
2. 插入性能
在插入方面 Map 比 Object 略微快些，波及大量插入操作 Map 是更优抉择
3. 查找速度
如果存在大量查问操作抉择 Object 是更优抉择
4. 删除性能
如果波及到大量删除操作 Map 是最优抉择

WeakMap

弱映射，一种汇合类型，为 JavaScript 提供加强的键 / 值对存储机制

应用办法

//**weakMap 中的键只能是 Object 或者继承自 Object 的类型
// 创立
const key={id:1},key1={id:2},key2={id:3}
const wm = new WeakMap([[key,001],[key1,002],[key2,003]]);
// 查问
wm.get(key)// 1 返回键值
wm.has(key1)//true 返回 boolean
// 增加 
const key3={id:4},key4={id:5}
wm.set(key3,4).set(key4,5)
wm//WeakMap {{…} => 5, {…} => 3, {…} => 4, {…} => 1, {…} => 2}
// 删除
wm.delete(key3);// 删除指定键值对

弱键

WeakMap 中的弱映射的键，不属于正式的引入，不会阻止垃圾回收的解决，然而弱映射的值，只有键存在，键值对就存在映射中，并被当作对值的援用，不会被当作垃圾回收。

const wm = new WeakMap(); 
wm.set({}, "val");
// 因为空对象被当做一个字符串的键，对象没有被指向援用，会被当作垃圾回收，之后键值对就在映射中隐没成为一个空映射
const wm = new WeakMap(); 
const container = {key: {} 
}; 
wm.set(container.key, "val"); 
function removeReference() {container.key = null;}
//container 对象保护着一个对弱映射键的援用，所有这个对象键不会被当作垃圾回收，只有执行 removeReference 办法后键值对才会被销毁。

不可迭代键

因为 WeakMap 中的键 / 值对任何时候都可能被销毁，所以没必要提供迭代其键 / 值对的能力。

弱映射的应用场景

1. 公有变量

const User = (() => {const wm = new WeakMap(); 
 class User {constructor(id) {this.idProperty = Symbol('id'); 
 this.setId(id); 
 } 
 setPrivate(property, value) {const privateMembers = wm.get(this) || {}; 
 privateMembers[property] = value; 
 wm.set(this, privateMembers); 
 } 
 getPrivate(property) {return wm.get(this)[property]; 
 } 
 setId(id) {this.setPrivate(this.idProperty, id); 
 } 
 getId(id) {return this.getPrivate(this.idProperty); 
 } 
 } 
 return User; 
})(); 
const user = new User(123); 
user.getId(); // 123 
user.setId(456); 
user.getId(); // 456

2. DOM 节点元数据
   WeakMap 实例不会障碍垃圾回收，所以非常适合保留关联元数据。因为 WeakMap 的次要长处是它对对象是弱援用，所以被它们援用的对象很容易地被垃圾收集器移除。它用作“次要”对象存储之外的“辅助”数据结构。一旦将对象从主存储器中删除，如果该对象仅被用作 WeakMap 的键，那么它将被主动革除。

   let wm=new WeakMap();
   let login=document.querySelector('#login');
   m.set(login, {disabled: true});
   // 那么当节点从 DOM 树中被删除后，垃圾回收程序就能够立刻开释其内存（假如没有其余中央援用这个对象）

   Set

   一种汇合类型，Map 的加强版

应用办法

//Set 对象能够应用 JavaScript 中所有的数据类型作为值
// 创立
let s=new Set(["value1", "value2", "value3"]);
// 增加
s.add("value4").add("value5")//Set(5) {"value1", "value2", "value3", "value4", "value5"}
// 查问
s.has("value1")//true 返回 boolean 值
s.size//5
// 删除
s.delete("value1")// 删除指定的值
s.clear()// 删除所用的值

程序与迭代

let s=new Set(["val1","val2","val3","val4"]);
s.values\s.keys\s[Symbol.iterator] //ƒ values() { [native code] }
s.values === s[Symbol.iterator] // true 
s.keys === s[Symbol.iterator] // true
s.values()/s.keys()//SetIterator {"val1", "val2", "val3", "val4"}
// 迭代
for(let item of 迭代对象){// 迭代对象：s.values()/s[Symbol.iterator]()/s
item//"val1","val2","val3","val4"
// 迭代对象：s.entries()
item// ["val1", "val1"]、["val2", "val2"]、["val3", "val3"]、["val4", "val4"]
  }
// 汇合转数组能够通过扩大操作符
[...s]// ["val1", "val2", "val3", "val4"]

定义正式汇合操作

* 某些 Set 操作是有关联性的，因而最好让实现的办法能反对解决任意多个汇合实例。* Set 保留插入程序，所有办法返回的汇合必须保障程序。* 尽可能高效地应用内存。扩大操作符的语法很简洁，但尽可能防止汇合和数组间的互相转换可能节俭对象初始化老本。* 不要批改已有的汇合实例。union(a, b)或 a.union(b)应该返回蕴含后果的新汇合实例。

WeakSet

WeakSet 一种汇合类型，是 Set 的兄弟类型。

应用办法

//! 弱汇合中的值只能是 Object 或者继承自 Object 的类型
// 创立
const val1={id:1},val2={id:2},val3={id:3}
let ws=new WeakSet([val1,val2,val3]);
// 查找
ws.has(val1)//true 返回 boolean
// 增加
const val4={id:4},val5={id:5}
ws.add(val4).add(val5)//
// 删除
ws.delete(val5)// 指定删除项

弱值

WeakSet 中的值不属于正式的援用，不会阻止垃圾回收。

const ws = new WeakSet(); 
ws.add({});
// 新对象用作值，没有被指向援用，会被当作垃圾回收，这个值在弱汇合中打消。const ws = new WeakSet(); 
const container = {val: {} 
}; 
ws.add(container.val); 
function removeReference() {container.val = null;}
//container 对象保护着一个对弱汇合值的援用, 因而这个对象值不会成为垃圾回收的指标。如果调用了 removeReference()，就会捣毁值对象的最初一个援用，垃圾回收程序就能够把这个值清理掉。

不可迭代值

WeakSet 中的值任何时候都可能被销毁，所以没必要提供迭代其值的能力，

应用弱汇合

WeakSet 的实例没有 WeakMap 用途大，
应用场景：给对象打标签

const disabledElements = new WeakSet();

const loginButton = document.querySelector('#login');

// 通过退出对应汇合，给这个节点打上“禁用”标签

disabledElements.add(loginButton);
// 只有 WeakSet 中任何元素从 DOM 树中被删除，垃圾回收程序就能够疏忽其存在，而立刻开释其内存（假如没有其余中央援用这个对象）。

迭代与扩大操作

迭代器和扩大运算符对汇合援用类型（Array、定向数组、Map、Set）的之间的互相操作、复制、批改十分便当。

迭代器 :for …of

扩大操作符 :[…]能够对可迭代对象执行浅复制时十分不便。