Set对象

Set 对象允许你存储任何类型的唯一值&＃xff0c;无论是原始值或者是对象引用。

简述

Set对象是值的集合&＃xff0c;你可以按照插入的顺序迭代它的元素。 Set中的元素只会出现一次&＃xff0c;即 Set 中的元素是唯一的。

值的相等
因为 Set 中的值总是唯一的&＃xff0c;所以需要判断两个值是否相等。在ECMAScript规范的早期版本中&＃xff0c;这不是基于和&＃061;&＃061;&＃061;操作符中使用的算法相同的算法。具体来说&＃xff0c;对于 Set s&＃xff0c; &＃043;0 &＃xff08;&＃043;0 严格相等于-0&＃xff09;和-0是不同的值。然而&＃xff0c;在 ECMAScript 2015规范中这点已被更改。有关详细信息&＃xff0c;请参阅浏览器兼容性 表中的“Key equality for -0 and 0”。

另外&＃xff0c;NaN和undefined都可以被存储在Set 中&＃xff0c; NaN之间被视为相同的值&＃xff08;NaN被认为是相同的&＃xff0c;尽管 NaN !&＃061;&＃061; NaN&＃xff09;。

Constructor

Set()
创建一个新的Set对象。
静态属性

get Set[&＃064;&＃064;species]
构造函数用来创建派生对象.
实例属性

Set.prototype.size
返回 Set 对象中的值的个数
实例方法

Set.prototype.add(value)
在Set对象尾部添加一个元素。返回该Set对象。
Set.prototype.clear()
移除Set对象内的所有元素。
Set.prototype.delete(value)
移除Set的中与这个值相等的元素&＃xff0c;返回Set.prototype.has(value)在这个操作前会返回的值&＃xff08;即如果该元素存在&＃xff0c;返回true&＃xff0c;否则返回false&＃xff09;。Set.prototype.has(value)在此后会返回false。
Set.prototype.entries()
返回一个新的迭代器对象&＃xff0c;该对象包含Set对象中的按插入顺序排列的所有元素的值的[value, value]数组。为了使这个方法和Map对象保持相似&＃xff0c; 每个值的键和值相等。
Set.prototype.forEach(callbackFn[, thisArg])
按照插入顺序&＃xff0c;为Set对象中的每一个值调用一次callBackFn。如果提供了thisArg参数&＃xff0c;回调中的this会是这个参数。
Set.prototype.has(value)
返回一个布尔值&＃xff0c;表示该值在Set中存在与否。
Set.prototype.keys()
与values()方法相同&＃xff0c;返回一个新的迭代器对象&＃xff0c;该对象包含Set对象中的按插入顺序排列的所有元素的值。
Set.prototype.values()
返回一个新的迭代器对象&＃xff0c;该对象包含Set对象中的按插入顺序排列的所有元素的值。
Set.prototype&＃064;&＃064;iterator
返回一个新的迭代器对象&＃xff0c;该对象包含Set对象中的按插入顺序排列的所有元素的值。
示例

使用Set对象
let mySet &＃061; new Set();

mySet.add(1); // Set [ 1 ]
mySet.add(5); // Set [ 1, 5 ]
mySet.add(5); // Set [ 1, 5 ]
mySet.add(“some text”); // Set [ 1, 5, “some text” ]
let o &＃061; {a: 1, b: 2};
mySet.add(o);

mySet.add({a: 1, b: 2}); // o 指向的是不同的对象&＃xff0c;所以没问题

mySet.has(1); // true
mySet.has(3); // false
mySet.has(5); // true
mySet.has(Math.sqrt(25)); // true
mySet.has(“Some Text”.toLowerCase()); // true
mySet.has(o); // true

mySet.size; // 5

mySet.delete(5); // true, 从set中移除5
mySet.has(5); // false, 5已经被移除

mySet.size; // 4, 刚刚移除一个值

console.log(mySet);
// logs Set(4) [ 1, “some text”, {…}, {…} ] in Firefox
// logs Set(4) { 1, “some text”, {…}, {…} } in Chrome
迭代Set
// 迭代整个set
// 按顺序输出&＃xff1a;1, “some text”, {“a”: 1, “b”: 2}, {“a”: 1, “b”: 2}
for (let item of mySet) console.log(item);

// 按顺序输出&＃xff1a;1, “some text”, {“a”: 1, “b”: 2}, {“a”: 1, “b”: 2}
for (let item of mySet.keys()) console.log(item);

