本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 文本函数
<a name="recipe-actions.functions.text"></a>

以下为与配方操作配合使用的文本函数的参考主题。

**Topics**
+ [CHAR](recipe-actions.functions.CHAR.md)
+ [ENDS\$1WITH](recipe-actions.functions.ENDS_WITH.md)
+ [EXACT](recipe-actions.functions.EXACT.md)
+ [FIND](recipe-actions.functions.FIND.md)
+ [LEFT](recipe-actions.functions.LEFT.md)
+ [LEN](recipe-actions.functions.LEN.md)
+ [LOWER](recipe-actions.functions.LOWER.md)
+ [MERGE\$1COLUMNS\$1AND\$1VALUES](recipe-actions.functions.MERGE.md)
+ [PROPER](recipe-actions.functions.PROPER.md)
+ [REMOVE\$1SYMBOLS](recipe-actions.functions.REMOVE_SYMBOLS.md)
+ [REMOVE\$1WHITESPACE](recipe-actions.functions.REMOVE_WHITESPACE.md)
+ [REPEAT\$1STRING](recipe-actions.functions.REPEAT.md)
+ [RIGHT](recipe-actions.functions.RIGHT.md)
+ [RIGHT\$1FIND](recipe-actions.functions.RIGHT_FIND.md)
+ [STARTS\$1WITH](recipe-actions.functions.STARTS_WITH.md)
+ [STRING\$1GREATER\$1THAN](recipe-actions.functions.STRING_GREATER_THAN.md)
+ [STRING\$1GREATER\$1THAN\$1EQUAL](recipe-actions.functions.STRING_GREATER_THAN_EQUAL.md)
+ [STRING\$1LESS\$1THAN](recipe-actions.functions.STRING_LESS_THAN.md)
+ [STRING\$1LESS\$1THAN\$1EQUAL](recipe-actions.functions.STRING_LESS_THAN_EQUAL.md)
+ [SUBSTRING](recipe-actions.functions.SUBSTRING.md)
+ [TRIM](recipe-actions.functions.TRIM.md)
+ [UNICODE](recipe-actions.functions.UNICODE.md)
+ [UPPER](recipe-actions.functions.UPPER.md)

# CHAR
<a name="recipe-actions.functions.CHAR"></a>

在新列中返回源列中每个整数的 Unicode 字符，或者返回自定义整数值的 Unicode 字符。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：表示 Unicode 值的整数。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "CHAR",
        "Parameters": {
            "sourceColumn": "age",
            "targetColumn": "age_char"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "CHAR",
        "Parameters": {
            "value": 42,
            "targetColumn": "asterisk"
        }
    }
}
```

# ENDS\$1WITH
<a name="recipe-actions.functions.ENDS_WITH"></a>

如果最右侧指定数量的字符或自定义字符串与模式匹配，则在新列中返回 `true`。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `pattern`：必须匹配字符串结尾的正则表达式。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "ENDS_WITH",
        "Parameters": {
            "sourceColumn": "nationality",
            "pattern": "[Ss]",
            "targetColumn": "nationality_ends_with"
        }
    }
}
```

# EXACT
<a name="recipe-actions.functions.EXACT"></a>

创建新列，填充以下内容之一：
+ `True`：如果一列（或值）中的一个字符串与另一列（或值）中的另一个字符串完全匹配。
+ `False`：如果没有匹配项。

**参数**
+ `sourceColumn1`：现有列的名称。
+ `sourceColumn2`：现有列的名称。
+ `value1`：要计算的字符串。
+ `value2`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您只能指定以下组合之一：  
两个 `sourceColumnN`。
一个 `sourceColumnN` 和一个 `valueN`。
两个 `valueN`。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "EXACT",
        "Parameters": {
            "sourceColumn1": "nationality",
            "value2": "Argentina",
            "targetColumn": "nationality_exact"
        }
    }
}
```

# FIND
<a name="recipe-actions.functions.FIND"></a>

从左到右搜索，查找与源列或自定义值中的指定字符串相匹配的字符串，然后在新列中返回结果。

**参数**
+ `sourceColumn`：现有列的名称。
+ `pattern`：要搜索的正则表达式。
+ `position`：要从字符串左端开始的字符位置。
+ `ignoreCase`：如果为 `true`，则忽略字母之间的大小写差异。要强制严格匹配，请改用 `false`。
+ `targetColumn`：要创建的新列的名称。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "FIND",
        "Parameters": {
            "sourceColumn": "city",
            "pattern": "[AEIOU]",
            "position": "1",
            "ignoreCase": "false",
            "targetColumn": "begins_with_a_vowel"
        }
    }
}
```

