摘要：接口設(shè)計(jì)同樣實(shí)現(xiàn)了跟一致的數(shù)據(jù)管理接口，如下依賴源碼分析之緩存源碼分析之緩存源碼分析是否使用這個(gè)函數(shù)用來判斷是否使用緩存。返回表示使用緩存，返回則使用或者緩存。獲取對(duì)應(yīng)緩存方式的實(shí)例這個(gè)函數(shù)根據(jù)來獲取儲(chǔ)存了該的緩存實(shí)例。

每個(gè)人心里都有一團(tuán)火，路過的人只看到煙。
——《至愛梵高·星空之謎》

本文為讀 lodash 源碼的第八篇，后續(xù)文章會(huì)更新到這個(gè)倉庫中，歡迎 star：pocket-lodash

gitbook也會(huì)同步倉庫的更新，gitbook地址：pocket-lodash

在《lodash源碼分析之Hash緩存》和《lodash源碼分析之List緩存》介紹了 lodash 的兩種緩存方式，這兩種緩存方式都實(shí)現(xiàn)了和 Map 一致的數(shù)據(jù)管理接口，其中 List 緩存只在不支持 Map 的環(huán)境中使用，那何時(shí)使用 Hash 緩存，何時(shí)使用 Map 或者 List 緩存呢？這就是 MapCache 類所需要做的事情。

從之前的分析可以看出，Hash 緩存完全可以用 List 緩存或者 Map 來代替，為什么 lodash 不干脆統(tǒng)一用一種緩存方式呢？

原因是在數(shù)據(jù)量較大時(shí)，對(duì)象的存取比 Map 或者數(shù)組的性能要好。

因此，ladash 在能夠用 Hash 緩存時(shí)，都盡量使用 Hash 緩存，而能否使用 Hash 緩存的關(guān)鍵是 key 的類型。

以下便為 lodash 決定使用緩存方式的流程：

首先，判斷 key 的類型，以是否為 string/number/symbol/boolean 類型為成兩撥，如果是以上的類型，再判斷 key 是否等于 __proto__ ，如果不是 __proto__ ，則使用 Hash 緩存。不能為 __proto__ 的原因是，大部分 JS 引擎都以這個(gè)屬性來保存對(duì)象的原型。

如果不是以上的類型，則判斷 key 是否為 null，如果為 null ，則依然使用 Hash 緩存，其余的則使用 Map 或者 List 緩存。

從上面的流程圖還可以看到，在可以用 Hash 來緩存的 key 中，還以是否為 string 類型分成了兩個(gè) Hash 對(duì)象來緩存數(shù)據(jù)，為什么要這樣呢？

我們都知道，對(duì)象的 key 如果不是字符串或者 Symbol 類型時(shí)，會(huì)轉(zhuǎn)換成字符串的形式，因此如果緩存的數(shù)據(jù)中同時(shí)存在像數(shù)字 1 和字符串 "1" 時(shí)，數(shù)據(jù)都會(huì)儲(chǔ)存在字符串 "1" 上。這兩個(gè)不同的鍵值，最后獲取的都是同一份數(shù)據(jù)，這明顯是不行的，因此需要將要字符串的 key 和其他需要轉(zhuǎn)換類型的 key 分開兩個(gè) Hash 對(duì)象儲(chǔ)存。

MapCache 所做的事情有點(diǎn)像函數(shù)重載，其調(diào)用方式和 Hash 、Map 及 ListCache 一致。

new MapCache([
  ["key", "value"],
  [{key: "An Object Key"}, 1],
  [Symbol(),2]
])

所返回的結(jié)果如下：

{
  size: 3,
  __data__: {
    string: {
      ... 
    },
    hash: {
      ...
    },
    map: {
      ...  
    }
  }
}

可以看到，__data__ 里根據(jù) key 的類型分成了 string 、hash 和 map 三種類型來儲(chǔ)存數(shù)據(jù)。其中 string 和 hash 都是 Hash 的實(shí)例，而 map 則是 map 或 ListCache 的實(shí)例。

MapCache 同樣實(shí)現(xiàn)了跟 Map 一致的數(shù)據(jù)管理接口，如下：

import Hash from "./Hash.js"
import ListCache from "./ListCache.js"

《lodash源碼分析之Hash緩存》

《lodash源碼分析之List緩存》

function getMapData({ __data__ }, key) {
  const data = __data__
  return isKeyable(key)
    ? data[typeof key == "string" ? "string" : "hash"]
    : data.map
}

function isKeyable(value) {
  const type = typeof value
  return (type == "string" || type == "number" || type == "symbol" || type == "boolean")
    ? (value !== "__proto__")
    : (value === null)
}

class MapCache {

