第六章集合引用类型

2022-06-17

字数统计: 5.2k字 | 阅读时长≈ 21分

object

单独写在其他文章

array

1、创建数组方式
	let colors = new Array();	
	let colors = new Array(20);//指定长度	
	let colors = new Array('red','blue','green');//指定内容
	let colors = ["red", "blue", "green"]; // 创建一个包含 3 个元素的数组

【注】与对象一样，在使用数组字面量表示法创建数组不会调用 Array 构造函数。

-Array.from()
	接收一个类数组对象、即任意可迭代结构 或 有一个length属性 和 可索引元素结构。
    第二参数: 映射函数 
    第三参数：指定映射函数的 this 前提第二参数不为箭头函数
	eg:
		let m = [1,2,3];
		let m = new Map(); m.set(0,1);m.set(1,2);m.set(2,3);
		let m = {
			*[Symbol.iterator](){
                yield* [1,2,3]
            }
        }
		
		Array.from(m);//[1,2,3]
		const a3 = Array.from(m, function(x) {
            return x**this.exponent
        }, {exponent: 2});
		//2 4 6


-Array.of()
	把一组参数转化为数组，用于代替es5的 Array.prototype.slice.call(arguments)

2、数组空位
    const options = [,,,,,]; // 创建包含 5 个元素的数组 
    console.log(options.length); // 5 
    console.log(options); // [,,,,,]

	ES6新增方法普遍将这些空位当成存在的元素，只不过值位 undefined
	ES6 之前的方法则会忽略这个空位，但具体的行为也会因方法而异：

	const options = [1,,,,5]; 
	// map()会跳过空位置 
	console.log(options.map(() => 6)); // [6, undefined, undefined, undefined, 6] 
    // join()视空位置为空字符串 
    console.log(options.join('-')); // "1----5"

3、数组的检测
	一个网页中只有一个全局作用域时 instanceof 操作符 足矣
    如果要把数组从一个框架传入到另一个框架，则这个数组的构造函数将有区别于在第二个框架内本地创建的数组
    
    为解决这个问题，ECMAScript 提供了 Array.isArray()方法。这个方法的目的就是确定一个值是 否为数组，而不用管它是在哪个全局执行上下文中创建的。

4、迭代器方法
	-kays() 
	-values()
	-entries()
5、复制和填充
	-copyWithin(target, start, end) 
		target 复制插入到该索引位置，负数则 + 数组长度
		start  复制元素起始位置，负数则 + 数组长度
         end	复制元素结束位置，负数则 + 数组长度
         参数默认都是0
	-fill(val, start, end)
		val 填充的值
         start  填充元素起始位置，负数则 + 数组长度
         end	填充元素结束位置，负数则 + 数组长度
		fill()静默忽略超出数组边界、零长度及方向相反的索引范围：
6、转换方法
	-toLocaleString
		toLocaleString()方法也可能返回跟 toString()和 valueOf()相同的结果，它与其他两种方法区别在于为得到最终字符串。它会调用数组每个值的toLocaleString

	-toString
		toString()返回由数组中每个值的等效字符串拼接而成的一个逗号分隔的 字符串。
        也就是说，对数组的每个值都会调用其 toString()方法，以得到最终的字符串。

     -valueOf		返回数组本身
     
         let person1 = { 
             toLocaleString() { 
                 return "Nikolaos"; 
             }, 
             toString() { 
                 return "Nicholas"; 
             } 
         }; 
        let person2 = { 
            toLocaleString() { 
                return "Grigorios"; 
            }, 
            toString() { 
                return "Greg"; 
            } 
        }; 
        let people = [person1, person2]; 
        alert(people); // Nicholas,Greg 
        alert(people.toString()); // Nicholas,Greg 
        alert(people.toLocaleString()); // Nikolaos,Grigorios
	
	-join
		接收一个字符串分隔符，返回包含所有项的字符串。如果一个元素为 undefined 或 null，它会被转换为空字符串。