# LEFT
<a name="recipe-actions.functions.LEFT"></a>

给定一定数量的字符，选取源列中的字符串或自定义字符串中最左侧的若干字符数，然后在新列中返回最左侧指定数量的字符。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `position`：要从字符串左端开始的字符位置。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "LEFT",
        "Parameters": {
            "position": "3",
            "sourceColumn": "city",
            "targetColumn": "city_left"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "LEFT",
        "Parameters": {
            "position": "5",
            "value": "How now brown cow",
            "targetColumn": "how_now_5_left_chars"
        }
    }
}
```

# LEN
<a name="recipe-actions.functions.LEN"></a>

在新列中返回源列中的字符串或自定义字符串的长度。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "LEN",
        "Parameters": {
            "sourceColumn": "last_name",
            "targetColumn": "last_name_len"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "LEN",
        "Parameters": {
            "value": "Hello",
            "targetColumn": "hello_len"
        }
    }
}
```

# LOWER
<a name="recipe-actions.functions.LOWER"></a>

将源列中的字符串或自定义字符串中的所有字母字符转换为小写，然后在新列中返回结果。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "LOWER",
        "Parameters": {
            "sourceColumn": "last_name",
            "targetColumn": "last_name_lower"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "LOWER",
        "Parameters": {
            "value": "GOODBYE",
            "targetColumn": "goodbye_lower"
        }
    }
}
```

# MERGE\$1COLUMNS\$1AND\$1VALUES
<a name="recipe-actions.functions.MERGE"></a>

联接源列中的字符串，并在新列中返回结果。可以在合并后的值之间插入分隔符。

**参数**
+ `sourceColumns`：两个或多个现有列的 JSON 编码格式名称。
+ `delimiter`：可选。要在每两个源列值之间放置的一个或多个字符。
+ `targetColumn`：要创建的新列的名称。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "MERGE_COLUMNS_AND_VALUES",
        "Parameters": {
            "sourceColumns": "[\"last_name\",\"birth_date\"]",
            "delimiter": " was born on: ",
            "targetColumn": "merged_column"
        }
    }
}
```

# PROPER
<a name="recipe-actions.functions.PROPER"></a>

将源列中的字符串或自定义值中的所有字母字符转换为适当的大小写，然后在新列中返回结果。

采用*适当大小写*，也称为首字母大写，每个单词的第一个字母大写，单词的其余部分转换为小写。示例：The Quick Brown Fox Jumped Over The Fence 

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "PROPER",
        "Parameters": {
            "sourceColumn": "first_name",
            "targetColumn": "first_name_proper"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "PROPER",
        "Parameters": {
            "value": "MR. H. SMITH, ESQ.",
            "targetColumn": "formal_name_proper"
        }
    }
}
```

# REMOVE\$1SYMBOLS
<a name="recipe-actions.functions.REMOVE_SYMBOLS"></a>

从源列中的字符串或自定义字符串中删除不是字母、数字、带重音的拉丁字符或空格的字符，并在新列中返回结果。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "REMOVE_SYMBOLS",
        "Parameters": {
            "sourceColumn": "info_url",
            "targetColumn": "info_url_remove_symbols"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "REMOVE_SYMBOLS",
        "Parameters": {
            "value": "$&#$&HEY!#@@",
            "targetColumn": "without_symbols"
        }
    }
}
```

# REMOVE\$1WHITESPACE
<a name="recipe-actions.functions.REMOVE_WHITESPACE"></a>

