摘要：注意這里因為添加完元素之后返回的是該對象，所以可以鏈式調(diào)用結(jié)果是，但是中只會存一個模擬實現(xiàn)的整體結(jié)構(gòu)除此之外我們還需要二個輔助方法模擬行為對迭代器對象進行遍歷操作。

更多系列文章請看

在實現(xiàn)之前我們可以通過阮一峰的ECMAScript 6 入門了解一下Set的基本信息

new Set([ iterable ])

可以傳遞一個可迭代對象，它的所有元素將被添加到新的 Set中。如果不指定此參數(shù)或其值為null，則新的 Set為空。

let s = new Set([ 1, 2, 3 ]) // Set(3) {1, 2, 3}
let s2 = new Set() // Set(0) {}
let s3 = new Set(null /* or undefined */) // Set(0) {}

屬性

constructor: Set的構(gòu)造函數(shù)

size: Set 長度

操作方法

add(value):在Set對象尾部添加一個元素。返回該Set對象。

has(value):返回一個布爾值，表示該值在Set中存在與否。

delete(value):移除Set中與這個值相等的元素，返回has(value)在這個操作前會返回的值（即如果該元素存在，返回true，否則返回false）

-clear():移除Set對象內(nèi)的所有元素。沒有返回值

遍歷方法

keys():返回一個新的迭代器對象，該對象包含Set對象中的按插入順序排列的所有元素的值。

-values():返回一個新的迭代器對象，該對象包含Set對象中的按插入順序排列的所有元素的值。

entries():返回一個新的迭代器對象，該對象包含Set對象中的按插入順序排列的所有元素的值的[value, value]數(shù)組。為了使這個方法和Map對象保持相似， 每個值的鍵和值相等。

-forEach(callbackFn[, thisArg]):按照插入順序，為Set對象中的每一個值調(diào)用一次callBackFn。如果提供了thisArg參數(shù)，回調(diào)中的this會是這個參數(shù)。

let s = new Set()

s.add(1) // Set(1) {1}
  .add(2) // Set(2) {1, 2}
  .add(NaN) // Set(2) {1, 2, NaN}
  .add(NaN) // Set(2) {1, 2, NaN}

// 注意這里因為添加完元素之后返回的是該Set對象，所以可以鏈式調(diào)用
// NaN === NaN 結(jié)果是false，但是Set中只會存一個NaN

s.has(1) // true
s.has(NaN) // true

s.size // 3

s.delete(1)
s.has(1) // false
s.size // 2

s.clear()

s // Set(0) {}

let s2 = new Set([ "s", "e", "t" ])

s2 // SetIterator {"s", "e", "t"}
s2.keys() // SetIterator {"s", "e", "t"}
s2.values() // SetIterator {"s", "e", "t"}
s2.entries() // SetIterator {"s", "e", "t"}

// log
[ ...s2 ] // ["s", "e", "t"]
[ ...s2.keys() ] //  ["s", "e", "t"]
[ ...s2.values() ] //  ["s", "e", "t"]
[ ...s2.entries() ] //  [["s", "s"], ["e", "e"], ["t", "t"]]

s2.forEach(function (value, key, set) {
  console.log(value, key, set, this)
})

// s s Set(3) {"s", "e", "t"} Window
// e e Set(3) {"s", "e", "t"} Window
// t t Set(3) {"s", "e", "t"} Window

s2.forEach(function () {
  console.log(this)
}, { name: "qianlongo" })

// {name: "qianlongo"}
// {name: "qianlongo"}
// {name: "qianlongo"}

for (let value of s2) {
  console.log(value)
}
// s
// e
// t

for (let value of s2.entries()) {
  console.log(value)
}
// ["s", "s"]
// ["e", "e"]
// ["t", "t"]

class Set {

  constructor (iterable) {}

  get size () {}

  has () {}

  add () {}

  delete () {}  

  clear () {}

  forEach () {}

  keys () {}

  values () {}  

  entries () {}

  [ Symbol.iterator ] () {}
}

除此之外我們還需要二個輔助方法
1、forOf,模擬for of行為, 對迭代器對象進行遍歷操作。

const forOf = (iterable, callback, ctx) => {
  let result
  iterable = iterable[ Symbol.iterator ]()
  result = iterable.next()

  while (!result.done) {
    callback.call(ctx, result.value)
    result = iterable.next()
  }
}

2、Iterator迭代器,更多迭代器信息請看Iterator,我們這里面用迭代器是為了讓我們的set的values（）等可進行遍歷。

class Iterator {
    constructor (arrayLike, iteratee = (value) => value) {
      this.value = Array.from(arrayLike)
      this.nextIndex = 0
      this.len = this.value.length
      this.iteratee = iteratee
    }
  
    next () {
      let done = this.nextIndex >= this.len
      let value = done ? undefined : this.iteratee(this.value[ this.nextIndex++ ])
  
      return { done, value }
    }
  
    [ Symbol.iterator ] () {
      return this
    }
  }

class Set {
    constructor(iterable){
        this.value = [];
        if(!this instanceof Set) throw new Error("Constructor Set requires "new"");
        if(isDef(iterable)) {
            if(typeof iterable[ Symbol.iterator ] !== "function") new Error(`${iterable} is not iterable`);
            // 循環(huán)可迭代對象，初始化
            forOf(iterable, value => this.add(value));
        }
    }

    get size(){
        return this.value.length;
    }
    
    has(val) {
        return this.value.includes(val); // [ NaN ].includes(NaN)會返回true，正好Set也只能存一個NaN
    }
    add(val) {
        if(!this.has(val)) {
            this.value.push(val);
        }
        return this;
    }
    delete(val) {
        const index = this.value.indexOf(val);
        if (index > -1) {
            this.value.splice(index, 1);
            return true;
        }
        return false;
    }
    clear() {
        this.value.length = 0;
    }
    forEach(cb, arg) {
        forOf(this.values(), val => {
            cb.call(arg, val, val, this);
        })
    }
    keys() {
        return new Iterator(this.value);
    }

    values() {
        return this.keys();
    }
    entries() {
        return new Iterator(this.value, (value) => [ value, value ])
    }
    [Symbol.iterable]() {
        return this.values();
    }
}

模擬過程中可能會有相應(yīng)的錯誤，也不是和原生的實現(xiàn)完全一致。僅當(dāng)學(xué)習(xí)之用.