日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關(guān)咨詢(xún)
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時(shí)間：8:30-17:00
你可能遇到了下面的問(wèn)題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營(yíng)銷(xiāo)解決方案
從Chrome源碼看JS Object的實(shí)現(xiàn)

看到這個(gè)題目，可能有些人會(huì)覺(jué)得奇怪——Object不是JS的基本數(shù)據(jù)類(lèi)型么，有什么實(shí)現(xiàn)不實(shí)現(xiàn)的呢?如果你這么想的話，說(shuō)明你沒(méi)有接觸過(guò)其它語(yǔ)言，一直都是在和JS打交道，編程世界那么大，你沒(méi)有出去看一看。C/C++/Java等語(yǔ)言是沒(méi)有這種json的數(shù)據(jù)類(lèi)型的，其它一些有的：如在Pthyon里面叫做字典，在Ruby/Perl里面叫散列表，當(dāng)然這只是個(gè)名稱(chēng)而已，本質(zhì)上可以當(dāng)作json類(lèi)型。而C是“萬(wàn)物之母”，C里面沒(méi)有的，就得通過(guò)某種方式實(shí)現(xiàn)。

成都創(chuàng)新互聯(lián)公司2013年開(kāi)創(chuàng)至今，先為丹江口等服務(wù)建站，丹江口等地企業(yè)，進(jìn)行企業(yè)商務(wù)咨詢(xún)服務(wù)。為丹江口企業(yè)網(wǎng)站制作PC+手機(jī)+微官網(wǎng)三網(wǎng)同步一站式服務(wù)解決您的所有建站問(wèn)題。

并且JS里面的Object是如何查找屬性的，這個(gè)問(wèn)題有人說(shuō)是通過(guò)遍歷key的字符串查找的，也有人說(shuō)是通過(guò)哈希查找的。究竟它是怎么存儲(chǔ)和查找的，能不能把Object當(dāng)作一個(gè)map來(lái)使用?如果無(wú)法從源碼的角度實(shí)際地看一下瀏覽器的實(shí)現(xiàn)，你的觀點(diǎn)可能就站不住腳，只能人云亦云。

Chrome自行開(kāi)發(fā)了V8引擎，并被Node拿去當(dāng)解析器。本文將通過(guò)V8的源碼嘗試分析Object的實(shí)現(xiàn)。

1. V8的代碼結(jié)構(gòu)

v8的源碼位于 src/v8/src/ ，代碼層級(jí)相對(duì)比較簡(jiǎn)單，但是實(shí)現(xiàn)比較復(fù)雜，為了能看懂，需要找到一個(gè)切入點(diǎn)，通過(guò)打斷點(diǎn)、加log等方式確定這個(gè)切入點(diǎn)是對(duì)的，如果這個(gè)點(diǎn)并不是關(guān)鍵的點(diǎn)，進(jìn)行到某一步的時(shí)候就斷了，那么由這個(gè)點(diǎn)出發(fā)嘗試去找其它的點(diǎn)。不斷驗(yàn)證，***找到一個(gè)最關(guān)鍵的地方，由這個(gè)地方由淺入深地?cái)U(kuò)展到其它地方，***形成一個(gè)體系。

以下，先說(shuō)明JS Object的類(lèi)圖。

2. JS Object類(lèi)圖

V8里面所有的數(shù)據(jù)類(lèi)型的根父類(lèi)都是Object，Object派生HeapObject，提供存儲(chǔ)基本功能，往下的JSReceiver用于原型查找，再往下的JSObject就是JS里面的Object，Array/Function/Date等繼承于JSObject。左邊的FixedArray是實(shí)際存儲(chǔ)數(shù)據(jù)的地方。

3. 創(chuàng)建JSObject

在創(chuàng)建一個(gè)JSObject之前，會(huì)先把讀到的Object的文本屬性序列化成 constant_properties ，如下的data：

 
 
 
 
      
  
  
  
  1. var data = {  
    2.   
  
  
  
  2. name: "yin",  
    3.   
  
  
  
  3. age: 18,  
    4.   
  
  
  
  4. "-school-": "high school"  
    5.   
  
  
  
  5. }; 
    6.

