TypeScript utils.isFunction方法代码示例

 .filter(prop => {
   const descriptor = Object.getOwnPropertyDescriptor(prototype, prop);
   if (descriptor.set || descriptor.get) {
     return false;
   }
   return !isConstructor(prop) && isFunction(prototype[prop]);
 })

 public async transformToResult(resultOrDeffered) {
   if (resultOrDeffered instanceof Promise) {
     return await resultOrDeffered;
   } else if (resultOrDeffered && isFunction(resultOrDeffered.subscribe)) {
     return await resultOrDeffered.toPromise();
   }
   return resultOrDeffered;
 }

 public create(
   port: number,
   options?: any & { namespace?: string; server?: any },
 ): any {
   if (!options) {
     return this.createIOServer(port);
   }
   const { namespace, server, ...opt } = options;
   return server && isFunction(server.of)
     ? server.of(namespace)
     : namespace
       ? this.createIOServer(port, opt).of(namespace)
       : this.createIOServer(port, opt);
 }

 public mapPayload(payload: any): { data: any; ack?: Function } {
   if (!Array.isArray(payload)) {
     return { data: payload };
   }
   const lastElement = payload[payload.length - 1];
   const isAck = isFunction(lastElement);
   if (isAck) {
     const size = payload.length - 1;
     return {
       data: size === 1 ? payload[0] : payload.slice(0, size),
       ack: lastElement,
     };
   }
   return { data: payload };
 }

 public *scanForServerHooks(instance: NestGateway): IterableIterator<string> {
   for (const propertyKey in instance) {
     if (isFunction(propertyKey)) {
       continue;
     }
     const property = String(propertyKey);
     const isServer = Reflect.getMetadata(
       GATEWAY_SERVER_METADATA,
       instance,
       property,
     );
     if (!isUndefined(isServer)) {
       yield property;
     }
   }
 }

 public async resolveSingleParam<T>(
   wrapper: InstanceWrapper<T>,
   param: Type<any> | string | symbol | any,
   { index, length }: { index: number; length: number },
   module: Module,
 ) {
   if (isUndefined(param)) {
     throw new UndefinedDependencyException(wrapper.name, index, length);
   }
   const token = this.resolveParamToken(wrapper, param);
   return await this.resolveComponentInstance<T>(
     module,
     isFunction(token) ? (token as Type<any>).name : token,
     { index, length },
     wrapper,
   );
 }

 public async resolveSingleParam<T>(
   wrapper: InstanceWrapper<T>,
   param: Type<any> | string | symbol | any,
   dependencyContext: InjectorDependencyContext,
   module: Module,
 ) {
   if (isUndefined(param)) {
     throw new UndefinedDependencyException(wrapper.name, dependencyContext, module);
   }
   const token = this.resolveParamToken(wrapper, param);
   return this.resolveComponentInstance<T>(
     module,
     isFunction(token) ? (token as Type<any>).name : token,
     dependencyContext,
     wrapper,
   );
 }

 protected findInstanceByPrototypeOrToken<TInput = any, TResult = TInput>(
   metatypeOrToken: Type<TInput> | string | symbol,
   contextModule: Partial<Module>,
 ): TResult {
   const dependencies = new Map([
     ...contextModule.components,
     ...contextModule.routes,
     ...contextModule.injectables,
   ]);
   const name = isFunction(metatypeOrToken)
     ? (metatypeOrToken as any).name
     : metatypeOrToken;
   const instanceWrapper = dependencies.get(name);
   if (!instanceWrapper) {
     throw new UnknownElementException();
   }
   return (instanceWrapper as InstanceWrapper<any>).instance;
 }

  public *scanForClientHooks(
    instance: Controller,
  ): IterableIterator<ClientProperties> {
    for (const propertyKey in instance) {
      if (isFunction(propertyKey)) continue;

      const property = String(propertyKey);
      const isClient = Reflect.getMetadata(CLIENT_METADATA, instance, property);
      if (isUndefined(isClient)) continue;

      const metadata = Reflect.getMetadata(
        CLIENT_CONFIGURATION_METADATA,
        instance,
        property,
      );
      yield { property, metadata };
    }
  }

 (interceptor: NestInterceptor) =>
   interceptor && isFunction(interceptor.intercept),