In-depth explanation of Set and WeakSet collections in ES6

/*
 * Instantiation only: call the constructor without passing parameters*/ 
let empty_set = new Set()    


/*
 * Instantiate and initialize: pass in any iterate object and convert it into a Set collection*/ 
let transfer_set4arr = new Set([1, 2, 3])
// returns Set(3) {1, 2, 3}

let transfer_set4string = new Set("huilin")
// Returns Set(5) {"h", "u", "i", "l", "n"}

let transfer_set4set = new Set(new Set([5, 6]))
// returns Set(2) { 5, 6 }

console.log(empty_set.size) // 0
console.log(transfer_set4arr.size) // 3

// Compared to Array.includes(), Set.has() has higher performance because it is optimized for membership testing console.log(empty_set.has(1)) // false
console.log(transfer_set4arr.has('h')) // true

let n1 = NaN
let n2 = NaN

console.log(n1 === n2)  
// If the identity symbol judges that the two are inconsistent, output false

console.log(Object.is(n1,n2)) 
// But Object.is() judges that the two are the same and outputs false

// The Set collection does not allow two NaNs to be put into the collection let set = new Set()
set.add(n1).add(n2)
console.log(set.size)   
// size: 1

let same_value_set = new Set();
// First save an object same_value_set.add({num: 0});
// Store a new object with the same structure let obj = {num: 0};
same_value_set.add(obj);
// Both can be stored successfully console.log(same_value_set.size); // 2

// The add() method can append any type of data, whether it is a primitive value or an object reference let set1 = new Set()
// Since the add() method always returns a reference to the current instance, a chain call is made: set1.add(1).add(2).add(3)
console.log(set1) // Set(3) {1, 2, 3}

// Note: When add() is passed into an array, Set will insert the array instance into the set, not the elements in the array set1.add([4, 5])
console.log(set1) // Set(4) {1, 2, 3, [4, 5]}

// The delete() method returns whether the removal operation is successful, just like the .has() method let success = set1.delete(1)
console.log(success)
// true

let num_set = new Set([1, 6, 3])
console.log(num_set)
// Set(3) { 1, 6, 3 }

set1.clear()
console.log(num_set)
// Set(0) {}

let set = new Set([1, 2, 3, 4, 5])
for(let item of set){
    console.log(item)
}
// Output in sequence: 1 2 3 4 5

/*
 * There are three ways to create iterators * Set.prototype.entries()
 * Set.prototype.keys()
 * Set.prototype.values()
 */ 

// The Set collection has only values ​​but no keys, but in order to make it similar to traversing a Map object, when Set.entries() creates a new Iterator object, the key and value of each item are equal, that is, [value, value]
for(let [key,value] of set.entries()){
    console.log(value)
}
// Output in sequence: 1 2 3 4 5

// Set.keys() creates a new Iterator object and returns each value for(let key of set.keys()){
    console.log(key)
}
// Output in sequence: 1 2 3 4 5

// Set.values() is consistent with Set.keys(), returning the value of each item for(let value of set.values()){
    console.log(value)
}
// Output in sequence: 1 2 3 4 5

// forEach(callbackFn) calls callbackFn in the order of insertion and retrieves each value set.forEach(item => {
    console.log(item)
})
// Output in sequence: 1 2 3 4 5

/*
 * Set to Array
 */
let set1 = new Set([1, 2, 3])
// Array.from() method let arr1 = Array.from(set1)  
// Extension operator let arr2 = [...set1]  

/*
 * Array to Set
 */
 // Using the Set constructor let set = new Set(array)

let set = new Set([1, 2, 4, 4, 2, 5])
console.log(set)
// Set(4) { 1, 2, 4, 5 }

let arr1 = [1, 2, 4]
let arr2 = [1, 5, 6]

// Using the characteristics of the Set collection, the elements in the set are unique let result = new Set([...set1, ...set2]) 
console.log(result)
// Set(5) { 1, 2, 4, 5, 6 }

let set1 = new Set([1, 2, 4])
let set2 = new Set([1, 5, 6])

// Return elements that exist in both set1 and set2 let result = new Set([...set1].filter(x => set2.has(x))) 
console.log(result)
// Set(1) { 1 }

let set1 = new Set([1, 2, 4])
let set2 = new Set([1, 5, 6])

function isMixed(set, subset) {
    for (let elem of subset) {
        if (set.has(elem)) {
            return true;
        }
    }
    return false;
}

console.log(isMixed(set1, set2))
// true

let set1 = new Set([1, 2, 4])
let set2 = new Set([1, 5, 6])

function difference(setA, setB) {
    let result = new Set()
    for (let elem of setB) {
        if (setA.has(elem)){
            result.add(elem)
        }
    }
    return result;
}

console.log(difference(set1, set2))

let val1 = {id: 1},
    val2 = {id: 2}

let ws = new WeakSet()

// Like the Set collection, the values ​​of WeakSet are not repeated. At the same time, add() also returns a set instance, so the chain operation ws.add(val1).add(val1).add(val2) can be used

// Insertion of basic data types is not allowed ws.add(3)
// Error: TypeError: Invalid value used in WeakSet

// But you can wrap it into an object first and then insert it let val3 = new Number(3)
ws.add(val3)
console.log(ws.has(val3))
// Output: true

// declare an object let handsome = {
    name: 'huilin',
    age: 30
}

// Put it into the array let arr = [1, handsome, 2]
console.log('release before arr length', arr.length) // 3

// Put it into Map
let user = {
    oid: 10001,
    classify: 'Chinese',
    staffReference: handsome
}
console.log('release before map length', Object.keys(user).length) // 3

console.log('----')

// Suddenly set the object to null
handsome = null
// In the strongly referenced container, the object still exists and has not been recycled console.log('release after arr length', arr.length) // 3
console.log(arr[1]) // { name: 'huilin', age: 30 }
console.log('release after map length', Object.keys(user).length) // 3
console.log(user.staffReference) // { name: 'huilin', age: 30 }

let obj1 = {
    name: 'huilin',
    age: 30
}

let obj2 = {
    name: 'cc',
    age: 29
}

let ws1 = new WeakSet()
ws1.add(obj1).add(obj2)
console.log(ws1.has(obj1)) // true

// Regardless of whether it is an element operated from the container ws1.delete(obj1)
console.log(ws1.has(obj1)) // false

// Or if the object itself is set to null, it will be automatically recycled obj2 = null
console.log(ws1.has(obj2)) // false