
# 正则表达式函数
本文介绍正则表达式函数的语法规则，包括参数解释、函数示例等。
| **类型** |                                                                   **函数**                                                                    |        **说明**        |
|---|---|---|
| 值提取函数  | [regex_select]   | 根据正则表达式提取符合条件的值。     |
| 值提取函数  | [regex_findall] | 根据正则表达式获得符合条件的所有值列表。 |
| 匹配判断   | [regex_match]    | 判断是否匹配正则表达式。         |
| 替换     | [regex_replace]  | 根据正则表达式替换字符串中的指定字符。  |
| 切分     | [regex_split]  | 将一个字符串分割成字符串数组。      |
   
 #### regex_select
- **函数格式**
  ```
  regex_select(value, r"regular expression", mi=None, gi=None)
  ```
  
- **参数说明**
  
  |      **参数名称**      | **参数类型** | **是否必填** |           **说明**           |
  |---|---|---|---|
  | value              | 任意       | 是        | 填入要匹配的值。                   |
  | regular expression | String   | 是        | 匹配的正则表达式。                  |
  | mi                 | int      | 否        | 表示匹配到的第几个表达式，默认None，表示第一个。 |
  | gi                 | int      | 否        | 表示匹配到的第几个分组，默认None，表示第一个。  |
     
  
- **返回结果**
  返回提取的值。
  
- **函数示例**
  1. 示例1：提取字段str中符合正则表达式的第一个值。
     - 测试数据
       ```
       {
         "str": "iZbp1a65x3r1vhpe94fi2qZ"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("regex", regex_select(v("str"), r"\d+"))
       e_set("regex2", regex_select(v("str"), r"\d+", mi=None))
       e_set("regex3", regex_select(v("str"), r"\d+", mi=0))
       ```
       
     
     - 加工结果
       ```
       regex:1
       regex2:1
       regex3:1
       str:iZbp1a65x3r1vhpe94fi2qZ
       ```
       
      
  
  2. 示例2：提取字段str中符合正则表达式的第一个和第二个的值。
     - 测试数据
       ```
       {
         "str": "abc123 xyz456"
       }
       ```
       
     
     - 加工规则
       ```
       # 提取字段str中符合正则表达式的第一个值。
       e_set("regex", regex_select(v("str"), r"\d+"))
       # 提取字段str中符合正则表达式的第二个值。
       e_set("regex2", regex_select(v("str"), r"\d+", mi=1))
       ```
       
     
     - 加工结果
       ```
       regex:   123
       regex2:  456
       str: abc123 xyz456
       ```
       
      
  
  3. 示例3：提取字段str中不同表达式的不同分组的值。
     - 测试数据
       ```
       {
         "str": "abc123 xyz456"
       }
       ```
       
     
     - 加工规则
       ```
       # 提取字段str中符合正则表达式的第一个表达式的第一个分组的值。
       e_set("regex", regex_select(v("str"),r"[a-z]+(\d+)",gi=0))
       # 提取字段str中符合正则表达式的第二个表达式的第一个分组的值。
       e_set("regex2", regex_select(v("str"),r"[a-z]+(\d+)",mi=1,gi=0))
       # 提取字段str中符合正则表达式的第一个表达式的第一个分组的值。
       e_set("regex3", regex_select(v("str"),r"([a-z]+)(\d+)",gi=0))
       # 提取字段str中符合正则表达式的第一个表达式的第二个分组的值。
       e_set("regex4", regex_select(v("str"),r"([a-z]+)(\d+)",gi=1))
       ```
       
     
     - 加工结果
       ```
       str: abc123 xyz456 
       regex:   123
       regex2:  456
       regex3:  abc 
       regex4:  123
       ```
       
      
   
 
 #### regex_findall
根据正则表达式获得符合条件的所有值的一个列表。
- **函数格式**
  ```
  regex_findall(value, r"regular expression")
  ```
  
- **参数说明**
  
  |      **参数名称**      | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value              | 任意       | 是        | 要匹配的值。 |
  | regular expression | String   | 是        | 正则表达式。 |
     
  
- **返回结果**
  返回获得符合条件的列表。
  
- **函数示例**
  获取字段str所有的数字。
  - 测试数据
    ```
    {
      "str": "iZbp1a65x3r1vhpe94fi2qZ"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("regex_findall", regex_findall(v("str"),r"\d+"))
    ```
    
  
  - 加工结果
    ```
    str: iZbp1a65x3r1vhpe94fi2qZ 
    regex_findall:  ["1", "65", "3", "1", "94", "2"]
    ```
    
   
 
 #### regex_match