7、栈方法
	栈是一种后进先出的方法。
    -push
		向数组尾部添加一个数据，返回索引
    -pop
		删除数组尾部一个数据，返回数组
8、队列方法
	队列是一种先进先出的方法。
    -shift
		删除数组第一项并返回它，数组长度减一
     shift 与 push 可以把数组当成 队列来使用
    
    -unshift 
		向头部添加新数据
     unshift 与 pop 可以模拟相反的队列 
9、排序
	-resolve
		将数组反向排序
	-sort
		默认按照升序排列，先将数组中每项数据用String转型。在比较排序
        eg:
			['a','A',1000,4,35].sort();
			//[1000, 35, 4, "A", "a"]
		可接收一个比较函数
        sort(function(next, pre){
            return 1（大于0） 第一个值排在第二个值后面
            return -1（小于0） 第二个值排在第一个值后面
            return 0 不变
            return next - pre 降序
            return pre - next 升序
        })
10、操作方法
	-concat
		传入一个或多个数组，返回新数组
      eg:
		let newColors = ["black", "brown"];
		//设置数组 不被打平
         newColors[Symbol.isConcatSpreadable] =  false;
         let arr = [1,2,3];
         arr.concat('--',newColors);	// [1, 2, 3, "--", Array(2)]	
	-slice(start, end)
		接收开始，结束位置索引。返回两个索引之间数据的新数组
     -splice(index, n, newEl)
		参数1 开始操作的下标
         参数2 要删除的个数，不删除传0
         参数3 新增的项
		
         可实现数组的删除、新增、替换操作
         由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。
         如果没有删除元素，则返回空数组
12、搜索方法
		下面方法都接收两个参数：要查找的元素、起始搜索位置,对比方式为 ===
	-indexOf
		从头匹配，返回找到的第一个匹配项的索引，没有返回-1
	-lastIndexOf
		从尾匹配，返回找到的第一个匹配项的索引，没有返回-1
	-includes
		找到返回 true 否则 false

13、断言匹配
	都从元素最小索引开始匹配，返回真值，表示是否匹配
    参数1：函数 接收3个值：元素、索引、数组本身
    参数2：指定this
	-find
		返回找到的第一个匹配元素
	-findIndex
		返回找到的第一个匹配元素的索引
     eg:
		const people = [ { name: "Matt", age: 27 }, { name: "Nicholas", age: 29 } ];
        console.log(people.find((element, index, array) => element.age < 28)); 
		// {name: "Matt", age: 27}
        console.log(people.findIndex((element,index, array) => element.age < 28)); 
		// 0
14、迭代方法
	每个方法都接收两个参数：每项为参数的函数、指定参数1中的this（对箭头函数无效）
	-every
		每一项都返回true，则方法返回 true
	-some
		有一项返回true，则方法返回 true
	-filter
		函数返回 true 的项会组成数组之后返回，会忽略数组空位
     -forEach
		遍历数组,forEach()按顺序迭代数组，而且会将索引作为第二个参数传给函数。与for/of循环不同，forEach()能够感知稀疏数组，不会对没有的元素数组调用函数。
     -map
		返回 由每次函数调用的结果构成新数组
     -for/of
	for/of循环使用的内置数组迭代器按照升序返回数组的元素。对于稀疏数组，这个循环没有特殊行为，凡是不存在的元素都返回undefined。
     
15、归并方法
	都接收两个参数：归并函数（上一个归并值，当前项【有初始值则,为第二项，否则第一项】，当前索引，数组本身），初始值
	-reduce
		从头开始遍历
	-reduceRight
		从尾开始遍历
 
