TypeScript Map.get方法代码示例

  /**
   * Returns the {@link View} for a component:
   * - Set the {@link View} to the overridden view when it exists or fallback to the default
   * `TemplateResolver`,
   *   see `setView`.
   * - Override the directives, see `overrideViewDirective`.
   * - Override the @View definition, see `setInlineTemplate`.
   *
   * @param component
   * @returns {ViewDefinition}
   */
  resolve(component: Type): View {
    var view = this._viewCache.get(component);
    if (isPresent(view)) return view;

    view = this._views.get(component);
    if (isBlank(view)) {
      view = super.resolve(component);
    }

    var directives = view.directives;
    var overrides = this._directiveOverrides.get(component);

    if (isPresent(overrides) && isPresent(directives)) {
      directives = ListWrapper.clone(view.directives);
      MapWrapper.forEach(overrides, (to, from) => {
        var srcIndex = directives.indexOf(from);
        if (srcIndex == -1) {
          throw new BaseException(
              `Overriden directive ${stringify(from)} not found in the template of ${stringify(component)}`);
        }
        directives[srcIndex] = to;
      });
      view = new View(
          {template: view.template, templateUrl: view.templateUrl, directives: directives});
    }

    var inlineTemplate = this._inlineTemplates.get(component);
    if (isPresent(inlineTemplate)) {
      view = new View({template: inlineTemplate, templateUrl: null, directives: view.directives});
    }

    this._viewCache.set(component, view);
    return view;
  }

 setter(name: string): SetterFn {
   if (this._setters.has(name)) {
     return this._setters.get(name);
   } else {
     return this.reflectionCapabilities.setter(name);
   }
 }

 method(name: string): MethodFn {
   if (this._methods.has(name)) {
     return this._methods.get(name);
   } else {
     return this.reflectionCapabilities.method(name);
   }
 }

  /**
   * 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']);
      }
    }
  }

  /**
   * Once a component has been compiled, the AppProtoView is stored in the compiler cache.
   *
   * Then it should not be possible to override the component configuration after the component
   * has been compiled.
   *
   * @param {Type} component
   */
  _checkOverrideable(component: Type): void {
    var cached = this._viewCache.get(component);

    if (isPresent(cached)) {
      throw new BaseException(
          `The component ${stringify(component)} has already been compiled, its configuration can not be changed`);
    }
  }

 get(param: string): string {
   var storedParam = this.paramsMap.get(param);
   if (isListLikeIterable(storedParam)) {
     return ListWrapper.first(storedParam);
   } else {
     return null;
   }
 }

 interfaces(type: Type): List<any> {
   if (this._injectableInfo.has(type)) {
     var res = this._injectableInfo.get(type)._interfaces;
     return isPresent(res) ? res : [];
   } else {
     return this.reflectionCapabilities.interfaces(type);
   }
 }

export function getComponentId(componentStringId: string) {
  var id = _componentUIDs.get(componentStringId);
  if (isBlank(id)) {
    id = _nextComponentUID++;
    _componentUIDs.set(componentStringId, id);
  }
  return id;
}

 factory(type: Type): Function {
   if (this._containsReflectionInfo(type)) {
     var res = this._injectableInfo.get(type)._factory;
     return isPresent(res) ? res : null;
   } else {
     return this.reflectionCapabilities.factory(type);
   }
 }

  get(url: string): Promise<string> {
    var response = this._responses.get(url);
    if (isBlank(response)) {
      return PromiseWrapper.reject('xhr error', null);
    }

    return PromiseWrapper.resolve(response);
  }