會(huì)被序列成：

 
 
 
 
      
  
  
  
  1. ../../v8/src/runtime/runtime-literals.cc 72 constant_properties:  
    2.   
  
  
  
  2. 0xdf9ed2aed19: [FixedArray]  
    3.   
  
  
  
  3. – length: 6  
    4.   
  
  
  
  4. [0]: 0x1b5ec69833d1  
    5.   
  
  
  
  5. [1]: 0xdf9ed2aec51  
    6.   
  
  
  
  6. [2]: 0xdf9ed2aec71  
    7.   
  
  
  
  7. [3]: 18  
    8.   
  
  
  
  8. [4]: 0xdf9ed2aec91  
    9.   
  
  
  
  9. [5]: 0xdf9ed2aecb1  
    10.

它是一個(gè)FixedArray，一共有6個(gè)元素，由于data總共是有3個(gè)屬性，每個(gè)屬性有一個(gè)key和一個(gè)value，所以Array就有6個(gè)。***個(gè)元素是***個(gè)key，第二個(gè)元素是***個(gè)value，第三個(gè)元素是第二個(gè)key，第四個(gè)元素是第二個(gè)key，依次類(lèi)推。Object提供了一個(gè)Print()的函數(shù)，把它用來(lái)打印對(duì)象的信息非常有幫助。上面的輸出有兩種類(lèi)型的數(shù)據(jù)，一種是String類(lèi)型，第二種是整型類(lèi)型的。

FixedArray是V8實(shí)現(xiàn)的一個(gè)類(lèi)似于數(shù)組的類(lèi)，它表示一段連續(xù)的內(nèi)存，上面的FixedArray的length = 6，那么它占的內(nèi)存大小將是：

 
 
 
 
      
  
  
  
  1. length * kPointerSize 
    2.

因?yàn)樗娴亩际菍?duì)象的指針(或者直接是整型數(shù)據(jù)類(lèi)型，如上面的18)，在64位的操作系統(tǒng)上，一個(gè)指針為8個(gè)字節(jié)，它的大小將是48個(gè)字節(jié)。它記錄了一個(gè)初始的內(nèi)存開(kāi)始地址，使用元素index乘以指針大小作為偏移，加上開(kāi)始地址，就可以取到相應(yīng)index的元素，這和數(shù)組是一樣的道理。只是V8自己封裝了一個(gè)，方便添加一些自定義的函數(shù)。

FixedArray主要用于表示數(shù)據(jù)的存儲(chǔ)位置，在它上面還有一個(gè)Map，這個(gè)Map用于表示數(shù)據(jù)的結(jié)構(gòu)。這里的Map并不是哈希的意思，更接近于地圖的意義，用來(lái)操作FixedArray表示的這段內(nèi)存。V8根據(jù) constant_properties的 length，去開(kāi)辟相應(yīng)大小空間的Map：

 
 
 
 
      
  
  
  
  1. Handle map = ComputeObjectLiteralMap(context, constant_properties,  
    2.   
  
  
  
  2. &is_result_from_cache); 
    3.

把這個(gè)申請(qǐng)后的Map打印出來(lái)：

 
 
 
 
      
  
  
  
  1. ../../v8/src/heap/heap.cc 3472 map is  
    2.   
  
  
  
  2. 0x21528af9cb39: [Map]  
    3.   
  
  
  
  3. – type: JS_OBJECT_TYPE  
    4.   
  
  
  
  4. – instance size: 48  
    5.   
  
  
  
  5. – inobject properties: 3  
    6.   
  
  
  
  6. – back pointer: 0x3e2ca8902311  
    7.   
  
  
  
  7. – instance descriptors (own) #0: 0x3e2ca8902231  
    8.

從第4行加粗字體可以看到，它的大小確實(shí)和我們算的一樣。并且它還有一個(gè)叫做descriptors表示它的數(shù)據(jù)結(jié)構(gòu)。descriptor記錄了每個(gè)key-value對(duì)，以及它們?cè)贔ixedArray里面的index. 后續(xù)對(duì)properties的操作基本上通過(guò)descriptor進(jìn)行。

有了這個(gè)map的對(duì)象之后，用它來(lái)創(chuàng)建一個(gè)JSObect：

 
 
 
 
      
  
  
  
  1. Handle boilerplate =  
    2.   
  
  
  
  2. isolate->factory()->NewJSObjectFromMap(map, pretenure_flag); 
    3.