16、定型数组
	ECMAScript新增结构，目的是提升原生库传输数据的效率。
    
    	在 WebGL 的早期版本中，因为 JavaScript 数组与原生数组之间不匹配，所以出现了性能问题。图形 驱动程序 API 通常不需要以 JavaScript 默认双精度浮点格式传递给它们的数值，而这恰恰是 JavaScript 数组在内存中的格式。因此，每次 WebGL 与 JavaScript 运行时之间传递数组时，WebGL 绑定都需要在 目标环境分配新数组，以其当前格式迭代数组，然后将数值转型为新数组中的适当格式，而这些要花费 很多时间。

	这当然是难以接受的，Mozilla 为解决这个问题而实现了 CanvasFloatArray。这是一个提供 JavaScript 接口的、C 语言风格的浮点值数组。JavaScript 运行时使用这个类型可以分配、读取和写入数组。 这个数组可以直接传给底层图形驱动程序 API，也可以直接从底层获取到。最终，CanvasFloatArray 变成了 Float32Array，也就是今天定型数组中可用的第一个“类型”。
	-Float32Array 
	实际上是一种“视图”，可以允许 JavaScript 运行时访问一块名为 ArrayBuffer 的 预分配内存。ArrayBuffer 是所有定型数组及视图引用的基本单位。

	-ArrayBuffer()
		-byteLength 字节长度
		是一个普通的 JavaScript 构造函数，可用于在内存中分配特定数量的字节空间。SharedArrayBuffer 是 ArrayBuffer 的一个变体，可以无须复制就在执行上下 文间传递它。
		eg:
			const buf = new ArrayBuffer(16); // 在内存中分配 16 字节 
			alert(buf.byteLength); // 16 
			//ArrayBuffer 一经创建就不能再调整大小。不过，可以使用 slice()复制其全部或部分到一个新 实例中： 
			const buf1 = new ArrayBuffer(16); 
			const buf2 = buf1.slice(4, 12); 
			alert(buf2.byteLength); // 8

	-DataView
		-byteLength 字节长度
		-byteOffset 偏移量
         读：gtInt8(偏移量(单位字节))
         	dataview.gtInt8(byteOffset)
         写：setInt8（偏移量(单位字节),整数值）
        	dataview.setInt8(byteOffset, value)

		第一种读写ArrayBuffer 的视图。DataView。这个视图专为文件 I/O 和网络 I/O 设计，其 API 支持对缓冲数据的高度控制，但相比于其他类型的视图性能也差一些。DataView 对缓冲内容没有 任何预设，也不能迭代。
		//参数1：DataView 对象的数据源(ArrayBuffer 或 SharedArrayBuffer  对象),
         //参数2：butter中的字节偏移，
         //参数3：DataView 对象的字节长度
        //返回的对象想象成一个二进制字节缓存区 arraybuffer 的“解释器”——它知道如何在读取或写入时正确地转换字节码。这意味着它能在二进制层面处理整数与浮点转化、字节顺序等其他有关的细节问题。
        
        参数：（buffer对象，初始偏移量(默认0)，限制视图为n字节(默认剩余的缓冲)）
		let dataView = new DataView(buffer, byteOffset, byteLength)
        
         byteOffset 或者 byteLength 超出长度会报错。
         
         DataView 对存储在缓冲内的数据类型没有预设。它暴露的 API 强制开发者在读、写时指定一个 ElementType，然后 DataView 就会忠实地为读、写而完成相应的转换。 ECMAScript 6 支持 8 种不同的 ElementType（见下表）。 
         
  ElementType 		字 节 		说 明 		等价的 C 类型 		值的范围 
   Int8 		1 			8 位有符号整数 	signed char 		-128~127 
   Uint8 		1 			8 位无符号整数 	unsigned char 		 0~255 
   Int16 		2 			16 位有符号整数 	short 				-32768~32767 
   Uint16 		2 			16 位无符号整数 	unsigned short 		 0~65 535 
   Int32 		4 			32 位有符号整数 	int 				-2147483648~2147483647 
   Uint32 		4 			32 位无符号整数 	unsigned int 		 0~4 294 967 295 
   Float32 		4 			32 位IEEE-754 浮点数 float 			   -3.4e+38~+3.4e+38 
   Float64 		8 			64 位 IEEE-754 浮点数 double 			-1.7e+308~+1.7e+308


	
	-字节序
		前面例子中的缓冲有意回避了字节序的问题。“字节序”指的是计算系统维护的一种字节顺序的约 定。DataView 只支持两种约定：大端字节序和小端字节序。大端字节序也称为“网络字节序”，意思 是最高有效位保存在第一个字节，而最低有效位保存在最后一个字节。小端字节序正好相反，即最低有 效位保存在第一个字节，最高有效位保存在最后一个字节。
        DataView所有API默认是大端字节序
	
        
