

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 使用 Amazon States Language 定義 Step Functions 工作流程
<a name="concepts-amazon-states-language"></a>

Amazon States Language 是一種以 JSON 為基礎的結構化語言，用於定義您的狀態機器、 [狀態](workflow-states.md)集合，可執行 (`Task` 狀態）、判斷要轉換為下一個 (`Choice` 狀態）、停止執行並顯示錯誤 (`Fail` 狀態） 等。

如需詳細資訊，請參閱 [Amazon 狀態語言規格](https://states-language.net/spec.html)和 [Statelint](https://github.com/awslabs/statelint)，這是一種驗證 Amazon 狀態語言程式碼的工具。

若要使用 Amazon States Language 在 [Step Functions 主控台](https://console.aws.amazon.com/states/home?region=us-east-1#/)上建立狀態機器，請參閱[入門](getting-started.md)。

**注意**  
如果您在 Step Functions 主控台之外定義狀態機器，例如在您選擇的編輯器中，您必須使用副檔名 *.asl.json* 儲存狀態機器定義。

## Amazon States Language Specification (JSONata) 範例
<a name="example-amazon-states-language-specification"></a>

```
{
  "Comment": "An example of the Amazon States Language using a choice state.",
  "QueryLanguage": "JSONata",
  "StartAt": "FirstState",
  "States": {
    "FirstState": {
      "Type": "Task",
      "Assign": {
        "foo" : "{% $states.input.foo_input %}" 
        },
      "Resource": "arn:aws:lambda:region:123456789012:function:FUNCTION_NAME",
      "Next": "ChoiceState"
    },
    "ChoiceState": {
      "Type": "Choice",
      "Default": "DefaultState",
      "Choices": [
        {
          "Next": "FirstMatchState",
          "Condition": "{% $foo = 1 %}"
        },
        {
          "Next": "SecondMatchState",
          "Condition": "{% $foo = 2 %}"
        }
      ]
    },
    "FirstMatchState": {
      "Type" : "Task",
      "Resource": "arn:aws:lambda:region:123456789012:function:OnFirstMatch",
      "Next": "NextState"
    },

    "SecondMatchState": {
      "Type" : "Task",
      "Resource": "arn:aws:lambda:region:123456789012:function:OnSecondMatch",
      "Next": "NextState"
    },

    "DefaultState": {
      "Type": "Fail",
      "Error": "DefaultStateError",
      "Cause": "No Matches!"
    },

    "NextState": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:region:123456789012:function:FUNCTION_NAME",
      "End": true
    }
  }
}
```

# Step Functions 工作流程的 Amazon States Language 狀態機器結構
<a name="statemachine-structure"></a>

**管理狀態和轉換資料**  
了解如何[使用變數在狀態與使用 JSONata 轉換資料之間傳遞資料](workflow-variables.md)。 [ JSONata](transforming-data.md)

狀態機器是使用 JSON 文字來定義的，而該 JSON 文字代表包含下列欄位的結構。

** `Comment` (選用)**  
狀態機器的人類可讀描述。

** `QueryLanguage` （選用；省略 時，預設為 `JSONPath`)**  
+ 狀態機器使用的查詢語言名稱。允許的值為 `JSONPath` 和 `JSONata`。
+ 如果未提供狀態機器，則每個狀態的預設值為 JSONPath。
+ 當最上層狀態機器查詢語言為 時`JSONPath`，個別狀態可以透過將 QueryLanguage 設定為 來覆寫查詢語言`JSONata`。有鑑於此方法，您可以逐步將狀態機器從 JSONPath 轉換為 JSONata，一次一個狀態。
+ **注意：**您無法將頂層 JSONata 型狀態機器還原為 JSONata 和 JSONPath 狀態的混合。

** `StartAt` (必要)**  
一個字串，該字串必須完全符合其中一個狀態物件的名稱 (區分大小寫)。

** `TimeoutSeconds` （選用）**  
狀態機器可以執行的執行秒數上限。如果執行超過指定的時間，執行會失敗，出現`States.Timeout` [錯誤名稱](concepts-error-handling.md#error-handling-error-representation)。

** `Version` (選用)**  
狀態機器中使用的 Amazon States Language 版本 （預設為 "1.0")。

** `States` (必要)**  
一個物件，其中包含以逗號分隔的一組狀態。

`States` 欄位包含[狀態](workflow-states.md)。

```
{
    "State1" : {
    },

    "State2" : {
    },
    ...
}
```

狀態機器是由其包含的狀態和其間的關係所定義。

以下是範例。

```
{
  "Comment": "A Hello World example of the Amazon States Language using a Pass state",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Pass",
      "Result": "Hello World!",
      "End": true
    }
  }
}
```

啟動此狀態執行時，系統會從 `StartAt` 欄位 (`"HelloWorld"`) 中參考的狀態著手。如果此狀態具有 `"End": true` 欄位，則執行停止並傳回結果。否則，系統會尋找 `"Next":` 欄位並繼續以該狀態執行。此程序會重複執行，直到系統達到結束狀態 (具有 `"Type": "Succeed"`、`"Type": "Fail"` 或 `"End": true` 的狀態)，或發生執行時間錯誤為止。

下列規則適用於狀態機器內的狀態：
+ 封閉區塊內的狀態可以任何順序發生，但是其列出的順序不會影響其執行順序。此順序是由狀態本身的內容所決定。
+ 在狀態機器內，只能有一個狀態指定為 `start` 狀態，而該狀態是由最上層結構中 `StartAt` 欄位的值所指定。此狀態是開始執行時最先執行的狀態。
+ `End` 欄位為 `true` 的任何狀態都會被視為 `end` (或 `terminal`) 狀態。根據您的狀態機器邏輯，例如，如果您的狀態機器有多個執行分支，您可能有一個以上的`end`狀態。
+ 如果狀態機器只包含一個狀態，該狀態可能同時是 `start` 狀態和 `end` 狀態。

## 工作流程中的常見狀態欄位
<a name="amazon-states-language-common-fields"></a>

下列欄位適用於所有狀態元素。

** `Type` (必要)**  
狀態的類型：任務、選擇、平行、映射、通過、等待、成功、失敗。

**`QueryLanguage` （選用；省略 時，預設為 `JSONPath`)**  
+ 狀態使用的查詢語言名稱。允許的值為 `JSONPath` 和 `JSONata`。
+ 當最上層狀態機器查詢語言為 時`JSONPath`，個別狀態可以透過將 QueryLanguage 設定為 來覆寫查詢語言`JSONata`。有鑑於此方法，您可以逐步將狀態機器從 JSONPath 轉換為 JSONata，一次一個狀態。

** `Next` **  
下一個狀態的名稱將會在目前狀態完成時執行。有些狀態類型 (例如 `Choice`) 允許使用多個轉移狀態。  
如果目前狀態是工作流程中的最後一個狀態，或終端狀態，例如 [工作流程狀態成功](state-succeed.md)或 [失敗的工作流程狀態](state-fail.md)，則您不需要指定 `Next` 欄位。

** `End` **  
如果設定為 `true`，請將此狀態指定為結束狀態 (結束執行)。每個狀態機器可以有任意數量的結束狀態。只有其中一個 `Next` 或 `End` 可使用於狀態中。有些狀態類型，例如 `Choice`或終端狀態，例如 [工作流程狀態成功](state-succeed.md)和 [失敗的工作流程狀態](state-fail.md)，不支援或使用 `End` 欄位。

** `Comment` (選用)**  
保留人類可讀的狀態描述。

** `Assign` (選用)**  
用來存放變數。`Assign` 欄位接受 JSON 物件，其中包含定義變數名稱及其指派值的鍵/值對。任何字串值，包括物件或陣列內的值，都會在以`{% %}`字元包圍時評估為 JSONata   
如需詳細資訊，請參閱[使用變數在狀態之間傳遞資料](workflow-variables.md)。

** `Output` （選用，僅限 JSONata)**  
用來指定和轉換 狀態的輸出。指定時，值會覆寫狀態輸出預設值。  
輸出欄位接受任何 JSON 值 （物件、陣列、字串、數字、布林值、 null)。任何字串值，包括物件或陣列內的值，如果被 \$1% %\$1 字元包圍，將評估為 JSONata。  
 輸出也直接接受 JSONata 表達式，例如：「輸出」：「\$1% jsonata 表達式 %\$1」   
如需詳細資訊，請參閱[輸入和輸出處理](concepts-input-output-filtering.md)。

** `InputPath` （選用，僅限 JSONPath)**  
一個[路徑](concepts-input-output-filtering.md)，可供選取一部分的狀態輸入以傳遞至狀態的任務進行處理。如果省略，它具有可指定整個輸入的 `$` 值。如需詳細資訊，請參閱[輸入和輸出處理](concepts-input-output-filtering.md)。

