TypeScript lang.isArray函数代码示例

 transform(todos, args){ 
   if (isBlank(args) || args.length == 0) {
     throw new BaseException('VisibleTodos pipe requires one argument');
   }
   if (isPresent(todos) && !isArray(todos)){
     throw new BaseException('VisibleTodos pipe requires an Array as input');
   }
   return this.getVisibleTodos(todos, args[0]);
 }

function _extractToken(typeOrFunc, metadata /*any[] | any*/,
                       params: any[][]): ReflectiveDependency {
  var depProps = [];
  var token = null;
  var optional = false;

  if (!isArray(metadata)) {
    if (metadata instanceof InjectMetadata) {
      return _createDependency(metadata.token, optional, null, null, depProps);
    } else {
      return _createDependency(metadata, optional, null, null, depProps);
    }
  }

  var lowerBoundVisibility = null;
  var upperBoundVisibility = null;

  for (var i = 0; i < metadata.length; ++i) {
    var paramMetadata = metadata[i];

    if (paramMetadata instanceof Type) {
      token = paramMetadata;

    } else if (paramMetadata instanceof InjectMetadata) {
      token = paramMetadata.token;

    } else if (paramMetadata instanceof OptionalMetadata) {
      optional = true;

    } else if (paramMetadata instanceof SelfMetadata) {
      upperBoundVisibility = paramMetadata;

    } else if (paramMetadata instanceof HostMetadata) {
      upperBoundVisibility = paramMetadata;

    } else if (paramMetadata instanceof SkipSelfMetadata) {
      lowerBoundVisibility = paramMetadata;

    } else if (paramMetadata instanceof DependencyMetadata) {
      if (isPresent(paramMetadata.token)) {
        token = paramMetadata.token;
      }
      depProps.push(paramMetadata);
    }
  }

  token = resolveForwardRef(token);

  if (isPresent(token)) {
    return _createDependency(token, optional, lowerBoundVisibility, upperBoundVisibility, depProps);
  } else {
    throw new NoAnnotationError(typeOrFunc, params);
  }
}

 transform(todos:ToDoItem[], args:any[]):ToDoItem[] {
     if (args.length ==- 0) {
         throw new BaseException('Visible todos pipe requires one argument')
     }
     
     if (isPresent(todos) && !isArray(todos)) {
         throw new BaseException('Visible todo pipe requires an array as input')
     }
     
     return this.getVisibleToDos(todos, args[0]);
 }

  _createControl(controlConfig: any): modelModule.AbstractControl {
    if (controlConfig instanceof modelModule.Control ||
        controlConfig instanceof modelModule.ControlGroup ||
        controlConfig instanceof modelModule.ControlArray) {
      return controlConfig;

    } else if (isArray(controlConfig)) {
      var value = ListWrapper.get(controlConfig, 0);
      var validator = controlConfig.length > 1 ? controlConfig[1] : null;
      return this.control(value, validator);

    } else {
      return this.control(controlConfig);
    }
  }

  /** @internal */
  _createControl(controlConfig: any): modelModule.AbstractControl {
    if (controlConfig instanceof modelModule.Control ||
        controlConfig instanceof modelModule.ControlGroup ||
        controlConfig instanceof modelModule.ControlArray) {
      return controlConfig;

    } else if (isArray(controlConfig)) {
      var value = controlConfig[0];
      var validator = controlConfig.length > 1 ? controlConfig[1] : null;
      var asyncValidator = controlConfig.length > 2 ? controlConfig[2] : null;
      return this.control(value, validator, asyncValidator);

    } else {
      return this.control(controlConfig);
    }
  }

  deserialize(map: any, type: Type, data?: any): any {
    if (!isPresent(map)) {
      return null;
    }
    if (isArray(map)) {
      var obj: List<any> = new List<any>();
      ListWrapper.forEach(map, (val) => { obj.push(this.deserialize(val, type, data)); });
      return obj;
    }
    if (type == String) {
      return map;
    }

    if (type == ViewDefinition) {
      return this._deserializeViewDefinition(map);
    } else if (type == DirectiveBinder) {
      return this._deserializeDirectiveBinder(map);
    } else if (type == ProtoViewDto) {
      return this._deserializeProtoViewDto(map);
    } else if (type == RenderDirectiveMetadata) {
      return this._deserializeDirectiveMetadata(map);
    } else if (type == RenderElementBinder) {
      return this._deserializeElementBinder(map);
    } else if (type == ASTWithSource) {
      return this._deserializeASTWithSource(map, data);
    } else if (type == RenderProtoViewRef) {
      return this._protoViewStore.deserialize(map);
    } else if (type == RenderProtoViewMergeMapping) {
      return this._deserializeRenderProtoViewMergeMapping(map);
    } else if (type == RenderViewRef) {
      return this._renderViewStore.deserializeRenderViewRef(map);
    } else if (type == RenderFragmentRef) {
      return this._renderViewStore.deserializeRenderFragmentRef(map);
    } else if (type == WebWorkerElementRef) {
      return this._deserializeWorkerElementRef(map);
    } else if (type == EventBinding) {
      return this._deserializeEventBinding(map);
    } else if (type == ElementPropertyBinding) {
      return this._deserializeElementPropertyBinding(map);
    } else {
      throw new BaseException("No deserializer for " + type.toString());
    }
  }

 serialize(obj: any, type: Type): Object {
   if (!isPresent(obj)) {
     return null;
   }
   if (isArray(obj)) {
     var serializedObj = [];
     ListWrapper.forEach(obj, (val) => { serializedObj.push(this.serialize(val, type)); });
     return serializedObj;
   }
   if (type == String) {
     return obj;
   }
   if (type == ViewDefinition) {
     return this._serializeViewDefinition(obj);
   } else if (type == DirectiveBinder) {
     return this._serializeDirectiveBinder(obj);
   } else if (type == ProtoViewDto) {
     return this._serializeProtoViewDto(obj);
   } else if (type == RenderElementBinder) {
     return this._serializeElementBinder(obj);
   } else if (type == RenderDirectiveMetadata) {
     return this._serializeDirectiveMetadata(obj);
   } else if (type == ASTWithSource) {
     return this._serializeASTWithSource(obj);
   } else if (type == RenderProtoViewRef) {
     return this._protoViewStore.serialize(obj);
   } else if (type == RenderProtoViewMergeMapping) {
     return this._serializeRenderProtoViewMergeMapping(obj);
   } else if (type == RenderViewRef) {
     return this._renderViewStore.serializeRenderViewRef(obj);
   } else if (type == RenderFragmentRef) {
     return this._renderViewStore.serializeRenderFragmentRef(obj);
   } else if (type == WebWorkerElementRef) {
     return this._serializeWorkerElementRef(obj);
   } else if (type == ElementPropertyBinding) {
     return this._serializeElementPropertyBinding(obj);
   } else if (type == EventBinding) {
     return this._serializeEventBinding(obj);
   } else {
     throw new BaseException("No serializer for " + type.toString());
   }
 }

 static supportsObj(obj): boolean { return isString(obj) || isArray(obj); }

 private supports(obj: any): boolean { return isString(obj) || isArray(obj); }