从源列中的字符串或自定义字符串中删除空格，并在新列中返回结果。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "REMOVE_WHITESPACE",
        "Parameters": {
            "sourceColumn": "job_desc",
            "targetColumn": "job_desc_remove_whitespace"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "REMOVE_WHITESPACE",
        "Parameters": {
            "value": "This string has spaces in it",
            "targetColumn": "string_without_spaces"
        }
    }
}
```

# REPEAT\$1STRING
<a name="recipe-actions.functions.REPEAT"></a>

重复源列中的字符串或自定义输入值指定的次数，然后在新列中返回结果。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `count`：重复字符串的次数。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "REPEAT_STRING",
        "Parameters": {
            "count": 3,
            "sourceColumn": "last_name",
            "targetColumn": "last_name_repeat_string"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "REPEAT_STRING",
        "Parameters": {
            "count": 80,
            "value": "*",
            "targetColumn": "80_stars"
        }
    }
}
```

# RIGHT
<a name="recipe-actions.functions.RIGHT"></a>

给定一定数量的字符，选取源列中的字符串或自定义字符串中最右侧的若干字符数，然后在新列中返回最右侧指定数量的字符。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `position`：要从字符串右侧开始的字符位置。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "RIGHT",
        "Parameters": {
            "sourceColumn": "nationality",
            "position": "3",
            "targetColumn": "nationality_right"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "RIGHT",
        "Parameters": {
            "value": "United States of America",
            "position": "7",
            "targetColumn": "usa_right"
        }
    }
}
```

# RIGHT\$1FIND
<a name="recipe-actions.functions.RIGHT_FIND"></a>

从右到左搜索，查找与源列或自定义值中的指定字符串相匹配的字符串，然后在新列中返回结果。

**参数**
+ `sourceColumn`：现有列的名称。
+ `pattern`：要搜索的正则表达式。
+ `position`：要从字符串右端开始的字符位置。
+ `ignoreCase`：如果为 `true`，则忽略字母之间的大小写差异。要强制严格匹配，请改用 `false`。
+ `targetColumn`：要创建的新列的名称。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "RIGHT_FIND",
        "Parameters": {
            "sourceColumn": "nationality",
            "pattern": "s",
            "position": "1",
            "ignoreCase": "true",
            "targetColumn": "ends_with_an_s"
        }
    }
}
```

# STARTS\$1WITH
<a name="recipe-actions.functions.STARTS_WITH"></a>

如果最左侧指定数量的字符或自定义字符串与模式匹配，则在新列中返回 `true`。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `pattern`：必须匹配字符串开头的正则表达式。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "STARTS_WITH",
        "Parameters": {
            "sourceColumn": "nationality",
            "pattern": "[AEIOU]",
            "targetColumn": "nationality_starts_with"
        }
    }
}
```

# STRING\$1GREATER\$1THAN
<a name="recipe-actions.functions.STRING_GREATER_THAN"></a>

创建新列，填充以下内容之一：
+ `True`：如果一列（或值）中的一个字符串大于另一列（或值）中的另一个字符串。
+ `False`：如果没有匹配项。

**参数**
+ `sourceColumn1`：现有列的名称。
+ `sourceColumn2`：现有列的名称。
+ `value1`：要计算的字符串。
+ `value2`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您只能指定以下组合之一：  
两个 `sourceColumnN`。
一个 `sourceColumnN` 和一个 `valueN`。
两个 `valueN`。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "STRING_GREATER_THAN",
        "Parameters": {
            "sourceColumn1": "first_name",
            "sourceColumn2": "last_name",
            "targetColumn": "string_greater_than"
        }
    }
}
```

# STRING\$1GREATER\$1THAN\$1EQUAL
<a name="recipe-actions.functions.STRING_GREATER_THAN_EQUAL"></a>

创建新列，填充以下内容之一：
+ `True`：如果一列（或值）中的一个字符串大于或等于另一列（或值）中的另一个字符串。
+ `False`：如果没有匹配项。