** `OutputPath` （選用，僅限 JSONPath)**  
選取要傳遞至下一個狀態之狀態輸出的一部分的[路徑](concepts-input-output-filtering.md)。如果省略，則其具有`$`指定整個輸出的值。如需詳細資訊，請參閱[輸入和輸出處理](concepts-input-output-filtering.md)。

# Step Functions 中 JSONPath 狀態的內部函數
<a name="intrinsic-functions"></a>

**管理狀態和轉換資料**  
了解如何[使用變數在狀態與使用 JSONata 轉換資料之間傳遞資料](workflow-variables.md)。 [ JSONata](transforming-data.md)

**警告**  
內部函數僅適用於使用 **JSONPath** 查詢語言的狀態。如需 JSONata，請參閱 [在 Step Functions 中使用 JSONata 轉換資料](transforming-data.md)。

Amazon States Language 提供數個內部函數，也稱為*內部*函數，可用於接受 JSONPath 的欄位。透過 內部，您可以執行基本資料處理操作，而無需使用 `Task` 狀態。

內部看起來類似於程式設計語言中的 函數。它們可用來協助承載建置器處理進出使用 JSONPath 查詢語言之`Task`狀態`Resource`欄位的資料。

在 Amazon States Language 中，內部函數會根據您要執行的資料處理任務類型，分組為下列類別：
+ [陣列的內部](#asl-intrsc-func-arrays)
+ [資料編碼和解碼的內部](#asl-intrsc-func-data-encode-decode)
+ [雜湊計算的內部](#asl-intrsc-func-hash-calc)
+ [JSON 資料處理的內部](#asl-intrsc-func-json-manipulate)
+ [數學操作的內部](#asl-intrsc-func-math-operation)
+ [字串操作的內部](#asl-intrsc-func-string-operation)
+ [產生唯一識別符的內部](#asl-intrsc-func-uuid-generate)
+ [一般操作的內部](#asl-intrsc-func-generic)

若要使用內部函數，您必須在狀態機器定義的`.$`索引鍵值中指定 ，如下列範例所示：

```
"KeyId.$": "States.Array($.Id)"
```

您可以在工作流程的 欄位內巢狀化最多 10 個內部函數。下列範例顯示名為 的欄位`myArn`，其中包含九個巢狀內部函數：

```
"myArn.$": "States.Format('{}.{}.{}', States.ArrayGetItem(States.StringSplit(States.ArrayGetItem(States.StringSplit($.ImageRecipe.Arn, '/'), 2), '.'), 0), States.ArrayGetItem(States.StringSplit(States.ArrayGetItem(States.StringSplit($.ImageRecipe.Arn, '/'), 2), '.'), 1))"
```

**內部函數所需的 QueryLanguage**  
若要使用內部函數，狀態機器必須使用 **JSONPath 查詢語言**。  
使用 JSONata 的狀態無法使用內部函數；不過，JSONata 和 Step Functions 會提供同等選項。

## 支援內部函數的欄位
<a name="intrinsic-functions-states"></a>

下列狀態支援下列欄位中的內部函數：
+ **通過狀態**：參數
+ **任務狀態**：參數、ResultSelector、登入資料
+ **平行狀態**：參數、ResultSelector
+ **映射狀態**：參數、ResultSelector

## 陣列的內部
<a name="asl-intrsc-func-arrays"></a>

使用下列內部執行陣列操作。

**`States.Array`**  
`States.Array` 內部函數接受零個或多個引數。解譯器會依提供的順序傳回包含引數值的 JSON 陣列。例如，假設有下列輸入：  

```
{
  "Id": 123456
}
```
您可以使用  

```
"BuildId.$": "States.Array($.Id)"
```
這會傳回下列結果：``  

```
“BuildId”: [123456]
```

**`States.ArrayPartition`**  
使用`States.ArrayPartition`內部 函數來分割大型陣列。您也可以使用此內部來分割資料，然後以較小的區塊傳送承載。  
此內部函數需要兩個引數。第一個引數是陣列，而第二個引數定義區塊大小。解譯器會將輸入陣列區塊化為區塊大小所指定大小的多個陣列。如果陣列中剩餘項目的數量小於區塊大小，則最後一個陣列區塊的長度可能會小於先前陣列區塊的長度。  
**輸入驗證**  

+ 您必須指定陣列做為函數第一個引數的輸入值。
+ 您必須為代表區塊大小值的第二個引數指定非零的正整數。

  如果您為第二個引數指定非整數值，Step Functions 會將其四捨五入至最接近的整數。
+ 輸入陣列不得超過 Step Functions 的承載大小限制 256 KiB。
例如，指定下列輸入陣列：  

```
{"inputArray": [1,2,3,4,5,6,7,8,9] }
```
您可以使用 `States.ArrayPartition`函數將陣列分割為四個值的區塊：  

```
"inputArray.$": "States.ArrayPartition($.inputArray,4)"
```
這會傳回下列陣列區塊：  

```
{"inputArray": [ [1,2,3,4], [5,6,7,8], [9]] }
```
在先前的範例中，`States.ArrayPartition`函數會輸出三個陣列。前兩個陣列各包含四個值，如區塊大小所定義。第三個陣列包含剩餘值，且小於定義的區塊大小。

**`States.ArrayContains`**  
使用`States.ArrayContains`內部 函數來判斷陣列中是否存在特定值。例如，您可以使用此函數來偵測`Map`狀態反覆運算中是否有錯誤。  
此內部函數需要兩個引數。第一個引數是陣列，而第二個引數是要在陣列中搜尋的值。  
**輸入驗證**  

+ 您必須指定陣列做為函數第一個引數的輸入值。
+ 您必須指定有效的 JSON 物件做為第二個引數。
+ 輸入陣列不得超過 Step Functions 的承載大小限制 256 KiB。
例如，指定下列輸入陣列：  

```
{
   "inputArray": [1,2,3,4,5,6,7,8,9],
   "lookingFor": 5
}
```
您可以使用 `States.ArrayContains`函數來尋找 中的`lookingFor`值`inputArray`：  

```
"contains.$": "States.ArrayContains($.inputArray, $.lookingFor)"
```
由於存放在 中的值`lookingFor`包含在 中`inputArray`， `States.ArrayContains`會傳回下列結果：  

```
{"contains": true }
```

**`States.ArrayRange`**  
使用`States.ArrayRange`內部 函數來建立新的陣列，其中包含特定範圍的元素。新陣列最多可包含 1000 個元素。  
此函數需要三個引數。第一個引數是新陣列的第一個元素，第二個引數是新陣列的最終元素，第三個引數是新陣列中元素之間的增量值。  
**輸入驗證**  

+ 您必須為所有引數指定整數值。

  如果您為任何引數指定非整數值，Step Functions 會將其四捨五入至最接近的整數。
+ 您必須為第三個引數指定非零值。
+ 新產生的陣列不能包含超過 1000 個項目。
例如，下列 `States.ArrayRange`函數的使用將建立一個陣列，其第一個值為 1、最終值為 9，且每個項目第一個值與最終值之間的值會增加 2：  

```
"array.$": "States.ArrayRange(1, 9, 2)"
```
這會傳回下列陣列：  

```
{"array": [1,3,5,7,9] }
```

**`States.ArrayGetItem`**  
此內部函數會傳回指定索引的值。此函數需要兩個引數。第一個引數是值的陣列，第二個引數是要傳回值的陣列索引。  
例如，使用下列 `inputArray`和 `index`值：  

```
{
   "inputArray": [1,2,3,4,5,6,7,8,9],
   "index": 5
}
```
從這些值中，您可以使用 `States.ArrayGetItem`函數傳回陣列中`index`位置 5 的值：  

```
"item.$": "States.ArrayGetItem($.inputArray, $.index)"
```
在此範例中， `States.ArrayGetItem`會傳回下列結果：  

```
{ "item": 6 }
```

**`States.ArrayLength`**  
`States.ArrayLength` 內部函數會傳回陣列的長度。它有一個引數，即要傳回 長度的陣列。  
例如，指定下列輸入陣列：  

```
{
   "inputArray": [1,2,3,4,5,6,7,8,9]
}
```
您可以使用 `States.ArrayLength`傳回 的長度`inputArray`：  

```
"length.$": "States.ArrayLength($.inputArray)"
```
在此範例中， `States.ArrayLength`會傳回代表陣列長度的下列 JSON 物件：  

```
{ "length": 9 }
```

**`States.ArrayUnique`**  
`States.ArrayUnique` 內部函數會從陣列中移除重複值，並傳回僅包含唯一元素的陣列。此函數會採用陣列，此陣列可取消排序，做為其唯一引數。  
例如，以下`inputArray`包含一系列重複值：  

```
{"inputArray": [1,2,3,3,3,3,3,3,4] }
```
您可以使用 `States.ArrayUnique`函數做為 ，並指定要從中移除重複值的陣列：  

```
"array.$": "States.ArrayUnique($.inputArray)"
```
`States.ArrayUnique` 函數會傳回以下僅包含唯一元素的陣列，移除所有重複值：  

```
{"array": [1,2,3,4] }
```

## 資料編碼和解碼的內部
<a name="asl-intrsc-func-data-encode-decode"></a>

使用下列內部函數，根據 Base64 編碼機制來編碼或解碼資料。

**`States.Base64Encode`**  
使用`States.Base64Encode`內部 函數，根據 MIME Base64 編碼結構描述來編碼資料。您可以使用此函數將資料傳遞至其他 AWS 服務，而無需使用 AWS Lambda 函數。  
此函數最多需要 10，000 個字元的資料字串，才能編碼為其唯一的引數。  
例如，請考慮下列`input`字串：  

```
{"input": "Data to encode" }
```
您可以使用 `States.Base64Encode`函數將`input`字串編碼為 MIME Base64 字串：  

```
"base64.$": "States.Base64Encode($.input)"
```
`States.Base64Encode` 函數會傳回下列編碼資料以回應：  

```
{"base64": "RGF0YSB0byBlbmNvZGU=" }
```

**`States.Base64Decode`**  
使用`States.Base64Decode`內部 函數，根據 MIME Base64 解碼結構描述來解碼資料。您可以使用此函數將資料傳遞至其他 AWS 服務，而無需使用 Lambda 函數。  
此函數最多需要 10，000 個字元的 Base64 編碼資料字串，才能解碼為其唯一的引數。  
例如，假設有下列輸入：  

```
{"base64": "RGF0YSB0byBlbmNvZGU=" }
```
您可以使用 `States.Base64Decode`函數將 base64 字串解碼為人類可讀取的字串：  

```
"data.$": "States.Base64Decode($.base64)"
```
`States.Base64Decode function` 會傳回下列解碼資料以回應：  

```
{"data": "Decoded data" }
```

## 雜湊計算的內部
<a name="asl-intrsc-func-hash-calc"></a>

**`States.Hash`**  
使用`States.Hash`內部 函數來計算指定輸入的雜湊值。您可以使用此函數將資料傳遞給其他服務， AWS 而無需使用 Lambda 函數。  
此函數需要兩個引數。第一個引數是您要計算 雜湊值的資料。第二個引數是用來執行雜湊計算的雜湊演算法。您提供的資料必須是包含 10，000 個字元或更少的物件字串。  
您指定的雜湊演算法可以是下列任何演算法：  
+ `MD5`
+ `SHA-1`
+ `SHA-256`
+ `SHA-384`
+ `SHA-512`
例如，您可以使用此函數，使用指定的 來計算`Data`字串的雜湊值`Algorithm`：  

```
{
   "Data": "input data", 
   "Algorithm": "SHA-1" 
}
```
您可以使用 `States.Hash`函數來計算雜湊值：  

```
"output.$": "States.Hash($.Data, $.Algorithm)"
```
`States.Hash` 函數會傳回下列雜湊值以回應：  

```
{"output": "aaff4a450a104cd177d28d18d7485e8cae074b7" }
```

## JSON 資料處理的內部
<a name="asl-intrsc-func-json-manipulate"></a>

使用這些函數對 JSON 物件執行基本資料處理操作。

**`States.JsonMerge`**  
使用`States.JsonMerge`內部 函數將兩個 JSON 物件合併為單一物件。此函數需要三個引數。前兩個引數是您要合併的 JSON 物件。第三個引數是布林值 `false`。此布林值會判斷是否啟用深度合併模式。  
目前，Step Functions 僅支援淺合併模式；因此，您必須將布林值指定為 `false`。在淺模式中，如果兩個 JSON 物件中都存在相同的金鑰，則後者物件的金鑰會覆寫第一個物件中的相同金鑰。此外，當您使用淺合併時，不會合併巢狀在 JSON 物件中的物件。  
例如，您可以使用 `States.JsonMerge`函數合併下列共用金鑰 的 JSON 物件`a`。  

```
{
   "json1": { "a": {"a1": 1, "a2": 2}, "b": 2 },
   "json2": { "a": {"a3": 1, "a4": 2}, "c": 3 }
}
```
您可以將 json1 和 json2 物件指定為`States.JsonMerge`函數中的輸入，以合併在一起：  

```
"output.$": "States.JsonMerge($.json1, $.json2, false)"
```
`States.JsonMerge` 會傳回下列合併的 JSON 物件做為結果。在合併的 JSON 物件 中`output`，`json2`物件的金鑰 會`a`取代`json1`物件的金鑰 `a`。此外，`a`會捨棄`json1`物件金鑰中的巢狀物件，因為淺層模式不支援合併巢狀物件。  

```
{
   "output": {
      "a": {"a3": 1, "a4": 2},
      "b": 2, 
      "c": 3 
   }
}
```

** `States.StringToJson` **  
`States.StringToJson` 函數會將逸出 JSON 字串的參考路徑作為其唯一引數。  
解譯器會套用 JSON 剖析器，並傳回輸入的剖析 JSON 表單。例如，您可以使用此函數來逸出下列輸入字串：  

```
{
 "escapedJsonString": "{\"foo\": \"bar\"}"
}
```
使用 `States.StringToJson`函數，並將 指定`escapedJsonString`為輸入引數：  

```
States.StringToJson($.escapedJsonString)
```
`States.StringToJson` 函數會傳回下列結果：  

```
{ "foo": "bar" }
```

** `States.JsonToString` **  
`States.JsonToString` 函數只需要一個引數，這是包含要以未逸出字串傳回之 JSON 資料的路徑。解譯器會傳回字串，其中包含代表路徑所指定資料的 JSON 文字。例如，您可以提供包含逸出值的下列 JSON 路徑：  

```
{
  "unescapedJson": {
     "foo": "bar"
  }
}
```
為`States.JsonToString`函數提供包含在 中的資料`unescapedJson`：  

```
States.JsonToString($.unescapedJson)
```
`States.JsonToString` 函數會傳回下列回應：  

```
{\"foo\": \"bar\"}
```

## 數學操作的內部
<a name="asl-intrsc-func-math-operation"></a>

使用這些函數來執行數學操作。

**`States.MathRandom`**  
使用`States.MathRandom`內部 函數傳回指定起始編號 （包含） 和結束編號 （不含） 之間的隨機數字。  
您可以使用此函數在兩個或多個資源之間分配特定任務。  
此函數需要三個引數。第一個引數是起始數字，第二個引數是結束數字，最後一個引數控制選用的種子值，請注意，如果您使用此函數搭配相同的種子值，則會傳回相同的數字。  
由於`States.MathRandom`函數不會傳回密碼編譯的安全隨機數字，因此建議您不要將其用於安全敏感的應用程式。
**輸入驗證**  

+ 您必須為起始號碼和結束號碼引數指定整數值。

  如果您為起始號碼或結束號碼引數指定非整數值，Step Functions 會將其四捨五入至最接近的整數。
例如，若要產生介於 1 到 999 之間的隨機數字，您可以使用下列輸入值：  

```
{
   "start": 1,
   "end": 999
}
```
若要產生隨機數字，請將 `start`和 `end`值提供給`States.MathRandom`函數：  

```
"random.$": "States.MathRandom($.start, $.end)"
```
`States.MathRandom` 函數會傳回下列隨機數字做為回應：  

```
{"random": 456 }
```

**`States.MathAdd`**  
使用 `States.MathAdd` 內部函數來傳回兩個數字的總和。例如，您可以使用此函數來增加迴圈內的值，而無需叫用 Lambda 函數。  
**輸入驗證**  

+ 您必須為所有引數指定整數值。

  如果您為一個或兩個引數指定非整數值，Step Functions 會將其四捨五入至最接近的整數。
+ 您必須指定 -2147483648 和 2147483647 範圍內的整數值。
例如，您可以使用下列值從 111 中減去一個值：  

```
{
   "value1": 111,
   "step": -1
}
```
然後，使用`value1`定義為起始值的 `States.MathAdd` 函數，以及`step`定義為要遞增的值`value1`：  

```
"value1.$": "States.MathAdd($.value1, $.step)"
```
`States.MathAdd` 函數會傳回下列數字以回應：  

```
{"value1": 110 }
```

## 字串操作的內部
<a name="asl-intrsc-func-string-operation"></a>

**`States.StringSplit`**  
使用`States.StringSplit`內部 函數將字串分割為值陣列。此函數需要兩個引數。第一個引數是字串，第二個引數是函數用來分割字串的分隔字元。  

**Example - 使用單一分隔字元分割輸入字串**  
在此範例中，使用 `States.StringSplit`將下列 分割`inputString`，其中包含一系列逗號分隔值：  

```
{
    "inputString": "1,2,3,4,5",
    "splitter": ","
}
```
使用 `States.StringSplit`函數並將 定義為`inputString`第一個引數，並將 分隔字元 `splitter` 定義為第二個引數：  

```
"array.$": "States.StringSplit($.inputString, $.splitter)"
```
`States.StringSplit` 函數會傳回下列字串陣列做為結果：  

```
{"array":  ["1","2","3","4","5"] }
```

**Example - 使用多個分隔字元分割輸入字串**  
在此範例中，使用 `States.StringSplit`將下列 分割`inputString`，其中包含多個分隔字元：  

```
{
  "inputString": "This.is+a,test=string",
  "splitter": ".+,="
}
```
使用 `States.StringSplit`函數，如下所示：  

```
{
  "myStringArray.$": "States.StringSplit($.inputString, $.splitter)"
}
```
`States.StringSplit` 函數會傳回下列字串陣列做為結果：  

```
{"myStringArray": [
  "This",
  "is",
  "a",
  "test",
  "string"
]}
```

## 產生唯一識別符的內部
<a name="asl-intrsc-func-uuid-generate"></a>

**`States.UUID`**  
使用`States.UUID`內部 函數傳回使用隨機數字產生的第 4 版通用唯一識別碼 (v4 UUID)。例如，您可以使用此函數來呼叫需要 UUID 參數的其他 AWS 服務或資源，或在 DynamoDB 資料表中插入項目。  
`States.UUID` 函數呼叫時未指定引數：  

```
"uuid.$": "States.UUID()"
```
函數會傳回隨機產生的 UUID，如下列範例所示：  

```
{"uuid": "ca4c1140-dcc1-40cd-ad05-7b4aa23df4a8" }
```

## 一般操作的內部
<a name="asl-intrsc-func-generic"></a>

**`States.Format`**  
使用`States.Format`內部 函數從常值和插補值建構字串。此函數會採用一或多個引數。第一個引數的值必須是字串，且可包含字元序列 的零個或多個執行個體`{}`。內部函數調用中必須具有與發生 一樣多的剩餘引數`{}`。解譯器會傳回第一個引數中定義的字串，每個引數都會`{}`取代為內部調用中位置對應引數的值。  
例如，您可以使用個人 的下列輸入`name`，以及將名稱插入其中的`template`句子：  

```
{
 "name": "Arnav",
 "template": "Hello, my name is {}."
}
```
使用 `States.Format`函數並指定`template`字串和要插入的字串來取代`{}`字元：  

```
States.Format('Hello, my name is {}.', $.name)
```
或  

```
States.Format($.template, $.name)
```
使用上述任一輸入，`States.Format`函數會傳回完成的字串以回應：  

```
Hello, my name is Arnav.
```

## 內部函數中的預留字元
<a name="intrinsic-functions-escapes"></a>

 下列字元保留給內部 函數，如果您希望它們出現在值中，則必須以反斜線 ('\$1') 逸出： '\$1\$1和 \$1。

如果角色`\`需要顯示為值的一部分，而不做為逸出字元，您必須以反斜線逸出它。下列逸出字元序列會與內部函數搭配使用：
+ 常值字串`\'`代表 `'`。
+ 常值字串`\{`代表 `{`。
+ 常值字串`\}`代表 `}`。
+ 常值字串`\\`代表 `\`。

在 JSON 中，字串常值中包含的反斜線必須使用另一個反斜線逸出。JSON 的同等清單為：
+ 逸出字串`\\\'`代表 `\'`。
+ 逸出字串`\\\{`代表 `\{`。
+ 逸出字串`\\\}`代表 `\}`。
+ 逸出字串`\\\\`代表 `\\`。

**注意**  
如果在內部調用字串`\`中找到開啟的逸出反斜線，解譯器將傳回執行時間錯誤。

如果欄位名稱包含 [JsonPath ABNF](https://www.ietf.org/archive/id/draft-ietf-jsonpath-base-21.html#jsonpath-abnf) 規則`member-name-shorthand`定義中未包含的任何字元，您必須對傳遞為內部函數引數的**路徑**使用方括號表示法。如果您的**路徑**包含非英數字元，除了 之外`_`，您還必須使用方括號表示法。例如 `$.abc.['def ghi']`。