本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 解析程式和函數的AWS AppSync JavaScript 執行期功能
`APPSYNC_JS` 執行時間環境提供類似於 [ECMAScript (ES) 6.0 版的功能。](https://262.ecma-international.org/6.0/)它支援其功能子集，並提供一些不屬於 ES 規格的其他方法 （公用程式）。下列主題列出所有支援的語言功能：
+ [ 支援的執行期功能 ](https://docs.aws.amazon.com/appsync/latest/devguide/supported-features.html) - 進一步了解支援的核心功能、基本物件、內建物件和函數等。
+ [ 內建公用程式 ](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html) - util 變數包含可協助您處理資料的一般公用程式方法。除非另行指定，否則所有公用程式皆使用 UTF-8 字元集。
+ [ 內建模組 ](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html) - 進一步了解內建模組如何協助撰寫 JavaScript 解析程式和函數。
+ [ 執行期公用程式 ](https://docs.aws.amazon.com/appsync/latest/devguide/runtime-utils-js.html) - 執行期程式庫提供公用程式來控制或修改解析程式和函數的執行期屬性。
+ [ util.time 中的時間協助程式 ](https://docs.aws.amazon.com/appsync/latest/devguide/time-helpers-in-util-time-js.html) - util.time 變數包含日期時間方法，可協助產生時間戳記、在日期時間格式之間轉換，以及剖析日期時間字串。日期時間格式的語法是以 [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) 為基礎，您可以參考以取得進一步的文件。
+ [ util.dynamodb 中的 DynamoDB 協助程式 ](https://docs.aws.amazon.com/appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html) - util.dynamodb 包含協助程式方法，可讓您更輕鬆地將資料寫入和讀取至 Amazon DynamoDB，例如自動類型映射和格式化。
+ [ util.http 中的 HTTP 協助程式 ](https://docs.aws.amazon.com/appsync/latest/devguide/http-helpers-in-utils-http-js.html) - util.http 公用程式提供可用於管理 HTTP 請求參數和新增回應標頭的協助程式方法。
+ [ util.transform 中的轉換協助程式 ](https://docs.aws.amazon.com/appsync/latest/devguide/transformation-helpers-in-utils-transform-js.html) - util.transform 包含協助程式方法，可讓您更輕鬆地對資料來源執行複雜的操作。
+ [ util.str 中的字串協助程式 ](https://docs.aws.amazon.com/appsync/latest/devguide/str-helpers-in-util-str-js.html) - util.str 包含有助於常見字串操作的方法。
+ [ 延伸模組 ](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html) - 延伸模組包含一組方法，可在解析程式中執行其他動作。
+ [ util.xml 中的 XML 協助程式 ](https://docs.aws.amazon.com/appsync/latest/devguide/xml-helpers-in-util-xml-js.html) - util.xml 包含有助於 XML 字串轉換的方法。
**注意**
目前，此參考僅適用於執行時間 **1.0.0** 版。
# 支援的執行時間功能
以下各節說明 APPSYNC\$1JS 執行時間的支援功能集。
## 核心功能
支援下列核心功能。
------
#### [ Types ]
以下是支援的類型：
+ 數字
+ 字串
+ 布林值
+ objects
+ 陣列
+ 函數
------
#### [ Operators ]
支援運算子，包括：
+ 標準數學運算子 (`+`、`-`、`/``%`、、 `*`等）
+ nullish coalescing 運算子 (`??`)
+ 選用鏈結 (`?.`)
+ 位元運算子
+ `void` 和 `typeof` 運算子
+ 分散運算子 (`...`)
不支援下列運算子：
+ 統一運算子 `++`(`--`、 和 `~`)
+ `in`運算子
**注意**
使用 `Object.hasOwn` 運算子來檢查指定的屬性是否位於指定的物件中。
------
#### [ Statements ]
支援下列陳述式：
+ `const`
+ `let`
+ `var`
+ `break`
+ `else`
+ `for-in`
+ `for-of`
+ `if`
+ `return`
+ `switch`
+ 分散語法
不支援下列項目：
+ `catch`
+ `continue`
+ `do-while`
+ `finally`
+ `for(initialization; condition; afterthought)`
**注意**
支援的例外是 `for-in`和 `for-of`表達式。
+ `throw`
+ `try`
+ `while`
+ 標籤陳述式
------
#### [ Literals ]
支援下列 ES 6 [範本常值](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals)：
+ 多行字串
+ 表達式插補
+ 巢狀化範本
------
#### [ Functions ]
支援下列函數語法：
+ 支援函數宣告。
+ 支援 ES 6 箭頭函數。
+ 支援 ES 6 靜態參數語法。
------
#### [ Strict mode ]
函數按預設會在嚴格模式下運作，因此您不需要在函數程式碼中新增 `use_strict` 陳述式。無法對此進行變更。
------
## 基本物件
支援以下基本的 ES 物件及其函數。
------
#### [ Object ]
支援下列物件：
+ `Object.assign()`
+ `Object.entries()`
+ `Object.hasOwn()`
+ `Object.keys()`
+ `Object.values()`
+ `delete`
------
#### [ String ]
支援下列字串：
+ `String.prototype.length()`
+ `String.prototype.charAt()`
+ `String.prototype.concat()`
+ `String.prototype.endsWith()`
+ `String.prototype.indexOf()`
+ `String.prototype.lastIndexOf()`
+ `String.raw()`
+ `String.prototype.replace()`
**注意**
不支援規則運算式。
不過，提供的參數中支援 Java 樣式的規則表達式建構。如需詳細資訊，請參閱[模式](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)。
+ `String.prototype.replaceAll()`
**注意**
不支援規則運算式。
不過，提供的參數中支援 Java 樣式的規則表達式建構。如需詳細資訊，請參閱[模式](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)。
+ `String.prototype.slice()`
+ `String.prototype.split()`
+ `String.prototype.startsWith()`
+ `String.prototype.toLowerCase()`
+ `String.prototype.toUpperCase()`
+ `String.prototype.trim()`
+ `String.prototype.trimEnd()`
+ `String.prototype.trimStart()`
------
#### [ Number ]
支援下列號碼：
+ `Number.isFinite`
+ `Number.isNaN`
------
## 內建物件和函數
支援下列函數和物件。
------
#### [ Math ]
支援下列數學函數：
+ `Math.random()`
+ `Math.min()`
+ `Math.max()`
+ `Math.round()`
+ `Math.floor()`
+ `Math.ceil()`
------
#### [ Array ]
支援下列陣列方法：
+ `Array.prototype.length`
+ `Array.prototype.concat()`
+ `Array.prototype.fill()`
+ `Array.prototype.flat()`
+ `Array.prototype.indexOf()`
+ `Array.prototype.join()`
+ `Array.prototype.lastIndexOf()`
+ `Array.prototype.pop()`
+ `Array.prototype.push()`
+ `Array.prototype.reverse()`
+ `Array.prototype.shift()`
+ `Array.prototype.slice()`
+ `Array.prototype.sort()`
**注意**
`Array.prototype.sort()` 不支援引數。
+ `Array.prototype.splice()`
+ `Array.prototype.unshift()`
+ `Array.prototype.forEach()`
+ `Array.prototype.map()`
+ `Array.prototype.flatMap()`
+ `Array.prototype.filter()`
+ `Array.prototype.reduce()`
+ `Array.prototype.reduceRight()`
+ `Array.prototype.find()`
+ `Array.prototype.some()`
+ `Array.prototype.every()`
+ `Array.prototype.findIndex()`
+ `Array.prototype.findLast()`
+ `Array.prototype.findLastIndex()`
+ `delete`
------
#### [ Console ]
主控台物件可用於偵錯。在即時查詢執行期間，主控台日誌/錯誤陳述式會傳送至 Amazon CloudWatch Logs （如果啟用記錄功能）。使用 進行程式碼評估期間`evaluateCode`，日誌陳述式會在命令回應中傳回。
+ `console.error()`
+ `console.log()`
------
#### [ Function ]
+ 不支援 `bind`、 `apply`和 `call`方法。
+ 不支援函數建構子。
+ 不支援將函數做為引數傳遞。
+ 不支援遞迴函數呼叫。
------
#### [ JSON ]
支援下列 JSON 方法：
+ `JSON.parse()`
**注意**
如果剖析的字串不是有效的 JSON，則傳回空白字串。
+ `JSON.stringify()`
------
#### [ Promises ]
不支援非同步程序，也不支援 promise。
**注意**
在 in. `APPSYNC_JS`執行時間內不支援網路和檔案系統存取 AWS AppSync。 會根據 AWS AppSync 解析程式或 AWS AppSync 函數提出的請求 AWS AppSync 來處理所有 I/O 操作。
------
## 全域變數
支援以下全局常數：
+ `NaN`
+ `Infinity`
+ `undefined`
+ [https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html)
+ [https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html)
+ `runtime`
## 錯誤類型
`throw` 不支援使用 擲回錯誤。您可以使用 `util.error()`函數傳回錯誤。您可以使用 `util.appendError`函數在 GraphQL 回應中包含錯誤。
如需詳細資訊，請參閱[錯誤 utils](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html#utility-helpers-in-error-js)。
# 內建公用程式
`util` 變數包含可協助您處理資料的一般公用程式方法。除非另行指定，否則所有公用程式皆使用 UTF-8 字元集。
## 編碼 utils
### 編碼 utils 清單
**`util.urlEncode(String)`**
以 `application/x-www-form-urlencoded` 編碼字串的形式傳回輸入字串。
**`util.urlDecode(String)`**
將 `application/x-www-form-urlencoded` 編碼的字串解碼回非編碼格式。
**`util.base64Encode(string) : string`**
將輸入編碼為 base64 編碼字串。
**`util.base64Decode(string) : string`**
解碼 base64 編碼字串中的資料。
## ID 產生 utils
### ID 產生 utils 清單
**`util.autoId()`**
傳回 128 位元隨機產生的 UUID。
**`util.autoUlid()`**
傳回 128 位元隨機產生的 ULID （通用可排序序列識別符）。
**`util.autoKsuid()`**
傳回 128 位元隨機產生的 KSUID (K-Sortable Unique Identifier) base62，其編碼為長度為 27 的字串。
## 錯誤率
### 錯誤使用率清單
**`util.error(String, String?, Object?, Object?)`**
擲回自訂錯誤。如果範本偵測到要求或呼叫結果的錯誤，您可以將此用於要求或回應映射範本。此外，也可以指定 `errorType` 欄位、 `data` 欄位和 `errorInfo` 欄位。`data` 值將新增到 GraphQL 回應中，`error` 內對應的 `errors` 區塊。
`data` 將根據查詢選取集進行篩選。`errorInfo` 值將新增到 GraphQL 回應中，`error` 內對應的 `errors` 區塊。
`errorInfo` **不會**根據查詢選取集進行篩選。
**`util.appendError(String, String?, Object?, Object?)`**
附加自訂錯誤。如果範本偵測到要求或呼叫結果的錯誤，您可以將此用於要求或回應映射範本。此外，也可以指定 `errorType` 欄位、 `data` 欄位和 `errorInfo` 欄位。與 `util.error(String, String?, Object?, Object?)` 不同的是，範本評估不會受中斷，因此可以將資料傳回給發起人。`data` 值將新增到 GraphQL 回應中，`error` 內對應的 `errors` 區塊。
`data` 將根據查詢選取集進行篩選。`errorInfo` 值將新增到 GraphQL 回應中，`error` 內對應的 `errors` 區塊。
`errorInfo` **不會**根據查詢選取集進行篩選。
## 類型和模式比對 utils
### 類型和模式比對 utils 清單
**`util.matches(String, String) : Boolean`**
如果第一個引數中指定的模式與第二個引數中提供的資料相符，則傳回真。模式必須為規則表達式，例如 `util.matches("a*b", "aaaaab")`。此功能是根據[模式](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html)，您可以參考以取得更詳細的文件。
**`util.authType()`**
傳回描述請求所使用之多重驗證類型的字串，傳回「IAM 授權」、「使用者集區授權」、「開放式 ID Connect 授權」或「API 金鑰授權」。
## 傳回值行為 utils
### 傳回值行為 utils 清單
**`util.escapeJavaScript(String)`**
以 JavaScript 逸出字串傳回輸入字串。
## 解析程式授權公用程式
### 解析程式授權使用率清單
**`util.unauthorized()`**
擲回欲解析之欄位的 `Unauthorized`。在請求或回應映射範本中使用此選項，以決定是否允許發起人解析 欄位。
# 內建模組
模組是`APPSYNC_JS`執行時間的一部分，並提供公用程式以協助撰寫 JavaScript 解析程式和函數。如需範例和範例，請參閱 [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub 儲存庫。
## DynamoDB 模組函數
DynamoDB 模組函數可在與 DynamoDB 資料來源互動時提供增強的體驗。您可以使用 函數向 DynamoDB 資料來源提出請求，而無需新增類型映射。
使用 匯入模組`@aws-appsync/utils/dynamodb`：
```
// Modules are imported using @aws-appsync/utils/dynamodb
import * as ddb from '@aws-appsync/utils/dynamodb';
```
### 函數
#### 函數清單
**` get(payload: GetInput): DynamoDBGetItemRequest`**
如需 GetInput 的相關資訊[輸入](#built-in-ddb-modules-inputs)，請參閱 。
產生`DynamoDBGetItemRequest`物件以向 DynamoDB 提出 [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem) 請求。
```
import { get } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return get({ key: { id: ctx.args.id } });
}
```
**`put(payload): DynamoDBPutItemRequest`**
產生`DynamoDBPutItemRequest`物件以向 DynamoDB 提出 [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem) 請求。
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
return ddb.put({ key: { id: util.autoId() }, item: ctx.args });
}
```
**`remove(payload): DynamoDBDeleteItemRequest`**
產生`DynamoDBDeleteItemRequest`物件以向 DynamoDB 提出 [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem) 請求。
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return ddb.remove({ key: { id: ctx.args.id } });
}
```
**`scan(payload): DynamoDBScanRequest`**
產生 `DynamoDBScanRequest`以向 DynamoDB 提出[掃描](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan)請求。
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 10, nextToken } = ctx.args;
return ddb.scan({ limit, nextToken });
}
```
**`sync(payload): DynamoDBSyncRequest`**
產生`DynamoDBSyncRequest`物件以提出[同步](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync)請求。請求只會接收自上次查詢後更改的資料 （差異更新）。只能對版本控制的 DynamoDB 資料來源提出請求。
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 10, nextToken, lastSync } = ctx.args;
return ddb.sync({ limit, nextToken, lastSync });
}
```
**`update(payload): DynamoDBUpdateItemRequest`**
產生`DynamoDBUpdateItemRequest`物件以向 DynamoDB 提出 [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem) 請求。
### 作業
操作協助程式可讓您在更新期間對部分資料採取特定動作。若要開始使用，`operations`請從 匯入`@aws-appsync/utils/dynamodb`：
```
// Modules are imported using operations
import {operations} from '@aws-appsync/utils/dynamodb';
```
#### 操作清單
**`add(payload)`**
在更新 DynamoDB 時新增屬性項目的協助程式函數。
**範例**
若要使用 ID 值將地址 （街道、城市和郵遞區號） 新增至現有的 DynamoDB 項目：
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
address: operations.add({
street1: '123 Main St',
city: 'New York',
zip: '10001',
}),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`append (payload)`**
將承載附加至 DynamoDB 中現有清單的協助程式函數。
**範例**
若要在更新期間將新增IDs (`newFriendIds`) 附加至現有的朋友清單 (`friendsIds`)：
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [101, 104, 111];
const updateObj = {
friendsIds: operations.append(newFriendIds),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`decrement (by?)`**
在更新 DynamoDB 時減少項目中現有屬性值的協助程式函數。
**範例**
若要將朋友計數器 (`friendsCount`) 減少 10：
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
friendsCount: operations.decrement(10),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`increment (by?)`**
在更新 DynamoDB 時遞增項目中現有屬性值的協助程式函數。
**範例**
若要將好友計數器 (`friendsCount`) 增加 10：
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
friendsCount: operations.increment(10),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`prepend (payload)`**
在 DynamoDB 中現有清單前面的協助程式函數。
**範例**
若要在更新期間將新增IDs (`newFriendIds`) 附加至現有的朋友清單 (`friendsIds`)：
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [101, 104, 111];
const updateObj = {
friendsIds: operations.prepend(newFriendIds),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`replace (payload)`**
在 DynamoDB 中更新項目時取代現有屬性的協助程式函數。當您想要更新屬性中的整個物件或子物件，而不只是承載中的索引鍵時，此功能非常有用。
**範例**
若要取代 `info` 物件中的地址 （街道、城市和郵遞區號）：
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
info: {
address: operations.replace({
street1: '123 Main St',
city: 'New York',
zip: '10001',
}),
},
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`updateListItem (payload, index)`**
取代清單中項目的協助程式函數。
**範例**
在更新範圍 (`newFriendIds`) 中，此範例用於`updateListItem`更新清單中第二個項目 （索引：`1`，新 ID：`102`) 和第三個項目 （索引：`2`，新 ID：`112`) 的 ID 值 ()`friendsIds`。
```
import { update, operations as ops } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [
ops.updateListItem('102', 1), ops.updateListItem('112', 2)
];
const updateObj = { friendsIds: newFriendIds };
return update({ key: { id: 1 }, update: updateObj });
}
```
### 輸入
#### 輸入清單
**`Type GetInput`**
```
GetInput: {
consistentRead?: boolean;
key: DynamoDBKey;
}
```
**類型宣告**
+ `consistentRead?: boolean` (選用)
選用布林值，用於指定是否要與 DynamoDB 執行強式一致讀取。
+ `key: DynamoDBKey` (必要)
在 DynamoDB 中指定項目索引鍵的必要參數。DynamoDB 項目可能有單一雜湊索引鍵或雜湊和排序索引鍵。
**`Type PutInput`**
```
PutInput: {
_version?: number;
condition?: DynamoDBFilterObject | null;
customPartitionKey?: string;
item: Partial;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**類型宣告**
+ `_version?: number` (選用)
+ `condition?: DynamoDBFilterObject | null` (選用)
當您將物件放入 DynamoDB 資料表時，您可以選擇指定條件式表達式，以根據在執行操作之前已在 DynamoDB 中的物件狀態來控制請求是否成功。
+ `customPartitionKey?: string` (選用)
啟用時，此字串值會修改啟用版本控制時差異同步資料表所使用的 `ds_sk`和 `ds_pk` 記錄格式。啟用時，也會啟用`populateIndexFields`項目的處理。
+ `item: Partial` (必要)
要放入 DynamoDB 之項目的其餘屬性。
+ `key: DynamoDBKey` (必要)
必要參數，指定 DynamoDB 中要對其執行放置的項目索引鍵。DynamoDB 項目可能有單一雜湊索引鍵或雜湊和排序索引鍵。
+ `populateIndexFields?: boolean` (選用)
布林值，當 與 啟用時`customPartitionKey`，會為差異同步資料表中的每個記錄建立新的項目，特別是在 `gsi_ds_pk`和 `gsi_ds_sk`欄中。如需詳細資訊，請參閱《 *AWS AppSync 開發人員指南*》中的[衝突偵測和同步](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html)。
**`Type QueryInput`**
```
QueryInput: ScanInput & {
query: DynamoDBKeyCondition>;
}
```
**類型宣告**
+ `query: DynamoDBKeyCondition>` (必要)
指定描述要查詢之項目的金鑰條件。對於指定的索引，分割區索引鍵的條件應為等式，排序索引鍵應為比較或 `beginsWith`（當它是字串時）。分割區和排序索引鍵僅支援數字和字串類型。
**範例**
請採用以下`User`類型：
```
type User = {
id: string;
name: string;
age: number;
isVerified: boolean;
friendsIds: string[]
}
```
查詢只能包含下列欄位：`id`、 `name`和 `age`：
```
const query: QueryInput = {
name: { eq: 'John' },
age: { gt: 20 },
}
```
**`Type RemoveInput`**
```
RemoveInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**類型宣告**
+ `_version?: number` (選用)
+ `condition?: DynamoDBFilterObject` (選用)
當您在 DynamoDB 中移除物件時，您可以選擇指定條件式表達式，以根據在執行操作之前已在 DynamoDB 中的物件狀態來控制請求是否成功。
**範例**
下列範例是包含條件的`DeleteItem`表達式，只有在文件擁有者符合提出請求的使用者時，才會允許操作成功。
```
type Task = {
id: string;
title: string;
description: string;
owner: string;
isComplete: boolean;
}
const condition: DynamoDBFilterObject = {
owner: { eq: 'XXXXXXXXXXXXXXXX' },
}
remove({
key: {
id: 'XXXXXXXXXXXXXXXX',
},
condition,
});
```
+ `customPartitionKey?: string` (選用)
啟用時， `customPartitionKey`值會修改啟用版本控制時差異同步資料表所使用的 `ds_sk`和 `ds_pk` 記錄格式。啟用時，也會啟用`populateIndexFields`項目的處理。
+ `key: DynamoDBKey` (必要)
必要參數，指定要移除之 DynamoDB 中項目的索引鍵。DynamoDB 項目可能有單一雜湊索引鍵或雜湊和排序索引鍵。
**範例**
如果`User`只有使用者 的雜湊金鑰`id`，則金鑰看起來會如下所示：
```
type User = {
id: number
name: string
age: number
isVerified: boolean
}
const key: DynamoDBKey = {
id: 1,
}
```
如果資料表使用者具有雜湊索引鍵 (`id`) 和排序索引鍵 (`name`)，則索引鍵看起來會如下所示：
```
type User = {
id: number
name: string
age: number
isVerified: boolean
friendsIds: string[]
}
const key: DynamoDBKey = {
id: 1,
name: 'XXXXXXXXXX',
}
```
+ `populateIndexFields?: boolean` (選用)
布林值，當 與 啟用時`customPartitionKey`，會為差異同步資料表中的每個記錄建立新的項目，特別是在 `gsi_ds_pk`和 `gsi_ds_sk`欄中。
**`Type ScanInput`**
```
ScanInput: {
consistentRead?: boolean | null;
filter?: DynamoDBFilterObject | null;
index?: string | null;
limit?: number | null;
nextToken?: string | null;
scanIndexForward?: boolean | null;
segment?: number;
select?: DynamoDBSelectAttributes;
totalSegments?: number;
}
```
**類型宣告**
+ `consistentRead?: boolean | null` (選用)
在查詢 DynamoDB 時指出一致讀取的選用布林值。預設值為 `false`。
+ `filter?: DynamoDBFilterObject | null` (選用)
從資料表擷取結果後，要套用至結果的選用篩選條件。
+ `index?: string | null` (選用)
要掃描的索引選用名稱。
+ `limit?: number | null` (選用)
要傳回的選用結果數目上限。
+ `nextToken?: string | null` (選用)
選用分頁字符，以繼續先前的查詢。這會是從先前查詢所取得的。
+ `scanIndexForward?: boolean | null` (選用)
選用布林值，指出查詢是以遞增或遞減順序執行。依預設，此值是設為 `true`。
+ `segment?: number` (選用)
+ `select?: DynamoDBSelectAttributes` (選用)
從 DynamoDB 傳回的屬性。根據預設， AWS AppSync DynamoDB 解析程式只會傳回投影到索引中的屬性。支援的值是：
+ `ALL_ATTRIBUTES`
從指定的資料表或索引傳回所有項目屬性。如果您查詢本機次要索引，DynamoDB 會從索引中每個相符項目的父資料表擷取整個項目。如果索引設定為投射所有項目屬性，所有資料都可從本機次要索引取得，不需進行任何擷取。
+ `ALL_PROJECTED_ATTRIBUTES`
傳回已投影至索引的所有屬性。如果索引設定為投射所有屬性，此傳回值相當於指定 `ALL_ATTRIBUTES`。
+ `SPECIFIC_ATTRIBUTES`
僅傳回 中列出的屬性`ProjectionExpression`。此傳回值等同於指定 ，`ProjectionExpression`而不指定 的任何值`AttributesToGet`。
+ `totalSegments?: number` (選用)
**`Type DynamoDBSyncInput`**
```
DynamoDBSyncInput: {
basePartitionKey?: string;
deltaIndexName?: string;
filter?: DynamoDBFilterObject | null;
lastSync?: number;
limit?: number | null;
nextToken?: string | null;
}
```
**類型宣告**
+ `basePartitionKey?: string` (選用)
執行同步操作時要使用之基底資料表的分割區索引鍵。此欄位允許在資料表使用自訂分割區索引鍵時執行 Sync 操作。
+ `deltaIndexName?: string` (選用)
用於同步操作的索引。當資料表使用自訂分割區索引鍵時，需要此索引才能在整個差異存放區資料表上啟用同步操作。同步操作將在 GSI 上執行 （在 `gsi_ds_pk`和 上建立`gsi_ds_sk`)。
+ `filter?: DynamoDBFilterObject | null` (選用)
從資料表擷取結果後，要套用至結果的選用篩選條件。
+ `lastSync?: number` (選用)
上次成功同步操作開始的時刻，以 epoch 毫秒為單位。如果指定此值，只會傳回 `lastSync` 之後變更的項目。只有在從初始同步操作擷取所有頁面之後，才應該填入此欄位。如果省略，則會傳回基礎資料表的結果。否則，將會傳回差異資料表的結果。
+ `limit?: number | null` (選用)
要一次評估的選用項目數量上限。如果省略此值，預設限制將設為 `100` 個項目。此欄位的最大值為 `1000` 個項目。
+ `nextToken?: string | null` (選用)
**`Type DynamoDBUpdateInput`**
```
DynamoDBUpdateInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
update: DynamoDBUpdateObject;
}
```
**類型宣告**
+ `_version?: number` (選用)
+ `condition?: DynamoDBFilterObject` (選用)
當您更新 DynamoDB 中的物件時，您可以選擇指定條件式表達式，以根據在執行操作之前已在 DynamoDB 中的物件狀態來控制請求是否成功。
+ `customPartitionKey?: string` (選用)
啟用時， `customPartitionKey`值會修改啟用版本控制時差異同步資料表所使用的 `ds_sk`和 `ds_pk` 記錄格式。啟用時，也會啟用`populateIndexFields`項目的處理。
+ `key: DynamoDBKey` (必要)
必要參數，指定正在更新的 DynamoDB 中項目的索引鍵。DynamoDB 項目可能有單一雜湊索引鍵或雜湊和排序索引鍵。
+ `populateIndexFields?: boolean` (選用)
布林值，當 與 啟用時`customPartitionKey`，會為差異同步資料表中的每個記錄建立新的項目，特別是在 `gsi_ds_pk`和 `gsi_ds_sk`欄中。
+ `update: DynamoDBUpdateObject`
指定要更新的屬性及其新值的物件。更新物件可與 `add`、`remove`、、`replace``increment`、`decrement`、`append`、`prepend`、 搭配使用`updateListItem`。
## Amazon RDS 模組函數
Amazon RDS 模組函數可在與使用 Amazon RDS Data API 設定的資料庫互動時提供增強的體驗。使用 匯入模組`@aws-appsync/utils/rds`：
```
import * as rds from '@aws-appsync/utils/rds';
```
也可以個別匯入函數。例如，以下匯入使用 `sql`：
```
import { sql } from '@aws-appsync/utils/rds';
```
### 函數
您可以使用 AWS AppSync RDS 模組的公用程式協助程式來與資料庫互動。
#### Select
`select` 公用程式會建立 `SELECT`陳述式來查詢您的關聯式資料庫。
**基本使用**
以其基本形式，您可以指定要查詢的資料表：
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// "SELECT * FROM "persons"
return createPgStatement(select({table: 'persons'}));
}
```
請注意，您也可以在資料表識別符中指定結構描述：
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// SELECT * FROM "private"."persons"
return createPgStatement(select({table: 'private.persons'}));
}
```
**指定資料欄**
您可以使用 `columns` 屬性指定資料欄。如果未將此值設定為 ，則預設為 `*`：
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name']
}));
}
```
您也可以指定資料欄的資料表：
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "persons"."name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'persons.name']
}));
}
```
**限制和位移**
您可以套用 `limit`和 `offset`至查詢：
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// LIMIT :limit
// OFFSET :offset
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
limit: 10,
offset: 40
}));
}
```
**排序依據**
您可以使用 `orderBy` 屬性排序結果。提供指定 欄和選用 `dir` 屬性的物件陣列：
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name" FROM "persons"
// ORDER BY "name", "id" DESC
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
orderBy: [{column: 'name'}, {column: 'id', dir: 'DESC'}]
}));
}
```
**篩選條件**
您可以使用特殊條件物件來建置篩選條件：
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: {name: {eq: 'Stephane'}}
}));
}
```
您也可以合併篩選條件：
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME and "id" > :ID
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: {name: {eq: 'Stephane'}, id: {gt: 10}}
}));
}
```
您也可以建立`OR`陳述式：
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME OR "id" > :ID
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: { or: [
{ name: { eq: 'Stephane'} },
{ id: { gt: 10 } }
]}
}));
}
```
您也可以使用 否定條件`not`：
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE NOT ("name" = :NAME AND "id" > :ID)
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: { not: [
{ name: { eq: 'Stephane'} },
{ id: { gt: 10 } }
]}
}));
}
```
您也可以使用下列運算子來比較值：
|
|
| 運算子 | Description | 可能的值類型 |
| --- |--- |--- |
| eq | Equal | number, string, boolean |
| ne | Not equal | number, string, boolean |
| le | Less than or equal | number, string |
| lt | Less than | number, string |
| ge | Greater than or equal | number, string |
| gt | Greater than | number, string |
| contains | Like | string |
| notContains | Not like | string |
| beginsWith | Starts with prefix | string |
| between | Between two values | number, string |
| attributeExists | The attribute is not null | number, string, boolean |
| size | checks the length of the element | string |
#### Insert
`insert` 公用程式提供使用 `INSERT`操作在資料庫中插入單一資料列項目的直接方式。
**單一項目插入**
若要插入項目，請指定 資料表，然後傳入值的物件。物件索引鍵會映射到您的資料表資料欄。資料欄名稱會自動逸出，並使用變數映射將值傳送至資料庫：
```
import { insert, createMySQLStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({ table: 'persons', values });
// Generates statement:
// INSERT INTO `persons`(`name`)
// VALUES(:NAME)
return createMySQLStatement(insertStatement)
}
```
**MySQL 使用案例**
您可以結合 `insert`後接 `select`來擷取插入的資料列：
```
import { insert, select, createMySQLStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({ table: 'persons', values });
const selectStatement = select({
table: 'persons',
columns: '*',
where: { id: { eq: values.id } },
limit: 1,
});
// Generates statement:
// INSERT INTO `persons`(`name`)
// VALUES(:NAME)
// and
// SELECT *
// FROM `persons`
// WHERE `id` = :ID
return createMySQLStatement(insertStatement, selectStatement)
}
```
**Postgres 使用案例**
使用 Postgres，您可以使用 從您插入的資料列[https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html)取得資料。它接受 `*`或一組資料欄名稱：
```
import { insert, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({
table: 'persons',
values,
returning: '*'
});
// Generates statement:
// INSERT INTO "persons"("name")
// VALUES(:NAME)
// RETURNING *
return createPgStatement(insertStatement)
}
```
#### 更新
`update` 公用程式可讓您更新現有的資料列。您可以使用 條件物件，將變更套用至滿足條件的所有資料列中的指定資料欄。例如，假設我們有一個結構描述，允許我們進行此變動。我們希望以 `Person` `id`的值更新 `name` 的 ，`3`但前提是我們從 開始知道它們 (`known_since`)`2000`：
```
mutation Update {
updatePerson(
input: {id: 3, name: "Jon"},
condition: {known_since: {ge: "2000"}}
) {
id
name
}
}
```
我們的更新解析程式如下所示：
```
import { update, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: { id, ...values }, condition } = ctx.args;
const where = {
...condition,
id: { eq: id },
};
const updateStatement = update({
table: 'persons',
values,
where,
returning: ['id', 'name'],
});
// Generates statement:
// UPDATE "persons"
// SET "name" = :NAME, "birthday" = :BDAY, "country" = :COUNTRY
// WHERE "id" = :ID
// RETURNING "id", "name"
return createPgStatement(updateStatement)
}
```
我們可以將檢查新增至條件，以確保只會更新主索引鍵`id`等於 `3` 的資料列。同樣地，對於 Postgres `inserts`，您可以使用 `returning` 來傳回修改後的資料。
#### 移除
`remove` 公用程式可讓您刪除現有的資料列。您可以在滿足條件的所有資料列上使用條件物件。請注意， `delete` 是 JavaScript 中的預留關鍵字。 `remove` 應該改用：
```
import { remove, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: { id }, condition } = ctx.args;
const where = { ...condition, id: { eq: id } };
const deleteStatement = remove({
table: 'persons',
where,
returning: ['id', 'name'],
});
// Generates statement:
// DELETE "persons"
// WHERE "id" = :ID
// RETURNING "id", "name"
return createPgStatement(updateStatement)
}
```
### 轉換
在某些情況下，您可能希望在陳述式中使用有關正確物件類型的更具體性。您可以使用提供的類型提示來指定參數的類型。 AWS AppSync 支援與資料 API [相同的類型提示](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint)。您可以使用 模組的 `typeHint`函數來 AWS AppSync `rds`轉換參數。
下列範例可讓您將陣列做為值傳送，該值會轉換為 JSON 物件。我們使用 `->`運算子來擷取 JSON 陣列`index``2`中 的 元素：
```
import { sql, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const arr = ctx.args.list_of_ids
const statement = sql`select ${typeHint.JSON(arr)}->2 as value`
return createPgStatement(statement)
}
export function response(ctx) {
return toJsonObject(ctx.result)[0][0].value
}
```
在處理和比較 `DATE`、 和 時`TIME`，投射也很有用`TIMESTAMP`：
```
import { select, createPgStatement, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const when = ctx.args.when
const statement = select({
table: 'persons',
where: { createdAt : { gt: typeHint.DATETIME(when) } }
})
return createPgStatement(statement)
}
```
以下另一個範例示範如何傳送目前的日期和時間：
```
import { sql, createPgStatement, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const now = util.time.nowFormatted('YYYY-MM-dd HH:mm:ss')
return createPgStatement(sql`select ${typeHint.TIMESTAMP(now)}`)
}
```
**可用的類型提示**
+ `typeHint.DATE` - 對應的參數會以 `DATE`類型的物件傳送至資料庫。接受的格式為 `YYYY-MM-DD`。
+ `typeHint.DECIMAL` - 對應的參數會以 `DECIMAL`類型的物件傳送至資料庫。
+ `typeHint.JSON` - 對應的參數會以 `JSON`類型的物件傳送至資料庫。
+ `typeHint.TIME` - 對應的字串參數值會以 `TIME`類型的物件傳送至資料庫。接受的格式為 `HH:MM:SS[.FFF]`。
+ `typeHint.TIMESTAMP` - 對應的字串參數值會以 `TIMESTAMP`類型的物件傳送至資料庫。接受的格式為 `YYYY-MM-DD HH:MM:SS[.FFF]`。
+ `typeHint.UUID` - 對應的字串參數值會以 `UUID`類型的物件傳送至資料庫。
# 執行期公用程式
`runtime` 程式庫提供公用程式來控制或修改解析程式和函數的執行期屬性。
## 執行期 utils 清單
**`runtime.earlyReturn(obj?: unknown, returnOptions?: {skipTo: 'END' | 'NEXT'}): never`**
根據目前的內容，叫用此函數會停止執行目前的處理常式、 AWS AppSync 函數或解析程式 （單位或管道解析程式）。系統會傳回指定的物件做為結果。
+ 在 AWS AppSync 函數請求處理常式中呼叫 時，會略過資料來源和回應處理常式，並呼叫下一個函數請求處理常式 （如果這是最後一個 AWS AppSync 函數，則為管道解析程式回應處理常式）。
+ 在 AWS AppSync 管道解析程式請求處理常式中呼叫 時，會略過管道執行，並立即呼叫管道解析程式回應處理常式。
+ `returnOptions` 將 `skipTo` 設為 "END" 時，會略過管道執行，並立即呼叫管道解析程式回應處理常式。
+ `returnOptions` 將 `skipTo` 設為 "NEXT" 時，會略過函數執行，並呼叫下一個管道處理常式。
**範例**
```
import { runtime } from '@aws-appsync/utils'
export function request(ctx) {
runtime.earlyReturn({ hello: 'world' })
// code below is not executed
return ctx.args
}
// never called because request returned early
export function response(ctx) {
return ctx.result
}
```
# util.time 中的時間協助程式
`util.time` 變數包含日期時間方法，可協助產生時間戳記、在日期時間格式之間轉換，以及剖析日期時間字串。日期時間格式的語法是根據 [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)，您可以參考以取得更詳細的文件。
## 時間使用率清單
**`util.time.nowISO8601()`**
以 [ISO8601 格式](https://en.wikipedia.org/wiki/ISO_8601)傳回 UTC 的字串表示方式。
**`util.time.nowEpochSeconds()`**
傳回從 1970-01-01T00:00:00Z 的 epoch 到現在的秒數。
**`util.time.nowEpochMilliSeconds()`**
傳回從 1970-01-01T00:00:00Z 的 epoch 到現在的毫秒數。
**`util.time.nowFormatted(String)`**
使用字串輸入類型的指定格式，傳回 UTC 中目前時間戳記的字串。
**`util.time.nowFormatted(String, String)`**
使用字串輸入類型的指定格式和時區，傳回時區目前時間戳記的字串。
**`util.time.parseFormattedToEpochMilliSeconds(String, String)`**
剖析以字串形式傳遞的時間戳記，以及包含時區的格式，然後傳回自 epoch 以來以毫秒為單位的時間戳記。
**`util.time.parseFormattedToEpochMilliSeconds(String, String, String)`**
剖析以字串形式傳遞的時間戳記，以及格式和時區，然後以毫秒為單位傳回自 epoch 以來的時間戳記。
**`util.time.parseISO8601ToEpochMilliSeconds(String)`**
剖析以字串形式傳遞的 ISO8601 時間戳記，然後將時間戳記傳回為自 epoch 以來的毫秒。
**`util.time.epochMilliSecondsToSeconds(long)`**
將 epoch 毫秒時間戳記轉換為 epoch 秒時間戳記。
**`util.time.epochMilliSecondsToISO8601(long)`**
將 epoch 毫秒時間戳記轉換為 ISO8601 時間戳記。
**`util.time.epochMilliSecondsToFormatted(long, String)`**
將 epoch 毫秒時間戳記轉換為根據 UTC 格式提供的時間戳記。
**`util.time.epochMilliSecondsToFormatted(long, String, String)`**
將長傳遞的 epoch 毫秒時間戳記轉換為根據所提供時區中提供的格式格式化的時間戳記。
# util.dynamodb 中的 DynamoDB 協助程式
`util.dynamodb` 包含協助程式方法，可讓您更輕鬆地將資料寫入和讀取至 Amazon DynamoDB，例如自動類型映射和格式化。
## toDynamoDB
### toDynamoDB 公用程式清單
**`util.dynamodb.toDynamoDB(Object)`**
DynamoDB 的一般物件轉換工具，可將輸入物件轉換為適當的 DynamoDB 表示法。它在代表一些類型的方式上是固定的：例如，它會使用清單 (「L」) 而不是集合 (「SS」、「NS」、「BS」)。這會傳回描述 DynamoDB 屬性值的物件。
**字串範例**
```
Input: util.dynamodb.toDynamoDB("foo")
Output: { "S" : "foo" }
```
**數字範例**
```
Input: util.dynamodb.toDynamoDB(12345)
Output: { "N" : 12345 }
```
**布林值範例**
```
Input: util.dynamodb.toDynamoDB(true)
Output: { "BOOL" : true }
```
**清單範例**
```
Input: util.dynamodb.toDynamoDB([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
**地圖範例**
```
Input: util.dynamodb.toDynamoDB({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"M" : {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
}
```
## toString utils
### toString utils 清單
**`util.dynamodb.toString(String)`**
將輸入字串轉換為 DynamoDB 字串格式。這會傳回描述 DynamoDB 屬性值的物件。
```
Input: util.dynamodb.toString("foo")
Output: { "S" : "foo" }
```
**`util.dynamodb.toStringSet(List)`**
將具有字串的清單轉換為 DynamoDB 字串集格式。這會傳回描述 DynamoDB 屬性值的物件。
```
Input: util.dynamodb.toStringSet([ "foo", "bar", "baz" ])
Output: { "SS" : [ "foo", "bar", "baz" ] }
```
## toNumber utils
### toNumber utils 清單
**`util.dynamodb.toNumber(Number)`**
將數字轉換為 DynamoDB 數字格式。這會傳回描述 DynamoDB 屬性值的物件。
```
Input: util.dynamodb.toNumber(12345)
Output: { "N" : 12345 }
```
**`util.dynamodb.toNumberSet(List)`**
將數字清單轉換為 DynamoDB 數字集格式。這會傳回描述 DynamoDB 屬性值的物件。
```
Input: util.dynamodb.toNumberSet([ 1, 23, 4.56 ])
Output: { "NS" : [ 1, 23, 4.56 ] }
```
## toBinary utils
### toBinary utils 清單
**`util.dynamodb.toBinary(String)`**
將編碼為 base64 字串的二進位資料轉換為 DynamoDB 二進位格式。這會傳回描述 DynamoDB 屬性值的物件。
```
Input: util.dynamodb.toBinary("foo")
Output: { "B" : "foo" }
```
**`util.dynamodb.toBinarySet(List)`**
將編碼為 base64 字串的二進位資料清單轉換為 DynamoDB 二進位集格式。這會傳回描述 DynamoDB 屬性值的物件。
```
Input: util.dynamodb.toBinarySet([ "foo", "bar", "baz" ])
Output: { "BS" : [ "foo", "bar", "baz" ] }
```
## toBoolean utils
### toBoolean utils 清單
**`util.dynamodb.toBoolean(Boolean)`**
將布林值轉換為適當的 DynamoDB 布林值格式。這會傳回描述 DynamoDB 屬性值的物件。
```
Input: util.dynamodb.toBoolean(true)
Output: { "BOOL" : true }
```
## toNull utils
### toNull utils 清單
**`util.dynamodb.toNull()`**
以 DynamoDB null 格式傳回 null。這會傳回描述 DynamoDB 屬性值的物件。
```
Input: util.dynamodb.toNull()
Output: { "NULL" : null }
```
## toList utils
### toList utils 清單
**`util.dynamodb.toList(List)`**
將物件清單轉換為 DynamoDB 清單格式。清單中的每個項目也會轉換為其適當的 DynamoDB 格式。它在代表一些巢狀物件的方式上是固定的：例如，它會使用清單 (「L」) 而不是集合 (「SS」、「NS」、「BS」)。這會傳回描述 DynamoDB 屬性值的物件。
```
Input: util.dynamodb.toList([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
## toMap 公用程式
### toMap 公用程式清單
**`util.dynamodb.toMap(Map)`**
將映射轉換為 DynamoDB 映射格式。映射中的每個值也會轉換為其適當的 DynamoDB 格式。它在代表一些巢狀物件的方式上是固定的：例如，它會使用清單 (「L」) 而不是集合 (「SS」、「NS」、「BS」)。這會傳回描述 DynamoDB 屬性值的物件。
```
Input: util.dynamodb.toMap({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"M" : {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
}
```
**`util.dynamodb.toMapValues(Map)`**
建立映射的副本，其中每個值都已轉換為其適當的 DynamoDB 格式。它在代表一些巢狀物件的方式上是固定的：例如，它會使用清單 (「L」) 而不是集合 (「SS」、「NS」、「BS」)。
```
Input: util.dynamodb.toMapValues({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
```
這與 略有不同，`util.dynamodb.toMap(Map)`因為它只會傳回 DynamoDB 屬性值的內容，但不會傳回整個屬性值本身。例如，下列陳述式完全相同：
```
util.dynamodb.toMapValues(