Fungsi intrinsik untuk JSONPath status di Step Functions

Fungsi States.Array intrinsik membutuhkan nol atau lebih argumen. Interpreter mengembalikan JSON array yang berisi nilai-nilai argumen dalam urutan yang disediakan. Misalnya, diberikan input berikut:

{
  "Id": 123456
}

Anda dapat menggunakan

"BuildId.$": "States.Array($.Id)"

Yang akan mengembalikan hasil berikut:

“BuildId”: [123456]

Gunakan fungsi States.ArrayPartition intrinsik untuk mempartisi array besar. Anda juga dapat menggunakan intrinsik ini untuk mengiris data dan kemudian mengirim muatan dalam potongan yang lebih kecil.

Fungsi intrinsik ini membutuhkan dua argumen. Argumen pertama adalah array, sedangkan argumen kedua mendefinisikan ukuran potongan. Interpreter memotong array input menjadi beberapa array dari ukuran yang ditentukan oleh ukuran chunk. Panjang potongan array terakhir mungkin kurang dari panjang potongan array sebelumnya jika jumlah item yang tersisa dalam array lebih kecil dari ukuran potongan.

Validasi masukan

Misalnya, diberikan array input berikut:

{"inputArray": [1,2,3,4,5,6,7,8,9] }

Anda dapat menggunakan States.ArrayPartition fungsi untuk membagi array menjadi potongan-potongan dari empat nilai:

"inputArray.$": "States.ArrayPartition($.inputArray,4)"

Yang akan mengembalikan potongan array berikut:

{"inputArray": [ [1,2,3,4], [5,6,7,8], [9]] }

Pada contoh sebelumnya, States.ArrayPartition fungsi menampilkan tiga array. Dua array pertama masing-masing berisi empat nilai, seperti yang didefinisikan oleh ukuran potongan. Array ketiga berisi nilai yang tersisa dan lebih kecil dari ukuran potongan yang ditentukan.

Gunakan fungsi States.ArrayContains intrinsik untuk menentukan apakah nilai tertentu hadir dalam array. Misalnya, Anda dapat menggunakan fungsi ini untuk mendeteksi jika ada kesalahan dalam iterasi Map status.

Fungsi intrinsik ini membutuhkan dua argumen. Argumen pertama adalah array, sedangkan argumen kedua adalah nilai yang akan dicari dalam array.

Validasi masukan

Misalnya, diberikan array input berikut:

{
   "inputArray": [1,2,3,4,5,6,7,8,9],
   "lookingFor": 5
}

Anda dapat menggunakan States.ArrayContains fungsi untuk menemukan lookingFor nilai dalaminputArray:

"contains.$": "States.ArrayContains($.inputArray, $.lookingFor)"

Karena nilai yang lookingFor disimpan dalam termasuk dalaminputArray, States.ArrayContains mengembalikan hasil sebagai berikut:

{"contains": true }

Gunakan fungsi States.ArrayRange intrinsik untuk membuat array baru yang berisi berbagai elemen tertentu. Array baru dapat berisi hingga 1000 elemen.

Fungsi ini membutuhkan tiga argumen. Argumen pertama adalah elemen pertama dari array baru, argumen kedua adalah elemen akhir dari array baru, dan argumen ketiga adalah nilai kenaikan antara unsur-unsur dalam array baru.

Validasi masukan

Misalnya, penggunaan States.ArrayRange fungsi berikut akan membuat array dengan nilai pertama 1, nilai akhir 9, dan nilai di antara nilai pertama dan akhir meningkat dua untuk setiap item:

"array.$": "States.ArrayRange(1, 9, 2)"

Yang akan mengembalikan array berikut:

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

Fungsi intrinsik ini mengembalikan nilai indeks tertentu. Fungsi ini membutuhkan dua argumen. Argumen pertama adalah array nilai dan argumen kedua adalah indeks array dari nilai untuk kembali.

Misalnya, gunakan yang berikut inputArray dan index nilai:

