type HashSet struct {
  m map[interface{}]bool
}

if m["a"] {// 判斷是否m中包含鍵為“a”的鍵值對
  //省略其他語句
}

func NewHashSet() *HashSet {
  return &HashSet{m: make(map[interface{}]bool)}
}

//方法Add會返回一個bool類型的結(jié)果值，以表示添加元素值的操作是否成功。
//方法Add的聲明中的接收者類型是*HashSet。
func (set *HashSet) Add(e interface{}) bool {
  if !set.m[e] {//當前的m的值中還未包含以e的值為鍵的鍵值對
    set.m[e] = true//將鍵為e(代表的值)、元素為true的鍵值對添加到m的值當中
    return true //添加成功
  }
  return false //添加失敗
}

//調(diào)用delete內(nèi)建函數(shù)刪除HashSet內(nèi)部支持的字典值
func (set *HashSet) Remove(e interface{}) {
  delete(set.m, e)//第一個參數(shù)為目標字典類型，第二個參數(shù)為要刪除的那個鍵值對的鍵
}

//為HashSet中的字段m重新賦值
func (set *HashSet) Clear() {
  set.m = make(map[interface{}]bool)
}

//方法Contains用于判斷其值是否包含某個元素值。
//這里判斷結(jié)果得益于元素類型為bool的字段m
func (set *HashSet) Contains(e interface{}) bool {
  return set.m[e]
}

//方法Len用于獲取HashSet元素值數(shù)量
func (set *HashSet) Len() int {
  return len(set.m)
}

//方法Same用來判斷兩個HashSet類型值是否相同
func (set *HashSet) Same(other *HashSet) bool {
  if other == nil {
    return false
  }
  if set.Len() != other.Len() {
    return false
  }
  for key := range set.m {
    if !other.Contains(key) {
      return false
    }
  }
  return true
}

//方法Elements用于生成快照
func (set *HashSet) Elements() []interface{} {
  initialLen := len(set.m)//獲取HashSet中字段m的長度，即m中包含元素的數(shù)量
  //初始化一個[]interface{}類型的變量snapshot來存儲m的值中的元素值
  snapshot := make([]interface{}, initialLen)
  actualLen := 0
  //按照既定順序?qū)⒌翟O置到快照值(變量snapshot的值)的指定元素位置上,這一過程并不會創(chuàng)建任何新值。
  for key := range set.m {
    if actualLen < initialLen {
      snapshot[actualLen] = key
    } else {//m的值中的元素數(shù)量有所增加，使得實際迭代的次數(shù)大于先前初始化的快照值的長度
      snapshot = append(snapshot, key)//使用append函數(shù)向快照值追加元素值。
    }
    actualLen++//實際迭代的次數(shù)
  }
  //對于已被初始化的[]interface{}類型的切片值來說，未被顯示初始化的元素位置上的值均為nil。
  //m的值中的元素數(shù)量有所減少，使得實際迭代的次數(shù)小于先前初始化的快照值的長度。
  //這樣快照值的尾部存在若干個沒有任何意義的值為nil的元素，
  //可以通過snapshot = snapshot[:actualLen]將無用的元素值從快照值中去掉。
  if actualLen < initialLen {
    snapshot = snapshot[:actualLen]
  }
  return snapshot
}

//這個String方法的簽名算是一個慣用法。 //代碼包fmt中的打印函數(shù)總會使用參數(shù)值附帶的具有如此簽名的String方法的結(jié)果值作為該參數(shù)值的字符串表示形式。
func (set *HashSet) String() string {
  var buf bytes.Buffer//作為結(jié)果值的緩沖區(qū)
  buf.WriteString("HashSet{")
  first := true
  for key := range set.m {
    if first {
      first = false
    } else {
      buf.WriteString(",")
    }
    buf.WriteString(fmt.Sprintf("%v", key))
  }
  //n := 1
  //for key := range set.m {
  // buf.WriteString(fmt.Sprintf("%v", key))
  // if n == len(set.m) {//最后一個元素的后面不添加逗號
  // break;
  // } else {
  // buf.WriteString(",")
  // }
  // n++;
  //}
  buf.WriteString("}")
  return buf.String() 
}

