Merge pull request #966 from JonasBa/jb/core/hashmap-es6

feat(polyfill): use native map if available

Author: plainheart

src/core/util.ts

@@ -653,20 +653,68 @@ export function isPrimitive(obj: any): boolean {
     return obj[primitiveKey];
 }
 
+interface MapInterface<T, KEY extends string | number = string | number> {
+    delete(key: KEY): boolean;
+    get(key: KEY): T | undefined
+    set(key: KEY, value: T): this
+    keys(): KEY[];
+    forEach(callback: (value: T, key: KEY) => void): void
+}
+
+class MapPolyfill<T, KEY extends string | number = string | number> implements MapInterface<T, KEY> {
+    private data: Record<KEY, T> = {} as Record<KEY, T>;
+
+    delete(key: KEY): boolean {
+        const existed = this.data.hasOwnProperty(key);
+        if (existed) {
+            delete this.data[key];
+        }
+        return existed;
+    }
+    get(key: KEY): T | undefined {
+        return this.data[key];
+    }
+    set(key: KEY, value: T): this {
+        this.data[key] = value;
+        return this;
+    }
+    keys(): KEY[] {
+        return keys(this.data);
+    }
+    forEach(callback: (value: T, key: KEY) => void): void {
+        // This is a potential performance bottleneck, see details in
+        // https://github.com/ecomfe/zrender/issues/965, however it is now
+        // less likely to occur as we default to native maps when possible.
+        const data = this.data;
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {
+                callback(data[key], key);
+            }
+        }
+    }
+}
+
+// We want to use native Map if it is available, but we do not want to polyfill the global scope
+// in case users ship their own polyfills or patch the native map object in any way.
+const isNativeMapSupported = typeof Map === 'function';
+function maybeNativeMap<T, KEY extends string | number = string | number>(): MapInterface<T, KEY> {
+    // Map may be a native class if we are running in an ES6 compatible environment.
+    // eslint-disable-next-line
+    return (isNativeMapSupported ? new Map<KEY, T>() : new MapPolyfill<T, KEY>()) as MapInterface<T, KEY>;
+}
 
 /**
  * @constructor
- * @param {Object} obj Only apply `ownProperty`.
+ * @param {Object} obj
  */
 export class HashMap<T, KEY extends string | number = string | number> {
-
-    data: {[key in KEY]: T} = {} as {[key in KEY]: T};
+    data: MapInterface<T, KEY>
 
     constructor(obj?: HashMap<T, KEY> | { [key in KEY]?: T } | KEY[]) {
         const isArr = isArray(obj);
         // Key should not be set on this, otherwise
         // methods get/set/... may be overrided.
-        this.data = {} as {[key in KEY]: T};
+        this.data = maybeNativeMap<T, KEY>();
         const thisMap = this;
 
         (obj instanceof HashMap)
@@ -682,31 +730,36 @@ export class HashMap<T, KEY extends string | number = string | number> {
     // (We usually treat `null` and `undefined` as the same, different
     // from ES6 Map).
     get(key: KEY): T {
-        return this.data.hasOwnProperty(key) ? this.data[key] : null;
+        return this.data.get(key);
     }
     set(key: KEY, value: T): T {
         // Comparing with invocation chaining, `return value` is more commonly
         // used in this case: `const someVal = map.set('a', genVal());`
-        return (this.data[key] = value);
+        this.data.set(key, value);
+        return value;
     }
     // Although util.each can be performed on this hashMap directly, user
     // should not use the exposed keys, who are prefixed.
     each<Context>(
         cb: (this: Context, value?: T, key?: KEY) => void,
         context?: Context
     ) {
-        for (let key in this.data) {
-            if (this.data.hasOwnProperty(key)) {
-                cb.call(context, this.data[key], key);
-            }
-        }
+        this.data.forEach((value, key) => {
+            cb.call(context, value, key);
+        });
     }
     keys(): KEY[] {
-        return keys(this.data);
+        // Native map return an iterator so we need to convert it to an array
+        if (isNativeMapSupported) {
+            return Array.from(this.data.keys());
+        }
+
+        // Polyfilled map return and Array<KEYS> for keys
+        return this.data.keys();
     }
     // Do not use this method if performance sensitive.
-    removeKey(key: KEY) {
-        delete this.data[key];
+    removeKey(key: KEY): void {
+        this.data.delete(key);
     }
 }