边界问题
const buf = new ArrayBuffer(6); 
const view = new DataView(buf); // 尝试读取部分超出缓冲范围的值 
view.getInt32(4);//Int32位占4字节，偏移量最大为2
//RangeError


17、定型数组
	定型数组是另一种形式的 ArrayBuffer 视图。虽然概念上与 DataView 接近，但定型数组的区别 在于，它特定于一种 ElementType 且遵循系统原生的字节序。相应地，定型数组提供了适用面更广的 API 和更高的性能。设计定型数组的目的就是提高与 WebGL 等原生库交换二进制数据的效率。
    由于定 型数组的二进制表示对操作系统而言是一种容易使用的格式，JavaScript 引擎可以重度优化算术运算、 按位运算和其他对定型数组的常见操作，因此使用它们速度极快。 创建定型数组的方式包括读取已有的缓冲、使用自有缓冲、填充可迭代结构，以及填充基于任意类 型的定型数组。
    另外，通过<ElementType>.from()和<ElementType>.of()也可以创建定型数组：

	-创建定型数组
	// 创建一个长度为 6 的 Int32Array 
    const ints2 = new Int32Array(6); 
    // 每个数值使用 4 字节，因此 ArrayBuffer 是 24 字节 
    alert(ints2.length); // 6 	-类似元素的个数
    // 类似 DataView，定型数组也有一个指向关联缓冲的引用
    alert(ints2.buffer.byteLength); // 24 	-所有元素所占的字节

    // 创建一个包含[2, 4, 6, 8]的 Int32Array 
    const ints3 = new Int32Array([2, 4, 6, 8]); 
    alert(ints3.length); // 4 
    alert(ints3.buffer.byteLength); // 16 
    alert(ints3[2]); // 6

	[注意]：
    	1、创建没有指定内容的定型数组时，其关联缓冲默认填充0
        2、定型数组的构造函数和实例都有一个 BYTES_PER_ELEMENT 属性，返回该类型数组中每个元素的大小： 
        alert(Int16Array.BYTES_PER_ELEMENT); // 2 
		alert(Int32Array.BYTES_PER_ELEMENT); // 4

	-定型数组行为与普通数组类似
	 [] 
	 copyWithin() 
	 entries()
	 every() 
	 fill() 
     filter() 
     find() 
     findIndex() 
     forEach() 
     indexOf() 
     join() 
     keys() 
     lastIndexOf() 
     length 
     map() 
     reduce() 
     reduceRight() 
     reverse() 
     slice() 
     some() 
     sort() 
     toLocaleString() 
     toString() 
     values()

	-定型数组使用缓冲来储存数据，而数组缓冲无法调整大小。因此合并、复制、修改方法不适用于定型数组
	eg: concat()  pop()  push()  shift()  splice()  unshift()

	-定型数组新方法
	
        -set()从提供的数组或定型数组中把值复制到当前定型数组中指定的索引位置：
            // 把普通数组复制为后 4 个值 // 偏移量 4 表示从索引 4 开始插入 
            const container = new Int16Array(8);
            container.set([5,6,7,8], 4);
        -subarray()执行与 set()相反的操作，它会基于从原始定型数组中复制的值返回一个新定型数组。 复制值时的开始索引和结束索引是可选的：
            // 从索引 1 开始复制到索引 3 
            const source = Int16Array.of(2, 4, 6, 8);
            const partialCopy = source.subarray(1, 3);//[4,6]

	-上溢，下溢
	