{
   "inputArray": [1,2,3,4,5,6,7,8,9],
   "index": 5
}

Dari nilai-nilai ini, Anda dapat menggunakan States.ArrayGetItem fungsi untuk mengembalikan nilai di index posisi 5 dalam array:

"item.$": "States.ArrayGetItem($.inputArray, $.index)"

Dalam contoh ini, States.ArrayGetItem akan mengembalikan hasil sebagai berikut:

{ "item": 6 }

Fungsi States.ArrayLength intrinsik mengembalikan panjang array. Ini memiliki satu argumen, array untuk mengembalikan panjang.

Misalnya, diberikan array input berikut:

{
   "inputArray": [1,2,3,4,5,6,7,8,9]
}

Anda dapat menggunakan States.ArrayLength untuk mengembalikan panjanginputArray:

"length.$": "States.ArrayLength($.inputArray)"

Dalam contoh ini, States.ArrayLength akan mengembalikan JSON objek berikut yang mewakili panjang array:

{ "length": 9 }

Fungsi States.ArrayUnique intrinsik menghapus nilai duplikat dari array dan mengembalikan array yang hanya berisi elemen unik. Fungsi ini mengambil array, yang dapat unsorted, sebagai argumen tunggal.

Misalnya, berikut ini inputArray berisi serangkaian nilai duplikat:

{"inputArray": [1,2,3,3,3,3,3,3,4] }

Anda dapat menggunakan States.ArrayUnique fungsi sebagai dan menentukan array yang ingin Anda hapus nilai duplikat dari:

"array.$": "States.ArrayUnique($.inputArray)"

States.ArrayUniqueFungsi akan mengembalikan array berikut yang hanya berisi elemen unik, menghapus semua nilai duplikat:

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

Gunakan fungsi States.Base64Encode intrinsik untuk menyandikan data berdasarkan skema pengkodean MIME Base64. Anda dapat menggunakan fungsi ini untuk meneruskan data ke AWS layanan lain tanpa menggunakan AWS Lambda fungsi.

Fungsi ini mengambil string data hingga 10.000 karakter untuk dikodekan sebagai satu-satunya argumen.

Misalnya, pertimbangkan input string berikut:

{"input": "Data to encode" }

Anda dapat menggunakan States.Base64Encode fungsi untuk menyandikan input string sebagai string MIME Base64:

"base64.$": "States.Base64Encode($.input)"

States.Base64EncodeFungsi mengembalikan data dikodekan berikut sebagai tanggapan:

{"base64": "RGF0YSB0byBlbmNvZGU=" }

Gunakan fungsi States.Base64Decode intrinsik untuk memecahkan kode data berdasarkan skema decoding MIME Base64. Anda dapat menggunakan fungsi ini untuk meneruskan data ke AWS layanan lain tanpa menggunakan fungsi Lambda.

Fungsi ini mengambil string data yang dikodekan Base64 hingga 10.000 karakter untuk memecahkan kode sebagai satu-satunya argumen.

Misalnya, diberikan input berikut:

{"base64": "RGF0YSB0byBlbmNvZGU=" }

Anda dapat menggunakan States.Base64Decode fungsi untuk memecahkan kode string base64 ke string yang dapat dibaca manusia:

"data.$": "States.Base64Decode($.base64)"

Ini States.Base64Decode function akan mengembalikan data yang diterjemahkan berikut sebagai tanggapan:

{"data": "Decoded data" }

Gunakan fungsi States.Hash intrinsik untuk menghitung nilai hash dari input yang diberikan. Anda dapat menggunakan fungsi ini untuk meneruskan data ke AWS layanan lain tanpa menggunakan fungsi Lambda.

Fungsi ini membutuhkan dua argumen. Argumen pertama adalah data yang ingin Anda hitung nilai hash. Argumen kedua adalah algoritma hashing yang digunakan untuk melakukan perhitungan hash. Data yang Anda berikan harus berupa string objek yang berisi 10.000 karakter atau kurang.

