语法

本章节介绍常见语句示例，以给出语法规则。

• 对象判空

  单个对象示例：

  if(object){
      //ignore
  }

  集合对象示例：

  if(collection&&collection.length!=0){
      //ignore
  }

• 数字类型统一定义成“Number”、日期类型定义成“Date”。

  @action.param({
      type: "Date",
      label: "effectiveTime",
      description: "Date."
  })
  effectiveTime: Date;
  
  @action.param({
      type: "Number",
      label: "salePrice",
      description: "salePrice."
  })
  salePrice: number;

• 变量或数组定义时，要说明类型，集合需要加上泛型。

  let isDone:Boolean = false;
  let decLiteral : number =6;
  let productList = new Array<productObject>();

• 遍历循环推荐用“forEach”，不推荐用“for…in”。

  testArray.forEach((value, index, array )=>{
         //ignore
  });

• 推荐用“let”变量声明，不推荐用“var”。

  【推荐】：

  let offeringId : String = “aaa”;

  【不推荐】：

  var offeringId = “aaa”;

• 前段代码有对象声明时，推荐使用“.fieldName”获取对象的字段，而不是用“[‘fieldName’]”。

  【推荐】：

  offeringStruct.id = result[i].base.offeringId;

  【不推荐】：

  offeringStruct.id = result[i][‘base’][‘offeringId’];

• 在需要默认值的情况下，使用“||”代替“if”判断。

  function(value){
         //使用||对value进行判空
         value = value || “hello”
  }

• 创建一个已知对象时，推荐用“new”方法。

  【推荐】：

  let offeringIdRequest = new OfferingIdRequest();
  offeringIdRequest.catalogList = catalogList;
  offeringIdRequest.classificationList:=classificationList;
  let getOfferingIdByConditionInput = {
         "OfferingIdRequest": offeringIdRequest
  }

  【不推荐】：

  let getOfferingIdByConditionInput = {
         "OfferingIdRequest": {
                "catalogList": catalogList,
                "classificationList": classificationList,
                "status": "",
                "stockCondition": "",
                "keyWord": "",
                "offset": "",
                "limit": ""
         }
  }

• 函数定义

  let traitRec = function(xxxx,xxx) {
      //ignore
   }

  只能在函数定义后的语句中，使用该函数。

• 没有初始化值的变量申明，使用“undefined”，不要使用“null”。

  let object = undefined;

• 局部变量需要在“class”内定义，不要在全局命名空间内定义类型/值（即不要在“class”外定义变量），常量可以定义成全局。

  let identityIdList = [];

• 使用“lambda”表达式代替匿名函数。

  只有需要时，才把“arrow”函数的参数括起来。正确使用“arrow”的示例如下：

  x => x + x
  (x,y) => x + y
  <T>(x: T, y: T) => x === y