18、flat 与 flatMap 打平数组

	在不传参调用时，flat()会打平一级嵌套。原始数组中本身也是数组的元素会被打平，但打平后的元素如果还是数组则不会再打平。如果想打平更多层级，需要给flat()传一个数值参数：
eg:
	[1, [2, 3]].flat()  // [1, 2, 3]
	[1, [2, [3]]].flat() // [1, 2, [3]]
	[1, [2, [3]]].flat(2) // [1, 2, 3]

flatMap()方法与map()方法相似，只不过返回的数组会自动被打平，就像传给了flat()一样。换句话说，调用a.flatMap(f)等同于（但效率远高于）a.map(f).flat()：

Map

ECMAScript 6 以前，在 JavaScript 中实现“键/值”式存储可以使用 Object 来方便高效地完成，也就是使用对象属性作为键，再使用属性来引用值。但这种实现并非没有问题，为此 TC39 委员会专门为 “键/值”存储定义了一个规范.

1、基本方法
	//初始化可传入二维数组，迭代器
	const m = new Map([["a":"b"],["b":"c"]]);
	m.set("firstName", "Matt").set(110,12580);
	m.has("a");// true
	m.get("firstName");// Matt
	m.delete("firstName");//删除指定的键值对
	m.clear();// 清除这个映射实例中的所有键/值对
	m.size; // 0
	
	[注]：
    	-Map可以使用任何js数据类型作为 键，映射的值也没有限制
        -Map会维护键值插入的顺序， 可以通过 entries方法(Symbol.iterator) 取得这个迭代器
        	 const m = new Map([ ["key1", "val1"], ["key2", "val2"], ["key3", "val3"] ]);
			m.entries === m[Symbol.iterator];// true
		- 作为键的 字符串原始值不能修改，但是作为键的 对象内部属性可以修改，不会影响映射
         -支持拓展运算符 [...m] 返回二维数组
2、Object VS  Map
	-内存占用
		Map大约可以比Object多储存50%的键值对
	-插入性能
		Map微块，但涉及大量操作，显然Map更佳
    -查找速度
		Object略胜一筹
    -删除性能
		Map更优

weakMap

新增的“弱映射”（WeakMap）是一种新的集合类型，为这门语言带来了增强的键/ 值对存储机制。WeakMap 是 Map 的“兄弟”类型，其 API 也是 Map 的子集。WeakMap 中的“weak”（弱），描述的是 JavaScript 垃圾回收程序对待“弱映射”中键的方式。

1、基本API
	//弱映射中的键只能是 Object 或者继承自 Object 的类型，
	//尝试使用非对象设置键会抛出 TypeError。值的类型没有限制。

	const key1 = {id: 1}, key2 = {id: 2}, key3 = {id: 3};
	const wm = new WeakMap([[key1, "val1"], [key2, "val2"]]);//可接收一个可迭代对象
	wm.set(key3, "val3");
	wm.get(key1); // "val1"
	wm.has(key3); // true
	wm.delete(key1); // 只删除这一个键/值对
	
2、弱键
	weakMap中的 'weak' 表示映射的键是 '弱弱的拿着' 。意为 这些建不属于正式引用，不会阻止垃圾回收。
    但是 弱映射中的值得引用就不是 '弱弱得拿着'。 只要 键存在于映射中，并被当作对值的引用，因此不会被垃圾回收
    
    eg:
        wm.set({}, "val");
        let obj = {a:'b'};
        wm.set(obj,'我是？')
        obj.a = '123'
        console.log(wm.get(obj));//'我是？'
		obj.a = {c: 'sada'}
        console.log(wm.get(obj));//undefined
3、不可迭代键
	因为 WeakMap 中的键/值 任何时候都可能被销毁，所以没必要提供其迭代能力
	
    
4、应用
	-1. 私有变量

	-2. DOM 节点元数据