// 判斷集合 set 是否是集合 other 的超集 
func (set *HashSet) IsSuperset(other *HashSet) bool {
  if other == nil {//如果other為nil，則other不是set的子集
    return false
  }
  setLen := set.Len()//獲取set的元素值數(shù)量
  otherLen := other.Len()//獲取other的元素值數(shù)量
  if setLen == 0 || setLen == otherLen {//set的元素值數(shù)量等于0或者等于other的元素數(shù)量
    return false
  }
  if setLen > 0 && otherLen == 0 {//other為元素數(shù)量為0，set元素數(shù)量大于0，則set也是other的超集
    return true
  }
  for _, v := range other.Elements() {
    if !set.Contains(v) {//只要set中有一個包含other中的數(shù)據(jù)，就返回false
      return false
    }
  }
  return true
}

// 生成集合 set 和集合 other 的并集
func (set *HashSet) Union(other *HashSet) *HashSet {
  if set == nil || other == nil {// set和other都為nil，則它們的并集為nil
    return nil
  }
  unionedSet := NewHashSet()//新創(chuàng)建一個HashSet類型值，它的長度為0，即元素數(shù)量為0
  for _, v := range set.Elements() {//將set中的元素添加到unionedSet中
    unionedSet.Add(v)
  }
  if other.Len() == 0 {
    return unionedSet
  }
  for _, v := range other.Elements() {//將other中的元素添加到unionedSet中，如果遇到相同，則不添加（在Add方法邏輯中體現(xiàn)）
    unionedSet.Add(v)
  }
  return unionedSet
}

// 生成集合 set 和集合 other 的交集
func (set *HashSet) Intersect(other *HashSet) *HashSet {
  if set == nil || other == nil {// set和other都為nil，則它們的交集為nil
    return nil
  }
  intersectedSet := NewHashSet()//新創(chuàng)建一個HashSet類型值，它的長度為0，即元素數(shù)量為0
  if other.Len() == 0 {//other的元素數(shù)量為0，直接返回intersectedSet
    return intersectedSet
  }
  if set.Len() < other.Len() {//set的元素數(shù)量少于other的元素數(shù)量
    for _, v := range set.Elements() {//遍歷set
      if other.Contains(v) {//只要將set和other共有的添加到intersectedSet
        intersectedSet.Add(v)
      }
    }
  } else {//set的元素數(shù)量多于other的元素數(shù)量
    for _, v := range other.Elements() {//遍歷other
      if set.Contains(v) {//只要將set和other共有的添加到intersectedSet
        intersectedSet.Add(v)
      }
    }
  }
  return intersectedSet
}

// 生成集合 set 對集合 other 的差集
func (set *HashSet) Difference(other *HashSet) *HashSet {
  if set == nil || other == nil {// set和other都為nil，則它們的差集為nil
    return nil
  }
  differencedSet := NewHashSet()//新創(chuàng)建一個HashSet類型值，它的長度為0，即元素數(shù)量為0
  if other.Len() == 0 { // 如果other的元素數(shù)量為0
    for _, v := range set.Elements() {//遍歷set，并將set中的元素v添加到differencedSet
      differencedSet.Add(v)
    }
    return differencedSet//直接返回differencedSet
  }
  for _, v := range set.Elements() {//other的元素數(shù)量不為0，遍歷set
    if !other.Contains(v) {//如果other中不包含v，就將v添加到differencedSet中
      differencedSet.Add(v)
    }
  }
  return differencedSet
}

// 生成集合 one 和集合 other 的對稱差集
func (set *HashSet) SymmetricDifference(other *HashSet) *HashSet {
  if set == nil || other == nil {// set和other都為nil，則它們的對稱差集為nil
    return nil
  }
  diffA := set.Difference(other)//生成集合 set 對集合 other 的差集
  if other.Len() == 0 {//如果other的元素數(shù)量等于0，那么other對集合set的差集為空，則直接返回diffA
    return diffA
  }
  diffB := other.Difference(set)//生成集合 other 對集合 set 的差集
  return diffA.Union(diffB)//返回集合 diffA 和集合 diffB 的并集
}

type Set interface {
  Add(e interface{}) bool
  Remove(e interface{})
  Clear()
  Contains(e interface{}) bool
  Len() int
  Same(other Set) bool
  Elements() []interface{}
  String() string
}

func (set *HashSet) Same(other Set) bool {
  //省略若干語句
}

// 判斷集合 one 是否是集合 other 的超集
// 讀者應重點關注IsSuperset與附屬于HashSet類型的IsSuperset方法的區(qū)別
func IsSuperset(one Set, other Set) bool {
  if one == nil || other == nil {
    return false
  }
  oneLen := one.Len()
  otherLen := other.Len()
  if oneLen == 0 || oneLen == otherLen {
    return false
  }
  if oneLen > 0 && otherLen == 0 {
    return true
  }
  for _, v := range other.Elements() {
    if !one.Contains(v) {
      return false
    }
  }
  return true
}