Web高级 JavaScript中的数据结构

复杂度分析

• 大O复杂度表示法
  常见的有O(1), O(n), O(logn), O(nlogn)
  时间复杂度除了大O表示法外,还有如下状况
• 最好状况时间复杂度
• 最坏状况时间复杂度
• 平均状况时间复杂度
• 均摊时间复杂度

代码执行效率分析

大多数状况下,代码执行的效率能够采用时间复杂度分析,可是大O表示法一般会省略常数。
可是在工业级实现中，真正的执行效率一般会考虑多方面：

• 时间复杂度
• 空间复杂度
• 缓存友好
• 指令条数
• 性能退化(如哈希冲突解决方案等)
• 等

以上是理论层级,对于前端开发来讲,若是你开发的是基础库会被普遍使用时,只是基于理论的分析是不够的。
此时就能够借助一些基准库来对你的模块进行测试: benchmark.js

数据结构

1. 数组

• 特色: 连续内存,支持下标访问,缓存友好,时间复杂度O(1)
  
• 深刻: 从JS继承链能够知道在JS中的Array数组继承于Object,在某些状况下数组会退化为哈希表结构[Dictionary]。
  
• 思考: 考虑以下状况,浏览器会怎样存储该数组?
  

let myArray = [10000];
myArray[0] = 0;
myArray[9999] = 1;

2. 链表

• 特色: 非连续内存,查找元素时间复杂度最坏状况O(n),最好状况O(1)。
  

1. 单向链表
2. 双向链表

• 深刻: 判断链表是否有环形?
  
• 使用一个步进为1,和一个额外的步进为2的参数,若是在遍历完以前相遇,则有环。

3. 栈

• 特色: 先进后出,后进先出,底层结构能够为数组或链表。
  
• 场景: 函数调用时对当前执行环境进行入栈操做,调用完成后出栈恢复调用前上下文。
  
• 深刻: 递归调用时连续入栈操做,若是递归层级过深形成堆栈溢出。
  好比AngularJS中的脏值检查嵌套深度上线为10。
  
• 思考: 浏览器的前进后退功能能否用栈实现？
  使前进栈和后退栈的双栈结构

4. 队列

• 特色: 先进先出,底层结构能够为数组或链表。
  

1. 无阻塞队列
   基于链表
2. 阻塞队列
   基于数组的循环队列
   深刻: JS中的Macro队列和Micro队列

5. 跳表

• 底层为链表,为了增长查找效率,在链表基础上,以(2/3/4/../n)个节点增长一层查找链表

• 特色: '支持区间查找',支持动态数据结构,须要额外的存储空间来存储索引链节点
• 时间复杂度: 基于链表的查找时间复杂度由跳表层高决定

• 场景: 如Redis中的有序集合

6. 散列表

• 底层为数组结构，使用散列函数计算key将其映射到数组中的下标位置。
  
• 散列函数要求:

1. 散列值为非负整数
2. key1 = key2, 则 hash(key1) = hash(key2)
3. key1 != key2, 则 hash(key1) != hash(key2)

• 常见的哈希算法有: MD5, SHA, CRC等。
• 散列冲突：

1. 开放寻址
   线性探测：散列冲突时,依次日后查找空闲
   双重散列: 使用多个散列函数,若是第一个散列值被占用,则用第二个散列值
2. 链表法
   散列冲突时,在一级数据后连接一个链表结构。该链表能够是单/双链,或树形链表

• 装载因子: 整个数组中已经被使用的位置/总位置
• 动态扩容: 当装载因子达到某个限定值(如:0.75)时，对整个底层数组进行扩容
  注: 工业级实现中,动态扩容并非一次完成的。
  一次完成的动态扩容会形成性能瓶颈,通常是在装载因子达到设定值时,申请一个新的数组。在后续的每次操做时,将一个数据从原数组搬到新数组，直到原数组为空。

JavaScript 对象数据结构

1. 我在另外一篇文章中有将到JS中的对象在底层存储的时候会有好几种模式，下面咱们结合源码来详细分析一下

//https://github.com/v8/v8/blob/master/src/objects/js-objects.h
// 咱们先来看JS中object的定义,继承自JSReceiver
// Line 278
class JSObject : public JSReceiver {
    //省略...
}

// Line 26
// 接下来再看,JSReceiver继承自HeapObject,而且有几个重要属性
// JSReceiver includes types on which properties can be defined, i.e.,
// JSObject and JSProxy.
class JSReceiver : public HeapObject {
 public:
  NEVER_READ_ONLY_SPACE
  // Returns true if there is no slow (ie, dictionary) backing store.
  // 是否有快速属性模式
  inline bool HasFastProperties() const;

  // Returns the properties array backing store if it exists. 
  // Otherwise, returns an empty_property_array when there's a Smi (hash code) or an empty_fixed_array for a fast properties map.
  // 属性数组
  inline PropertyArray property_array() const;

  // Gets slow properties for non-global objects.
  // 字典属性
  inline NameDictionary property_dictionary() const;

  // Sets the properties backing store and makes sure any existing hash is moved
  // to the new properties store. To clear out the properties store, pass in the
  // empty_fixed_array(), the hash will be maintained in this case as well.
  void SetProperties(HeapObject properties);

  // There are five possible values for the properties offset.
  // 1) EmptyFixedArray/EmptyPropertyDictionary - This is the standard
  // placeholder.
  //
  // 2) Smi - This is the hash code of the object.
  //
  // 3) PropertyArray - This is similar to a FixedArray but stores
  // the hash code of the object in its length field. This is a fast
  // backing store.
  //
  // 4) NameDictionary - This is the dictionary-mode backing store.
  //
  // 4) GlobalDictionary - This is the backing store for the
  // GlobalObject.

