
# 编码解码函数
本文介绍编码解码函数的语法规则，包括参数解释、函数示例等。
#### 函数列表
| 分类     | 类型       | **函数**                                                                                                                                       | **说明**         |
|:---|:---|:---|:---|
| 编码与解码  | 字符串类型    | [str_encode]       | 对数据进行编码。       |
| 编码与解码  | 字符串类型    | [str_decode]       | 对数据进行解码。       |
| 编码与解码  | Base64类型 | [base64_encoding]  | 对数据进行Base64编码。 |
| 编码与解码  | Base64类型 | [base64_decoding] | 对数据进行Base64解码。 |
| 编码与解码  | HTML类型   | [html_encoding] | 对数据进行HTML编码。   |
| 编码与解码  | HTML类型   | [html_decoding] | 对数据进行HTML解码。   |
| 编码与解码  | URL类型    | [url_encoding]     | 对数据进行URL编码。    |
| 编码与解码  | URL类型    | [url_decoding]      | 对数据进行URL解码。    |
| 压缩与解压缩 | Gzip压缩库  | [gzip_compress]   | 对数据进行压缩并编码。    |
| 压缩与解压缩 | Gzip压缩库  | [gzip_decompress] | 将压缩数据解压缩。      |
| 压缩与解压缩 | Zlib压缩库  | [zlib_compress] | 对数据进行压缩并编码。    |
| 压缩与解压缩 | Zlib压缩库  | [zlib_decompress] | 将压缩数据解压缩。      |
| 哈希摘要   | MD5哈希    | [md5_encoding]    | 对数据进行MD5编码。    |
| 哈希摘要   | SHA1哈希   | [sha1_encoding]   | 对数据进行SHA1编码。   |
| 哈希摘要   | 循环冗余校验   | [crc32_encoding] | 计算数据的循环冗余校验码。  |
   
 #### str_encode
按照指定的编码格式对字符串进行编码。
- **函数格式**
  ```
  str_encode(value, "utf8", errors="ignore")
  ```
  
- **参数说明**
  
  | **参数名称** |    **数据类型**    | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被编码的值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
  | encoding | String         | 否        | 编码格式，默认为utf8。支持ASCII。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
  | errors   | String         | 否        | 按照编码格式无法识别字符时的处理方式。取值包括： - ignore（默认值）：忽略不做编码。  - strict：直接报错，丢弃此条日志数据。  - replace：使用半角问号（?）替换无法识别部分。  - xmlcharrefreplace：使用对应XML字符替换无法识别部分。   |
     
  
- **返回结果**
  返回编码后的字符串。
  
- **函数示例**
  1. 示例1：
     - 测试数据
       ```
       {
         "value": "test 测试"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result", str_encode(v("value"), "ascii", errors="ignore"))
       ```
       
     
     - 加工结果
       ```
       value: test 测试
       result: test
       ```
       
      
  
  2. 示例2：
     - 测试数据
       ```
       {
         "value": "test 测试"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result", str_encode(v("value"), "ascii", errors="strict"))
       ```
       
     
     - 加工结果：执行时直接报错
      
  
  3. 示例3：
     - 测试数据
       ```
       {
         "value": "test 测试"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result", str_encode(v("value"), "ascii", errors="replace"))
       ```
       
     
     - 加工结果
       ```
       value: test 测试
       result: test ??
       ```
       
      
  
  4. 示例4：
     - 测试数据
       ```
       {
         "value": "test 测试"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("result", str_encode(v("value"), "ascii", errors="xmlcharrefreplace"))
       ```
       
     
     - 加工结果
       ```
       value: test 测试
       result: test &#27979;&#35797;
       ```
       
      
   
 
 #### str_decode
按照指定的编码格式对传入值进行解码。
- **函数格式**
  ```
  str_decode(value, "utf8", errors="ignore")
  ```
  
- **参数说明**
  
  | **参数名称** |    **数据类型**    | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被解码的值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
  | encoding | 任意（自动转为String） | 否        | 编码格式，默认为utf8。 支持ASCII。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
  | errors   | 任意（自动转为String） | 否        | 按照编码格式无法识别字符时的处理方式。取值包括： - ignore（默认值）：忽略不做解码。  - strict：直接报错，丢弃此条日志数据。  - replace：使用半角问号（?）替换无法编解码部分。  - xmlcharrefreplace：使用对应XML字符替换无法编解码部分。   |
     
  
- **返回结果**
  返回解码后的值。
  
