# 操作符函数
本文介绍操作符函数的语法规则，包括参数解释、函数示例等。
#### 函数列表
如果值为负数，请使用op_neg(positive value)函数，例如：您要表示-1，请使用op_neg(1)。
表1操作符函数列表 
| **类型**  | **函数**                                                                                                                                   | **说明**                                                 |
|:---|:---|:---|
| 条件判断函数  | [op_if]        | 根据判断条件返回不同表达式的值。                                       |
| 条件判断函数  | [op_ifnull]   | 返回第一个值不为None的表达式的值。                                    |
| 条件判断函数  | [op_coalesce] | 返回第一个值不为None的表达式的值。                                    |
| 条件判断函数  | [op_nullif]    | 如果表达式1等于表达式2，返回None。否则返回表达式1的值。                        |
| 条件判断函数  | [op_and]      | 使用逻辑运算and，对任意类型值进行真假判断，所有参数值为真时返回true。                 |
| 条件判断函数  | [op_not]      | 使用逻辑运算not，对任意类型值进行真假判断，返回参数值的反义布尔值。                    |
| 条件判断函数  | [op_or]       | 使用逻辑运算or，对任意类型值进行真假判断。当任意参数值为真时返回true，所有参数值为假时返回false。 |
| 比较      | [op_eq]      | 按照a==b条件进行计算，返回true或false。a和b类型必须一致，例如都是字符串、数字或者列表。    |
| 比较      | [op_ge]        | 按照a\>=b条件进行计算，返回true或false。a和b类型必须一致，例如都是字符串、数字或者列表。   |
| 比较      | [op_gt]        | 按照a\>b条件进行计算，返回true或false。a和b类型必须一致，例如都是字符串、数字或者列表。    |
| 比较      | [op_le]      | 按照a\<=b条件进行计算，返回true或false。a和b类型必须一致，例如都是字符串、数字或者列表。   |
| 比较      | [op_lt]      | 按照a\<b条件进行计算，返回true或false。a和b类型必须一致，例如都是字符串、数字或者列表。    |
| 比较      | [op_ne]       | 按照a!=b条件进行计算，返回true或false。a和b类型必须一致，例如都是字符串、数字或者列表。    |
| 容器判断    | [op_len]       | 计算文本字符串中的字符数，可用于字符串和其他返回元组、列表、字典的表达式。                  |
| 容器判断    | [op_in]       | 判断字符串、元组、列表或字典中是否包含特定元素，返回true或false。                  |
| 容器判断    | [op_not_in] | 判断字符串、元组、列表或字典中是否不包含特定元素，返回true或false。                 |
| 容器判断    | [op_slice]    | 对指定字符串、数组、元组进行截取。                                      |
| 容器判断    | [op_index]     | 根据字符串、数组、元组的下标返回其对应的元素。                                |
| 一般性多值操作 | [op_add]        | 计算多个值的和，可以是字符串或者数字等。                                   |
| 一般性多值操作 | [op_max]      | 计算多个字段或表达式表示的数值的最大值。                                   |
| 一般性多值操作 | [op_min]      | 计算多个字段或表达式表示的数值的最小值。                                   |
   
 #### op_if
根据判断条件返回不同表达式的值。
- **函数格式**
  ```
  op_if(condition, expression1, expression2)
  ```
  
- **参数说明**
  
  |  **参数名称**   | **参数类型** | **是否必填** |            **说明**            |
  |---|---|---|---|
  | condition   | 任意       | 是        | 判断条件。如果该条件为非布尔值，系统将对其采用真假判断。 |
  | expression1 | 任意       | 是        | 判断结果为true时，返回该表达式的值。         |
  | expression2 | 任意       | 是        | 判断结果为false时，返回该表达式的值。        |
     
  
- **返回结果**
  返回相应的表达式的值。
  