Algoritma hashing yang Anda tentukan dapat berupa salah satu algoritma berikut:

Misalnya, Anda dapat menggunakan fungsi ini untuk menghitung nilai hash Data string menggunakan yang ditentukanAlgorithm:

{
   "Data": "input data", 
   "Algorithm": "SHA-1" 
}

Anda dapat menggunakan States.Hash fungsi untuk menghitung nilai hash:

"output.$": "States.Hash($.Data, $.Algorithm)"

States.HashFungsi mengembalikan nilai hash berikut sebagai tanggapan:

{"output": "aaff4a450a104cd177d28d18d7485e8cae074b7" }

Gunakan fungsi States.JsonMerge intrinsik untuk menggabungkan dua JSON objek menjadi satu objek. Fungsi ini membutuhkan tiga argumen. Dua argumen pertama adalah JSON objek yang ingin Anda gabungkan. Argumen ketiga adalah nilai boolean dari. false Nilai boolean ini menentukan apakah mode penggabungan mendalam diaktifkan.

Saat ini, Step Functions hanya mendukung mode penggabungan dangkal; oleh karena itu, Anda harus menentukan nilai boolean sebagai. false Dalam mode dangkal, jika kunci yang sama ada di kedua JSON objek, kunci objek yang terakhir mengganti kunci yang sama di objek pertama. Selain itu, objek yang bersarang di dalam JSON objek tidak digabungkan saat Anda menggunakan penggabungan dangkal.

Misalnya, Anda dapat menggunakan States.JsonMerge fungsi untuk menggabungkan JSON objek berikut yang berbagi kuncia.

{
   "json1": { "a": {"a1": 1, "a2": 2}, "b": 2 },
   "json2": { "a": {"a3": 1, "a4": 2}, "c": 3 }
}

Anda dapat menentukan objek json1 dan json2 sebagai input dalam States.JsonMerge fungsi untuk menggabungkannya:

"output.$": "States.JsonMerge($.json1, $.json2, false)"

States.JsonMergeMengembalikan JSON objek digabungkan berikut sebagai hasilnya. Dalam JSON objek gabunganoutput, kunci json2 objek a menggantikan kunci json1 objek. a Juga, objek bersarang di kunci json1 objek dibuang a karena mode dangkal tidak mendukung penggabungan objek bersarang.

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

States.StringToJsonFungsi mengambil jalur referensi ke JSON string yang lolos sebagai satu-satunya argumen.

Interpreter menerapkan JSON parser dan mengembalikan formulir JSON parsed input. Misalnya, Anda dapat menggunakan fungsi ini untuk melarikan diri dari string input berikut:

{
 "escapedJsonString": "{\"foo\": \"bar\"}"
}
                

Gunakan States.StringToJson fungsi dan tentukan escapedJsonString sebagai argumen masukan:

States.StringToJson($.escapedJsonString)

States.StringToJsonFungsi mengembalikan hasil sebagai berikut:

{ "foo": "bar" }

States.JsonToStringFungsi ini hanya membutuhkan satu argumen, yaitu jalur yang berisi JSON data untuk dikembalikan sebagai string unescaped. Interpreter mengembalikan string yang berisi JSON teks yang mewakili data yang ditentukan oleh Path. Misalnya, Anda dapat memberikan JSON Path berikut yang berisi nilai escaped:

{
  "unescapedJson": {
     "foo": "bar"
  }
}

Berikan States.JsonToString fungsi dengan data yang terkandung di dalamunescapedJson:

States.JsonToString($.unescapedJson)
                

States.JsonToStringFungsi mengembalikan respon berikut:

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

Gunakan fungsi States.MathRandom intrinsik untuk mengembalikan angka acak antara nomor awal yang ditentukan (inklusif) dan nomor akhir (eksklusif).

Anda dapat menggunakan fungsi ini untuk mendistribusikan tugas tertentu antara dua atau lebih sumber daya.

