@lcap/nasl 2.18.0 → 2.19.0-beta.1

package/src/concepts/basics/stdlib/nasl.util.ts

@@ -13,6 +13,7 @@ import Identifier from '../../Identifier__';
 import BooleanLiteral from '../../BooleanLiteral__';
 import StringLiteral from '../../StringLiteral__';
 import AnonymousFunction from '../../AnonymousFunction__';
+import StringInterpolation from '../../StringInterpolation__';
 
 export default new Namespace({
     name: 'util',
@@ -23,6 +24,7 @@ export default new Namespace({
                 new Param({
                     name: 'arg',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                    defaultExpression: new StringInterpolation(),
                 }),
             ],
         }),
@@ -74,6 +76,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'value',
+                    description: '选择变量或常量',
                     // typeAnnotation: new TypeAnnotation()
                     defaultExpression: new Identifier(),
                 }),
@@ -86,26 +89,66 @@ export default new Namespace({
             ],
         }),
 
+        new Function({
+            name: 'ToString',
+            description: '各类型转换成字符串',
+            params: [
+                new Param({
+                    name: 'value',
+                    defaultExpression: new Identifier(),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createPrimitive('String'),
+                }),
+            ],
+        }),
+
+        new Function({
+            name: 'FromString',
+            description: '字符串转换成其他类型',
+            typeParams: [
+                new TypeParam({
+                    name: 'T',
+                }),
+            ],
+            params: [
+                new Param({
+                    name: 'value',
+                    defaultExpression: new Identifier(),
+                }),
+            ],
+            returns: [
+                new Return({
+                    typeAnnotation: TypeAnnotation.createTypeParam('T'),
+                }),
+            ],
+        }),
+
         new Function({
             name: 'IndexOf',
             description: '搜索字符串位置',
             params: [
                 new Param({
                     name: 'str',
+                    description: '指定字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
                     name: 'search',
+                    description: '指定需要搜索的字段，String类型',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
                     name: 'fromIndex',
+                    description: '开始搜索的索引值，Integer类型，用数字表示第几项，项数索引从0开始',
                     defaultExpression: new NumericLiteral({ value: '0' }),
                 }),
 
                 new Param({
                     name: 'ignoreCase',
-                    description: '是否忽略大小写',
+                    description: '是否忽略大小写，true为忽略，false为不忽略',
                     defaultExpression: new BooleanLiteral({ value: 'true' }),
                     options: [
                         { text: 'true', value: 'true' },
@@ -125,16 +168,18 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'str',
+                    description: '指定字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
                     name: 'search',
+                    description: '指定需要搜索的字段，String类型',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
                     name: 'ignoreCase',
-                    description: '是否忽略大小写',
-                    defaultExpression: new BooleanLiteral({ value: 'false' }),
+                    description: '是否忽略大小写，true为忽略，false为不忽略',
+                    defaultExpression: new BooleanLiteral({ value: 'true' }),
                     options: [
                         { text: 'true', value: 'true' },
                         { text: 'false', value: 'false' },
@@ -153,14 +198,17 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'str',
+                    description: '指定原始字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
                     name: 'search',
+                    description: '指定原始字符串中需要被替换的字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
                     name: 'replace',
+                    description: '指定进行替换操作的字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -176,14 +224,17 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'str',
+                    description: '指定需要截取的字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
                     name: 'start',
+                    description: 'int类型，输入数字指定开始截取的位置',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
                     name: 'length',
+                    description: '指定截取的字符串长度',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -222,6 +273,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'value',
+                    description: '指定需要将枚举值转换为标题的字段',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -243,6 +295,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'value',
+                    description: '指定一个字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -258,10 +311,12 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'str',
+                    description: '指定字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
                     name: 'separator',
+                    description: '指定字符串中作为分隔符的参数',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -279,12 +334,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createPrimitive('String')],
                     }),
                 }),
                 new Param({
                     name: 'separator',
+                    description: '连接符，用于连接列表中的项',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -300,10 +357,12 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'str1',
+                    description: '指定字符串1',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
                 new Param({
                     name: 'str2',
+                    description: '指定字符串2',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -319,6 +378,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'param',
+                    description: '指定字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -334,6 +394,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'str1',
+                    description: '指定字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -349,6 +410,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'str1',
+                    description: '指定字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -364,6 +426,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'str1',
+                    description: '指定字符串',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
             ],
@@ -379,12 +442,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'index',
+                    description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
             ],
@@ -400,16 +465,19 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'index',
+                    description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
                 new Param({
                     name: 'item',
+                    description: '列表指定索引下的新项',
                     typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
@@ -425,12 +493,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'item',
+                    description: '指定项',
                     typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
@@ -446,12 +516,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'item',
+                    description: '指定需要在列表末尾增加的项',
                     typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
@@ -462,12 +534,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表1',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'addList',
+                    description: '指定列表2',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
@@ -485,16 +559,19 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'index',
+                    description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
                 new Param({
                     name: 'item',
+                    description: '待插入项',
                     typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
@@ -505,12 +582,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'item',
+                    description: '指定项',
                     typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
@@ -521,12 +600,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'index',
+                    description: '索引，integer类型，用数字表示第几项，项数索引从0开始',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
             ],
@@ -542,6 +623,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                 }),
             ],
             returns: [
@@ -556,6 +638,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                 }),
             ],
             returns: [
@@ -570,6 +653,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                 }),
             ],
             returns: [
@@ -586,11 +670,11 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                 }),
                 new Param({
                     name: 'by',
-                    description: `<div>(\${0}) → Boolean | Integer | Long | Decimal | String</div>
-                                  <div>(\${0}) → V</div>`,
+                    description: `根据项的属性及其本身进行key和value的定义`,
                     defaultExpression: new AnonymousFunction({
                         params: [
                             new Param({
@@ -621,10 +705,11 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                 }),
                 new Param({
                     name: 'by',
-                    description: '(${0}) → T',
+                    description: '指定对列表中项的某个属性或项本身的处理方式，支持算数运算和比较运算',
                     defaultExpression: new AnonymousFunction({
                         params: [
                             new Param({
@@ -649,6 +734,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                 }),
             ],
             returns: [
@@ -663,6 +749,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定数值类型列表',
                 }),
             ],
             returns: [
@@ -677,6 +764,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定数值类型列表',
                 }),
             ],
             returns: [
@@ -691,6 +779,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定数值类型列表',
                 }),
             ],
             returns: [
@@ -705,6 +794,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定数值类型列表',
                 }),
             ],
             returns: [
@@ -719,6 +809,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'map',
+                    description: '指定映射',
                     typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
                             TypeAnnotation.createTypeParam('K'),
@@ -728,6 +819,7 @@ export default new Namespace({
                 }),
                 new Param({
                     name: 'key',
+                    description: '指定参数key',
                     typeAnnotation: TypeAnnotation.createTypeParam('K'),
                 }),
             ],
@@ -743,6 +835,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'map',
+                    description: '指定映射',
                     typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
                             TypeAnnotation.createTypeParam('K'),
@@ -752,10 +845,12 @@ export default new Namespace({
                 }),
                 new Param({
                     name: 'key',
+                    description: '指定参数key',
                     typeAnnotation: TypeAnnotation.createTypeParam('K'),
                 }),
                 new Param({
                     name: 'value',
+                    description: '指定参数value',
                     typeAnnotation: TypeAnnotation.createTypeParam('V'),
                 }),
             ],
