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

更多系列文章請看

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

new Set([ iterable ])

可以傳遞一個可迭代對象，它的所有元素將被添加到新的 Set中。如果不指定此參數或其值為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的構造函數

size: Set 長度

操作方法

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

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

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

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

遍歷方法

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

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

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

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

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對象，所以可以鏈式調用
// NaN === NaN 結果是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`);
            // 循環可迭代對象，初始化
            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();
    }
}

模擬過程中可能會有相應的錯誤，也不是和原生的實現完全一致。僅當學習之用.