docs: function (param, traversePath) {
        if (param.isArray) {
          // 参数是数组类别
          return this._getArrayMockByArrEleType({
            defaultValue: param.defaultValue,
            genExpression: param.genExpression,
            type: param.type
          }, 3, traversePath);
        } else {
          var datatype = this.ds.find(function (dt) {
            return dt.id === param.type;
          });
          var getDefaultValue = function (param) {
            var dv = param.defaultValue;
            if (param.type <= 10003) {
              return dv;
            }
            // 哈希或者数组
            if (datatype.format === 0 || datatype.format === 2) {
              try {
                dv = JSON.parse(dv);
              } catch (e) {
                console.warn('默认值使用 JSON.parse 方法解析失败: ' + e);
                try {
                  dv = eval('(' + dv + ')');
                } catch (e) {
                  console.warn('默认值使用 eval 方法解析失败: ' + e);
                }
              }
            }
            return dv;
          };
          if (param.defaultValue) {
            // 有默认值, 优先考虑
            var params = [{
              type: datatype.id,
              defaultValue: getDefaultValue(param)
            }];
            // 如果是枚举类型, 则 type 为枚举元素的类型, 取第一个元素的类型
            if (datatype.format === 1) {
              params[0].type = datatype.params && datatype.params[0].type;
            }
            // 参数如果有默认值, 并且是哈希类型, 则将参数当作字符类型处理(否则就会产生循环调用)
            return this._getMockByParams(datatype.format === 0 ? 3 : datatype.format, params, datatype.name, traversePath);
          } else if (param.genExpression) {
            // 其次考虑生成规则
            param._isArray = datatype.format == 2;
            return this._evalExp(param.genExpression, param, this.ds);
          } else {
            // 否则就按正常的数据模型获取它的mock数据
            return this._getMockOfDatatypeId(param.type, param.name, traversePath);
          }
        }
      }