TypeScript Map.set方法代码示例

export function coalesce(records: ProtoRecord[]): ProtoRecord[] {
  var res: List<ProtoRecord> = [];
  var indexMap: Map<number, number> = new Map<number, number>();

  for (var i = 0; i < records.length; ++i) {
    var r = records[i];
    var record = _replaceIndices(r, res.length + 1, indexMap);
    var matchingRecord = _findMatching(record, res);

    if (isPresent(matchingRecord) && record.lastInBinding) {
      res.push(_selfRecord(record, matchingRecord.selfIndex, res.length + 1));
      indexMap.set(r.selfIndex, matchingRecord.selfIndex);
      matchingRecord.referencedBySelf = true;

    } else if (isPresent(matchingRecord) && !record.lastInBinding) {
      if (record.argumentToPureFunction) {
        matchingRecord.argumentToPureFunction = true;
      }

      indexMap.set(r.selfIndex, matchingRecord.selfIndex);

    } else {
      res.push(record);
      indexMap.set(r.selfIndex, record.selfIndex);
    }
  }

  return res;
}

 viewCreated(view: AppView) {
   var viewId = _nextId++;
   _allViewsById.set(viewId, view);
   _allIdsByView.set(view, viewId);
   for (var i = 0; i < view.elementRefs.length; i++) {
     _setElementId(this._renderer.getNativeElementSync(view.elementRefs[i]), [viewId, i]);
   }
 }

 onViewCreated(view: AppView) {
   var viewId = _nextId++;
   _allViewsById.set(viewId, view);
   _allIdsByView.set(view, viewId);
   for (var i = 0; i < view.appElements.length; i++) {
     var el = view.appElements[i];
     _setElementId(el.nativeElement, [viewId, i]);
   }
 }

 viewCreated(view: AppView) {
   var viewId = _nextId++;
   _allViewsById.set(viewId, view);
   _allIdsByView.set(view, viewId);
   var renderView = resolveInternalDomView(view.render);
   for (var i = 0; i < renderView.boundElements.length; i++) {
     _setElementId(renderView.boundElements[i].element, [viewId, i]);
   }
 }

 addEventListener(element, eventName: string, handler: Function, shouldSupportBubble: boolean) {
   if (shouldSupportBubble) {
     this._bubbleEventHandlers.set(eventName, handler);
   } else {
     this._nonBubbleEventHandlers.set(eventName, handler);
   }
   return () => {
     MapWrapper.delete(
         shouldSupportBubble ? this._bubbleEventHandlers : this._nonBubbleEventHandlers, eventName)
   };
 }

 MapWrapper.forEach(host, (value: string, key: string) => {
   var matches = RegExpWrapper.firstMatch(hostRegExp, key);
   if (isBlank(matches)) {
     hostAttributes.set(key, value);
   } else if (isPresent(matches[1])) {
     hostProperties.set(matches[1], value);
   } else if (isPresent(matches[2])) {
     hostListeners.set(matches[2], value);
   } else if (isPresent(matches[3])) {
     hostActions.set(matches[3], value);
   }
 });

 addConfig(path: string, handler: any, alias: string = null): void {
   var recognizer = new PathRecognizer(path, handler);
   MapWrapper.forEach(this.matchers, (matcher, _) => {
     if (recognizer.regex.toString() == matcher.regex.toString()) {
       throw new BaseException(
           `Configuration '${path}' conflicts with existing route '${matcher.path}'`);
     }
   });
   this.matchers.set(recognizer.regex, recognizer);
   if (isPresent(alias)) {
     this.names.set(alias, recognizer);
   }
 }

  /**
   * Given a component and a configuration object, add the route to this registry
   */
  config(parentComponent, config: StringMap<string, any>): void {
    assertValidConfig(config);

    var recognizer: RouteRecognizer = this._rules.get(parentComponent);

    if (isBlank(recognizer)) {
      recognizer = new RouteRecognizer();
      this._rules.set(parentComponent, recognizer);
    }

    if (StringMapWrapper.contains(config, 'redirectTo')) {
      recognizer.addRedirect(config['path'], config['redirectTo']);
      return;
    }

    config = StringMapWrapper.merge(
        config, {'component': normalizeComponentDeclaration(config['component'])});

    var component = config['component'];
    var terminal = recognizer.addConfig(config['path'], config, config['as']);

    if (component['type'] == 'constructor') {
      if (terminal) {
        assertTerminalComponent(component['constructor'], config['path']);
      } else {
        this.configFromComponent(component['constructor']);
      }
    }
  }

export function coalesce(srcRecords: ProtoRecord[]): ProtoRecord[] {
  let dstRecords = [];
  let excludedIdxs = [];
  let indexMap: Map<number, number> = new Map<number, number>();
  let skipDepth = 0;
  let skipSources: ProtoRecord[] = ListWrapper.createFixedSize(srcRecords.length);

  for (let protoIndex = 0; protoIndex < srcRecords.length; protoIndex++) {
    let skipRecord = skipSources[protoIndex];
    if (isPresent(skipRecord)) {
      skipDepth--;
      skipRecord.fixedArgs[0] = dstRecords.length;
    }

    let src = srcRecords[protoIndex];
    let dst = _cloneAndUpdateIndexes(src, dstRecords, indexMap);

    if (dst.isSkipRecord()) {
      dstRecords.push(dst);
      skipDepth++;
      skipSources[dst.fixedArgs[0]] = dst;
    } else {
      let record = _mayBeAddRecord(dst, dstRecords, excludedIdxs, skipDepth > 0);
      indexMap.set(src.selfIndex, record.selfIndex);
    }
  }

  return _optimizeSkips(dstRecords);
}

 ListWrapper.forEach(bindings, function(b) {
   if (b instanceof ResolvedBinding) {
     res.set(b.key.id, b);
   } else if (b instanceof List) {
     _flattenBindings(b, res);
   }
 });