判断是否匹配正则表达式。
- **函数格式**
  ```
  regex_match(value, r"regular expression", full=false)
  ```
  
- **参数说明**
  
  |      **参数名称**      | **参数类型** | **是否必填** |      **说明**      |
  |---|---|---|---|
  | value              | 任意       | 是        | 要匹配的值。           |
  | regular expression | String   | 是        | 正则表达式。           |
  | full               | Bool     | 否        | 是否完全匹配，默认为false。 |
     
  
- **返回结果**
  返回true或者false。
  
- **函数示例**
  判断字段str是否包含数字。
  - 测试数据
    ```
    {
      "str": "iZbp1a65x3r1vhpe94fi2qZ"
    }
    ```
    
  
  - 加工规则
    ```
    # 判断字段str是否包含数字。
    e_set("regex_match", regex_match(v("str"),r"\d+"))
    # 判断字段str是否全部为数字。
    e_set("regex_match2", regex_match(v("str"),r"\d+",full=true))
    ```
    
  
  - 加工结果
    ```
    str: iZbp1a65x3r1vhpe94fi2qZ 
    regex_match:  true
    regex_match2:  false
    ```
    
   
 
 #### regex_replace
根据正则表达式替换字符串中的指定字符。
- **函数格式**
  ```
  regex_replace(value, r"regular expression", replace="", count=0)
  ```
  
- **参数说明**
  
  |      **参数名称**      | **参数类型** | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                                                                                                 **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
  |---|---|---|---|
  | value              | 任意       | 是        | 要被替换的值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
  | regular expression | String   | 是        | 正则表达式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
  | replace            | String   | 否        | 替换后的新字符。默认为空，表示删除字符。 支持正则表达式，例如r"\\1\*\*\*\*\\2"，表示替换后的字符串要满足该正则表达式。 - \\1代表第一个分组。  - \\2代表第二个分组。   |
  | count              | Number   | 否        | 替换次数。 默认为0，表示替换所有。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
     
  
- **返回结果**
  返回替换后的新字符串。
  
- **函数示例**
  1. 示例1：把str中的所有数字用13替换。
     - 测试数据
       ```
       {
        "str": "iZbp1a65x3r1vhpe94fi2qZ ",
        "replace": "13"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("regex_replace", regex_replace(v("str"),r"\d+",v("replace")))
       ```
       
     
     - 加工结果
       ```
       str: iZbp1a65x3r1vhpe94fi2qZ 
       replace: 13
       regex_replace:  iZbp13a13x13r13vhpe13fi13qZ
       ```
       
      
  
  2. 示例2：对手机号中间4位数字进行脱敏处理。
     - 测试数据
       ```
       {
        "iphone": "13900001234"
       }
       ```
       
     
     - 加工规则
       - replace=r"\\1\*\*\*\*\\2"表示替换后的字符串要满足正则表达式r"\\1\*\*\*\*\\2"。
       
       - \\1代表第一个分组，即(\\d{0,3})。
       
       - \\2代表第二个分组，即(\\d{4})。
       
       
       ```
       e_set(
           "sec_iphone",
           regex_replace(v("iphone"), r"(\d{0,3})\d{4}(\d{4})", replace=r"\1****\2"),
       )
       ```
       
     
     - 加工结果
       ```
       iphone: 13900001234
       sec_iphone: 139****1234
       ```
       
      
   
 
 #### regex_split
将一个字符串分割成字符串数组。
- **函数格式**
  ```
  regex_split(value, r"regular expression", maxsplit=0)
  ```
  
- **参数说明**
  
  |      **参数名称**      | **参数类型** | **是否必填** |                     **说明**                      |
  |---|---|---|---|
  | value              | 任意       | 是        | 要分裂的值。                                          |
  | regular expression | String   | 是        | 正则表达式。                                          |
  | maxsplit           | int      | 否        | 最大分裂匹配次数。默认为0表示全部匹配分裂，如果为1，表示匹配中一个就分裂，剩余不再进行匹配。 |
     
  
- **返回结果**
  返回分割后的数组列表。
  
- **函数示例**
  将字段str按照数字进行分裂。
  - 测试数据
    ```
    {
      "str": "iZbp1a65x3r1vhpe94fi2qZ"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("regex_split", regex_split(v("str"),r"\d+"))
    ```
    
  
  - 加工结果
    ```
    str: iZbp1a65x3r1vhpe94fi2qZ 
    regex_split:  ["iZbp", "a", "x", "r", "vhpe", "fi", "qZ"]
    ```
    
   
 