// 按顺序输出&＃xff1a;1, “some text”, {“a”: 1, “b”: 2}, {“a”: 1, “b”: 2}
for (let item of mySet.values()) console.log(item);

// 按顺序输出&＃xff1a;1, “some text”, {“a”: 1, “b”: 2}, {“a”: 1, “b”: 2}
//(键与值相等)
for (let [key, value] of mySet.entries()) console.log(key);

// 使用 Array.from 转换Set为Array
var myArr &＃061; Array.from(mySet); // [1, “some text”, {“a”: 1, “b”: 2}, {“a”: 1, “b”: 2}]

// 如果在HTML文档中工作&＃xff0c;也可以&＃xff1a;
mySet.add(document.body);
mySet.has(document.querySelector(“body”)); // true

// Set 和 Array互换
mySet2 &＃061; new Set([1, 2, 3, 4]);
mySet2.size; // 4
[…mySet2]; // [1,2,3,4]

实现基本集合操作
function isSuperset(set, subset) {
for (let elem of subset) {
if (!set.has(elem)) {
return false;
}
}
return true;
}

function union(setA, setB) {
let _union &＃061; new Set(setA);
for (let elem of setB) {
_union.add(elem);
}
return _union;
}

function intersection(setA, setB) {
let _intersection &＃061; new Set();
for (let elem of setB) {
if (setA.has(elem)) {
_intersection.add(elem);
}
}
return _intersection;
}

function symmetricDifference(setA, setB) {
let _difference &＃061; new Set(setA);
for (let elem of setB) {
if (_difference.has(elem)) {
_difference.delete(elem);
} else {
_difference.add(elem);
}
}
return _difference;
}

function difference(setA, setB) {
let _difference &＃061; new Set(setA);
for (let elem of setB) {
_difference.delete(elem);
}
return _difference;
}

//Examples
let setA &＃061; new Set([1, 2, 3, 4]),
setB &＃061; new Set([2, 3]),
setC &＃061; new Set([3, 4, 5, 6]);

isSuperset(setA, setB); // &＃061;> true
union(setA, setC); // &＃061;> Set [1, 2, 3, 4, 5, 6]
intersection(setA, setC); // &＃061;> Set [3, 4]
symmetricDifference(setA, setC); // &＃061;> Set [1, 2, 5, 6]
difference(setA, setC); // &＃061;> Set [1, 2]
Array 相关
let myArray &＃061; [“value1”, “value2”, “value3”];

// 用Set构造器将Array转换为Set
let mySet &＃061; new Set(myArray);

mySet.has(“value1”); // returns true

// 用…(展开操作符)操作符将Set转换为Array
console.log([…mySet]); // 与myArray完全一致
数组去重
// Use to remove duplicate elements from the array
const numbers &＃061; [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5]
console.log([…new Set(numbers)])
// [2, 3, 4, 5, 6, 7, 32]
String 相关
let text &＃061; ‘India’;

let mySet &＃061; new Set(text); // Set {‘I’, ‘n’, ‘d’, ‘i’, ‘a’}
mySet.size; // 5

// 大小写敏感
new Set(“Firefox”) // Set(7) [ “F”, “i”, “r”, “e”, “f”, “o”, “x” ]
new Set(“firefox”) // Set(6) [ “f”, “i”, “r”, “e”, “o”, “x” ]

Javascript 标准库
Set
属性
Set.prototype.size
get Set[&＃064;&＃064;species]
方法
Set.prototype.add()
Set.prototype.clear()
Set.prototype.delete()
Set.prototype.entries()
Set.prototype.forEach()
Set.prototype.has()
Set.prototype.values()
Set.prototype&＃064;&＃064;iterator
继承
Function
属性
Function.arguments
Function.caller
Function.displayName
Function.length
Function.name
方法
Function.prototype.apply()
Function.prototype.bind()
Function.prototype.call()
Function.prototype.toSource()
Function.prototype.toString()
Object
属性
Object.prototype.proto
Object.prototype.constructor
方法
Object.prototype.defineGetter()
Object.prototype.defineSetter()
Object.prototype.lookupGetter()
Object.prototype.lookupSetter()
Object.prototype.hasOwnProperty()
Object.prototype.isPrototypeOf()
Object.prototype.propertyIsEnumerable()
Object.prototype.toLocaleString()
Object.prototype.toSource()
Object.prototype.toString()
Object.prototype.valueOf()
Object.setPrototypeOf()

本文地址：https://blog.csdn.net/weixin_48659263/article/details/109264158