  constructor(entries) {
    let index = -1
    const length = entries == null ? 0 : entries.length

    this.clear()
    while (++index < length) {
      const entry = entries[index]
      this.set(entry[0], entry[1])
    }
  }

  clear() {
    this.size = 0
    this.__data__ = {
      "hash": new Hash,
      "map": new (Map || ListCache),
      "string": new Hash
    }
  }

  delete(key) {
    const result = getMapData(this, key)["delete"](key)
    this.size -= result ? 1 : 0
    return result
  }

  get(key) {
    return getMapData(this, key).get(key)
  }

  has(key) {
    return getMapData(this, key).has(key)
  }

  set(key, value) {
    const data = getMapData(this, key)
    const size = data.size

    data.set(key, value)
    this.size += data.size == size ? 0 : 1
    return this
  }
}

function isKeyable(value) {
  const type = typeof value
  return (type == "string" || type == "number" || type == "symbol" || type == "boolean")
    ? (value !== "__proto__")
  : (value === null)
}

這個(gè)函數(shù)用來判斷是否使用 Hash 緩存。返回 true 表示使用 Hash 緩存，返回 false 則使用 Map 或者 ListCache 緩存。

這個(gè)在流程圖上已經(jīng)解釋過，不再作詳細(xì)的解釋。

function getMapData({ __data__ }, key) {
  const data = __data__
  return isKeyable(key)
    ? data[typeof key == "string" ? "string" : "hash"]
    : data.map
}

這個(gè)函數(shù)根據(jù) key 來獲取儲(chǔ)存了該 key 的緩存實(shí)例。

__data__ 即為 MapCache 實(shí)例中的 __data__ 屬性的值。

如果使用的是 Hash 緩存，則類型為字符串時(shí)，返回 __data__ 中的 string 屬性的值，否則返回 hash 屬性的值。這兩者都為 Hash 實(shí)例。

否則返回 map 屬性的值，這個(gè)可能是 Map 實(shí)例或者 ListCache 實(shí)例。

constructor(entries) {
  let index = -1
  const length = entries == null ? 0 : entries.length

  this.clear()
  while (++index < length) {
    const entry = entries[index]
    this.set(entry[0], entry[1])
  }
}

構(gòu)造器跟 Hash 和 ListCache 一模一樣，都是先調(diào)用 clear 方法，然后調(diào)用 set 方法，往緩存中加入初始數(shù)據(jù)。

clear() {
  this.size = 0
  this.__data__ = {
    "hash": new Hash,
    "map": new (Map || ListCache),
    "string": new Hash
  }
}

clear 是為了清空緩存。

這里值得注意的是 __data__ 屬性，使用 hash 、string 和 map 來保存不同類型的緩存數(shù)據(jù)，它們之間的區(qū)別上面已經(jīng)論述清楚。

這里也可以清晰地看到，如果在支持 Map 的環(huán)境中，會(huì)優(yōu)先使用 Map ，而不是 ListCache。

has(key) {
  return getMapData(this, key).has(key)
}

has 用來判斷是否已經(jīng)有緩存數(shù)據(jù)，如果緩存數(shù)據(jù)已經(jīng)存在，則返回 true 。

這里調(diào)用了 getMapData 方法，獲取到對(duì)應(yīng)的緩存實(shí)例（Hash 、Map 或者 ListCache 的實(shí)例），然后調(diào)用的是對(duì)應(yīng)實(shí)例中的 has 方法。

set(key, value) {
  const data = getMapData(this, key)
  const size = data.size

  data.set(key, value)
  this.size += data.size == size ? 0 : 1
  return this
}

set 用來增加或者更新需要緩存的值。set 的時(shí)候需要同時(shí)維護(hù) size 和緩存的值。

這里除了調(diào)用對(duì)應(yīng)的緩存實(shí)例的 set 方法來維護(hù)緩存的值外，還需要維護(hù)自身的 size 屬性，如果增加值，則加 1 。

get(key) {
  return getMapData(this, key).get(key)
}

get 方法是從緩存中取值。

同樣是調(diào)用對(duì)應(yīng)的緩存實(shí)例中的 get 方法。

delete(key) {
  const result = getMapData(this, key)["delete"](key)
  this.size -= result ? 1 : 0
  return result
}

delete 方法用來刪除指定 key 的緩存。成功刪除返回 true， 否則返回 false。 刪除操作同樣需要維護(hù) size 屬性。

同樣是調(diào)用對(duì)應(yīng)緩存實(shí)例中的 delete 方法，如果刪除成功，則需要將自身的 size 的值減少 1 。

署名-非商業(yè)性使用-禁止演繹 4.0 國(guó)際 (CC BY-NC-ND 4.0)

最后，所有文章都會(huì)同步發(fā)送到微信公眾號(hào)上，歡迎關(guān)注,歡迎提意見：

作者：對(duì)角另一面