# 多字符串和排序、反转、替换
#### str_format
按照指定格式对字符串进行格式化。
- **函数格式**
  ```
  str_format(format, str1, str2, ...)
  ```
  
- **参数说明**
  
  | **参数名称** | **参数类型** | **是否必填** | **说明**  |
  |---|---|---|---|
  | format   | string   | 是        | 转换后的格式  |
  | str1     | 任意       | 是        | 待格式化的值1 |
  | str2     | 任意       | 是        | 待格式化的值2 |
     
  
- **返回结果**
  格式化后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {}
    ```
    
  
  - 加工规则
    ```
    e_set("result", str_format("{}={}", "lts", 8))
    ```
    
  
  - 加工结果
    ```
    result: lts=8
    ```
    
   
 
#### str_join
通过连接符将输入的字符串连接生成一个新的字符串。
- **函数格式**
  ```
  str_join(connector, str1, str2, ...)
  ```
  
- **参数说明**
  
  | **参数名称**  |    **参数类型**    | **是否必填** |    **说明**    |
  |---|---|---|---|
  | connector | 任意（自动转为string） | 是        | 连接符，比如#,$,%等 |
  | str1      | 任意（自动转为string） | 是        | 待连接的值1       |
  | str2      | 任意（自动转为string） | 是        | 待连接的值2       |
     
  
- **返回结果**
  连接后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {}
    ```
    
  
  - 加工规则
    ```
    e_set("email", str_join("@", "lts", "aa", "com"))
    ```
    
  
  - 加工结果
    ```
    email:  lts@aa@com
    ```
    
   
 
#### str_zip
将两个值或表达式的字符串进行并发分裂然后再合并成一个字符串。
- **函数格式**
  ```
  str_zip(value1,value2,combine_sep=None,sep=None,quote=None,lparse=None,rparse=None)
  ```
  
- **参数说明**
  
  |  **参数名称**   |    **参数类型**    | **是否必填** |                                                                                              **说明**                                                                                               |
  |---|---|---|---|
  | value1      | 任意（自动转为String） | 是        | 需要被合并的值。                                                                                                                                                                                          |
  | value2      | 任意（自动转为String） | 是        | 需要被合并的值。                                                                                                                                                                                          |
  | combine_sep | 任意（自动转为String） | 否        | 合并时元素之间的合并标识，默认为**#**                                                                                                                                                                             |
  | sep         | 任意（自动转为String） | 否        | 合并后元素之间的分隔符，仅支持单个字符，默认为**,**                                                                                                                                                                      |
  | quote       | 任意（自动转为String） | 否        | 将合并后的元素括起来的字符，当值包含分隔符时需要使用，默认为**"**                                                                                                                                                               |
  | lparse      | 任意（自动转为String） | 否        | 指定value1中元素之间的分隔符和引用符，默认分隔符为,，默认引用符为"。格式为lparse=(',', '"')。 **说明** 引用符优先级高于分隔符。 |
  | rparse      | 任意（自动转为String） | 否        | 指定value2中元素之间的分隔符和引用符，默认分隔符为,，默认引用符为"。格式为rparse=(',', '"')。 **说明** 引用符优先级高于分隔符。 |
     
  
- **返回结果**
  合并后的字符串。
  
- **函数示例**
  1. 示例1：sep的使用。
     - 测试数据
       ```
       {
        "key1": "value1,value11",
        "key2": "value2,value21"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("combine", str_zip(v("key1"), v("key2"), sep="|"))
       ```
       
     
     - 加工结果
       ```
       key1: value1,value11 
       key2: value2,value21 
       combine: value1#value2|value11#value21
       ```
       
      
  
  2. 示例2：quote的使用。
     - 测试数据
       ```
       {
         "key1": "\"value1, value2\", value3, \"value4,value5\"",
         "key2": "value11,\"value12,value13\",value14"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("combine", str_zip(v("key1"), v("key2"), quote='|'))
       ```
       
     
     - 加工结果
       ```
       key1: "value1, value2", value3, "value4,value5"
       key2: value11,"value12,value13",value14 
       combine: |value1,value2#value11|,|value3#value12,value13|,|value4,value5#value14|
       ```
       
      
  
  3. 示例3：不同长度的值。
     - 测试数据
       ```
       {
        "key1": "value1,value2",
        "key2": "value11,value12,value13"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("combine", str_zip(v("key1"), v("key2")))
       ```
       
     
     - 加工结果
       ```
       key1: value1,value2 
       key2: value11,value12,value13 
       combine: value1#value11,value2#value12
       ```
       
      
  
  4. 示例4：lparse和rparse的使用。
     - 测试数据
       ```
       {
        "key1": "|value1, value1|, value2, |value3,value3|",
        "key2": "value11, #value12,value12#, value13"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("combine", str_zip(v("key1"), v("key2"), lparse=(",", '|'), rparse=(",", '#')))
       ```
       
     
     - 加工结果
       ```
       key1: |value1, value1|, value2, |value3,value3|
       key2: value11, #value12,value12#, value13
       combine: "value1,value1#value11","value2#value12,value12","value3,value3#value13"
       ```
       
      
   
 
#### str_sort
字符串排序。
- **函数格式**
  ```
  str_sort(value, reverse=false)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |      **说明**      |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被排序的原字符串。      |
  | reverse  | Boolean        | 否        | 默认为false，表示升序排列。 |
     
  
- **返回结果**
  排序后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {
     "key1": "value"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_sort", str_sort(v("key1")))
    ```
    
  
  - 加工结果
    ```
    key1: value 
    str_sort: aeluv
    ```
    
   
 
#### str_reverse
将一个字符串进行反转。
- **函数格式**
  ```
  str_reverse(value)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** | **说明**  |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被反转的值 |
     
  
- **返回结果**
  反转后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    { 
      "data": "switch"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("reverse_data", str_reverse(v("data")))
    ```
    
  
  - 加工结果
    ```
    data: switch 
    reverse_data: hctiws
    ```
    
   
 
#### str_replace
根据规则将旧字符串替换成新字符串。
- **函数格式**
  ```
  str_replace(value, old, new, count)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |            **说明**            |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被替换的值。                     |
  | old      | 任意（自动转为String） | 是        | 需要被替换的字符串。                   |
  | new      | 任意（自动转为String） | 是        | 替换后新的字符串。                    |
  | count    | Number         | 否        | 替换次数，可选项。如果不设置count，则表示替换所有。 |
     
  
- **返回结果**
  替换后的新字符串。
  
- **函数示例**
  - 测试数据
    ```
    {}
    ```
    
  
  - 加工规则
    ```
    e_set("str_replace", str_replace("this is string example", "is", "was"))
    ```
    
  
  - 加工结果
    ```
    str_replace： thwas was string example
    ```
    
   
 
#### str_translate
将字符串中的指定字符按照对应关系进行替换。
- **函数格式**
  ```
  str_translate(value, replace_string, mapping_string)
  ```
  
- **参数说明**
  
  |    **参数名称**    |    **参数类型**    | **是否必填** |   **说明**    |
  |---|---|---|---|
  | value          | 任意（自动转为String） | 是        | 需要被替换的原字符串。 |
  | replace_string | 任意（自动转为String） | 是        | 需要替换的字符集合。  |
  | mapping_string | 任意（自动转为String） | 是        | 替换后的字符集合。   |
     
  
- **返回结果**
  处理后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {}
    ```
    
  
  - 加工规则
    ```
    e_set("str_translate", str_translate("lts", "ts", "34"))
    ```
    
  
  - 加工结果
    ```
    str_translate： l34
    ```