重新開(kāi)辟一段內(nèi)存，把map的內(nèi)容拷過(guò)去。

由于map只是一段相應(yīng)大小的內(nèi)存空間，它的內(nèi)容是空的，所以接下來(lái)要設(shè)置它的properties：

 
 
 
 
      
  
  
  
  1. for (int index = 0; index < length; index += 2) { 
    2.   
  
  
  
  2.   Handle key(constant_properties->get(index + 0));   
  
  
  
  3.   Handle value(constant_properties->get(index + 1));   
  
  
  
  4.   Handle name = Handle::cast(key); 
    5.   
  
  
  
  5.   JSObject::SetOwnPropertyIgnoreAttributes(boilerplate, name, 
    6.   
  
  
  
  6.                                           value, NONE); 
    7.   
  
  
  
  7. } 
    8.  
 
 

    通過(guò)上面的代碼，把properties設(shè)置到map的FixedArray里面，并且可以通過(guò)index用descriptors迅速地取出key-value。由于這個(gè)過(guò)程比較復(fù)雜，細(xì)節(jié)不展開(kāi)討論。
    在設(shè)置properties的同時(shí)，會(huì)初始化一個(gè)searchCache，這個(gè)cache支持哈希查找某個(gè)屬性。
    4. 字符串哈希查找
    在設(shè)置cache的時(shí)候，會(huì)先進(jìn)行查找是否已存在相同的屬性名，如果已經(jīng)有了就把它的value值覆蓋掉，否則把它添加到cache里面：
     
 
 
 
        
  
  
  
    1. int DescriptorArray::SearchWithCache(Isolate* isolate, Name* name, Map* map) { 
      2.   
  
  
  
    2.   DescriptorLookupCache* cache = isolate->descriptor_lookup_cache(); 
      3.   
  
  
  
    3.   //找到它的index 
      4.   
  
  
  
    4.   int number = cache->Lookup(map, name); 
      5.   
  
  
  
    5.   //如果沒(méi)有的話 
      6.   
  
  
  
    6.   if (number == DescriptorLookupCache::kAbsent) { 
      7.   
  
  
  
    7.     //通過(guò)遍歷找到它的index 
      8.   
  
  
  
    8.     number = Search(name, number_of_own_descriptors); 
      9.   
  
  
  
    9.     //更新cache 
      10.   
  
  
  
    10.     cache->Update(map, name, number); 
      11.   
  
  
  
    11.   } 
      12.   
  
  
  
    12.   return number; 
      13.   
  
  
  
    13. } 
      14.  
 
 

    如上代碼的注釋?zhuān)覀兿葋?lái)看一下這個(gè)Search函數(shù)是怎么進(jìn)行的：
     
 
 
 
        
  
  
  
    1. template  
      2.   
  
  
  
    2. int Search(T* array, Name* name, int valid_entries, int* out_insertion_index) { 
      3.   
  
  
  
    3.   // Fast case: do linear search for small arrays. 
      4.   
  
  
  
    4.   const int kMaxElementsForLinearSearch = 8; 
      5.   
  
  
  
    5.   if (valid_entries <= kMaxElementsForLinearSearch) { 
      6.   
  
  
  
    6.     return LinearSearch(array, name, valid_entries, 
      7.   
  
  
  
    7.                                     out_insertion_index); 
      8.   
  
  
  
    8.   }   
      9.   
  
  
  
    9.   // Slow case: perform binary search. 
      10.   
  
  
  
    10.   return BinarySearch(array, name, valid_entries, 
      11.   
  
  
  
    11.                                   out_insertion_index); 
      12.   
  
  
  
    12. } 
      13.  
 
 

    如果屬性少于等于8個(gè)時(shí)，則直接線性查找即依次遍歷，否則進(jìn)行二分查找，在線性查找里面判斷是否相等，是用的內(nèi)存地址比較：
     
 
 
 
        
  
  
  
    1. for (int number = 0; number < valid_entries; number++) { 
      2.   
  
  
  
    2.   if (array->GetKey(number) == name) return number; 
      3.   
  
  
  
    3. } 
      4.  
 
 

    因?yàn)閚ame都是用的上面第三點(diǎn)設(shè)置Map的時(shí)候傳進(jìn)來(lái)的name，因此初始化的時(shí)候相同的name都指向同一個(gè)對(duì)象。所以可以直接用內(nèi)存地址進(jìn)行比較，得到FixedArray的索引number。然后用key和number去update cache：
     
 
 
 
        
  
  
  
    1. cache->Update(map, name, number); 
      2.  
 
 

    重點(diǎn)在于這個(gè)update cache。這個(gè)cache的數(shù)據(jù)結(jié)構(gòu)是這樣的：
     
 
 
 
        
  
  
  
    1. static const int kLength = 64;  
      2.   
  
  
  
    2. struct Key {  
      3.   
  
  
  
    3. Map* source;  
      4.   
  
  
  
    4. Name* name;  
      5.   
  
  
  
    5. };  
      6.   
  
  
  
    6. Keykeys_[kLength];  
      7.   
  
  
  
    7. int results_[kLength]; 
      8.  
 
 

    它有一個(gè)數(shù)組keys_的成員變量存放key，這個(gè)數(shù)組的大小是64，數(shù)組的索引用哈希算出來(lái)，不同的key有不同的哈希，這個(gè)哈希就是它在數(shù)組里面的索引。它還有一個(gè)results_，存放上面線性查找出來(lái)的number，這個(gè)number就是內(nèi)存里面的偏移，有了這個(gè)偏移就可以很快地定位到它的內(nèi)容，所以放到results里面.
    關(guān)鍵在于這個(gè)哈希是怎么算的。來(lái)看一下update的函數(shù)：
     
 
 
 
        
  
  
  
    1. void DescriptorLookupCache::Update(Map* source, Name* name, int result) { 
      2.   
  
  
  
    2.   int index = Hash(source, name); 
      3.   
  
  
  
    3.   Key& key = keys_[index]; 
      4.   
  
  
  
    4.   key.source = source; 
      5.   
  
  
  
    5.   key.name = name; 
      6.   
  
  
  
    6.   results_[index] = result; 
      7.   
  
  
  
    7. } 
      8.  
 
 

    先計(jì)算哈希索引index，然后把數(shù)據(jù)存到results_和keys_這兩個(gè)數(shù)組的index位置。這個(gè)Hash函數(shù)是這樣的：
     
 
 
 
        
  
  
  
    1. int DescriptorLookupCache::Hash(Object* source, Name* name) { 
      2.   
  
  
  
    2.   // Uses only lower 32 bits if pointers are larger. 
      3.   
  
  
  
    3.   uint32_tsource_hash = 
      4.   
  
  
  
    4.       static_cast(reinterpret_cast(source)) >> 
      5.   
  
  
  
    5.       kPointerSizeLog2; 
      6.   
  
  
  
    6.   uint32_tname_hash = name->hash_field(); 
      7.   
  
  
  
    7.   return (source_hash ^ name_hash) % kLength; 
      8.   
  
  
  
    8. } 
      9.  
 
 

     
    先計(jì)算map和key的hash，map的hash即source_hash是用map的地址的低32位，為了統(tǒng)一不同指針大小的區(qū)別，而計(jì)算key的hash即name_hash，最核心的代碼應(yīng)該是以下幾行：
     
 
 
 
        
  
  
  
    1. uint32_tStringHasher::AddCharacterCore(uint32_trunning_hash, uint16_t c) {  
      2.   
  
  
  
    2. running_hash += c;  
      3.   
  
  
  
    3. running_hash += (running_hash << 10);  
      4.   
  
  
  
    4. running_hash ^= (running_hash >> 6);  
      5.   
  
  
  
    5. return running_hash;  
      6.   
  
  
  
    6. } 
      7.  
 
 

    依次循環(huán)name的每個(gè)字符串做一些位運(yùn)算，結(jié)果累計(jì)給running_hash.
    source_hash是用map的內(nèi)存地址，因?yàn)檫@個(gè)地址是唯一的，而name_hash是用的字符串的內(nèi)容，只要字符串一樣，那么它的hash值就一定一樣，這樣保證了同一個(gè)object，它的同個(gè)key值的索引值就一定一樣。source_hash和name_hash***異或一下，模以kLength = 64得到它在數(shù)組里面的索引。
    這里自然而然會(huì)有一個(gè)問(wèn)題，通過(guò)這樣的計(jì)算不能夠保證不同的name計(jì)算出來(lái)的哈希值一定不一樣，好的哈希算法只能讓結(jié)果盡可能隨機(jī)，但是無(wú)法做到一定不重復(fù)，所以這里也有同樣的問(wèn)題。
    先來(lái)看一下，它是怎么查找的：
     
 
 
 
        
  
  
  
    1. int DescriptorLookupCache::Lookup(Map* source, Name* name) {  
      2.   
  
  
  
    2. int index = Hash(source, name);  
      3.   
  
  
  
    3. Key& key = keys_[index];  
      4.   
  
  
  
    4. if ((key.source == source) && (key.name == name)) return results_[index];  
      5.   
  
  
  
    5. return kAbsent;  
      6.   
  
  
  
    6. } 
      7.  
 
 

    先用同樣的哈希算法，算出同樣的index，取出key里面的map和name，和存儲(chǔ)的map和name進(jìn)行比較，如果相同則說(shuō)明找到了，否則的話返回不存在-1的標(biāo)志。一旦不存在了又會(huì)執(zhí)行上面的update cache，先調(diào)Search找到它的偏移index作為result，如果index存在重新update cache。所以上面的問(wèn)題就可以得到解答了，重復(fù)的哈希索引覆蓋了***個(gè)，導(dǎo)致查找***個(gè)的時(shí)候沒(méi)找找到，所以又去重新update，把那個(gè)索引值的數(shù)組元素又改成了***個(gè)的。因此，如果兩個(gè)重復(fù)的元素如果循環(huán)輪流訪問(wèn)的話，就會(huì)造成不斷地查找index，不斷地更新搜索cache。但是這種情況還是比較少的。
    如何保證傳進(jìn)來(lái)的具有相同字符串的name和原始的name是同一個(gè)對(duì)象，從而才能使它們的內(nèi)存地址一樣?一個(gè)辦法是維護(hù)一個(gè)Name的數(shù)據(jù)池，據(jù)有相同字符串的name只能存在一個(gè)。
    上面的那個(gè)data它的三個(gè)name的index在筆者電腦上實(shí)驗(yàn)計(jì)算結(jié)果為：
    • #name hash index = 62
    • #age hash index = 32
    • #-school- hash index = 51
    有一個(gè)比較奇怪的地方是重復(fù)實(shí)驗(yàn)，它們的哈希值都是一樣的。并且具有相同屬性且順序也相同的object，它們的map地址就是一樣的。
    如果一個(gè)元素的屬性值超過(guò)64個(gè)呢?那也是同樣的處理，后面設(shè)置的會(huì)覆蓋前面設(shè)置的。學(xué)過(guò)哈希的都知道，當(dāng)元素的個(gè)數(shù)大于容器容量的一半時(shí)，重復(fù)的概率將會(huì)大大增加。所以一個(gè)object的屬性的比較優(yōu)的***大小為32。一旦超過(guò)32，在一個(gè)：
     
 
 
 
        
  
  
  
    1. for(var keyin obj){  
      2.   
  
  
  
    2. obj[key] //do sth.  
      3.   
  
  
  
    3. } 
      4.  
 
 

    for循環(huán)里面，這種查找的開(kāi)銷(xiāo)將會(huì)很大。
    那為什么它要把長(zhǎng)度設(shè)置成64呢，如果改大了，不就可以減少重復(fù)率?但是這樣會(huì)造成更多的內(nèi)存消耗，即使一個(gè)Object只有一個(gè)屬性，它也會(huì)初始化一個(gè)這么大的數(shù)組，對(duì)于這種屬性比較少的object來(lái)說(shuō)就很浪費(fèi)。所以取64，應(yīng)該是一個(gè)比較適中的值。
    同時(shí)另一方面，經(jīng)常使用的那幾個(gè)屬性還是能夠很快通過(guò)哈希計(jì)算定位到它的內(nèi)容。并且這種場(chǎng)景還是很常見(jiàn)的，如獲取數(shù)組元素的lengh.
    根據(jù)上面的討論，將Object當(dāng)作map來(lái)使用，并不是很合適，在如下的代碼里面：
     
 
 
 
        
  
  
  
    1. var data = [10001, 10002/* 很多個(gè)元素 */]; 
      2.   
  
  
  
    2. var keys = { 
      3.   
  
  
  
    3.     "1000a": '' 
      4.   
  
  
  
    4.     "1000b": '' 
      5.   
  
  
  
    5.     /* 很多個(gè)屬性 */ 
      6.   
  
  
  
    6. } 
      7.   
  
  
  
    7. var exists = []; 
      8.   
  
  
  
    8. for(var i = 0; i < data.length; i++){ 
      9.   
  
  
  
    9.     if(typeof keys[data[i]] !== "undefined"){ 
      10.   
  
  
  
    10.         exists.push(data[i]); 
      11.   
  
  
  
    11.     } 
      12.   
  
  
  
    12. } 
      13.  
 
 

    由于在keys查找時(shí)，可能會(huì)存在大量沒(méi)有的元素，這樣就導(dǎo)致它哈希查找沒(méi)有找到，然后需要進(jìn)行線性查找/二分查找，結(jié)果也沒(méi)找到。所以它和哈希map還是有很多的差別的。這樣的效率雖然比不上直接使用一個(gè)哈希map，但至少它的效率要比寫(xiě)一個(gè)數(shù)組，然后一個(gè)個(gè)去比較來(lái)得高效，怎么說(shuō)它還是用的內(nèi)存地址進(jìn)行二分查找。
    這里就體現(xiàn)了ES6新增了Map/Set類(lèi)型的價(jià)值，它是一個(gè)真正的哈希Map。如果不能使用ES6的map，那么自行實(shí)現(xiàn)一個(gè)或者使用第三方的庫(kù)也是可取的。
    在說(shuō)Map之前，Object還有數(shù)字類(lèi)型的屬性沒(méi)有討論。
    5. 數(shù)字索引哈希查找
    假設(shè)data變成：
     
 
 
 
        
  
  
  
    1. var data = { 
      2.   
  
  
  
    2.        name: "yin", 
      3.   
  
  
  
    3.        age: 18, 
      4.   
  
  
  
    4.        "-school-": "high school", 
      5.   
  
  
  
    5.        1: "Monday", 
      6.   
  
  
  
    6.        2: "Thuesday", 
      7.   
  
  
  
    7.        "3": "Wednesday" 
      8.   
  
  
  
    8.    }; 
      9.  
 
 

    把生成的data Object打印出來(lái)是這樣的：
     
 
 
 
        
  
  
  
    1. ../../v8/src/runtime/runtime-literals.cc 105 boilerplate obj:  
      2.   
  
  
  
    2. 0x3930221af3a9: [JS_OBJECT_TYPE]  
      3.   
  
  
  
    3. – map = 0x6712e19cc41 [FastProperties]  
      4.   
  
  
  
    4. – prototype = 0x27d71d20f19  
      5.   
  
  
  
    5. – elements = 0x2e1e1a56b579 [FAST_HOLEY_ELEMENTS]  
      6.   
  
  
  
    6. – properties = 0x2c2a4d782241 {  
      7.   
  
  
  
    7. #name: 0x3930221aec51 (data field at offset 0)  
      8.   
  
  
  
    8. #age: 18 (data field at offset 1)  
      9.   
  
  
  
    9. #-school-: 0x3930221aecb1 (data field at offset 2)  
      10.   
  
  
  
    10. }  
      11.   
  
  
  
    11. – elements = {  
      12.   
  
  
  
    12. 0: 0x2c2a4d782351  
      13.   
  
  
  
    13. 1: 0x3930221aecf9  
      14.   
  
  
  
    14. 2: 0x3930221aed39  
      15.   
  
  
  
    15. 3: 0x3930221aed79 
      16.   
  
  
  
    16. 4-18: 0x2c2a4d782351  
      17.   
  
  
  
    17. } 
      18.  
 
 

    那些key為數(shù)字的存放在elements的數(shù)據(jù)結(jié)構(gòu)里面，elements和properties的區(qū)別在于——elements有獨(dú)立的一個(gè)哈希表，并且它不是覆蓋存放的，它會(huì)根據(jù)哈希值算元素的數(shù)組索引，判斷如果當(dāng)前索引已經(jīng)存在元素，則一直找到下一個(gè)空的位置來(lái)存放它：
     
 
 
 
        
  
  
  
    1. uint32_tcapacity = Capacity(); 
      2.   
  
  
  
    2.  uint32_tentry = FirstProbe(hash, capacity); 
      3.   
  
  
  
    3.  uint32_tcount = 1; 
      4.   
  
  
  
    4.  // EnsureCapacity will guarantee the hash table is never full. 
      5.   
  
  
  
    5.  while (true) { 
      6.   
  
  
  
    6.    Object* element = KeyAt(entry); 
      7.   
  
  
  
    7.    if (!IsKey(isolate, element)) break; 
      8.   
  
  
  
    8.    entry = NextProbe(entry, count++, capacity); 
      9.   
  
  
  
    9.  } 
      10.   
  
  
  
    10.  return entry; 
      11.  
 
 

    為什么數(shù)字的key要單獨(dú)這么搞呢?如果把它當(dāng)成一個(gè)字符串的key按上面字符串處理的邏輯也是行得通的。原因可能是一方面如果key是數(shù)字，那在在算哈希值可以做一個(gè)優(yōu)化，另一方面數(shù)字的key可能會(huì)有很多個(gè)就像上面提的例子，使用者可能把object當(dāng)作一個(gè)map來(lái)用，所以為它作一個(gè)優(yōu)化。
    可以說(shuō)elements幾乎是一個(gè)真正意義的哈希表。
    然后再來(lái)簡(jiǎn)單看一下ES6的Map的實(shí)現(xiàn)
    6. ES6 Map的實(shí)現(xiàn)
    這里有一個(gè)比較有趣的事情，就是V8的Map的核心邏輯是用JS實(shí)現(xiàn)的，具體文件是在 v8/src/js/collection.js ，用JS來(lái)實(shí)現(xiàn)JS，比寫(xiě)C++要高效多了，但是執(zhí)行效率可能就沒(méi)有直接寫(xiě)C++的高，可以來(lái)看一下set函數(shù)的實(shí)現(xiàn)：
     
 
 
 
        
  
  
  
    1. function MapSet(key, value) { 
      2.   
  
  
  
    2.   //添加一個(gè)log 
      3.   
  
  
  
    3.   %LOG("MapSet", key); 
      4.   
  
  
  
    4.   var table = %_JSCollectionGetTable(this); 
      5.   
  
  
  
    5.   var numBuckets = ORDERED_HASH_TABLE_BUCKET_COUNT(table); 
      6.   
  
  
  
    6.   var hash = GetHash(key); 
      7.   
  
  
  
    7.   var entry = MapFindEntry(table, numBuckets, key, hash); 
      8.   
  
  
  
    8.   if (entry !== NOT_FOUND) return ...//return代碼省略 
      9.   
  
  
  
    9.   //如果個(gè)數(shù)大于capacity的二分之一，則執(zhí)行%MapGrow(this)代碼略 
      10.   
  
  
  
    10.   FIXED_ARRAY_SET(table, index, key); 
      11.   
  
  
  
    11.   FIXED_ARRAY_SET(table, index + 1, value); 
      12.   
  
  
  
    12. } 
      13.  
 
 

    第三行添加一個(gè)log函數(shù)，確認(rèn)確實(shí)是執(zhí)行這里的代碼。%開(kāi)頭的LOG，表示它是一個(gè)C++的函數(shù)，這個(gè)代碼寫(xiě)在runtime.h和runtime.cc里面。這些JS代碼***會(huì)被組裝成native code。在V8里，除了Map/Set之外，很多ES6新加的功能，都是用的JS實(shí)現(xiàn)的，如數(shù)組新加的很多函數(shù)。
    上文介紹了Object是如何實(shí)現(xiàn)的，重點(diǎn)分析了V8是如何存儲(chǔ)一個(gè)Object的屬性，并用了一個(gè)真正的Map作為參照。***的結(jié)論是Object屬性主要是通過(guò)哈希查找的，但是它不太適合拿來(lái)當(dāng)作哈希Map使用，特別是當(dāng)key很多并且都是字符串的時(shí)候。
    其它的瀏覽器引擎可能會(huì)有不同的實(shí)現(xiàn)，但是至少不會(huì)笨到直接用key的字符串進(jìn)行遍歷。筆者將嘗試在下一篇介紹Array的實(shí)現(xiàn)，特別是分析一下它的操作函數(shù)是如何實(shí)現(xiàn)的。
                                                    
    
                                                本文題目：從Chrome源碼看JS Object的實(shí)現(xiàn)                                                
    
                                                轉(zhuǎn)載源于：http://www.5511xx.com/article/djsehpe.html