Fungsi ini membutuhkan tiga argumen. Argumen pertama adalah nomor awal, argumen kedua adalah nomor akhir, dan argumen terakhir mengontrol nilai seed opsional, Perhatikan bahwa jika Anda menggunakan fungsi ini dengan nilai seed yang sama, itu akan mengembalikan angka identik.

Validasi masukan

Misalnya, untuk menghasilkan angka acak antara satu dan 999, Anda dapat menggunakan nilai input berikut:

{
   "start": 1,
   "end": 999
}

Untuk menghasilkan angka acak, berikan start dan end nilai ke States.MathRandom fungsi:

"random.$": "States.MathRandom($.start, $.end)"

States.MathRandomFungsi mengembalikan nomor acak berikut sebagai respon:

{"random": 456 }

Gunakan fungsi States.MathAdd intrinsik untuk mengembalikan jumlah dua angka. Misalnya, Anda dapat menggunakan fungsi ini untuk menambah nilai di dalam loop tanpa menjalankan fungsi Lambda.

Validasi masukan

Misalnya, Anda dapat menggunakan nilai berikut untuk mengurangi satu dari 111:

{
   "value1": 111,
   "step": -1
}

Kemudian, gunakan States.MathAdd fungsi yang mendefinisikan value1 sebagai nilai awal, dan step sebagai nilai untuk bertambah dengan: value1

"value1.$": "States.MathAdd($.value1, $.step)"

States.MathAddFungsi akan mengembalikan nomor berikut sebagai tanggapan:

{"value1": 110 }

Gunakan fungsi States.StringSplit intrinsik untuk membagi string menjadi array nilai. Fungsi ini membutuhkan dua argumen. Argumen pertama adalah string dan argumen kedua adalah karakter pembatas yang akan digunakan fungsi untuk membagi string.

{
    "inputString": "1,2,3,4,5",
    "splitter": ","
}

"array.$": "States.StringSplit($.inputString, $.splitter)"

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

{
  "inputString": "This.is+a,test=string",
  "splitter": ".+,="
}

{
  "myStringArray.$": "States.StringSplit($.inputString, $.splitter)"
}

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

Gunakan fungsi States.UUID intrinsik untuk mengembalikan pengidentifikasi unik universal versi 4 (v4UUID) yang dihasilkan menggunakan angka acak. Misalnya, Anda dapat menggunakan fungsi ini untuk memanggil AWS layanan atau sumber daya lain yang memerlukan UUID parameter atau menyisipkan item dalam tabel DynamoDB.

States.UUIDFungsi ini dipanggil tanpa argumen yang ditentukan:

"uuid.$": "States.UUID()"

Fungsi mengembalikan dihasilkan secara acakUUID, seperti dalam contoh berikut:

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

Gunakan fungsi States.Format intrinsik untuk membangun string dari nilai literal dan interpolasi. Fungsi ini membutuhkan satu atau lebih argumen. Nilai argumen pertama harus berupa string, dan mungkin termasuk nol atau lebih contoh dari urutan {} karakter. Harus ada banyak argumen yang tersisa dalam pemanggilan fungsi intrinsik seperti halnya kemunculan. {} Interpreter mengembalikan string didefinisikan dalam argumen pertama dengan masing-masing {} diganti dengan nilai argumen yang sesuai secara posisi dalam pemanggilan Intrinsik.

Misalnya, Anda dapat menggunakan masukan berikut dari individuname, dan template kalimat untuk memasukkan nama mereka ke:

{
 "name": "Arnav",
 "template": "Hello, my name is {}."
}

Gunakan States.Format fungsi dan tentukan template string dan string untuk disisipkan sebagai pengganti {} karakter:

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

atau

States.Format($.template, $.name)

Dengan salah satu input sebelumnya, States.Format fungsi mengembalikan string selesai sebagai tanggapan:

Hello, my name is Arnav.