diff --git a/src/cli/cmake2gn/src/src/analyze_command.js b/src/cli/cmake2gn/src/src/analyze_command.js
index c3e795bfb8ea21b1f5bf2ddde2806fff9b3813c6..703bafb3a8ae747c126a6d4a70e8968e5d2c7c35 100644
--- a/src/cli/cmake2gn/src/src/analyze_command.js
+++ b/src/cli/cmake2gn/src/src/analyze_command.js
@@ -604,10 +604,10 @@ class AnalyzeCommand {
         }
         let ret = null;
         switch (AnalyzeCommand.getCompileCmdId(cmd)) {
-            case AnalyzeCommand.COMPILE_CMDS['clang']:
+            case AnalyzeCommand.COMPILE_CMDS.clang:
                 ret = AnalyzeCommand.analyzeCcClang(cmd);
                 break;
-            case AnalyzeCommand.COMPILE_CMDS['ar']:
+            case AnalyzeCommand.COMPILE_CMDS.ar:
                 ret = AnalyzeCommand.analyzeCcAr(cmd);
                 break;
             case AnalyzeCommand.COMPILE_CMDS['clang++']:
diff --git a/src/cli/dts2cpp/src/gen/analyze/function.js b/src/cli/dts2cpp/src/gen/analyze/function.js
index 36fa8b0e4f105df5d28b63f0bb28ad77201a3843..82fc133f1e9904fc1b975b00be12f285896dce0f 100644
--- a/src/cli/dts2cpp/src/gen/analyze/function.js
+++ b/src/cli/dts2cpp/src/gen/analyze/function.js
@@ -60,17 +60,17 @@ function analyzeSubInterfaceVal(t, tt, result) {
 }
 
 function getFuncParaType(v, interfaceName, data, results) {
-    let arrayType = re.match('(Async)*Callback<(Array<([a-zA-Z_0-9]+)>)>', v['type'])
-    let parameter = v['type']
+    let arrayType = re.match('(Async)*Callback<(Array<([a-zA-Z_0-9]+)>)>', v.type)
+    let parameter = v.type
     if (arrayType) {
-        parameter = re.getReg(v['type'], arrayType.regs[2])
+        parameter = re.getReg(v.type, arrayType.regs[2])
     }
     if (isEnum(parameter, data)) {
         let index = enumIndex(parameter, data)
         if (data.enum[index].body.enumValueType === EnumValueType.ENUM_VALUE_TYPE_NUMBER) {
-            v['type'] = v['type'].replace(parameter, 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
+            v.type = v.type.replace(parameter, 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
         } else if (data.enum[index].body.enumValueType === EnumValueType.ENUM_VALUE_TYPE_STRING) {
-            v['type'] = v['type'].replace(parameter, 'string')
+            v.type = v.type.replace(parameter, 'string')
         } else {
             NapiLog.logError('analyzeFunction getFuncParaType is not support this type %s.'
                 .format(data.enum[index].body.enumValueType), getLogErrInfo);
@@ -81,10 +81,10 @@ function getFuncParaType(v, interfaceName, data, results) {
      else if (isEnum(parameter, results)) {
         let index = enumIndex(parameter, results)
         if (results.enum[index].body.enumValueType === EnumValueType.ENUM_VALUE_TYPE_NUMBER) {
-          v['type'] = v['type'].replace(parameter, 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
-          v['realType'] = v['type']
+          v.type = v.type.replace(parameter, 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
+          v.realType = v.type
         } else if (results.enum[index].body.enumValueType === EnumValueType.ENUM_VALUE_TYPE_STRING) {
-          v['type'] = v['type'].replace(parameter, 'string')
+          v.type = v.type.replace(parameter, 'string')
         } else {
           NapiLog.logError('analyzeFunction getFuncParaType is not support this type %s.'
               .format(results.enum[index].body.enumValueType), getLogErrInfo());
@@ -94,19 +94,19 @@ function getFuncParaType(v, interfaceName, data, results) {
 
     let interfaceType = re.match('{([A-Za-z0-9_]+:[A-Za-z0-9_,]+)([A-Za-z0-9_]+:[A-Za-z0-9_]+)}$', v['type'])
     if (interfaceType) {
-        v['type'] = interfaceName
+        v.type = interfaceName
     }
 
     if (parameter.indexOf('number') >= 0) {
-        v['type'] = v['type'].replace('number', 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
-        v['realType'] = v['type']
+        v.type = v.type.replace('number', 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
+        v.realType = v.type
     }
 
     // type的处理
     if (isType(parameter, data)) {
       let index = typeIndex(parameter, data)
       if (data.type[index].isEnum) {
-        v['type'] = v['type'].replace(parameter, 'string')
+        v.type = v.type.replace(parameter, 'string')
       }
     }
     return v
diff --git a/src/cli/dts2cpp/src/gen/generate/interface.js b/src/cli/dts2cpp/src/gen/generate/interface.js
index c242aa9983d4d76ec2e0dced9ddcdc8c10212083..73e3edc444c3f87a1d3e19f2cb1a3f1a602a37a4 100644
--- a/src/cli/dts2cpp/src/gen/generate/interface.js
+++ b/src/cli/dts2cpp/src/gen/generate/interface.js
@@ -74,33 +74,16 @@ function getHDefineOfVariable(name, type, variable, optional) {
     if (type.indexOf("|") >= 0) {
         unionTypeString(name, type, variable, optional)
     } else if (type === "string") {
-        if (optional) {
-            variable.hDefine += "\n    std::optional<std::string> %s;".format(name)
-        } else {
-            variable.hDefine += "\n    std::string %s;".format(name)
-        }
+        variableTypeString(optional, variable, name);
     } else if (InterfaceList.getValue(type)) {
-        if (optional) {
-            variable.hDefine += "\n    std::optional<%s> %s;".format(type, name)
-        } else {
-            variable.hDefine += "\n    %s %s;".format(type, name)
-        }
+        variableTypeInterface(optional, variable, type, name);
     } else if (EnumList.getValue(type)) {
       // 如果是枚举string类型，需要将其转换为std::string类型
-      let enumBasicType = EnumList.getValue(type)[0].type
-      if (enumBasicType === 'string') {
-        variable.hDefine += "\n    %s %s;".format('std::string', name)
-      } else {
-        variable.hDefine += "\n    %s %s;".format(type, name)
-      }
+      variableTypeEnum(type, variable, name);
     } else if (type.indexOf("Array<") === 0) {
         typeArrFunctionOne(type, variable, name, optional);
     } else if (type === "boolean") {
-        if (optional) {
-            variable.hDefine += "\n    std::optional<bool> %s;".format(name)
-        } else {
-            variable.hDefine += "\n    bool %s;".format(name)
-        }
+        variableTypeBoolean(optional, variable, name);
     } else if (type.substring(type.length - 2) === "[]") {
         typeArrFunctionTwo(type, variable, name, optional);
     } else if (type.substring(0, 4) === "Map<" || type.indexOf("{[key:") === 0) {  // 支持可选参数？
@@ -108,11 +91,7 @@ function getHDefineOfVariable(name, type, variable, optional) {
     } else if (type === "any") {
         variable.hDefine += anyTypeString(type, name)
     } else if (type.substring(0, 12) === "NUMBER_TYPE_") {
-        if (optional) {
-            variable.hDefine += "\n    std::optional<%s> %s;".format(type, name)
-        } else {
-            variable.hDefine += "\n    %s %s;".format(type, name)
-        }
+        variableTypeNumber(optional, variable, type, name);
     } else if (type === "Object" || type === "object") {
         variable.hDefine += "\n    std::map<std::string, std::any> %s;".format(name)
     }
@@ -123,6 +102,47 @@ function getHDefineOfVariable(name, type, variable, optional) {
     }
 }
 
+function variableTypeNumber(optional, variable, type, name) {
+  if (optional) {
+    variable.hDefine += '\n    std::optional<%s> %s;'.format(type, name);
+  } else {
+    variable.hDefine += '\n    %s %s;'.format(type, name);
+  }
+}
+
+function variableTypeBoolean(optional, variable, name) {
+  if (optional) {
+    variable.hDefine += '\n    std::optional<bool> %s;'.format(name);
+  } else {
+    variable.hDefine += '\n    bool %s;'.format(name);
+  }
+}
+
+function variableTypeEnum(type, variable, name) {
+  let enumBasicType = EnumList.getValue(type)[0].type;
+  if (enumBasicType === 'string') {
+    variable.hDefine += '\n    %s %s;'.format('std::string', name);
+  } else {
+    variable.hDefine += '\n    %s %s;'.format(type, name);
+  }
+}
+
+function variableTypeInterface(optional, variable, type, name) {
+  if (optional) {
+    variable.hDefine += '\n    std::optional<%s> %s;'.format(type, name);
+  } else {
+    variable.hDefine += '\n    %s %s;'.format(type, name);
+  }
+}
+
+function variableTypeString(optional, variable, name) {
+  if (optional) {
+    variable.hDefine += '\n    std::optional<std::string> %s;'.format(name);
+  } else {
+    variable.hDefine += '\n    std::string %s;'.format(name);
+  }
+}
+
 function typeArrFunctionTwo(type, variable, name, optional) {
     let arrayType = getArrayTypeTwo(type);
     if (arrayType === "any") {
diff --git a/src/cli/dts2cpp/src/gen/generate/param_generate.js b/src/cli/dts2cpp/src/gen/generate/param_generate.js
index 5289399a63738e24edb3876ee83a058c51a65fb2..7570c080c203569da55bec52d297446e5a5f1516 100644
--- a/src/cli/dts2cpp/src/gen/generate/param_generate.js
+++ b/src/cli/dts2cpp/src/gen/generate/param_generate.js
@@ -450,18 +450,14 @@ function paramGenerateArray(p, funcValue, param) {
         } else if (arrayType === "any") {
             return paramGenerateAnyArray(p, name, type, param)
         }
-        else if (keyType === "[key:string]:"|| keyType === "Map<string,") {
+        else if (checkIsMap(keyType)) {
             let mapValueType = getMapValueType(strLen, keyType, arrayType);             
             arrayType = "std::map<std::string, %s>".format(mapValueType)
         }
         param.valueIn += funcValue.optional ? "\n    std::vector<%s>* in%d = nullptr;".format(arrayType, p) 
                                             : "\n    std::vector<%s> in%d;".format(arrayType, p)
         let arrValueCheckout = jsToC(inParamName, "pxt->GetArgv(%d)".format(getConstNum(p)), type)
-        if (funcValue.optional) {
-            arrValueCheckout = "if (pxt->GetArgc() > %s) {\n        vio->in%d = new std::vector<%s>;\n"
-                .format(getConstNum(p), p, arrayType) + arrValueCheckout + "    }\n"
-            param.optionalParamDestory += "C_DELETE(vio->in%d);\n    ".format(p)
-        }                                   
+        arrValueCheckout = getFuncOptionalValue(funcValue, arrValueCheckout, p, arrayType, param);                                   
         param.valueCheckout += arrValueCheckout
         param.valueFill += "%svio->in%d".format(param.valueFill.length > 0 ? ", " : "", p)
         param.valueDefine += "%sstd::vector<%s>%s%s".format(param.valueDefine.length > 0 ? ", "
@@ -472,6 +468,19 @@ function paramGenerateArray(p, funcValue, param) {
     }
 }
 
+function checkIsMap(keyType) {
+  return keyType === '[key:string]:' || keyType === 'Map<string,';
+}
+
+function getFuncOptionalValue(funcValue, arrValueCheckout, p, arrayType, param) {
+  if (funcValue.optional) {
+    arrValueCheckout = 'if (pxt->GetArgc() > %s) {\n        vio->in%d = new std::vector<%s>;\n'
+      .format(getConstNum(p), p, arrayType) + arrValueCheckout + '    }\n';
+    param.optionalParamDestory += 'C_DELETE(vio->in%d);\n    '.format(p);
+  }
+  return arrValueCheckout;
+}
+
 function paramGenerateAny(p, name, type, param) {
     param.valueIn += `\n    std::any in%d;
         std::string in%d_type;`.format(p, p)
diff --git a/src/cli/dts2cpp/src/gen/generate/return_generate.js b/src/cli/dts2cpp/src/gen/generate/return_generate.js
index 71ece84bae85ef6b62eee5bcabe0e64c0ab7b40f..7053f28701f7cbce2f1d53fb03e872bff258d8ef 100644
--- a/src/cli/dts2cpp/src/gen/generate/return_generate.js
+++ b/src/cli/dts2cpp/src/gen/generate/return_generate.js
@@ -137,7 +137,7 @@ function c2JsForEnum(deep, type, value, dest, propertyName) {
 
 function cToJs(value, type, dest, deep = 1, optional, enumType = 0) {
     var propertyName = delPrefix(value);
-    if (type === null || type === undefined) {
+    if (checkRetIsUndefined(type)) {
         NapiLog.logError("type is invalid!")
         return
     }
@@ -158,11 +158,11 @@ function cToJs(value, type, dest, deep = 1, optional, enumType = 0) {
     else if(EnumList.getValue(type)){
         return c2JsForEnum(deep, type, value, dest, propertyName);
     }
-    else if (type.substring(0, 6) === "Array<" || type.substring(type.length - 2) === "[]") {
+    else if (checkRetIsArray(type)) {
         let arrayType = checkArrayParamType(type)
         return arrayTempleteFunc(arrayType, deep, dest, value)
     }
-    else if (type.substring(0, 4) === "Map<" || type.indexOf("{[key:") === 0) {
+    else if (checkRetIsMap(type)) {
         return mapTempleteFunc(type, deep, dest, value)
     }
     else if (type.substring(0, 12) === "NUMBER_TYPE_") {
@@ -175,7 +175,7 @@ function cToJs(value, type, dest, deep = 1, optional, enumType = 0) {
     else if (type === "any") {
         return anyTempleteFunc(value)
     }
-    else if (type === "Object" || type === "object") { 
+    else if (checkRetIsObject(type)) { 
         return objectTempleteFuncReturn(value)
     }
     else {
@@ -184,6 +184,22 @@ function cToJs(value, type, dest, deep = 1, optional, enumType = 0) {
     }
 }
 
+function checkRetIsUndefined(type) {
+  return type === null || type === undefined;
+}
+
+function checkRetIsObject(type) {
+  return type === 'Object' || type === 'object';
+}
+
+function checkRetIsArray(type) {
+  return type.substring(0, 6) === 'Array<' || type.substring(type.length - 2) === '[]';
+}
+
+function checkRetIsMap(type) {
+  return type.substring(0, 4) === 'Map<' || type.indexOf('{[key:') === 0;
+}
+
 function c2JsForRetEnum(enumType, value, deep, dest) {
     let retEnum = `std::underlying_type<%s>::type enumType;
     if (typeid(enumType) == typeid(uint32_t)) {
@@ -691,29 +707,33 @@ function returnGenerate(returnInfo, param, data, isOnFuncFlag = false) {
     outParam = result[1]
     generateOptionalAndUnion(returnInfo, param, data, outParam, c2JsresultName);
 
-    if (type === "string") {
-        param.valueOut = returnInfo.optional ? "std::string* out = nullptr;" : "std::string out;\n"        
-        param.valueDefine += "%sstd::string%s out".format(param.valueDefine.length > 0 ? ", " : "", modifiers)
-    } else if (type === "void") {
-        NapiLog.logInfo("The current void type don't need generate");
-    } else if (type === "boolean") {
-        param.valueOut = returnInfo.optional ? "bool* out = nullptr;" : "bool out;\n"
-        param.valueDefine += "%sbool%s out".format(param.valueDefine.length > 0 ? ", " : "", modifiers)
-    } else if (isEnum(type, data)) {
-        returnGenerateEnum(data, returnInfo, param)
-    } else if(generateType(type)){
-        returnGenerate2(returnInfo, param, data)
-    } else if (type.substring(0, 12) === "NUMBER_TYPE_") {
-        param.valueOut = type + (returnInfo.optional ? "* out = nullptr;" : " out;\n")
-        param.valueDefine += "%s%s%s out".format(param.valueDefine.length > 0 ? ", " : "", type, modifiers)
-    } else if (isObjectType(type)) {
-        returnGenerateObject(returnInfo, param, data)
-    } else if (isArrowFunc(type)) {
-        genArrowFuncParam(param, returnInfo, data);
-    } else {
-        NapiLog.logError("Do not support returning the type [%s]."
-            .format(type), getLogErrInfo());
-    }  
+    returnGenerateCheckType(type, param, returnInfo, modifiers, data);  
+}
+
+function returnGenerateCheckType(type, param, returnInfo, modifiers, data) {
+  if (type === 'string') {
+    param.valueOut = returnInfo.optional ? 'std::string* out = nullptr;' : 'std::string out;\n';
+    param.valueDefine += '%sstd::string%s out'.format(param.valueDefine.length > 0 ? ', ' : '', modifiers);
+  } else if (type === 'void') {
+    NapiLog.logInfo('The current void type do not need generate');
+  } else if (type === 'boolean') {
+    param.valueOut = returnInfo.optional ? 'bool* out = nullptr;' : 'bool out;\n';
+    param.valueDefine += '%sbool%s out'.format(param.valueDefine.length > 0 ? ', ' : '', modifiers);
+  } else if (isEnum(type, data)) {
+    returnGenerateEnum(data, returnInfo, param);
+  } else if (generateType(type)) {
+    returnGenerate2(returnInfo, param, data);
+  } else if (type.substring(0, 12) === 'NUMBER_TYPE_') {
+    param.valueOut = type + (returnInfo.optional ? '* out = nullptr;' : ' out;\n');
+    param.valueDefine += '%s%s%s out'.format(param.valueDefine.length > 0 ? ', ' : '', type, modifiers);
+  } else if (isObjectType(type)) {
+    returnGenerateObject(returnInfo, param, data);
+  } else if (isArrowFunc(type)) {
+    genArrowFuncParam(param, returnInfo, data);
+  } else {
+    NapiLog.logError('Do not support returning the type [%s].'
+      .format(type), getLogErrInfo());
+  }
 }
 
 function genArrowFuncParam(param, returnInfo, data) {
diff --git a/src/cli/dts2cpp/src/gen/generate/type.js b/src/cli/dts2cpp/src/gen/generate/type.js
index f7612736ce40ddaaa7969fbd28940a816c1e7aff..b43aa7eab04b56247905d1e82e3393678db26480 100644
--- a/src/cli/dts2cpp/src/gen/generate/type.js
+++ b/src/cli/dts2cpp/src/gen/generate/type.js
@@ -75,35 +75,23 @@ function getHDefineOfVariable(name, type, variable, optional) {
     if (type.indexOf("|") >= 0) {
         unionTypeString(name, type, variable, optional)
     } else if (type === "string") {
-        if (optional) {
-            variable.hDefine += "\n    std::optional<std::string> %s;".format(name)
-        } else {
-            variable.hDefine += "\n    std::string %s;".format(name)
-        }
+        variableTypeString(optional, variable, name);
     }
     else if (TypeList.getValue(type)) variable.hDefine += "\n    %s %s;".format(type, name)
     else if (EnumList.getValue(type)) variable.hDefine += "\n    %s %s;".format(type, name)
     else if (type.indexOf("Array<") === 0) {
         typeArrFunctionOne(type, variable, name, optional);
     } else if (type === "boolean") {
-        if (optional) {
-            variable.hDefine += "\n    std::optional<bool> %s;".format(name)
-        } else {
-            variable.hDefine += "\n    bool %s;".format(name)
-        }
+        variableTypeBoolean(optional, variable, name);
     } else if (type.substring(type.length - 2) === "[]") {
         typeArrFunctionTwo(type, variable, name, optional);
-    } else if (type.substring(0, 4) === "Map<" || type.indexOf("{[key:") === 0) {
+    } else if (checkIsMap(type)) {
         variable.hDefine += mapTypeString(type, name, optional)
     } else if (type === "any") {
         variable.hDefine += anyTypeString(type, name)
     } else if (type.substring(0, 12) === "NUMBER_TYPE_") {
-        if (optional) {
-            variable.hDefine += "\n    std::optional<%s> %s;".format(type, name)
-        } else {
-            variable.hDefine += "\n    %s %s;".format(type, name)
-        }
-    } else if (type === "Object" || type === "object") {
+        variableTypeNumber(optional, variable, type, name);
+    } else if (checkIsObject(type)) {
         variable.hDefine += "\n    std::map<std::string, std::any> %s;".format(name)
     }
     else {
@@ -113,6 +101,38 @@ function getHDefineOfVariable(name, type, variable, optional) {
     }
 }
 
+function checkIsObject(type) {
+  return type === 'Object' || type === 'object';
+}
+
+function checkIsMap(type) {
+  return type.substring(0, 4) === 'Map<' || type.indexOf('{[key:') === 0;
+}
+
+function variableTypeNumber(optional, variable, type, name) {
+  if (optional) {
+    variable.hDefine += '\n    std::optional<%s> %s;'.format(type, name);
+  } else {
+    variable.hDefine += '\n    %s %s;'.format(type, name);
+  }
+}
+
+function variableTypeBoolean(optional, variable, name) {
+  if (optional) {
+    variable.hDefine += '\n    std::optional<bool> %s;'.format(name);
+  } else {
+    variable.hDefine += '\n    bool %s;'.format(name);
+  }
+}
+
+function variableTypeString(optional, variable, name) {
+  if (optional) {
+    variable.hDefine += '\n    std::optional<std::string> %s;'.format(name);
+  } else {
+    variable.hDefine += '\n    std::string %s;'.format(name);
+  }
+}
+
 function typeArrFunctionTwo(type, variable, name, optional) {
     let arrayType = getArrayTypeTwo(type);
     if (arrayType === "any") {
diff --git a/src/cli/dts2ets/appCodeGen/src/analyze/function.js b/src/cli/dts2ets/appCodeGen/src/analyze/function.js
index 91eda57d650dd1d743a5268de3751c9509f07cbd..0f749c7ad4a3b4071352538bccc84e7e4fc696a8 100644
--- a/src/cli/dts2ets/appCodeGen/src/analyze/function.js
+++ b/src/cli/dts2ets/appCodeGen/src/analyze/function.js
@@ -60,17 +60,17 @@ function analyzeSubInterfaceVariable(t, tt, result) {
 }
 
 function getFuncParaType(v, interfaceName, data, results) {
-    let arrayType = re.match('(Async)*Callback<(Array<([a-zA-Z_0-9]+)>)>', v['type'])
-    let parameter = v['type']
+    let arrayType = re.match('(Async)*Callback<(Array<([a-zA-Z_0-9]+)>)>', v.type)
+    let parameter = v.type
     if (arrayType) {
-        parameter = re.getReg(v['type'], arrayType.regs[2])
+        parameter = re.getReg(v.type, arrayType.regs[2])
     }
     if (isEnum(parameter, data)) {
         let index = enumIndex(parameter, data)
         if (data.enum[index].body.enumValueType === EnumValueType.ENUM_VALUE_TYPE_NUMBER) {
-            v['type'] = v['type'].replace(parameter, 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
+            v.type = v.type.replace(parameter, 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
         } else if (data.enum[index].body.enumValueType === EnumValueType.ENUM_VALUE_TYPE_STRING) {
-            v['type'] = v['type'].replace(parameter, 'string')
+            v.type = v.type.replace(parameter, 'string')
         } else {
             NapiLog.logError('analyzeFunction getFuncParaType is not support this type %s.'
                 .format(data.enum[index].body.enumValueType), getLogErrInfo);
@@ -81,9 +81,9 @@ function getFuncParaType(v, interfaceName, data, results) {
      else if (isEnum(parameter, results)) {
         let index = enumIndex(parameter, results)
         if (results.enum[index].body.enumValueType === EnumValueType.ENUM_VALUE_TYPE_NUMBER) {
-          v['type'] = v['type'].replace(parameter, 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
+          v.type = v.type.replace(parameter, 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
         } else if (results.enum[index].body.enumValueType === EnumValueType.ENUM_VALUE_TYPE_STRING) {
-          v['type'] = v['type'].replace(parameter, 'string')
+          v.type = v.type.replace(parameter, 'string')
         } else {
           NapiLog.logError('analyzeFunction getFuncParaType is not support this type %s.'
               .format(results.enum[index].body.enumValueType), getLogErrInfo());
@@ -93,18 +93,18 @@ function getFuncParaType(v, interfaceName, data, results) {
 
     let interfaceType = re.match('{([A-Za-z0-9_]+:[A-Za-z0-9_,]+)([A-Za-z0-9_]+:[A-Za-z0-9_]+)}$', v['type'])
     if (interfaceType) {
-        v['type'] = interfaceName
+        v.type = interfaceName
     }
 
     if (parameter.indexOf('number') >= 0) {
-        v['type'] = v['type'].replace('number', 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
+        v.type = v.type.replace('number', 'NUMBER_TYPE_' + NumberIncrease.getAndIncrease())
     }
 
     // type的处理
     if (isType(parameter, data)) {
       let index = typeIndex(parameter, data)
       if (data.type[index].isEnum) {
-        v['type'] = v['type'].replace(parameter, 'string')
+        v.type = v.type.replace(parameter, 'string')
       }
     }
     return v