- **函数示例**
  1. 示例1：如果content为true，则把表达式1的值赋给test_if。
     - 测试数据
       ```
       {
        "content": "hello"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_if", op_if(v("content"),"still origion content","replace this"))
       ```
       
     
     - 加工结果
       ```
       content: hello
       test_if:  still origion content
       ```
       
      
  
  2. 示例2：如果content为false，则把表达式2的值赋给test_if。
     - 测试数据
       ```
       {
        "content": 0
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_if", op_if(ct_int(v("content", default=0)),"still origion content","replace this"))
       ```
       
     
     - 加工结果
       ```
       content: 0
       test_if:  replace this
       ```
       
      
   
 
 #### op_ifnull
返回第一个值不为None的表达式的值。
- **函数格式**
  ```
  op_ifnull(expression1, expression2, ....)
  ```
  
- **参数说明**
  
  |  **参数名称**   | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | expression1 | 任意       | 是        | 表达式1。  |
  | expression2 | 任意       | 是        | 表达式2。  |
     
  
- **返回结果**
  返回第一个值不为None的表达式的值。
  
- **函数示例**
  1. 示例1：
     - 测试数据
       ```
       {
        "test_if": "hello",
        "escape_name": "Etl"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_ifnull", op_ifnull(v("escape_name"),v("test_if")))
       ```
       
     
     - 加工结果
       ```
       test_if: hello
       escape_name: Etl 
       test_ifnull:  Etl
       ```
       
      
  
  2. 示例2：
     - 测试数据
       ```
       {
        "test_if": "hello",
        "escape_name": "Etl"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_ifnull", op_ifnull(v("test_if"),v("escape_name")))
       ```
       
     
     - 加工结果
       ```
       test_if: hello
       escape_name: Etl 
       test_ifnull:  hello
       ```
       
      
   
 
 #### op_coalesce
返回第一个值不为None的表达式的值。
- **函数格式**
  ```
  op_coalesce(expression1, expression2, ...)
  ```
  
- **参数说明**
  
  |  **参数名称**   | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | expression1 | 任意       | 是        | 表达式1。  |
  | expression2 | 任意       | 是        | 表达式2。  |
     
  
- **返回结果**
  返回第一个值不为None的表达式的值。
  
- **函数示例**
  1. 示例1：
     - 测试数据
       ```
       {
        "test_if": "hello",
        "escape_name": "Etl"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_coalesce", op_coalesce(v("escape_name"),v("test_if")))
       ```
       
     
     - 加工结果
       ```
       test_if: hello
       escape_name: Etl
       test_coalesce: Etl
       ```
       
      
  
  2. 示例2：
     - 测试数据
       ```
       {
        "test_if": "hello",
        "escape_name": "Etl"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_coalesce", op_coalesce(v("test_if"),v("escape_name")))
       ```
       
     
     - 加工结果
       ```
       test_if: hello
       escape_name: Etl
       test_coalesce: hello
       ```
       
      
   
 
 #### op_nullif
如果表达式1等于表达式2，返回None。否则返回表达式1的值。
- **函数格式**
  ```
  op_nullif(expression1, expression2)
  ```
  
- **参数说明**
  
  |  **参数名称**   | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | expression1 | 任意       | 是        | 表达式1。  |
  | expression2 | 任意       | 是        | 表达式2。  |
     
  
- **返回结果**
  如果表达式1和表达式2相等返回None，否则返回表达式1的值。
  
- **函数示例**
  1. 示例1：
     - 测试数据
       ```
       {
        "test_if": "hello",
        "escape_name": "Etl"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_ifnull", op_nullif(v("test_if"),v("escape_name")))
       ```
       
     
     - 加工结果
       ```
       test_if: hello
       escape_name: Etl 
       test_ifnull:  hello
       ```
       
      
  
  2. 示例2：
     - 测试数据
       ```
       {
        "test_if": "hello",
        "escape_name": "hello"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_ifnull", op_nullif(v("content"),v("escape_name")))
       ```
       
     
     - 加工结果
       ```
       #因为content与escape_name内容一样，所以没有任何内容返回给test_isnull字段。
       test_if: hello 
       escape_name: hello
       ```
       
      
   
 
 #### op_and