Set

1、基本API
	
	Set 可以包含任何 JavaScript 数据类型作为值。
	特性：类似于数组，但是成员的值都是唯一的，没有重复的值

	const m = new Set(['val1','val2','val3']);
	// 使用自定义迭代器初始化集合 
	const s2 = new Set({ [Symbol.iterator]: function*() { 
        yield "val1"; yield "val2"; yield "val3"; 
    } });

    m.size; //3
    s2.size; //3

	m.add('val4')
	m.has('val4');// true
	m.delete('val2');
	s.clear();// 销毁集合实例中的所有值

2、顺序迭代
	const s = new Set(["val1", "val2", "val3"]); 
	alert(s.values === s[Symbol.iterator]); // true 
	alert(s.keys === s[Symbol.iterator]); // true

	console.log([...s]); // ["val1", "val2", "val3"]

	-Set 会维护值插入时的顺序，因此支持按顺序迭代。
	-支持拓展运算符
	- 作为值的 字符串原始值不能修改，但是作为值的 对象内部属性可以修改，不糊影响映射
	
3、集合操作

class XSet extends Set { 
    union(...sets) { 
        return XSet.union(this, ...sets) 
    } 
    
    intersection(...sets) { 
        return XSet.intersection(this, ...sets); 
    } 
    
    difference(set) { 
        return XSet.difference(this, set); 
    } 
    
    symmetricDifference(set) { 
        return XSet.symmetricDifference(this, set); 
    } 
    
    cartesianProduct(set) { 
        return XSet.cartesianProduct(this, set); 
    } 
    
    powerSet() { 
        return XSet.powerSet(this); 
    }

    // 返回两个或更多集合的并集 
    static union(a, ...bSets) { 
        const unionSet = new XSet(a); 
        for (const b of bSets) { 
            for (const bValue of b) { 
                unionSet.add(bValue); 
            } } 
        return unionSet; 
    } 
    // 返回两个或更多集合的交集 
    static intersection(a, ...bSets) { 
        const intersectionSet = new XSet(a); 
        for (const aValue of intersectionSet) { 
            for (const b of bSets) { 
                if (!b.has(aValue)) { 
                    intersectionSet.delete(aValue); 
                } 
            } 
        } 
        return intersectionSet; 
    } 
    // 返回两个集合的差集 
    static difference(a, b) { 
        const differenceSet = new XSet(a); 
        for (const bValue of b) { 
            if (a.has(bValue)) { 
                differenceSet.delete(bValue); 
            } } 
        return differenceSet;
    } 
    // 返回两个集合的对称差集 
    static symmetricDifference(a, b) { 
        // 按照定义，对称差集可以表达为 
        return a.union(b).difference(a.intersection(b)); 
    } 
    // 返回两个集合（数组对形式）的笛卡儿积 
    // 必须返回数组集合，因为笛卡儿积可能包含相同值的对 
    static cartesianProduct(a, b) { 
        const cartesianProductSet
		for (const set of new XSet(powerSet)) { 
            powerSet.add(new XSet(set).add(aValue)); 
        } 
        return powerSet; 
    } 
}

WeakSet

1、基本APi
	弱集合中的值只能是 Object 或者继承自 Object 的类型，尝试使用非对象设置值会抛出 TypeError。
	
    const ws = new WeakSet();
	-add()再添加新值
    -has()查询
    -delete()删除：

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

3、应用
	相比于 WeakMap 实例，WeakSet 实例的用处没有那么大。不过，弱集合在给对象打标签时还是有 价值的。

上述类型中默认支持迭代器

 Array

 所有定型数组

 Map

 Set

上面的这些类型都支持多种构建方法，比如 Array.of()和 Array.from()静态方法。在与扩展操作符一起使用时，可以非常方便地实现互操作：

本文作者： 王不留行
本文链接： https://wyf195075595.github.io/2022/06/17/programming/红宝书笔记/第六章集合引用类型/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！