**参数**
+ `sourceColumn1`：现有列的名称。
+ `sourceColumn2`：现有列的名称。
+ `value1`：要计算的字符串。
+ `value2`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您只能指定以下组合之一：  
两个 `sourceColumnN`。
一个 `sourceColumnN` 和一个 `valueN`。
两个 `valueN`。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "STRING_GREATER_THAN_EQUAL",
        "Parameters": {
            "sourceColumn1": "nationality",
            "targetColumn": "string_greater_than_equal",
            "value2": "s"
        }
    }
}
```

# STRING\$1LESS\$1THAN
<a name="recipe-actions.functions.STRING_LESS_THAN"></a>

创建新列，填充以下内容之一：
+ `True`：如果一列（或值）中的一个字符串小于另一列（或值）中的另一个字符串。
+ `False`：如果没有匹配项。

**参数**
+ `sourceColumn1`：现有列的名称。
+ `sourceColumn2`：现有列的名称。
+ `value1`：要计算的字符串。
+ `value2`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您只能指定以下组合之一：  
两个 `sourceColumnN`。
一个 `sourceColumnN` 和一个 `valueN`。
两个 `valueN`。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "STRING_LESS_THAN",
        "Parameters": {
            "sourceColumn1": "first_name",
            "sourceColumn2": "last_name",
            "targetColumn": "string_less_than"
        }
    }
}
```

# STRING\$1LESS\$1THAN\$1EQUAL
<a name="recipe-actions.functions.STRING_LESS_THAN_EQUAL"></a>

创建新列，填充以下内容之一：
+ `True`：如果一列（或值）中的一个字符串小于或等于另一列（或值）中的另一个字符串。
+ `False`：如果没有匹配项。

**参数**
+ `sourceColumn1`：现有列的名称。
+ `sourceColumn2`：现有列的名称。
+ `value1`：要计算的字符串。
+ `value2`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您只能指定以下组合之一：  
两个 `sourceColumnN`。
一个 `sourceColumnN` 和一个 `valueN`。
两个 `valueN`。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "STRING_LESS_THAN_EQUAL",
        "Parameters": {
            "sourceColumn1": "first_name",
            "targetColumn": "string_less_than_equal",
            "value2": "s"
        }
    }
}
```

# SUBSTRING
<a name="recipe-actions.functions.SUBSTRING"></a>

根据用户定义的起始和结束索引值，在新列中返回源列中指定字符串的部分或全部。

**参数**
+ `sourceColumn`：现有列的名称。
+ `startPosition`：要从字符串左端开始的字符位置。
+ `endPosition`：要从字符串左端结束的字符位置。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "SUBSTRING",
        "Parameters": {
            "sourceColumn": "last_name",
            "startPosition": "5",
            "endPosition": "8",
            "targetColumn": "chars_5_through_8"
        }
    }
}
```

# TRIM
<a name="recipe-actions.functions.TRIM"></a>

从源列中的字符串或自定义字符串中删除前导和尾随空格，并在新列中返回结果。单词之间的空格不会被删除。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "TRIM",
        "Parameters": {
            "sourceColumn": "nationality",
            "targetColumn": "nationality_trim"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "TRIM",
        "Parameters": {
            "value": "   This string should be trimmed       ",
            "targetColumn": "string_trimmed"
        }
    }
}
```

# UNICODE
<a name="recipe-actions.functions.UNICODE"></a>

在新列中返回源列中字符串的第一个字符或自定义字符串的 Unicode 索引值。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "UNICODE",
        "Parameters": {
            "sourceColumn": "first_name",
            "targetColumn": "first_name_unicode"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "UNICODE",
        "Parameters": {
            "value": "?",
            "targetColumn": "sixty_three"
        }
    }
}
```

# UPPER
<a name="recipe-actions.functions.UPPER"></a>

将源列中的字符串或自定义字符串中的所有字母字符转换为大写，然后在新列中返回结果。

**参数**
+ `sourceColumn`：现有列的名称。
+ `value`：要计算的字符串。
+ `targetColumn`：要创建的新列的名称。

**注意**  
您可以指定 `sourceColumn` 或 `value`，但不能同时指定两者。

**Example 示例**  
  

```
{
    "RecipeAction": {
        "Operation": "UPPER",
        "Parameters": {
            "sourceColumn": "last_name",
            "targetColumn": "last_name_upper"
        }
    }
}
```
  

```
{
    "RecipeAction": {
        "Operation": "UPPER",
        "Parameters": {
            "value": "a string of lowercase letters",
            "targetColumn": "string_upper"
        }
    }
}
```