@@ -766,6 +861,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'map',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
                             TypeAnnotation.createTypeParam('K'),
@@ -775,6 +871,7 @@ export default new Namespace({
                 }),
                 new Param({
                     name: 'key',
+                    description: '指定参数key',
                     typeAnnotation: TypeAnnotation.createTypeParam('K'),
                 }),
             ],
@@ -785,6 +882,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'map',
+                    description: '指定映射',
                     typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
                             TypeAnnotation.createTypeParam('K'),
@@ -794,6 +892,7 @@ export default new Namespace({
                 }),
                 new Param({
                     name: 'key',
+                    description: '指定参数key',
                     typeAnnotation: TypeAnnotation.createTypeParam('K'),
                 }),
             ],
@@ -809,6 +908,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'map',
+                    description: '指定映射',
                     typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
                             TypeAnnotation.createTypeParam('K'),
@@ -831,6 +931,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'map',
+                    description: '指定映射',
                     typeAnnotation: TypeAnnotation.createGeneric('map', {
                         typeArguments: [
                             TypeAnnotation.createTypeParam('K'),
@@ -853,10 +954,11 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'map',
+                    description: '指定映射',
                 }),
                 new Param({
                     name: 'by',
-                    description: '(${0},${1}) → Boolean',
+                    description: '针对键值对的参数key和value设置过滤条件，支持算数运算、比较运算和逻辑运算',
                     defaultExpression: new AnonymousFunction({
                         name: '',
                         description: '',
@@ -890,11 +992,11 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'map',
+                    description: '指定映射',
                 }),
                 new Param({
                     name: 'by',
-                    description: `<div>(\${0}, \${1}) → Boolean | Integer | Long | Decimal | String</div>
-                                  <div>(\${0}, \${1}) → V</div>`,
+                    description: `指定映射中键值对的参数处理方式，支持算数运算和比较运算`,
                     defaultExpression: new AnonymousFunction({
                         params: [
                             new Param({
@@ -971,11 +1073,12 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'date',
+                    description: '指定需要格式化日期的字段',
                     typeAnnotation: TypeAnnotation.createPrimitive('Date'),
                 }),
                 new Param({
                     name: 'formatter',
-                    defaultValue: 'yyyy-MM-dd',
+                    defaultValue: '格式化规则，默认为yyyy-MM-dd，即年月日格式',
                     defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd' }),
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                 }),
@@ -992,12 +1095,13 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'date',
+                    description: '指定需要格式化日期时间的字段',
                     typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
                 new Param({
                     name: 'formatter',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
-                    defaultValue: 'yyyy-MM-dd HH:mm:ss',
+                    defaultValue: '格式化规则，默认为yyyy-MM-dd',
                     defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd HH:mm:ss' }),
                 }),
             ],
@@ -1013,6 +1117,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'value',
+                    description: '指定需要格式化小数位数的字段',
                     typeAnnotation: TypeAnnotation.createPrimitive('Decimal'),
                     defaultExpression: new Identifier(),
                 }),
@@ -1025,6 +1130,7 @@ export default new Namespace({
                 }),
                 new Param({
                     name: 'showGroups',
+                    description: '是否显示千分位：true显示，false不显示',
                     typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
                     defaultValue: 'false',
                     defaultExpression: new BooleanLiteral({ value: 'false' }),
@@ -1032,7 +1138,6 @@ export default new Namespace({
                         { text: 'true', value: 'true' },
                         { text: 'false', value: 'false' },
                     ],
-                    description: '是否显示千分位：true显示，false不显示',
                 }),
             ],
             returns: [
@@ -1047,10 +1152,12 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'dateTime',
+                    description: '指定日期时间',
                     typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
                 new Param({
                     name: 'amount',
+                    description: '增加的天数',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
             ],
@@ -1066,10 +1173,12 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'dateTime',
+                    description: '指定日期时间',
                     typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                 }),
                 new Param({
                     name: 'amount',
+                    description: '增加的月数',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
             ],
@@ -1085,17 +1194,19 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'dateTime1',
+                    description: '指定日期时间1',
                     typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                     defaultExpression: new Identifier(),
                 }),
                 new Param({
                     name: 'dateTime2',
+                    description: '指定日期时间2',
                     typeAnnotation: TypeAnnotation.createPrimitive('DateTime'),
                     defaultExpression: new Identifier(),
                 }),
                 new Param({
                     name: 'calcType',
-                    description: '计算类型。如选择天数，则计算前两个参数的天数差值。',
+                    description: '计算类型。计算两个日期时间之间的差值，支持年数、季度数、月数、星期数、天数、小时数、分钟数、秒数',
                     typeAnnotation: TypeAnnotation.createPrimitive('String'),
                     defaultValue: 'd',
                     defaultExpression: new StringLiteral({ value: 'd' }),
@@ -1123,6 +1234,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'struct',
+                    description: '指定对象',
                     typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
@@ -1138,6 +1250,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'struct',
+                    description: '指定对象',
                     typeAnnotation: TypeAnnotation.createTypeParam('T'),
                 }),
             ],
@@ -1172,12 +1285,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'total',
+                    description: '指定数据条数',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
             ],
@@ -1195,12 +1310,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'by',
+                    description: '指定列表中项的某个属性或项本身，支持算数运算和比较运算',
                     defaultExpression: new Function({
                         name: '',
                         description: '',
@@ -1214,13 +1331,13 @@ export default new Namespace({
                 }),
                 new Param({
                     name: 'sort',
-                    description: '下拉选择升序、降序',
+                    description: '支持升序或降序设置，asc为升序，desc为降序。',
                     typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
                     defaultValue: 'asc',
                     defaultExpression: new BooleanLiteral({ value: 'true' }),
                     options: [
-                        { text: 'asc', value: 'true' },
-                        { text: 'desc', value: 'false' },
+                        { text: 'asc(升序)', value: 'true' },
+                        { text: 'desc(降序)', value: 'false' },
                     ],
                 }),
             ],
@@ -1232,12 +1349,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'by',
+                    description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
                     defaultExpression: new Function({
                         name: '',
                         description: '',
@@ -1262,12 +1381,14 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'by',
+                    description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
                     defaultExpression: new Function({
                         name: '',
                         description: '',
@@ -1292,10 +1413,11 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                 }),
                 new Param({
                     name: 'by',
-                    description: '(${0}) → Boolean',
+                    description: '指定列表中项的某个属性或项本身，通过算数运算、比较运算或逻辑运算进行条件判断并输出布尔值',
                     defaultExpression: new AnonymousFunction({
                         params: [
                             new Param({
@@ -1321,6 +1443,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
@@ -1334,6 +1457,7 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
@@ -1347,14 +1471,16 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                 }),
                 new Param({
                     name: 'by',
-                    description: '(${0}) → T',
+                    description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
                     defaultExpression: new AnonymousFunction({
                         params: [
                             new Param({
                                 name: 'item',
+                                description: '是否忽略大小写',
                                 typeAnnotation: null,
                             }),
                         ],
@@ -1376,14 +1502,16 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                 }),
                 new Param({
                     name: 'by',
-                    description: '(${0}) → Boolean | Integer | Long | Decimal | String',
+                    description: '指定列表中项的某个属性，若项无属性，则该函数不生效',
                     defaultExpression: new AnonymousFunction({
                         params: [
                             new Param({
                                 name: 'item',
+                                description: '是否忽略大小写',
                                 typeAnnotation: null,
                             }),
                         ],
@@ -1408,16 +1536,19 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'start',
+                    description: '切片起始的索引，integer类型，项数索引从0开始',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
                 new Param({
                     name: 'end',
+                    description: '切片结束的索引，integer类型，用数字表示第几项，项数索引从0开始',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
             ],
@@ -1435,16 +1566,19 @@ export default new Namespace({
             params: [
                 new Param({
                     name: 'list',
+                    description: '指定列表',
                     typeAnnotation: TypeAnnotation.createGeneric('List', {
                         typeArguments: [TypeAnnotation.createTypeParam('T')],
                     }),
                 }),
                 new Param({
                     name: 'page',
+                    description: '页数，integer类型，从1开始',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
                 new Param({
                     name: 'size',
+                    description: '每页的大小，integer类型',
                     typeAnnotation: TypeAnnotation.createPrimitive('Integer'),
                 }),
             ],