我无法从ECMA 2015规范中找到任何方法来获取插入到集合中的最后一个值，可能他们从未打算使用这样的方法，但您可以这样做：

const a = new Set([1, 2, 3]);
a.add(10);
const lastValue = Array.from(a).pop();

• • 编辑：**

再想想，节省空间的解决方案可能是：

function getLastValue(set){
  let value;
  for(value of set);
  return value;
}

const a = new Set([1, 2, 3]);
a.add(10);
console.log('last value: ', getLastValue(a));

一些想法：

• 考虑使用数组而不是集合。提取数组的最后一个元素很容易。

array[array.length-1];
array.slice(-1)[0];
array.pop(); // <-- This alters the array

如果确实需要一个集合，可以在提取最后一项时将其转换为数组，但这会耗费时间和空间。

• 手动迭代集合。这将花费时间，但不像复制到数组中那样多的空间。例如（可能有更优雅的方法来完成此操作）

var set = new Set([1, 2, 3]);
var iter = set.values(), prev, curr;
do {
  prev = curr;
  curr = iter.next();
} while(!curr.done)
var last = prev.value; // 3

• 考虑以相反的顺序插入项目，这样您只需要获取集合中的第一个项目，这样会更容易：

set.values().next().value;

• 子类Set添加此新功能：

class MySet extends Set {
  add(value) {
    super.add(value);
    this.last = value;
  }
}
var set = new MySet();
set.add(1); set.add(2); set.add(3);
set.last; // 3

注意，这只会检测用add添加的值。为了更完整，它还应该在构造集合时检测最新的值，并在删除最后一项时更新该值。

是的，有一种方法可以做到这一点，您可以简单地将集合转换为数组并弹出最后一项

function getLastItem(_set) {
    return [..._set].pop();
}

要获取键/值等，您可以执行以下操作

return [..._set.entries()].pop(); // the entire entry
return [..._set.keys()].pop();    // the key only
return [..._set.values()].pop();  // the value only

如果你不想创建一个数组，你可能需要迭代并得到最后一个值，如下所示

var last; s.forEach(k => { last = k }); // last === "Beta"

FIDDLE

只是另一种方法。

Set.prototype.last = function(){
  return new Set().add( [...this].pop() );
}

Set.prototype.lastKey = function(){
  return [...this.keys()].pop();
}

Set.prototype.lastValue = function(){
  return [...this.values()].pop();
}

var lastSet = s.last(); // "Beta"
var lastKey = s.lastKey(); // "Beta"
var lastValue = s.lastValue(); //  "Beta"

我已经创建了Set的替代品，它使用底层Map重新实现集合的链接功能。

class LinkedSetLink {
  constructor(value) {
    this.value = value;
    this.prev = this;
    this.next = this;
  }
  
  insertBefore(item) {
    const prev = item.prev = this.prev;
    const next = item.next = this;
    next.prev = item;
    prev.next = item;
  }
  
  remove() {
    const prev = this.prev;
    const next = this.next;
    next.prev = prev;
    prev.next = next;
  }
}


class LinkedSet {
  constructor(iterable) {
    this._map = new Map();
    this._pivot = new LinkedSetLink(/* undefined */);
    if (iterable) {
      this._addAll(iterable);
    }
  }

  _addAll(iterable) {
    for (const item of iterable) {
      this.add(item);
    }
  }

  has(item) {
    return this._map.has(item);
  }

  add(item) {
    if (!this._map.has(item)) {
      const link = new LinkedSetLink(item);
      this._pivot.insertBefore(link);
      this._map.set(item, link);
    }
  }

  delete(item) {
    const link = this._map.get(item);
    if (link) {
      this._map.delete(item);
      link.remove();
    }
  }

  clear() {
    this._map.clear();
    this._pivot.next = this._pivot.prev = this._pivot;
  }

  get size() {
    return this._map.size;
  }

  values() {
    return this._map.keys();
  }

  keys() {
    return this.values();
  }

  [Symbol.iterator]() {
    return this.values();
  }

  *entries() {
    for (const key of this.values()) {
      yield [key, key];
    }
  }

  first() {
    return this._pivot.next.value;
  }

  last() {
    return this._pivot.prev.value;
  }
}

function test1() {
  console.log(Array.from(new LinkedSet(["a", "b", "c"]).entries()));
}
function test2() {
  console.log(new LinkedSet(["a", "b", "c"]).last());
}

<button onclick="test1()">test entries</button>
<button onclick="test2()">test last</button>

没有访问最后一项的方法，但您可以按如下所示进行访问

let setOfNumbers = new Set([10]);
setOfNumbers.add(20).add(2);
let lastValue = [...setOfNumbers].pop()

一个简单的解决方案，但O(N)：

const getLastValueFromSet = (set) => {
    for (var value of set);
    return value;
}