题目描述：

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例:

  1. LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );
  3. cache.put(1, 1);
  4. cache.put(2, 2);
  5. cache.get(1);       // 返回  1
  6. cache.put(3, 3);    // 该操作会使得密钥 2 作废
  7. cache.get(2);       // 返回 -1 (未找到)
  8. cache.put(4, 4);    // 该操作会使得密钥 1 作废
  9. cache.get(1);       // 返回 -1 (未找到)
  10. cache.get(3);       // 返回  3
  11. cache.get(4);       // 返回  4

算法实现：

  1. /**
  2.  * @param {number} capacity
  3.  */
  4. var LRUCache = function(capacity) {
  5.     this.cache = new Map()
  6.     this.capacity = capacity
  7. };
  9. /** 
  10.  * @param {number} key
  11.  * @return {number}
  12.  */
  13. LRUCache.prototype.get = function(key) {
  14.     var cache = this.cache
  15.     if (cache.has(key)) {
  16.         var temp = cache.get(key)
  17.         cache.delete(key)
  18.         cache.set(key, temp)
  19.         return temp
  20.     } else {
  21.         return -1
  22.     }
  23. };
  25. /** 
  26.  * @param {number} key 
  27.  * @param {number} value
  28.  * @return {void}
  29.  */
  30. LRUCache.prototype.put = function(key, value) {
  31.     var cache = this.cache
  32.     if (cache.has(key)) {
  33.         cache.delete(key)
  34.     } else if (cache.size >= this.capacity) {
  35.         cache.delete(cache.keys().next().value)
  36.     }
  37.     cache.set(key, value)
  38. };
  40. /** 
  41.  * Your LRUCache object will be instantiated and called as such:
  42.  * var obj = new LRUCache(capacity)
  43.  * var param_1 = obj.get(key)
  44.  * obj.put(key,value)
  45.  */

思考：

运用了es6的Map方法，很精妙，Map本身是键值对的集合，又可以用方法来添加和删除键值对，对于这道题很契合。

总结：

好久没有看es6了，发现有好多不常用的东西又忘的差不多了，做了这道题又重新看了一下阮一峰的set与map数据结构，受益颇深，这段时间打算再看一遍es6，温故而知新。