使用逻辑运算and，对任意类型值进行真假判断，所有参数值为真时返回true。
- **函数格式**
  ```
  op_and(value1, value2, ...)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 任意       | 是        | 运算值1。  |
  | value2   | 任意       | 是        | 运算值2。  |
     
  
- **返回结果**
  - 所有参数值为真时返回true。
  
  - 对任意类型值进行真假判断。
   
- **函数示例**
  1. 示例1：
     - 测试数据
       ```
       {
        "number1": 123,
        "number2": 234
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_and", op_and(v("number1"),v("number2")))
       ```
       
     
     - 加工结果
       ```
       number1: 123
       number2: 234
       op_and:  true
       ```
       
      
  
  2. 示例2：
     - 测试数据
       ```
       {
        "number1": 0,
        "number2": 234
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_and", op_and(v("number1"),v("number2")))
       ```
       
     
     - 加工结果
       ```
       number1: 0
       number2: 234
       op_and: false
       ```
       
      
  
  3. 示例3：
     - 测试数据
       ```
       {
        "ctx1": "false",
        "ctx2": 234
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_and", op_and(v("ctx1"),v("ctx2")))
       ```
       
     
     - 加工结果
       ```
       ctx1: false
       ctx2: 234
       op_and: true
       ```
       
      
  
  4. 示例4：
     - 测试数据
       ```
       {
        "ctx1": "true",
        "ctx2": 234
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_and", op_and(v("ctx1"),v("ctx2")))
       ```
       
     
     - 加工结果
       ```
       ctx1: true
       ctx2: 234
       op_and: true
       ```
       
      
   
 
 #### op_not
使用逻辑运算not，对任意类型值进行真假判断，返回表达式值的反义布尔值。
- **函数格式**
  ```
  op_not(expression)
  ```
  
- **参数说明**
  
  |  **参数名称**  | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | expression | 任意       | 是        | 表达式。   |
     
  
- **返回结果**
  - 返回表达式值的反义布尔值。
  
  - 对任意类型值进行真假判断。
   
- **函数示例**
  1. 示例1：
     - 测试数据
       ```
       {
        "ctx1": "true"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_not", op_not(v("ctx1")))
       ```
       
     
     - 加工结果
       ```
       ctx1: true
       op_not:  false
       ```
       
      
  
  2. 示例2：
     - 测试数据
       ```
       {
        "ctx1": 345
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_not", op_not(v("ctx1")))
       ```
       
     
     - 加工结果
       ```
       ctx1: 345
       op_not:  false
       ```
       
      
  
  3. 示例3：
     - 测试数据
       ```
       {
        "ctx1": 0
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_not", op_not(ct_int(v("ctx1"))))
       ```
       
     
     - 加工结果
       ```
       ctx1: 0
       op_not:  true
       ```
       
      
  
  4. 示例4：
     - 测试数据
       ```
       {
        "ctx1": "ETL"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_not", op_not(v("ctx1")))
       ```
       
     
     - 加工结果
       ```
       ctx1: ETL
       op_not:  false
       ```
       
      
  
  5. 示例5：
     - 测试数据
       ```
       {
        "ctx1": "None"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_not", op_not(v("ctx1")))
       ```
       
     
     - 加工结果
       ```
       ctx1: None
       op_not:  false
       ```
       
      
   
 
 #### op_or
使用逻辑运算or，对任意类型值进行真假判断。当任意表达式的值为真时返回true，所有表达式值为假时返回false。
- **函数格式**
  ```
  op_or(expression1, expression2, ...)
  ```
  
- **参数说明**
  
  |  **参数名称**   | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | expression1 | 任意       | 是        | 表达式1。  |
  | expression2 | 任意       | 是        | 表达式2。  |
     
  
- **返回结果**
  - 任意表达式的值为真时返回true，所有表达式的值为假时返回false。
  
  - 对任意类型值进行真假判断。
   
- **函数示例**
  1. 示例1：
     - 测试数据
       ```
       {
        "ctx1": 123,
        "ctx2": 234
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_or", op_or(v("ctx1"),v("ctx2")))
       ```
       
     
     - 加工结果
       ```
       ctx1: 123
       ctx2: 234
       op_or:  true
       ```
       
      
  
  2. 示例2：
     - 测试数据
       ```
       {
        "ctx1": 0,
        "ctx2": 234
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_or", op_or(v("ctx1"),v("ctx2")))
       ```
       
     
     - 加工结果
       ```
       ctx1: 0
       ctx2: 234
       op_or:  true
       ```
       
      
  
  3. 示例3：
     - 测试数据
       ```
       {
        "ctx1": "ETL",
        "ctx2": "aa"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_or", op_or(v("ctx1"),v("ctx2")))
       ```
       
     
     - 加工结果
       ```
       ctx1: ETL
       ctx2: aa 
       op_or:  true
       ```
       
      
  
  4. 示例4：
     - 测试数据
       ```
       {
        "ctx1": "true",
        "ctx2":"false"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_or", op_or(v("ctx1"),v("ctx2")))
       ```
       
     
     - 加工结果
       ```
       ctx1: true
       ctx2: false
       op_or:  true
       ```
       
      
  
  5. 示例5：
     - 测试数据
       ```
       {
        "ctx1": 0,
        "ctx2":"false"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_or", op_or(ct_int(v("ctx1")),v("ctx2")))
       ```
       
     
     - 加工结果
       ```
       ctx1: 0
       ctx2: false
       op_or:  true
       ```
       
      
  
  6. 示例6：
     - 测试数据
       ```
       {
        "ctx1": 124,
        "ctx2": "true"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_or", op_or(v("ctx1"),v("ctx2")))
       ```
       
     
     - 加工结果
       ```
       ctx1: 124
       ctx2: true
       op_or:  true
       ```
       
      
   
 
 #### op_eq
按照a==b条件进行计算，返回true或false。
- **函数格式**
  ```
  op_eq(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 任意       | 是        | 运算值1。  |
  | value2   | 必须与值1相同  | 是        | 运算值2。  |
     
  
- **返回结果**
  如果值1与值2相等返回true，否则返回false。
  
- **函数示例**
  1. 示例1：
     - 测试数据
       ```
       {
        "content": "hello",
        "ctx": "hello"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_eq", op_eq(v("content"),v("ctx")))
       ```
       
     
     - 加工结果
       ```
       content: hello
       ctx: hello 
       test_eq: true
       ```
       
      
  
  2. 示例2：
     - 测试数据
       ```
       {
        "content": "hello",
        "ctx": "ctx"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_eq", op_eq(v("content"),v("ctx")))
       ```
       
     
     - 加工结果
       ```
       content: hello
       ctx: ctx 
       test_eq: false
       ```
       
      
   
 
 #### op_ge
按照a\>=b条件进行计算，返回true或false。
- **函数格式**
  ```
  op_ge(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 任意       | 是        | 运算值1。  |
  | value2   | 必须与值1相同  | 是        | 运算值2。  |
     
  
- **返回结果**
  如果值1大于等于值2返回true，否则返回false。
  
- **函数示例**
  1. 示例1：假如apple_price的值大于等于orange_price的值，则返回true。
     - 测试数据
       ```
       {
        "apple_price": 16,
        "orange_price": 14
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_ge", op_ge(ct_int(v("apple_price")),ct_int(v("orange_price"))))
       ```
       
     
     - 加工结果
       ```
       apple_price: 16
       orange_price: 14
       test_ge: true
       ```
       
      
  
  2. 示例2：假如apple_price的值小于orange_price的值，则返回false。
     - 测试数据
       ```
       {
        "apple_price": 12,
        "orange_price": 14
       }
       ```
       
     
     - 加工规则
       ```
       e_set("test_ge", op_ge(ct_int(v("apple_price")),ct_int(v("orange_price"))))
       ```
       
     
     - 加工结果
       ```
       apple_price: 12
       orange_price: 14
       test_ge: false
       ```
       
      
   
 
 #### op_gt
按照a\>b条件进行计算，返回true或false。
- **函数格式**
  ```
  op_gt(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 任意       | 是        | 运算值1。  |
  | value2   | 必须与值1相同  | 是        | 运算值2。  |
     
  
- **返回结果**
  如果值1大于值2返回true，否则返回false。
  
- **函数示例**
  1. 示例1：判断old_number取值是否大于young_number取值，大于返回true否则返回false。
     - 测试数据
       ```
       {
        "old_number": 16,
        "young_number": 14
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_gt",op_gt(ct_int(v("old_number")),ct_int(v("young_number"))))
       ```
       
     
     - 加工结果
       ```
       old_number: 16
       young_number: 14
       test_ge: true
       ```
       
      
  
  2. 示例2：判断priority取值是否大于price取值，大于返回true否则返回false。
     - 测试数据
       ```
       {
        "priority": 14,
        "price": 16
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_gt",op_gt(ct_int(v("priority")),ct_int(v("price"))))
       ```
       
     
     - 加工结果
       ```
       priority: 14
       price: 16
       test_ge: false
       ```
       
      
   
 
 #### op_le
按照a\<=b条件进行计算，返回true或false。
- **函数格式**
  ```
  op_le(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 任意       | 是        | 运算值1。  |
  | value2   | 必须与值1相同  | 是        | 运算值2。  |
     
  
- **返回结果**
  如果值1小于等于值2返回true，否则返回false。
  
- **函数示例**
  1. 示例1：如果priority的值小于等于price的值，返回true否则返回false。
     - 测试数据
       ```
       {
        "priority": 16,
        "price": 14
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_le",op_le(ct_int(v("priority")),ct_int(v("price"))))
       ```
       
     
     - 加工结果
       ```
       priority: 16
       price: 14
       op_le: false
       ```
       
      
  
  2. 示例2：如果priority的值小于等于price的值，返回true否则返回false。
     - 测试数据
       ```
       {
        "priority": 14,
        "price": 16
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_le",op_le(ct_int(v("priority")),ct_int(v("price"))))
       ```
       
     
     - 加工结果
       ```
       priority: 14
       price: 16
       test_ge: true
       ```
       
      
   
 
 #### op_lt
按照a\<b条件进行计算，返回true或false。
- **函数格式**
  ```
  op_lt(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 任意       | 是        | 运算值1。  |
  | value2   | 必须与值1相同  | 是        | 运算值2。  |
     
  
- **返回结果**
  如果值1小于值2，返回true，否则返回false。
  
- **函数示例**
  1. 示例1： 如果priority的值小于price的值，返回true否则返回false。
     - 测试数据
       ```
       {
        "priority": 16,
        "price": 14
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_lt",op_lt(ct_int(v("priority")),ct_int(v("price"))))
       ```
       
     
     - 加工结果
       ```
       priority: 16
       price: 14
       op_lt: false
       ```
       
      
  
  2. 示例2：如果priority的值小于price的值，返回true否则返回false。
     - 测试数据
       ```
       {
        "priority": 14,
        "price": 15
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_lt",op_lt(ct_int(v("priority")),ct_int(v("price"))))
       ```
       
     
     - 加工结果
       ```
       priority: 14
       price: 15
       op_lt: true
       ```
       
      
   
 
 #### op_ne
按照a!=b条件进行计算，返回true或false。
- **函数格式**
  ```
  op_ne(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 任意       | 是        | 运算值1。  |
  | value2   | 必须与值1相同  | 是        | 运算值2。  |
     
  
- **返回结果**
  如果值1不等于值2，返回true，否则返回false。
  
- **函数示例**
  1. 示例1：
     - 测试数据
       ```
       {
        "priority": 16,
        "price": 14
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_ne",op_ne(ct_int(v("priority")),ct_int(v("price"))))
       ```
       
     
     - 加工结果
       ```
       priority: 16
       price: 14
       op_ne: true
       ```
       
      
  
  2. 示例2：
     - 测试数据
       ```
       {
        "priority": 14,
        "price": 14
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_ne",op_ne(ct_int(v("priority")),ct_int(v("price"))))
       ```
       
     
     - 加工结果
       ```
       priority: 14
       price: 14
       op_ne: false
       ```
       
      
   
 
 #### op_len
计算文本字符串中的字符数，可用于字符串和其他返回元组、列表、字典的表达式。
- **函数格式**
  ```
  op_len(value）
  ```
  
- **参数说明**
  
  | **参数名称** |   **参数类型**    | **是否必填** | **说明** |
  |---|---|---|---|
  | value    | 字符串、元组、列表或字典等 | 是        | 运算值。   |
     
  
- **返回结果**
  返回字段的长度。
  
- **函数示例**
  - 测试数据
    ```
    {
     "content": "I,love,this,world"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("op_len",op_len(v("content")))
    ```
    
  
  - 加工结果
    ```
    content: I,love,this,world
    op_len: 17
    ```
    
   
 
 #### op_in
判断字符串、元组、列表或字典中是否包含特定元素，返回true或false。
- **函数格式**
  ```
  op_in(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** |   **参数类型**    | **是否必填** |     **说明**      |
  |---|---|---|---|
  | value1   | 字符串、元组、列表或字典等 | 是        | 字符串、元组、列表或者字典等。 |
  | value2   | 任意            | 是        | 判断的元素。          |
     
  **说明** 函数中字符串、元组、列表或字典参数在前，元素在后。
  
- **返回结果**
  如果字符串、元组、列表或字典a中包含元素b返回true，否则返回false。
  
- **函数示例**
  - 测试数据
    ```
    {
     "list":  [1, 3, 2, 7, 4, 6],
     "num2":  2
    }
    ```
    
  
  - 加工规则
    ```
    e_set("op_in",op_in(v("list"),v("num2")))
    ```
    
  
  - 加工结果
    ```
    list:  [1, 3, 2, 7, 4, 6]
    num2:  2
    op_in: true
    ```
    
   
 
 #### op_not_in
判断字符串、元组、列表或字典中是否不包含特定元素，返回true或false。
- **函数格式**
  ```
  op_not_in(value1, value2)
  ```
  
- **参数说明**
  
  | **参数名称** |   **参数类型**    | **是否必填** |     **说明**      |
  |---|---|---|---|
  | value1   | 字符串、元组、列表或字典等 | 是        | 字符串、元组、列表或者字典等。 |
  | value2   | 任意            | 是        | 判断的元素。          |
     
  **说明** 函数中字符串、元组、列表或字典参数在前，元素在后。
  
- **返回结果**
  如果字符串、元组、列表或字典中不包含元素返回true，否则返回false。
  
- **函数示例**
  - 测试数据
    ```
    {
     "list":  [1, 3, 2, 7, 4, 6],
     "num2":  12
    }
    ```
    
  
  - 加工规则
    ```
    e_set("op_not_in",op_not_in(v("list"),v("num2")))
    ```
    
  
  - 加工结果
    ```
    list:  [1, 3, 2, 7, 4, 6]
    num2:  12
    op_not_in: true
    ```
    
   
 
 #### op_slice
对指定字符串、数组、元组进行截取。
- **函数格式**
  ```
  op_slice(value, start=0, end=None, step=None)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |           **说明**           |
  |---|---|---|---|
  | value    | String   | 是        | 函数要切片的值。                   |
  | start    | Num      | 否        | 截取的起始位置，默认为位置0。            |
  | end      | Num      | 否        | 截取的结束位置，不包含该位置，默认为字符串结尾位置。 |
  | step     | Num      | 否        | 每次截取的长度。                   |
     
  
- **返回结果**
  返回提取后的字符串。
  
- **函数示例**
  1. 示例1：对word字段从起点开始进行截取，结尾为2。
     - 测试数据
       ```
       {
        "word":  "I,love,this,world"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_slice",op_slice(v("word"),2))
       ```
       
     
     - 加工结果
       ```
       word:  I,love,this,world
       op_slice: I,
       ```
       
      
  
  2. 示例2：对word字段从位置2到位置9进行截取，步长为1。
     - 测试数据
       ```
       {
        "word":  "I,love,this,world"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_slice",op_slice(v("word"),2,9,1))
       ```
       
     
     - 加工结果
       ```
       word:  I,love,this,world
       op_slice: love,th
       ```
       
      
   
 
 #### op_index
根据字符串、数组、元组的下标返回其对应的元素。
- **函数格式**
  ```
  op_index(value, index)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |       **说明**       |
  |---|---|---|---|
  | value    | String   | 是        | 字符串、数组、元组等。        |
  | index    | Num      | 否        | 需要传入的字符串、数组或元组的下标。 |
     
  
- **返回结果**
  返回下标对应的元素。
  
- **函数示例**
  1. 示例1：返回word字段下标为0的元素。
     - 测试数据
       ```
       {
        "word":  "I,love,this,world"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_index",op_index(v("word"),0))
       ```
       
     
     - 加工结果
       ```
       word:  I,love,this,world
       op_index: I
       ```
       
      
  
  2. 示例2：返回word字段下标为3的元素。
     - 测试数据
       ```
       {
        "word":  "I,love,this,world"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("op_index",op_index(v("word"),3))
       ```
       
     
     - 加工结果
       ```
       word:  I,love,this,world
       op_index: o
       ```
       
      
   
 
 #### op_add
计算多个值的和，可以是字符串或者数字等。
- **函数格式**
  ```
  op_add(value1, value2, ...)
  ```
  
- **参数说明**
  
  | **参数名称** |   **参数类型**    | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 字符串、元组、列表或字典等 | 是        | 运算值1。  |
  | value2   | 必须与值1一样       | 是        | 运算值2。  |
     
  
- **返回结果**
  返回求和操作后的数值。
  
- **函数示例**
  1. 示例1：计算price_orange和price_apple总金额。
     - 测试数据
       ```
       {
        "price_orange": 2,
        "price_apple": 13
       }
       ```
       
     
     - 加工规则
       ```
       e_set("account",op_add(ct_int(v("price_orange")),ct_int(v("price_apple"))))
       ```
       
     
     - 加工结果
       ```
       price_orange: 2,
        price_apple: 13,
        account:  15
       ```
       
      
  
  2. 示例2：统计bytes_in和bytes_out的和。
     - 测试数据
       ```
       {
        "bytes_in": 214,
        "bytes_out": 123
       }
       ```
       
     
     - 加工规则
       ```
       e_set("total_bytes", op_add(ct_int(v("bytes_in")), ct_int(v("bytes_out"))))
       ```
       
     
     - 加工结果
       ```
       bytes_in: 214
       bytes_out: 123
       total_bytes:  337
       ```
       
      
  
  3. 示例3：给网址添加HTTPS头。
     - 测试数据
       ```
       {
        "host": "xx.com"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("website", op_add("https://", v("host")))
       ```
       
     
     - 加工结果
       ```
       host: xx.com
       website: https://xx.com
       ```
       
      
   
 
 #### op_max
计算多个字段或表达式表示的数值的最大值。
- **函数格式**
  ```
  op_max(value1, value2, ...)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 任意       | 是        | 运算值1。  |
  | value2   | 必须与值1一样  | 是        | 运算值2。  |
     
  
- **返回结果**
  返回多个数值中的最大值。
  
- **函数示例**
  - 测试数据
    ```
    {
     "price_orange":  2,
     "priority_apple":  13
    }
    ```
    
  
  - 加工规则
    ```
    e_set("max_price", op_max(ct_int(v("price_orange")),ct_int(v("priority_apple"))))
    ```
    
  
  - 加工结果
    ```
    price_orange:  2
    priority_apple:  13
    max_price:  13
    ```
    
   
 
 #### op_min
计算多个字段或表达式表示的数值的最小值。
- **函数格式**
  ```
  op_min(value1, value2, ...)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value1   | 任意       | 是        | 运算值1。  |
  | value2   | 必须与值1一样  | 是        | 运算值2。  |
     
  
- **返回结果**
  返回多个数值中的最小值。
  
- **函数示例**
  - 测试数据
    ```
    {
     "price_orange":  2,
     "priority_apple":  13
    }
    ```
    
  
  - 加工规则
    ```
    e_set("op_min", op_min(ct_int(v("price_orange")),ct_int(v("priority_apple"))))
    ```
    
  
  - 加工结果
    ```
    price_orange:  2
    priority_apple:  13
    op_min:  2
    ```