# 查找判断、切分和格式化
#### str_count
统计字符串里某个字符出现的次数。
- **函数格式**
  ```
  str_count(value, sub, start, end)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                               **说明**                                                                                                                                                                                                                                                                                                                                                                                |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 被统计的原字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
  | sub      | 任意（自动转为String） | 是        | 需要统计个数的字符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
  | start    | Number         | 否        | 字符串开始搜索的位置。 - 0（默认值）：第一个字符。  - -1：最后一个字符。    |
  | end      | Number         | 否        | 字符串中结束搜索的位置。 - 0：第一个字符。  - -1（默认值）：最后一个字符。   |
     
  
- **返回结果**
  返回指定字符出现的次数。
  
- **函数示例**
  - 测试数据
    ```
    {
      "name":  "lts is a log service"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_count", str_count(v("name"), "l"))
    ```
    
  
  - 加工结果
    ```
    name:  lts is a log service 
    str_count: 2
    ```
    
   
 
#### str_find
判断原字符串中是否包含指定的子字符串。
- **函数格式**
  ```
  str_find(value, str, begin, end)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |                 **说明**                  |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被查找的原字符串。                             |
  | str      | 任意（自动转为String） | 是        | 指定查找的子字符串。                              |
  | begin    | Number         | 否        | 开始索引的位置。默认为0表示第一个字符，-1表示倒数第一个字符。        |
  | end      | Number         | 否        | 结束索引的位置。默认为字符串的长度。0表示第一个字符，-1表示倒数第一个字符。 |
     
  
- **返回结果**
  指定子字符串在原字符串中的位置。如果指定的子字符串在原字符串中出现多次，只返回第一次出现的子字符串的位置。
  
- **函数示例**
  - 测试数据
    ```
    {
      "name":  "lts is a log service"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_find",str_find(v("name"), "l"))
    ```
    
  
  - 加工结果
    ```
    name:  lts is a log service 
    str_find: 0
    ```
    
   
 
#### str_rfind
判断原字符串中是否包含指定的子字符串。
- **函数格式**
  ```
  str_rfind(value, substr, beg, end)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |       **说明**       |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 被查找的原字符串。          |
  | substr   | 任意（自动转为String） | 是        | 需要查找的字符。           |
  | beg      | Number         | 否        | 开始查找的位置，默认为0。      |
  | end      | Number         | 否        | 结束查找的位置，默认为字符串的长度。 |
     
  
- **返回结果**
  返回字符或字符串最后一次出现的位置。
  
- **函数示例**
  - 测试数据
    ```
    {
      "name":  "lts is a log service"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_rfind", str_rfind(v("name"), "i"))
    ```
    
  
  - 加工结果
    ```
    name:  lts is a log service 
    str_rfind: 17
    ```
    
   
 
#### str_endswith
判断字符串是否以指定后缀结尾。
- **函数格式**
  ```
  str_endswith(value, suffix, start, end)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |              **说明**              |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被判断的原字符串。                      |
  | suffix   | 任意（自动转为String） | 是        | 后缀结尾规则。该参数可以是一个字符串或者是一个元素。       |
  | start    | Number         | 否        | 字符串检测的起始位置。0表示第一个字符，-1表示倒数第一个字符。 |
  | end      | Number         | 否        | 字符串检测的结束位置。0表示第一个字符，-1表示倒数第一个字符。 |
     
  
- **返回结果**
  如果字符串以指定后缀结尾则返回true，否则返回false。
  
- **函数示例**
  - 测试数据
    ```
    {
      "name":  "lts is a log service"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_endswith",str_endswith(v("name"), "service"))
    ```
    
  
  - 加工结果
    ```
    name:  lts is a log service 
    str_endswith: true
    ```
    
   
 
#### str_startswith
判断字符串是否以指定字符串开头。
- **函数格式**
  ```
  str_startswith(value, prefix, start, end)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |              **说明**              |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被判断的原字符串。                      |
  | prefix   | 任意（自动转为String） | 是        | 前缀规则。该参数可以是一个字符串或者是一个元素。         |
  | start    | Number         | 否        | 字符串检测的起始位置。0表示第一个字符，-1表示倒数第一个字符。 |
  | end      | Number         | 否        | 字符串检测的结束位置。0表示第一个字符，-1表示倒数第一个字符。 |
     
  
- **返回结果**
  如果字符串以指定前缀开头则返回true，否则返回false。
  
- **函数示例**
  - 测试数据
    ```
    {
      "name":  "lts is a log service"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_startswith",str_startswith(v("name"), "lts"))
    ```
    
  
  - 加工结果
    ```
    name:  lts is a log service 
    str_startswith: true
    ```
    
   
 
#### str_split
通过指定分隔符对字符串进行分割。
- **函数格式**
  ```
  str_split(value, sep=None, maxsplit=-1)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |     **说明**     |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被分割的原字符串。    |
  | sep      | Number         | 否        | 分隔符，None表示空格。  |
  | maxsplit | Number         | 否        | 最大分裂数。-1表示不限制。 |
     
  
- **返回结果**
  处理后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {
     "content": "lts,a,log,service"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_split", str_split(v("content"), ","))
    ```
    
  
  - 加工结果
    ```
    content: lts,a,log,service 
    str_split: ["lts","a","log","service"]
    ```
    
   
 
#### str_splitlines
通过换行符对字符串进行分割。
- **函数格式**
  ```
  str_splitlines(value, keepends)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |                            **说明**                             |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被分割的原字符串。                                                   |
  | keepends | Boolean        | 否        | 在输出结果里是否去掉换行符（\\r、\\r\\n、\\n）。默认为false，不包含换行符，如果为true，则保留换行符。 |
     
  
- **返回结果**
  处理后的列表。
  
- **函数示例**
  - 测试数据
    ```
    {
     "value": "lts\nis\ra\r\n"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_splitlines", str_splitlines(v("value"), false))
    ```
    
  
  - 加工结果
    ```
    value： lts\nis\ra\r\n 
    str_splitlines: ['lts','is','a']
    ```
    
   
 
#### str_partition
根据指定的分隔符将字符串从左往右分割为三部分。
- **函数格式**
  ```
  str_partition(value, substr)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |   **说明**   |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被分割的字符串。 |
  | substr   | 任意（自动转为String） | 否        | 指定的分隔符。    |
     
  
- **返回结果**
  分隔后的列表。
  
- **函数示例**
  - 测试数据
    ```
    {
     "address":"big.middle.small"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_partition", str_partition(v("address"), "."))
    ```
    
  
  - 加工结果
    ```
    address: big.middle.small 
    str_partition: ["big",".","middle.small"]
    ```
    
   
 
#### str_rpartition
根据指定的分隔符将字符串从右往左分割为三部分。
- **函数格式**
  ```
  str_rpartition(value, substr)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |   **说明**    |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被分割的原字符串。 |
  | substr   | 任意（自动转为String） | 否        | 指定的分隔符。     |
     
  
- **返回结果**
  分隔后的列表。
  
- **函数示例**
  - 测试数据
    ```
    {
     "address":"big.middle.small"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_partition", str_rpartition(v("address"), "."))
    ```
    
  
  - 加工结果
    ```
    address: big.middle.small 
    str_partition: ["big.middle",".","small"]
    ```
    
   
 
#### str_center
用指定字符将字符串填充到指定长度。
- **函数格式**
  ```
  str_center(value, width, fillchar)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |   **说明**    |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被修改的原字符串。 |
  | width    | Number         | 是        | 填充后字符串的总长度。 |
  | fillchar | 任意（自动转为String） | 否        | 填充字符，默认为空格。 |
     
  
- **返回结果**
  处理后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {
     "value": "lts is a log service"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_center", str_center(v("value"), 40, "*"))
    ```
    
  
  - 加工结果
    ```
    center: lts is a log service 
    str_center: **********lts is a log service**********
    ```
    
   
 
#### str_ljust
用指定字符将原字符串从结尾填充至指定长度。
- **函数格式**
  ```
  str_ljust(value, width, fillchar)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |   **说明**    |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被修改的原字符串。 |
  | width    | Number         | 是        | 填充后字符串的总长度。 |
  | fillchar | 任意（自动转为String） | 否        | 填充字符，默认为空格。 |
     
  
- **返回结果**
  处理后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {
     "value": "lts is a log service"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_ljust", str_ljust(v("value"), 30, "*"))
    ```
    
  
  - 加工结果
    ```
    value: lts is a log service 
    str_ljust: lts is a log service**********
    ```
    
   
 
#### str_rjust
用指定字符将原字符串从开头填充至指定长度。
- **函数格式**
  ```
  str_rjust(value, width, fillchar)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |   **说明**    |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被修改的原字符串。 |
  | width    | Number         | 是        | 填充后字符串的总长度。 |
  | fillchar | 任意（自动转为String） | 否        | 填充字符，默认为空格。 |
     
  
- **返回结果**
  处理后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {
     "value": "lts is a log service"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_rjust", str_rjust(v("value"), 30, "*"))
    ```
    
  
  - 加工结果
    ```
    value: lts is a log service 
    str_ljust: **********lts is a log service
    ```
    
   
 
#### str_zfill
用字符0从开头将字符串填充至指定长度。
- **函数格式**
  ```
  str_zfill(value, width)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |   **说明**    |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被修改的原字符串。 |
  | width    | Number         | 是        | 填充后字符串的总长度。 |
     
  
- **返回结果**
  处理后的字符串。
  
- **函数示例**
  - 测试数据
    ```
    {
     "value": "this is lts"
    }
    ```
    
  
  - 加工规则
    ```
    e_set("str_zfill", str_zfill(v("value"), 20))
    ```
    
  
  - 加工结果
    ```
    value: this is lts 
    str_zfill: 000000000this is lts
    ```
    
   
 
#### str_expandtabs
将字符串中的\\t转为空格。
- **函数格式**
  ```
  str_expandtabs(value, tabsize)
  ```
  
- **参数说明**
  
  | **参数名称** |    **参数类型**    | **是否必填** |    **说明**    |
  |---|---|---|---|
  | value    | 任意（自动转为String） | 是        | 需要被修改的原字符串。  |
  | tabsize  | Number         | 否        | 指定转换后空格的字符数。 |
     
  
- **返回结果**
  处理后的字符串。
  
- **函数示例**
  1. 示例1：把key中的\\t字符转为空格。
     - 测试数据
       ```
       {
        "key": "this is\tlts"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("str_expandtabs", str_expandtabs(v("key")))
       ```
       
     
     - 加工结果
       ```
       key: this is\tlts 
       str_expandtabs: this is lts
       ```
       
      
  
  2. 示例2：把key中的\\t字符转为空格，并填充指定空格的数量。
     - 测试数据
       ```
       {
         "key": "this is\tlts"
       }
       ```
       
     
     - 加工规则
       ```
       e_set("str_expandtabs", str_expandtabs(v("key"), 5))
       ```
       
     
     - 加工结果
       ```
       key: this is\tlts 
       str_expandtabs: this is   lts
       ```