- **函数示例**
  - 测试数据
    ```
    {
      "test": "asewds"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("encoding", str_decode(b'\xe4\xbd\xa0\xe5\xa5\xbd', "utf8", 'strict'))
    ```
    
  
  - 加工结果
    ```
    test: asewds 
    encoding: 您好
    ```
    
   
 
 #### base64_encoding
对数据进行Base64编码。
- **函数格式**
  ```
  base64_encoding(value, format=None)
  ```
  
- **参数说明**
  
  | **参数名称** | **数据类型** | **是否必填** |                       **说明**                       |
  |---|---|---|---|
  | value    | String   | 是        | 填入需要被编码的值。                                         |
  | format   | String   | 否        | Base64编码协议。默认为format=RFC3548，还可以配置为format=RFC4648。 |
     
  
- **返回结果**
  返回编码后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {
      "str_en": "data to be encoded"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_base64",base64_encoding(v("str_en")))
    ```
    
  
  - 加工结果
    ```
    str_en : data to be encoded 
    str_base64 : ZGF0YSB0byBiZSBlbmNvZGVk
    ```
    
   
 
 #### base64_decoding
对数据进行Base64解码。
- **函数格式**
  ```
  base64_decoding(value, format=None)
  ```
  
- **参数说明**
  
  | **参数名称** | **数据类型** | **是否必填** |                                                                                                      **说明**                                                                                                       |
  |---|---|---|---|
  | value    | String   | 是        | 被解码的值。                                                                                                                                                                                                            |
  | format   | String   | 否        | Base64解码协议。默认为format=RFC3548，还可以配置为format=RFC4648。 RFC4648的Base64解码协议使用等号（=）将被解码的值填充到4字节的倍数。 |
     
  
- **返回结果**
  返回解码后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {
      "str_de": "ZGF0YSB0byBiZSBlbmNvZGVk"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_de_base64",base64_decoding(v("str_de")))
    ```
    
  
  - 加工结果
    ```
    str_de: ZGF0YSB0byBiZSBlbmNvZGVk 
    str_de_base64: data to be encoded
    ```
    
   
 
 #### html_encoding
对数据进行HTML编码。
- **函数格式**
  ```
  html_encoding(value)
  ```
  
- **参数说明**
  
  | **参数名称** | **数据类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value    | String   | 是        | 被编码的值。 |
     
  
- **返回结果**
  返回编码后字符串。
  
- **函数示例**
  - 测试数据
    ```
    { 
      "str":"<img class=\"size-medium wp-image-113\" style=\"margin-left: 15px;\" title=\"su1\" src=\"http://aadoc.com/wp-content/uploads/2008/10/su1-300x194.jpg\" alt=\"\" width=\"300\" height=\"194\" />" 
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_html_en",html_encoding(v("str")))
    ```
    
  
  - 加工结果
    ```
    str : <img class="size-medium wp-image-113" style="margin-left: 15px;" title="su1" src="http://aadoc.com/wp-content/uploads/2008/10/su1-300x194.jpg" alt="" width="300" height="194" />
    str_html_en : &lt;img class=&quot;size-medium wp-image-113&quot; style=&quot;margin-left: 15px;&quot; title=&quot;su1&quot; src=&quot;http://aadoc.com/wp-content/uploads/2008/10/su1-300x194.jpg&quot; alt=&quot;&quot; width=&quot;300&quot; height=&quot;194&quot; /&gt;
    ```
    
   
 
 #### html_decoding
对数据进行HTML解码。
- **函数格式**
  ```
  html_decoding(value)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明** |
  |---|---|---|---|
  | value    | String   | 是        | 被解码的值。 |
     
  
- **返回结果**
  返回解码后字符串。
  
- **函数示例**
  - 测试数据
    ```
    {
      "str": "&lt;img class=&quot;size-medium wp-image-113&quot; style=&quot;margin-left: 15px;&quot; title=&quot;su1&quot; src=&quot;http://aadoc.com/wp-content/uploads/2008/10/su1-300x194.jpg&quot; alt=&quot;&quot; width=&quot;300&quot; height=&quot;194&quot; /&gt;"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_html_de",html_decoding(v("str")))
    ```
    
  
  - 加工结果
    ```
    {
     "str": "&lt;img class=&quot;size-medium wp-image-113&quot; style=&quot;margin-left: 15px;&quot; title=&quot;su1&quot; src=&quot;http://aadoc.com/wp-content/uploads/2008/10/su1-300x194.jpg&quot; alt=&quot;&quot; width=&quot;300&quot; height=&quot;194&quot; /&gt;",
     "str_html_de": "<img class=\"size-medium wp-image-113\" style=\"margin-left: 15px;\" title=\"su1\" src=\"http://aadoc.com/wp-content/uploads/2008/10/su1-300x194.jpg\" alt=\"\" width=\"300\" height=\"194\" />"
    }
    ```
    
   
 
 #### url_encoding
对数据进行URL编码。
- **函数格式**
  ```
  url_encoding(value, plus=false)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                               **说明**                                                                                                                                                                                                                                                                                                                                                                                               |
  |---|---|---|---|
  | value    | String   | 是        | 被编码的值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  | plus     | Boolean  | 否        | 是否将空格转换为加号，默认为false。 - true：将空格转换为加号。  - false：不转换空格为加号。   |
     
  
- **返回结果**
  返回编码后的字符串。
  
- **函数示例**
  1. 示例1：对数据进行URL编码。
     - 测试数据
       ```
       {
         "content": "https://www.example.org/hello/asdah"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("url",url_encoding(v("content")))
       ```
       
     
     - 加工结果
       ```
       content : https://www.example.org/hello/asdah
       url: https%3A%2F%www.example.org%2FHello%2Fasdah
       ```
       
      
  
  2. 示例2：对数据进行URL编码。其中，未设置plus参数，不转换数据中的空格为加号。
     - 测试数据
       ```
       {
         "content": "1 2+3:4"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("URL",url_encoding(v("content")))
       ```
       
     
     - 加工结果
       ```
       content:1 2+3:4 
       URL:1%202%2B3%3A4
       ```
       
      
  
  3. 示例3：对数据进行URL编码。其中，设置plus参数为true，将数据中的空格转换为加号。
     - 测试数据
       ```
       {
         "content": "1 2+3:4"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("URL", url_encoding(v("content"), plus=true))
       ```
       
     
     - 加工结果
       ```
       content:1 2+3:4
       URL:1+2%2B3%3A4
       ```
       
      
   
 
 #### url_decoding
对数据进行URL解码。
- **函数格式**
  ```
  url_decoding(value, plus=false)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                      **说明**                                                                                                                                                                                                                                                                                                                                                                                       |
  |---|---|---|---|
  | value    | String   | 是        | 被解码的值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
  | plus     | Boolean  | 否        | 是否将加号转换为空格，默认为false。 - true：将加号转换为空格。  - false：不转换加号为空格。   |
     
  
- **返回结果**
  返回解码后的字符串。
  
- **函数示例**
  1. 示例1：对数据进行URL解码。
     - 测试数据
       ```
       {
         "content": "https%3A%2F%www.example.org%2FHello%2Fasdah"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("URL",url_decoding(v("content")))
       ```
       
     
     - 加工结果
       ```
       content : https%3A%2F%www.example.org%2FHello%2Fasdah 
       URL : https://www.example.org/hello/asdah
       ```
       
      
  
  2. 示例2：对数据进行URL解码。其中，未设置plus参数，不转换数据中的加号为空格。
     - 测试数据
       ```
       {
         "content": "/answer?event_date=2022-06-30+09%3A06%3A53%20123"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("URL",url_decoding(v("content")))
       ```
       
     
     - 加工结果
       ```
       content:/answer?event_date=2022-06-30+09%3A06%3A53%20123
       URL:/answer?event_date=2022-06-30+09:06:53 123
       ```
       
      
  
  3. 示例3：对数据进行URL解码。其中，设置plus参数为true，将数据中的加号转换为空格。
     - 测试数据
       ```
       {
         "content": "/answer?event_date=2022-06-30+09%3A06%3A53%20123"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("URL",url_decoding(v("content"),plus=true))
       ```
       
     
     - 加工结果
       ```
       content:/answer?event_date=2022-06-30+09%3A06%3A53%20123
       URL:/answer?event_date=2022-06-30 09:06:53 123
       ```
       
      
   
 
 #### gzip_compress
将数据进行压缩并编码。
- **函数格式**
  ```
  gzip_compress(data, compresslevel=6, to_format="base64", encoding="utf-8")
  ```
  
- **参数说明**
  
  |   **参数名称**    | **参数类型** | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
  |---|---|---|---|
  | data          | String   | 是        | 输入需要压缩的数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
  | compresslevel | Int      | 否        | 用于控制压缩等级，可配置为0\~9的整数。默认值为6。 - 1：压缩速度最快但压缩比例最小。  - 9：压缩速度最慢但压缩比例最大。  - 0：不压缩。   其他级别（2\~8），随着级别数值的升高，压缩速度逐渐变慢，压缩比例逐渐变大，可根据业务对压缩速度以及压缩后数据的大小要求进行选择。 |
  | to_format     | String   | 否        | 对压缩后的数据进行编码的格式，目前支持进行Base64和hex编码。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
  | encoding      | String   | 否        | 原始未压缩数据的编码格式，默认为utf-8。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
     
  
- **返回结果**
  返回编码后的字符串。
  
- **函数示例** （加密结果仅供参考。）
  1. 示例1：对日志字段进行压缩并Base64编码。
     - 测试数据
       ```
       {
         "content":"I always look forward to my holidays whether I travel or stay at home."
       }
       ```
       
     
     - 加工规则
       ```
       e_set("base64_encode_gzip_compress",gzip_compress(v("content"),to_format="base64"))
       ```
       
     
     - 加工结果
       ```
       content: I always look forward to my holidays whether I travel or stay at home. base64_encode_gzip_compress: H4sIAA8JXl4C/xXK0QmAMAwFwFXeBO7RMQKNREx5kAZDtle/7wbES3rDyRsnoyQmklgNo1/ztzJN08BAhjzqYGCnNCS/tPR4AcgrnWVGAAAA
       ```
       
      
  
  2. 示例2：对日志字段进行hex编码。
     - 测试数据
       ```
       {
          "content":"H4sIAA8JXl4C/xXK0QmAMAwFwFXeBO7RMQKNREx5kAZDtle/7wbES3rDyRsnoyQmklgNo1/ztzJN08BAhjzqYGCnNCS/tPR4AcgrnWVGAAAA"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("hex_encode_gzip_compress", gzip_compress(v("content"), to_format="hex"))
       ```
       
     
     - 加工结果
       ```
       content:H4sIAA8JXl4C/xXK0QmAMAwFwFXeBO7RMQKNREx5kAZDtle/7wbES3rDyRsnoyQmklgNo1/ztzJN08BAhjzqYGCnNCS/tPR4AcgrnWVGAAAA hex_encode_gzip_compress:1f8b08004a478c6202ff0dc1dd0e43301800d047aa65156e3ff52f4a2ba17649c43255194d4a9f9e73527c64007e2e2426e81485c35628c1c42616535079bc6405e5d1e92ef009b59c906786a879efe1c50fb55d6c5de44cb717b2dae6d4f103f8feecbf4f88a2a441bae618c679575d9bc0e306907876806c000000
       ```
       
      
   
 
 #### gzip_decompress
将压缩数据解压缩。
- **函数格式**
  ```
  gzip_decompress(data, from_format="base64", encoding="utf-8")
  ```
  
- **参数说明**
  
  |  **参数名称**   | **参数类型** | **是否必填** |                **说明**                 |
  |---|---|---|---|
  | data        | 任意       | 是        | 输入需要解压的数据。                            |
  | from_format | String   | 否        | 解压数据的编码格式，目前支持Base64和hex格式解码。         |
  | encoding    | String   | 否        | 原始未压缩数据的编码格式，默认utf-8，其他编码格式请参见标准编码格式。 |
     
  
- **返回结果**
  返回解压后的对象。
  
- 函数示例
  1. 示例1：对日志字段进行Base64解码。
     - 测试数据
       ```
       {
         "content": "H4sIAA8JXl4C/xXK0QmAMAwFwFXeBO7RMQKNREx5kAZDtle/7wbES3rDyRsnoyQmklgNo1/ztzJN08BAhjzqYGCnNCS/tPR4AcgrnWVGAAAA"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("gzip_decompress",gzip_decompress(v("content"),from_format="base64"))
       ```
       
     
     - 加工结果
       ```
       content: H4sIAA8JXl4C/xXK0QmAMAwFwFXeBO7RMQKNREx5kAZDtle/7wbES3rDyRsnoyQmklgNo1/ztzJN08BAhjzqYGCnNCS/tPR4AcgrnWVGAAAA gzip_decompress: I always look forward to my holidays whether I travel or stay at home.
       ```
       
      
  
  2. 示例2：对日志字段进行hex解码。
     - 测试数据
       ```
       {
       "content":"1f8b0800bff8856202ff0dc1dd0e43301800d047aa65156e3ff52f4a2ba17649c43255194d4a9f9e73527c64007e2e2426e81485c35628c1c42616535079bc6405e5d1e92ef009b59c906786a879efe1c50fb55d6c5de44cb717b2dae6d4f103f8feecbf4f88a2a441bae618c679575d9bc0e306907876806c000000"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("gzip_decompress", gzip_decompress(v("content"), from_format="hex"))
       ```
       
     
     - 加工结果
       ```
       content:1f8b0800bff8856202ff0dc1dd0e43301800d047aa65156e3ff52f4a2ba17649c43255194d4a9f9e73527c64007e2e2426e81485c35628c1c42616535079bc6405e5d1e92ef009b59c906786a879efe1c50fb55d6c5de44cb717b2dae6d4f103f8feecbf4f88a2a441bae618c679575d9bc0e306907876806c000000
       gzip_decompress:H4sIAA8JXl4C/xXK0QmAMAwFwFXeBO7RMQKNREx5kAZDtle/7wbES3rDyRsnoyQmklgNo1/ztzJN08BAhjzqYGCnNCS/tPR4AcgrnWVGAAAA
       ```
       
      
   
 
 #### zlib_compress
将数据进行压缩并编码。
- **函数格式**
  zlib_compress(data, compresslevel=6, to_format="base64", encoding="utf-8")
  
- **参数说明**
  
  |   **参数名称**    | **参数类型** | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
  |---|---|---|---|
  | data          | String   | 是        | 输入需要压缩的数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
  | compresslevel | Int      | 否        | 用于控制压缩等级，可配置为0\~9的整数。默认值为6。 - 1：压缩速度最快但压缩比例最小。  - 9：压缩速度最慢但压缩比例最大。  - 0：不压缩。   其他级别（2\~8），随着级别数值的升高，压缩速度逐渐变慢，压缩比例逐渐变大，可根据业务对压缩速度以及压缩后数据大小要求进行选择。 |
  | to_format     | String   | 否        | 对压缩后的数据进行编码的格式，目前只支持进行Base64编码。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
  | encoding      | String   | 否        | 原始未压缩数据的编码格式，默认为utf-8。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
     
  
- **返回结果**
  返回编码后的对象。
  
- **函数示例**
  - 测试数据
    ```
    {
       "content":"I always look forward to my holidays whether I travel or stay at home."
    }
    ```
    
  
  - 加工规则
    ```
    e_set("zlib_compress", zlib_compress(v("content"), to_format="base64"))
    ```
    
  
  - 加工结果（加密结果仅供参考。）
    ```
    zlib_compress: eJwVytEJgDAMBcBV3gTu0TECjURMeZAGQ7ZXv+8GxEt6w8kbJ6MkJpJYDaNf87cyTdPAQIY86mBgpzQkv7T0eAGNshln
    content: I always look forward to my holidays whether I travel or stay at home.
    ```
    
   
 
 #### zlib_decompress
- **函数格式**
  ```
  zlib_decompress(data, from_format="base64", encoding="utf-8")
  ```
  
- **参数说明**
  
  |  **参数名称**   | **参数类型** | **是否必填** |          **说明**          |
  |---|---|---|---|
  | data        | String   | 是        | 输入需要解压的数据。               |
  | from_format | String   | 否        | 解压数据的编码格式，目前只支持Base64编码。 |
  | encoding    | String   | 否        | 编码格式，默认utf-8。            |
     
  
- **返回结果**
  返回解压后的对象。
  
- **函数示例**
  - 测试数据
    ```
    {
      "content": "eJwVytEJgDAMBcBV3gTu0TECjURMeZAGQ7ZXv+8GxEt6w8kbJ6MkJpJYDaNf87cyTdPAQIY86mBgpzQkv7T0eAGNshln"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("zlib_decompress", zlib_decompress(v("content"), from_format="base64"))
    ```
    
  
  - 加工结果
    ```
    content: eJwVytEJgDAMBcBV3gTu0TECjURMeZAGQ7ZXv+8GxEt6w8kbJ6MkJpJYDaNf87cyTdPAQIY86mBgpzQkv7T0eAGNshln
    zlib_decompress: I always look forward to my holidays whether I travel or stay at home.
    ```
    
   
 
 #### md5_encoding
对数据进行MD5编码。
- **函数格式**
  ```
  md5_encoding(value, format="hex")
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |         **说明**          |
  |---|---|---|---|
  | value    | String   | 是        | 被编码的值。                  |
  | format   | String   | 否        | 默认值为hex，可选值：binary、hex。 |
     
  
- **返回结果**
  返回编码后的字符串。
  
- **函数示例**
  1. 示例1
     - 测试数据
       ```
       {
         "str": "GeeksforGeeks"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("str_md5_en",md5_encoding(v("str")))
       ```
       
     
     - 加工结果
       ```
       str : GeeksforGeeks
       str_md5_en : f1e069787ece74531d112559945c6871
       ```
       
      
  
  2. 示例2
     - 测试数据
       ```
       {
         "str": "GeeksforGeeks"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("str_md5_en",base64_encoding(md5_encoding(v("str"), format="binary")))
       ```
       
     
     - 加工结果
       ```
       str : GeeksforGeeks
       str_md5_en : 8eBpeH7OdFMdESVZlFxocQ==
       ```
       
      
   
 
 #### sha1_encoding
对数据进行SHA-1编码。
- **函数格式**
  ```
  sha1_encoding(value, format=None)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** |                     **说明**                      |
  |---|---|---|---|
  | value    | String   | 是        | 被编码的值。                                          |
  | format   | String   | 否        | 编码类型，默认为SHA1类型，可选SHA256、SHA384、SHA224、SHA512类型。 |
     
  
- **返回结果**
  返回编码后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {
      "str": "GeeksforGeeks"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_sha1",sha1_encoding(v("str")))
    e_set("str_sha512",sha1_encoding(v("str"),format='SHA512'))
    e_set("str_sha224",sha1_encoding(v("str"),format='SHA224'))
    e_set("str_sha384",sha1_encoding(v("str"),format='SHA384'))
    e_set("str_sha256",sha1_encoding(v("str"),format='SHA256'))
    ```
    
  
  - 加工结果
    ```
    str : GeeksforGeeks 
    str_sha1 : 4175a37afd561152fb60c305d4fa6026b7e79856 
    str_sha512 : 0d8fb9370a5bf7b892be4865cdf8b658a82209624e33ed71cae353b0df254a75db63d1baa35ad99f26f1b399c31f3c666a7fc67ecef3bdcdb7d60e8ada90b722
    str_sha224 : 173994f309f727ca939bb185086cd7b36e66141c9e52ba0bdcfd145d 
    str_sha384 : d1e67b8819b009ec7929933b6fc1928dd64b5df31bcde6381b9d3f90488d253240490460c0a5a1a873da8236c12ef9b3 
    str_sha256 : f6071725e7ddeb434fb6b32b8ec4a2b14dd7db0d785347b2fb48f9975126178f
    ```
    
   
 
 #### crc32_encoding
计算数据的循环冗余校验码。
- **函数格式**
  ```
  crc32_encoding(data, input_format="raw", input_encoding="utf-8")
  ```
  
- **参数说明**
  
  |    **参数名称**    | **参数类型** | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
  |---|---|---|---|
  | data           | String   | 是        | 计算校验码的值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
  | input_format   | String   | 否        | 输入值的字符格式。默认为raw，可选值包括： - raw：Bytes格式  - hex：十六进制格式  - base64：Base64编码格式   |
  | input_encoding | String   | 否        | 仅当input_format取值为raw时需要配置。配置字符编码格式。默认为utf-8。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
     
  
- **返回结果**
  返回传入数据的循环冗余校验码。
  
- **函数示例**
  1. 示例1：计算字段test的循环冗余校验码。
     - 测试数据
       ```
       {
         "test": "aatest"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("str_crc32", crc32_encoding(v("test")))
       ```
       
     
     - 加工结果
       ```
       str_crc32: 788759217
       test: aatest
       ```
       
      
  
  2. 示例2：将字段test1和test2连接后进行MD5编码，最后计算其循环冗余校验码。
     - 测试数据
       ```
       {
       "test1": "test1",
       "test2": "test2"
       }
       ```
       
     
     - 加工规则
       ```
       e_set(
           "str_crc32",
           crc32_encoding(
               md5_encoding(str_join("+", v("test1"), v("test2")), format="binary") 
          ),
       )
       ```
       
     
     - 加工结果
       ```
       str_crc32:369733261 
       test1:test1 
       test2:test2
       ```
       
      
  
  3. 示例3：计算字段test的循环冗余校验码，其值为Base64编码格式。
     - 测试数据
       ```
       {
        "test": "Taloz+e+PzP3NltrEXiCig=="
       }
       ```
       
     
     - 加工规则
       ```
       e_set("str_crc32", crc32_encoding(v("test"), input_format="base64"))
       ```
       
     
     - 加工结果
       ```
       str_crc32:1093789404
       test:Taloz+e+PzP3NltrEXiCig==
       ```
       
      
   
 