  // 初始化属性
  inline void initialize_properties();

1. 由上可知对象有快速属性和字典属性两种模式，快速属性由数组存储，字典属性采用hash表存储。
   
2. 快速属性这里不深刻，咱们接下来看看NameDictionary的底层结构

// https://github.com/v8/v8/blob/master/src/objects/dictionary.h
// 咱们先来看看继承链
// Line 202
class V8_EXPORT_PRIVATE NameDictionary : public BaseNameDictionary<NameDictionary, NameDictionaryShape>{}
// Line 128
class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) BaseNameDictionary : public Dictionary<Derived, Shape> {}
// Line 26
class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) Dictionary : public HashTable<Derived, Shape> {}

// 由上可知继承自HashTable，咱们来看HashTable的定义
// https://github.com/v8/v8/blob/master/src/objects/hash-table.h
// 而且在文件开头的注释已经很详细了

// HashTable is a subclass of FixedArray that implements a hash table that uses open addressing and quadratic probing.
*重要: hash表使用数组为基础数据,并在其上实现了开放寻址和二次探测
// In order for the quadratic probing to work, elements that have not yet been used and elements that have been deleted are distinguished.  
// Probing continues when deleted elements are encountered and stops when unused elements are encountered.
* 为了使二次探测工做正常,未使用/被删除的元素将被标记删除而不是直接删除
// - Elements with key == undefined have not been used yet.
// - Elements with key == the_hole have been deleted.

// 如下会被使用的hash表派生类
// Line 292
template <typename Derived, typename Shape>
class EXPORT_TEMPLATE_DECLARE(V8_EXPORT_PRIVATE) ObjectHashTableBase
    : public HashTable<Derived, Shape> {}

接下来咱们看看V8在实现hash表时的几个重要行为和参数
// https://github.com/v8/v8/blob/master/src/objects/objects.cc

1. 扩容
// Line 7590
// 下面源代码是新增一个元素后的逻辑
ObjectHashTableBase<Derived, Shape>::Put(Isolate* isolate, Handle<Derived> table, Handle<Object> key, Handle<Object> value, int32_t hash) {    
  int entry = table->FindEntry(roots, key, hash);
  // Key is already in table, just overwrite value.
  // key已经存在,覆盖值
  if (entry != kNotFound) {
    table->set(Derived::EntryToValueIndex(entry), *value);
    return table;
  }

  // 若是33%以上元素都被删除了,考虑从新hash
  // Rehash if more than 33% of the entries are deleted entries.
  // TODO(jochen): Consider to shrink the fixed array in place.
  if ((table->NumberOfDeletedElements() << 1) > table->NumberOfElements()) {
    table->Rehash(roots);
  }
  // If we're out of luck, we didn't get a GC recently, and so rehashing isn't enough to avoid a crash.
  // 若是没有足够的预估空位,按二倍大小进行从新hash
  if (!table->HasSufficientCapacityToAdd(1)) {
    int nof = table->NumberOfElements() + 1;
    int capacity = ObjectHashTable::ComputeCapacity(nof * 2);
    if (capacity > ObjectHashTable::kMaxCapacity) {
      for (size_t i = 0; i < 2; ++i) {
        isolate->heap()->CollectAllGarbage(
            Heap::kNoGCFlags, GarbageCollectionReason::kFullHashtable);
      }
      table->Rehash(roots);
    }
  }

// Line 6583.
// 下面是计算预估空位的逻辑
HashTable<Derived, Shape>::EnsureCapacity(Isolate* isolate, Handle<Derived> table, int n, AllocationType allocation) {
  if (table->HasSufficientCapacityToAdd(n)) return table;
  int capacity = table->Capacity();
  int new_nof = table->NumberOfElements() + n;
  const int kMinCapacityForPretenure = 256;
  bool should_pretenure = allocation == AllocationType::kOld ||
                          ((capacity > kMinCapacityForPretenure) &&
                           !Heap::InYoungGeneration(*table));
  Handle<Derived> new_table = HashTable::New(
      isolate, new_nof,
      should_pretenure ? AllocationType::kOld : AllocationType::kYoung);

  table->Rehash(ReadOnlyRoots(isolate), *new_table);
  return new_table;
}

2. 收缩 
// Line 6622
HashTable<Derived, Shape>::Shrink(Isolate* isolate,
                                                  Handle<Derived> table,
                                                  int additionalCapacity) {
  int capacity = table->Capacity();
  int nof = table->NumberOfElements();

  // Shrink to fit the number of elements if only a quarter of the capacity is filled with elements.
  // 当只有1/4的装载量时,进行收缩
  if (nof > (capacity >> 2)) return table;
  // Allocate a new dictionary with room for at least the current number of
  // elements + {additionalCapacity}. The allocation method will make sure that
  // there is extra room in the dictionary for additions. Don't go lower than
  // room for {kMinShrinkCapacity} elements.
  int at_least_room_for = nof + additionalCapacity;
  int new_capacity = ComputeCapacity(at_least_room_for);
  if (new_capacity < Derived::kMinShrinkCapacity) return table;
  if (new_capacity == capacity) return table;

  const int kMinCapacityForPretenure = 256;
  bool pretenure = (at_least_room_for > kMinCapacityForPretenure) &&
                   !Heap::InYoungGeneration(*table);
  Handle<Derived> new_table =
      HashTable::New(isolate, new_capacity,
                     pretenure ? AllocationType::kOld : AllocationType::kYoung,
                     USE_CUSTOM_MINIMUM_CAPACITY);

  table->Rehash(ReadOnlyRoots(isolate), *new_table);
  return new_table;
}