หน้านี้ได้รับการแปลโดย Cloud Translation API

เทมเพลตข้อความ

คุณกำลังดูเอกสารประกอบของ Apigee Edge
ไปที่เอกสารประกอบของ Apigee X ข้อมูล

หัวข้อนี้จะกล่าวถึงวิธีใช้เทมเพลตข้อความในพร็อกซี API และให้ข้อมูลอ้างอิงฟังก์ชัน

เทมเพลตข้อความคืออะไร

เทมเพลตข้อความช่วยให้คุณดำเนินการแทนที่สตริงตัวแปรในนโยบายและองค์ประกอบ TargetEndpoint บางรายการได้ ฟีเจอร์นี้จะช่วยให้คุณเติมสตริงแบบไดนามิกเมื่อพร็อกซีทำงาน ได้หากรองรับ

คุณสามารถรวมการอ้างอิงตัวแปรโฟลว์และข้อความตามตัวอักษรในเทมเพลตข้อความไว้ด้วยกันได้ ชื่อตัวแปรโฟลว์ต้องอยู่ในวงเล็บปีกกา ขณะที่ข้อความที่ไม่ได้อยู่ในวงเล็บปีกกาจะแสดงผลเป็นข้อความลิเทอรัล

โปรดดูหัวข้อคุณจะใช้เทมเพลตข้อความได้จากที่ใด

ตัวอย่าง

เช่น นโยบายมอบหมายข้อความช่วยให้คุณใช้เทมเพลตข้อความที่อยู่ภายในองค์ประกอบ <Payload> ได้ดังนี้

<AssignMessage name="set-dynamic-content">
  <AssignTo createNew="false" type="response"></AssignTo>
  <Set>
    <Payload contentType="application/json">
      {"name":"Alert", "message":"You entered an invalid username: {user.name}"}
    </Payload>
  </Set>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
</AssignMessage>

ในตัวอย่างข้างต้น ระบบจะประเมินค่าตัวแปรโฟลว์ user.name (ในวงเล็บปีกกา) และแทนที่ด้วยสตริงเพย์โหลดขณะรันไทม์ เช่น หากเป็น user.name=jdoe เอาต์พุตข้อความที่ปรากฏในเพย์โหลดจะเป็น You entered an invalid username: jdoe หากแก้ไขตัวแปรไม่ได้ ระบบจะแสดงผลสตริงว่าง

ตัวอย่าง

เมื่อเกินโควต้า ทางที่ดีควรส่งข้อความที่มีความสำคัญกลับไปยังผู้โทร รูปแบบนี้มักใช้กับ "กฎความผิดพลาด" เพื่อมอบเอาต์พุตเพื่อให้ข้อมูลผู้โทรเกี่ยวกับการละเมิดโควต้า ในนโยบาย Assign Message ต่อไปนี้ จะมีการใช้เทมเพลตข้อความ เพื่อป้อนข้อมูลโควต้าแบบไดนามิกในองค์ประกอบ XML หลายรายการ ดังนี้

<AssignMessage name='AM-QuotaViolationMessage'>
  <Description>message for quota exceeded</Description>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Set>
    <Headers>
      <Header name='X-Quota-Reset'>{ratelimit.Quota-1.expiry.time}</Header>
      <Header name='X-Quota-Allowed'>{ratelimit.Quota-1.allowed.count}</Header>
      <Header name='X-Quota-Available'>{ratelimit.Quota-1.available.count}</Header>
    </Headers>
    <Payload contentType='application/json'>{
  "error" : {
    "message" : "you have exceeded your quota",
    "clientId" : "{request.queryparam.apikey}"
  }
}
    </Payload>
    <StatusCode>429</StatusCode>
    <ReasonPhrase>Quota Exceeded</ReasonPhrase>
  </Set>
</AssignMessage>

ในนโยบาย AssignMessage องค์ประกอบต่อไปนี้ในองค์ประกอบ <Set> รองรับเทมเพลตข้อความ

ส่วนหัว
QueryParam
FormParam
PayLoad
เวอร์ชัน
คำกริยา
เส้นทาง
StatusCode
ReasonPhrase

และโปรดทราบว่าตัวแปรโฟลว์ในเทมเพลตข้อความต้องอยู่ในวงเล็บปีกกา

สิ่งที่จะเกิดขึ้นเมื่อนโยบายนี้มีผลบังคับใช้

องค์ประกอบส่วนหัวจะได้รับค่าของตัวแปรโฟลว์ที่ระบุ
เพย์โหลดประกอบด้วยข้อความตามตัวอักษรและตัวแปรผสมกัน (ระบบเติมข้อมูล client_id แบบไดนามิก)
StatusCode และ REASONPhrase จะมีเฉพาะข้อความตามตัวอักษรเท่านั้น อย่างไรก็ตาม องค์ประกอบเหล่านี้ยังรองรับการกำหนดเทมเพลตข้อความด้วยหากคุณต้องการใช้งาน

ตัวอย่าง

ในคำจำกัดความของ TargetEndpoint องค์ประกอบย่อยของ <SSLInfo> การจัดรูปแบบข้อความรองรับ โดยใช้รูปแบบเดียวกันกับที่ใช้ในนโยบาย ตัวแปรโฟลว์ในวงเล็บปีกกาจะถูกแทนที่เมื่อพร็อกซีทำงาน

<TargetEndpoint name="default">
  …
  <HTTPTargetConnection>
    <SSLInfo>
        <Enabled>{myvars.ssl.enabled}</Enabled>
        <ClientAuthEnabled>{myvars.ssl.client.auth.enabled}</ClientAuthEnabled>
        <KeyStore>{myvars.ssl.keystore}</KeyStore>
        <KeyAlias>{myvars.ssl.keyAlias}</KeyAlias>
        <TrustStore>{myvars.ssl.trustStore}</TrustStore>
    </SSLInfo>

  </HTTPTargetConnection>
  …
</TargetEndpoint>

คุณจะใช้เทมเพลตข้อความได้จากที่ใด

นโยบายหลายรายการ รวมถึงองค์ประกอบบางอย่างที่ใช้ในการกําหนดค่า TargetEndpoint รองรับเทมเพลตข้อความ

นโยบายที่ยอมรับเทมเพลตข้อความ

นโยบาย	องค์ประกอบและองค์ประกอบย่อยที่รองรับเทมเพลตข้อความ
นโยบาย AccessControl	`<SourceAddress>` สำหรับแอตทริบิวต์ `mask` และที่อยู่ IP
นโยบาย AssignMessage	องค์ประกอบย่อยของ `<Set>`: Payload, ContentType, Verb, Version, Path, StatusCode, reasonPhrase, Headers, QueryParams, FormParams องค์ประกอบย่อย `<Add>`: ส่วนหัว, QueryParams, FormParams องค์ประกอบย่อย `<AssignVariable>`: `<Template>`
นโยบายส่วนขยายไฮไลต์	`<Input>`
นโยบายการแยกตัวแปร	`<JsonPath>` `<XMLPath>`ไม่ยอมรับเทมเพลตข้อความ
สร้างนโยบาย GenerateJWS นโยบาย ConfirmJWS	`<Payload>` (นโยบาย GenerateJWS เท่านั้น) `<AdditionalHeaders><Claim>` * องค์ประกอบเหล่านี้รองรับเทมเพลตข้อความเฉพาะเมื่อ type=map เท่านั้น
สร้างนโยบาย GenerateJWT นโยบาย ConfirmJWT	`<AdditionalClaims><Claim>` `<AdditionalHeaders><Claim>` * องค์ประกอบเหล่านี้รองรับเทมเพลตข้อความเฉพาะเมื่อ type=map เท่านั้น
นโยบาย LDAP	`<SearchQuery>`
นโยบาย MessageLในเร็วๆ นี้	`<Syslog><Message>` `<File><Message>`
นโยบายการตรวจสอบความถูกต้องของ OAS	องค์ประกอบ `<OASResource>`
นโยบาย RaiseFault	องค์ประกอบ `<Set>`: Payload, ContentType, Verb, Version, Path, StatusCode, reasonPhrase, Headers, QueryParams, FormParams องค์ประกอบ `<Add>`: ส่วนหัว, QueryParams, FormParams
นโยบาย SAMLAssertion	`<Template>` * เฉพาะเวลาที่ลายเซ็นนโยบายคือ `<GenerateSAMLAssertion>`
นโยบาย Serviceคำขอราคาเสนอ	องค์ประกอบ `<Set>`: Payload, ContentType, Verb, Version, Path, StatusCode, reasonPhrase, /Headers, QueryParams, FormParams องค์ประกอบ `<Add>`: ส่วนหัว, QueryParams, FormParams `<HTTPTargetConnection>/<URL>`: โปรดทราบว่าส่วนแรกของสตริงต้องเป็น http หรือ https

องค์ประกอบ TargetEndpoint ที่ยอมรับเทมเพลตข้อความ

องค์ประกอบ HTTPTargetConnection	องค์ประกอบย่อยที่รองรับเทมเพลตข้อความ
SSLInfo	เปิดใช้, KeyAlias, คีย์สโตร์, TrustStore, ClientAuthEnabled, CLRStore
LocalTargetConnection	ApiProxy, ProxyEndpoint
เส้นทาง	ไม่มีข้อมูล

ไวยากรณ์เทมเพลตข้อความ

ส่วนนี้จะอธิบายถึงกฎที่คุณต้องปฏิบัติตามเพื่อใช้เทมเพลตข้อความ

ใช้วงเล็บปีกกาเพื่อแสดงตัวแปร

ใส่ชื่อตัวแปรไว้ในวงเล็บปีกกา { } หากไม่มีตัวแปร ระบบจะแสดงผลสตริงว่างในเอาต์พุต แต่คุณระบุค่าเริ่มต้นในเทมเพลตข้อความได้ (ค่าที่จะแทนที่ในกรณีที่ตัวแปรไม่ได้รับการแก้ไข) โปรดดูการตั้งค่าเริ่มต้นในเทมเพลตข้อความ

โปรดทราบว่าคุณใส่เครื่องหมายคำพูดล้อมรอบสตริงเทมเพลตข้อความทั้งหมดได้ แต่จะใช้หรือไม่ใส่ก็ได้ ตัวอย่างเช่น เทมเพลตข้อความ 2 รายการต่อไปนี้เทียบเท่ากัน

<Set>
    <Headers>
        <Header name="x-h1">"Hello {user.name}"</Header>
        <Header name="x-h1">Hello {user.name}</Header>
    </Headers>
</Set>

การตั้งค่าเริ่มต้นในเทมเพลตข้อความ

หากแก้ไขตัวแปรที่ใช้เทมเพลตไม่ได้ Edge จะแทนสตริงว่าง แต่คุณสามารถระบุค่าเริ่มต้นได้ดังนี้

<Header name="x-h1">Test message. id = {request.header.id:Unknown}</Header>

ในตัวอย่างด้านบน หากแก้ไขตัวแปร request.header.id ไม่ได้ ค่าจะถูกแทนที่ด้วย Unknown เช่น

Test message. id = Unknown

ไม่อนุญาตให้เว้นวรรคในนิพจน์ฟังก์ชัน

ต้องไม่มีการเว้นวรรคในนิพจน์ฟังก์ชันของเทมเพลตข้อความ เช่น

อนุญาต:

{substring(alpha,0,4)}
{createUuid()}
{randomLong(10)}

ไม่อนุญาต:

{substring( alpha, 0, 4 )}
{ createUuid( ) }
{randomLong( 10 )}

ไวยากรณ์เดิมสำหรับเพย์โหลด JSON

ในเวอร์ชัน Edge ก่อน Cloud รุ่น 16.08.17 คุณไม่สามารถใช้วงเล็บปีกกาเพื่อแสดงการอ้างอิงตัวแปรภายในเพย์โหลด JSON ในเวอร์ชันที่เก่ากว่านี้ คุณต้องใช้แอตทริบิวต์ variablePrefix และ variableSuffix เพื่อระบุอักขระตัวคั่นและใช้อักขระเหล่านั้นเพื่อรวมชื่อตัวแปร ดังนี้

<Set>
  <Payload contentType="application/json" variablePrefix="@" variableSuffix="#">
    {"name":"foo", "type":"@variable_name#"}
  </Payload>
</Set>

แม้ว่า Apigee จะแนะนำให้คุณใช้ไวยากรณ์วงเล็บปีกกาที่ใหม่กว่า แต่ไวยากรณ์ที่เก่ากว่ายังคงใช้งานได้อยู่

การใช้ฟังก์ชันเทมเพลตข้อความ

Edge มีชุดฟังก์ชันที่คุณใช้ภายในเทมเพลตข้อความเพื่อกำหนดเป็นอักขระหลีก เข้ารหัส แฮช และจัดรูปแบบตัวแปรสตริงได้

ระบบอธิบายรายละเอียดฟังก์ชันของเทมเพลตข้อความไว้ในข้อมูลอ้างอิงฟังก์ชันของเทมเพลตข้อความ

ตัวอย่าง: toLowerCase()

ใช้ฟังก์ชัน toLowerCase() ในตัวเพื่อเปลี่ยนตัวแปรสตริงเป็นตัวพิมพ์เล็ก

<AssignMessage name="AM-Set-Custom-Response">
    <AssignTo createNew="false" type="response"/>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <Set>
        <Headers>
            <Header name="x-h1">Test header: {toLowerCase(foo.bar:FOO)}</Header>
        </Headers>
    </Set>
</AssignMessage>

หากตัวแปรโฟลว์ foo.bar แก้ไขได้ อักขระของตัวแปรก็จะเป็นตัวพิมพ์เล็กทั้งหมด หาก foo.bar ไม่ได้รับการแก้ไข ระบบจะแทนที่ค่าเริ่มต้น FOO และแปลงเป็นอักขระตัวพิมพ์เล็ก เช่น

Test header: foo

ตัวอย่าง: EscapeJSON()

กรณีการใช้งานที่น่าสนใจมีดังนี้ สมมติว่าแอปแบ็กเอนด์แสดงผลการตอบกลับ JSON ที่มีอักขระหลีกที่ถูกต้อง เช่น

{
      "code": "INVALID",
      "user_message": "Invalid value for \"logonId\" check your input."
}

จากนั้น สมมติว่าคุณต้องการส่งคืนข้อความนี้ไปยังผู้เรียกใช้ของไคลเอ็นต์ในเพย์โหลดที่กำหนดเอง วิธีทั่วไปในการดำเนินการนี้คือ ดึงข้อความจากเพย์โหลดการตอบสนองเป้าหมายและใช้ Assign Message เพื่อเพิ่มข้อความไปยังการตอบกลับพร็อกซีที่กำหนดเอง (กล่าวคือ ส่งข้อความกลับไปให้ไคลเอ็นต์)

นโยบายดึงข้อมูลตัวแปรที่ดึงข้อมูล user_message มาเปลี่ยนเป็นตัวแปรชื่อ standard.systemMessage มีดังนี้

<ExtractVariables name="EV-BackendErrorResponse">
    <DisplayName>EV-BackendErrorResponse</DisplayName>
    <JSONPayload>
        <Variable name="standard.systemMessage">
            <JSONPath>$.user_message</JSONPath>
        </Variable>
    </JSONPayload>
</ExtractVariables>

ต่อไปมาดูนโยบาย "กำหนดข้อความ" ที่ถูกต้องที่สุดซึ่งจะเพิ่มตัวแปรที่ดึงมาในเพย์โหลดการตอบกลับ (การตอบกลับพร็อกซี) ที่

<AssignMessage name="AM-SetStandardFaultResponse">
    <DisplayName>AM-SetStandardFaultResponse</DisplayName>
    <Set>
        <Payload contentType="application/json">
           {
              "systemMessage": "{standard.systemMessage}"
           }
        </Payload>
    </Set>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <AssignTo createNew="false" transport="http" type="response"/>
</AssignMessage>

มีปัญหาเกิดขึ้น นโยบายการดึงข้อมูลตัวแปรได้นำเครื่องหมายคำพูดที่กำหนดไว้รอบบางส่วนของข้อความออก ซึ่งหมายความว่าการตอบกลับที่ส่งไปยังไคลเอ็นต์จะเป็น JSON ที่ไม่ถูกต้อง เห็นได้ชัดว่านี่ไม่ใช่สิ่งที่คุณตั้งใจ

{
    "systemMessage": "Invalid value for "logonId" check your input."
}

หากต้องการแก้ปัญหานี้ ให้แก้ไขนโยบาย "กำหนดข้อความ" เพื่อใช้ฟังก์ชันเทมเพลตข้อความที่แยกเครื่องหมายคำพูดภายใน JSON ออก ฟังก์ชันนี้ escapeJSON() จะยกเว้นเครื่องหมายคำพูดหรือสัญลักษณ์พิเศษอื่นๆ ที่เกิดขึ้นภายในนิพจน์ JSON ดังนี้

<AssignMessage name="AM-SetStandardFaultResponse">
    <DisplayName>AM-SetStandardFaultResponse</DisplayName>
    <Set>
        <Payload contentType="application/json">
           {
              "systemMessage": "{escapeJSON(standard.systemMessage)}"
           }
        </Payload>
    </Set>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <AssignTo createNew="false" transport="http" type="response"/>
</AssignMessage>

ฟังก์ชันนี้ใช้อักขระหลีกกับเครื่องหมายคำพูดแบบฝังเพื่อให้เป็น JSON ที่ถูกต้อง ซึ่งคือสิ่งที่คุณต้องการจริงๆ

{
      "systemMessage": "Invalid value for \"logonId\" check your input.",
}

เทมเพลตข้อความคือฟีเจอร์การแทนที่สตริงแบบไดนามิกที่คุณใช้ในนโยบายบางรายการและในคำจำกัดความของ TargetEndpoint ได้ ฟังก์ชันของเทมเพลตข้อความช่วยให้คุณดำเนินการที่เป็นประโยชน์ได้ เช่น การแฮช การจัดการสตริง การ Escape อักขระ และอื่นๆ ภายในเทมเพลตข้อความ

เช่น ในนโยบาย AssignMessage ต่อไปนี้ ฟังก์ชัน toLowerCase() จะใช้ในเทมเพลตข้อความ

<AssignMessage name="AM-Set-Custom-Response">
    <AssignTo createNew="false" type="response"/>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <Set>
       <Headers>
         <Header name="x-h1">Test header: {Hello, toLowerCase(user.name)}</Header>
       </Headers>
    </Set>
</AssignMessage>

หัวข้อนี้อธิบายฟังก์ชันของเทมเพลตข้อความ อาร์กิวเมนต์ และเอาต์พุต หัวข้อนี้จะถือว่าคุณคุ้นเคยกับเทมเพลตข้อความและบริบทในการใช้เทมเพลตข้อความดีอยู่แล้ว

คุณไม่สามารถฝังการเรียกใช้ฟังก์ชันได้ ตัวอย่างเช่น คุณจะดำเนินการต่อไปนี้ไม่ได้

{substring({timeFormat("yyyy-MM-dd","1494390266")},0,4)}

ฟังก์ชันแฮช

คำนวณค่าแฮชและแสดงผลสตริงของแฮชนั้น

ฟังก์ชันแฮชฐานสิบหก

คำนวณค่าแฮชและแสดงผลสตริงของแฮชนั้นเป็นเลขฐานสิบหก

ไวยากรณ์

การทำงาน	คำอธิบาย
`md5Hex(string)`	ประมวลผลแฮช MD5 ที่แสดงเป็นตัวเลขฐานสิบหก
`sha1Hex(string)`	ประมวลผลแฮช SHA1 ที่แสดงเป็นตัวเลขฐานสิบหก
`sha256Hex(string)`	ประมวลผลแฮช SHA256 ที่แสดงเป็นตัวเลขฐานสิบหก
`sha384Hex(string)`	ประมวลผลแฮช SHA384 ที่แสดงเป็นตัวเลขฐานสิบหก
`sha512Hex(string)`	ประมวลผลแฮช SHA512 ที่แสดงเป็นตัวเลขฐานสิบหก

อาร์กิวเมนต์

string - ฟังก์ชันแฮชจะใช้อาร์กิวเมนต์สตริงเดียวที่ใช้คำนวณอัลกอริทึมแฮช อาร์กิวเมนต์อาจเป็นสตริงตรงตัวหรือตัวแปรโฟลว์ของสตริงก็ได้

ตัวอย่าง

การเรียกฟังก์ชัน:

sha256Hex('abc')

ผลลัพธ์:

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

การเรียกฟังก์ชัน:

var str = 'abc';
sha256Hex(str)

ผลลัพธ์:

ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad

ฟังก์ชันแฮช Base64

คำนวณค่าแฮชและแสดงผลสตริงของแฮชนั้นเป็นค่าที่เข้ารหัส Base64

ไวยากรณ์

การทำงาน	คำอธิบาย
`md5Base64(string)`	ประมวลผลแฮช MD5 ที่แสดงเป็นค่าที่เข้ารหัส Base64
`sha1Base64(string)`	ประมวลผลแฮช SHA1 ที่แสดงเป็นค่าที่เข้ารหัส Base64
`sha256Base64(string)`	ประมวลผลแฮช SHA256 ที่แสดงเป็นค่าที่เข้ารหัส Base64
`sha384Base64(string)`	ประมวลผลแฮช SHA384 ที่แสดงเป็นค่าที่เข้ารหัส Base64
`sha512Base64(string)`	ประมวลผลแฮช SHA512 ที่แสดงเป็นค่าที่เข้ารหัส Base64

อาร์กิวเมนต์

ตัวอย่าง

การเรียกฟังก์ชัน:

sha256Base64('abc')

ผลลัพธ์:

ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0=

การเรียกฟังก์ชัน:

var str = 'abc';
sha256Base64(str)

ผลลัพธ์:

ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0=

ฟังก์ชันสตริง

ดำเนินการกับสตริงภายในเทมเพลตข้อความ

ฟังก์ชันการเข้ารหัส Base64

เข้ารหัสและถอดรหัสสตริงโดยใช้รูปแบบการเข้ารหัส Base64

ไวยากรณ์

การทำงาน	คำอธิบาย
`encodeBase64(string)`	เข้ารหัสสตริงโดยใช้การเข้ารหัส Base64 เช่น `encodeBase64(value)` เมื่อ `value` เก็บ `abc` ไว้ ฟังก์ชันจะแสดงผลสตริง `YWJj`
`decodeBase64(string)`	ถอดรหัสสตริงที่เข้ารหัส Base64 เช่น `decodeBase64(value)` เมื่อ `value` มี `aGVsbG8sIHdvcmxk` อยู่ ฟังก์ชันจะแสดงผลสตริง `hello, world`

อาร์กิวเมนต์

string - สตริงที่จะเข้ารหัสหรือถอดรหัส สามารถเป็นสตริงตามตัวอักษรหรือตัวแปรโฟลว์ของสตริงก็ได้

ตัวอย่าง

<AssignMessage name="AM-Set-Custom-Response">
    <AssignTo createNew="false" type="response"/>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <Set>
       <Headers>
         <Header name="x-h1">Hello, {decodeBase64('d29ybGQK')}</Header>
       </Headers>
    </Set>
</AssignMessage>

ฟังก์ชันการแปลงตัวพิมพ์

แปลงสตริงให้เป็นอักษรตัวพิมพ์ใหญ่ทั้งหมดหรือตัวพิมพ์เล็กทั้งหมด

ไวยากรณ์

การทำงาน	คำอธิบาย
`toUpperCase(string)`	แปลงสตริงเป็นตัวพิมพ์ใหญ่
`toLowerCase(string)`	แปลงสตริงให้เป็นตัวพิมพ์เล็ก

อาร์กิวเมนต์

string - สตริงที่จะแปลง สามารถเป็นสตริงตามตัวอักษรหรือตัวแปรโฟลว์ของสตริงก็ได้

ตัวอย่าง

<AssignMessage name="AM-Set-Custom-Response">
    <AssignTo createNew="false" type="response"/>
    <IgnoreUnresolvedVariables>true</IgnoreUnresolvedVariables>
    <Set>
       <Headers>
         <Header name="x-h1">Hello, {toLowerCase(user.name)}</Header>
       </Headers>
    </Set>
</AssignMessage>

ฟังก์ชันสตริงย่อย

แสดงผลอักขระระหว่างดัชนีเริ่มต้นและดัชนีสิ้นสุดของสตริงที่ระบุ

ไวยากรณ์

substring(str,start_index,end_index)

อาร์กิวเมนต์

str - สตริงลิเทอรัลหรือตัวแปรโฟลว์ของสตริง
start_index - ดัชนีเริ่มต้นในสตริง
end_index - (ไม่บังคับ) ดัชนีสิ้นสุดเป็นสตริง หากไม่ระบุ ดัชนีสิ้นสุดจะเป็นส่วนท้ายของสตริง

ตัวอย่าง

สำหรับตัวอย่างต่อไปนี้ สมมติว่ามีตัวแปรโฟลว์เหล่านี้อยู่

ชื่อตัวแปร	ค่า
`alpha`	กขฃคฅฆงจฉชซฌญฎฏฐฑฒณดตถทธนบปผฝพฟภมยรลวศษสหฬอฮ
`seven`	7

ต่อไปนี้คือผลลัพธ์ของการเรียกฟังก์ชันที่ใช้ตัวแปรเหล่านี้

นิพจน์เทมเพลตข้อความ	ผลลัพธ์
`{substring(alpha,22)}`	`WXYZ`
`hello {substring(alpha,22)}`	`hello WXYZ`
`{substring(alpha,-4)}`	`WXYZ`
`{substring(alpha,-8,-4)}`	`STUV`
`{substring(alpha,0,10)}`	`ABCDEFGHIJ`
`{substring(alpha,0,seven)}`	`ABCDEFG`

แทนที่ฟังก์ชันทั้งหมด

ใช้นิพจน์ทั่วไปกับสตริง และแทนที่การจับคู่ที่ตรงกันด้วยค่าแทนที่สำหรับการจับคู่ที่ตรงกัน

ไวยากรณ์

replaceAll(string,regex,value)

อาร์กิวเมนต์

string - สตริงตามตัวอักษรหรือตัวแปรโฟลว์ของสตริงที่จะแทนที่
regex - นิพจน์ทั่วไป
value - ค่าที่จะแทนที่นิพจน์ทั่วไปที่ตรงกันทั้งหมดภายในสตริง

ตัวอย่าง

สำหรับตัวอย่างต่อไปนี้ สมมติว่ามีตัวแปรโฟลว์เหล่านี้อยู่

ชื่อตัวแปร	ค่า
`header`	`Bearer ABCDEFGHIJKLMNOPQRSTUVWXYZ-9993`
`regex1`	`"^Bearer "`
`replacement`	`"TOKEN: "`

ต่อไปนี้คือผลลัพธ์ของการเรียกฟังก์ชันที่ใช้ตัวแปรเหล่านี้

นิพจน์เทมเพลตข้อความ	ผลลัพธ์
`{replaceAll(header,"9993",'')}`	`Bearer ABCDEFGHIJKLMNOPQRSTUVWXYZ-`
`{replaceAll(header,regex1,'')}`	`ABCDEFGHIJKLMNOPQRSTUVWXYZ-9993`
`{replaceAll(header,regex1,replacement)}`	`TOKEN: ABCDEFGHIJKLMNOPQRSTUVWXYZ-9993`

แทนที่ฟังก์ชันแรก

แทนที่เฉพาะรายการแรกของการจับคู่นิพจน์ทั่วไปที่ระบุในสตริง

ไวยากรณ์

replaceFirst(string,regex,value)

อาร์กิวเมนต์

string - สตริงตามตัวอักษรหรือตัวแปรโฟลว์ของสตริงที่จะแทนที่
regex - นิพจน์ทั่วไป
value - ค่าที่จะแทนที่นิพจน์ทั่วไปจะจับคู่ภายในสตริง

ฟังก์ชันอักขระหลีกและการเข้ารหัส

ฟังก์ชันที่ Escape หรือเข้ารหัสสัญลักษณ์พิเศษในสตริง

ไวยากรณ์

การทำงาน	คำอธิบาย
EscapeJSON(สตริง)	เครื่องหมายอัญประกาศคู่ที่ใช้เครื่องหมายแบ็กสแลชเป็นอักขระหลีก
EscapeXML(สตริง)	แทนที่วงเล็บมุม อะพอสทรอฟี อัญประกาศคู่ และเครื่องหมายและด้วยเอนทิตี XML ที่เกี่ยวข้อง ใช้สำหรับเอกสาร XML 1.0 ใช้ EscapeXML สำหรับเอกสาร XML1.0 และ EscapeXML11 สำหรับเอกสาร XML 1.1
EscapeXML11(สตริง)	ทำงานเหมือนกับ EscapeXML แต่ใช้กับเอนทิตี XML v1.1 โปรดดูหมายเหตุการใช้งานด้านล่าง
encodeHTML(สตริง)	เข้ารหัสอะพอสทรอฟี วงเล็บมุม และเครื่องหมายแอมเพอร์แซนด์

อาร์กิวเมนต์

string - สตริงที่จะใช้เป็นอักขระหลีก สามารถเป็นสตริงตามตัวอักษรหรือตัวแปรโฟลว์ของสตริงก็ได้

หมายเหตุการใช้งาน

XML 1.1 สามารถแทนอักขระควบคุมบางตัวได้ แต่จะไม่สามารถแสดงแทนไบต์ที่เป็นค่าว่างหรือจุดแทนของ Unicode ที่ไม่ได้จับคู่ แม้ว่าจะทำการ Escape แล้วก็ตาม ฟังก์ชัน EscapeXML11() จะลบอักขระที่ไม่พอดีกับช่วงต่อไปนี้

[#x1-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]

ฟังก์ชัน escapeXML11() จะเลี่ยงอักขระในช่วงต่อไปนี้

[#x1-#x8] | [#xB-#xC] | [#xE-#x1F] | [#x7F-#x84] | [#x86-#x9F]

ตัวอย่าง

สมมติว่ามีตัวแปรโฟลว์ชื่อ food อยู่กับค่านี้ "bread" & "butter" จากนั้น ฟังก์ชันจะทำดังนี้

{escapeHTML(food)}

ผลลัพธ์ใน:

"bread" & "butter"

ฟังก์ชันรูปแบบเวลา

แสดงผลสตริงเวลาในรูปแบบเขตเวลาท้องถิ่นหรือ UTC

ไวยากรณ์

การทำงาน	คำอธิบาย
`timeFormat(format,str)`	แสดงผลวันที่ในรูปแบบเขตเวลาท้องถิ่น
`timeFormatMs(format,str)`	แสดงผลวันที่ในรูปแบบเขตเวลาท้องถิ่น
`timeFormatUTC(format,str)`	แสดงผลวันที่ในรูปแบบ UTC
`timeFormatUTCMs(format,str)`	แสดงผลวันที่ในรูปแบบ UTC

อาร์กิวเมนต์

format - สตริงรูปแบบวันที่/เวลา สามารถเป็นสตริงตัวอักษรหรือตัวแปรสตริงก็ได้
str - ตัวแปรโฟลว์ของสตริงหรือสตริงที่มีค่าเวลา ค่าอาจเป็น seconds-since-epoch หรือms-since-epoch สําหรับ timeFormatMs

ตัวอย่าง

ให้ใช้ค่าต่อไปนี้และสมมติว่าเขตเวลาท้องถิ่นเป็นแปซิฟิก

epoch_time_ms = 1494390266000
epoch_time = 1494390266
fmt1 = yyyy-MM-dd
fmt2 = yyyy-MM-dd HH-mm-ss
fmt3 = yyyyMMddHHmmss

ฟังก์ชันจะแสดงผลลัพธ์ต่อไปนี้

การทำงาน	เอาต์พุต
`timeFormatMs(fmt1,epoch_time_ms)`	`2017-05-09`
`timeFormat(fmt1,epoch_time)`	`2017-05-09`
`timeFormat(fmt2,epoch_time)`	`2017-05-09 21:24:26`
`timeFormat(fmt3,epoch_time)`	`20170509212426`
`timeFormatUTC(fmt1,epoch_time)`	`2017-05-10`
`timeFormatUTC(fmt2,epoch_time)`	`2017-05-10 04:24:26`
`timeFormatUTC(fmt3,epoch_time)`	`20170510042426`

ฟังก์ชันการคำนวณ HMAC

ฟังก์ชันการคำนวณ HMAC เป็นทางเลือกในการใช้นโยบาย HMAC ในการคำนวณ HMAC ฟังก์ชันมีประโยชน์เมื่อคํานวณ HMAC แบบ Cascade เช่น เมื่อมีการใช้เอาต์พุตของ HMAC เครื่องหนึ่งเป็นคีย์สําหรับ HMAC รายการที่ 2

ไวยากรณ์

การทำงาน	คำอธิบาย
`hmacSha224(key,valueToSign[,keyencoding[,outputencoding]])`	ประมวลผล HMAC ด้วยฟังก์ชันแฮช SHA-224
`hmacSha256(key,valueToSign[,keyencoding[,outputencoding]])`	เข้ารหัส HMAC ด้วยฟังก์ชันแฮช SHA-256
`hmacSha384(key,valueToSign[,keyencoding[,outputencoding]])`	เข้ารหัส HMAC ด้วยฟังก์ชันแฮช SHA-384
`hmacSha512(key,valueToSign[,keyencoding[,outputencoding]])`	เข้ารหัส HMAC ด้วยฟังก์ชันแฮช SHA-512
`hmacMd5(key,valueToSign[,keyencoding[,outputencoding]])`	เข้ารหัส HMAC ด้วยฟังก์ชันแฮช MD5
`hmacSha1(key, valueToSign [,keyencoding[,outputencoding]])`	เข้ารหัส HMAC ด้วยอัลกอริทึมการเข้ารหัส SHA-1

หมายเหตุด้านความปลอดภัย: SHA-1 และ MD-5 รวมอยู่ที่นี่เพื่อความสมบูรณ์ แต่ Google ขอแนะนำไม่ให้ผู้ใช้ใช้แฮชเหล่านี้ Google แสดงให้เห็นการโจมตีแบบ SHA-1 เป็นครั้งแรกในปี 2017 และแนะนำว่าอย่าใช้ SHA-1 นอกจากนี้ NIST ยังแนะนำให้ผู้ใช้หยุดใช้ SHA-1 ในตอนแรก สถาบันวิศวกรรมซอฟต์แวร์ของ CMU แนะนำว่าควรหลีกเลี่ยงการใช้อัลกอริทึม MD5 ไม่ว่าจะด้วยความสามารถใดก็ตาม ในปี 2008

อาร์กิวเมนต์

key - (ต้องระบุ) ระบุคีย์ลับซึ่งเข้ารหัสเป็นสตริงที่ใช้ในการคำนวณ HMAC
valueToSign - (ต้องระบุ) ระบุข้อความที่จะลงนาม ควรเป็นสตริง
keyencoding - (ไม่บังคับ) ระบบจะถอดรหัสสตริงคีย์ลับตามการเข้ารหัสที่ระบุนี้ ค่าที่ถูกต้อง: hex, base16, base64, utf-8 ค่าเริ่มต้น: utf-8
เอาต์พุตการเข้ารหัส - (ไม่บังคับ) ระบุอัลกอริทึมการเข้ารหัสที่จะใช้สำหรับเอาต์พุต ค่าที่ถูกต้อง: hex, base16, base64 ค่าต่างๆ ไม่คํานึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ โดย hex และ base16 คือคําพ้องความหมาย ค่าเริ่มต้น: base64

ตัวอย่าง

ตัวอย่างนี้ใช้นโยบาย AssignMessage เพื่อคำนวณ HMAC-256 และมอบหมายให้กับตัวแปรโฟลว์ ดังนี้

<AssignMessage name='AM-HMAC-1'>
  <AssignVariable>
    <Name>valueToSign</Name>
    <Template>{request.header.apikey}.{request.header.date}</Template>
  </AssignVariable>
  <AssignVariable>
    <Name>hmac_value</Name>
    <Template>{hmacSha256(private.secretkey,valueToSign)}</Template>
  </AssignVariable>
</AssignMessage>

ตัวอย่างนี้แสดงวิธีสร้าง HMAC แบบ Cascading ที่ใช้กับกระบวนการลงนาม AWS Signature v4 ได้ ตัวอย่างนี้ใช้นโยบาย AssignMessage เพื่อสร้าง HMAC แบบ Cascade 5 ระดับที่ใช้ในการคำนวณลายเซ็นสำหรับ AWS Signature v4

<AssignMessage name='AM-HMAC-AWS-1'>
  <!-- 1 -->
  <AssignVariable>
    <Name>DateValue</Name>
    <Template>{timeFormatUTCMs('yyyyMMdd',system.timestamp)}</Template>
  </AssignVariable>
  <!-- 2 -->
  <AssignVariable>
    <Name>FirstKey</Name>
    <Template>AWS4{private.secret_aws_access_key}</Template>
  </AssignVariable>
  <!-- 3 -->
  <AssignVariable>
    <Name>DateKey</Name>
    <Template>{hmacSha256(FirstKey,DateValue,'utf-8','base16')}</Template>
  </AssignVariable>
  <!-- 4 -->
  <AssignVariable>
    <Name>DateRegionKey</Name>
    <Template>{hmacSha256(DateKey,aws_region,'base16','base16')}</Template>
  </AssignVariable>
  <!-- 5 -->
  <AssignVariable>
    <Name>DateRegionServiceKey</Name>
    <Template>{hmacSha256(DateRegionKey,aws_service,'base16','base16')}</Template>
  </AssignVariable>
  <!-- 6 -->
  <AssignVariable>
    <Name>SigningKey</Name>
    <Template>{hmacSha256(DateRegionServiceKey,'aws4_request','base16','base16')}</Template>
  </AssignVariable>
  <!-- 7 -->
  <AssignVariable>
    <Name>aws4_hmac_value</Name>
    <Template>{hmacSha256(SigningKey,stringToSign,'base16','base16')}</Template>
  </AssignVariable>
</AssignMessage>

ฟังก์ชันอื่นๆ

สร้างฟังก์ชัน UUID

สร้างและแสดงผล UUID

ไวยากรณ์

createUuid()

อาร์กิวเมนต์

ไม่มี

ตัวอย่าง

{createUuid()}

ผลลัพธ์ตัวอย่าง:

ec3ca9be-d1e1-4ef4-aee4-4a58f3130db8

ฟังก์ชันโปรแกรมสร้างแบบยาวแบบสุ่ม

แสดงผลจำนวนเต็มแบบยาวแบบสุ่ม

ไวยากรณ์

randomLong(args)

อาร์กิวเมนต์

หากไม่ได้ระบุอาร์กิวเมนต์ ฟังก์ชันจะแสดงผลจำนวนเต็มแบบยาวแบบสุ่ม ดังที่คำนวณโดยคลาส Java SecureRandom
ถ้ามีอาร์กิวเมนต์ 1 รายการจะถือเป็นค่าต่ำสุดของการคำนวณ
ถ้ามีอาร์กิวเมนต์ที่ 2 จะถือว่ามีค่าสูงสุดของการคำนวณ

ตัวอย่าง

{random()}

ได้ผลลัพธ์ดังนี้

5211338197474042880

โปรแกรมสร้างข้อความนิพจน์ทั่วไป

สร้างสตริงข้อความที่ตรงกับนิพจน์ทั่วไปที่ระบุ

ไวยากรณ์

xeger(regex)

อาร์กิวเมนต์

regex - นิพจน์ทั่วไป

ตัวอย่าง

ตัวอย่างนี้สร้างสตริง 7 หลักที่ไม่มีเลขศูนย์

xeger('[1-9]{7}')

ตัวอย่างผลการค้นหา

ฟังก์ชันการประสานงานค่า Null

ฟังก์ชัน firstnonnull() จะแสดงผลค่าของอาร์กิวเมนต์ซ้ายสุดที่ไม่ใช่ค่าว่าง

ไวยากรณ์

firstnonnull(var1,var_n)

อาร์กิวเมนต์

var1 - ตัวแปรบริบท

var_n - ตัวแปรบริบทอย่างน้อย 1 รายการ คุณจะตั้งค่าอาร์กิวเมนต์ขวาสุดเป็นสตริงเพื่อระบุค่าสำรองได้ (ระบบจะตั้งค่าในกรณีที่ไม่มีการตั้งค่าอาร์กิวเมนต์ทางด้านซ้ายมือ)

ตัวอย่าง

ตารางต่อไปนี้จะแสดงวิธีใช้ฟังก์ชัน

เทมเพลต	Var1	Var2	Var3	ผลลัพธ์
`{firstnonnull(var1,var2)}`	ไม่ได้ตั้งค่า	`foo`	ไม่มีข้อมูล	`foo`
`{firstnonnull(var1,var2)}`	`foo`	`bar`	ไม่มีข้อมูล	`foo`
`{firstnonnull(var1,var2)}`	`foo`	ไม่ได้ตั้งค่า	ไม่มีข้อมูล	`foo`
`{firstnonnull(var1,var2,var3)}`	`foo`	`bar`	`baz`	`foo`
`{firstnonnull(var1,var2,var3)}`	ไม่ได้ตั้งค่า	`bar`	`baz`	`bar`
`{firstnonnull(var1,var2,var3)}`	ไม่ได้ตั้งค่า	ไม่ได้ตั้งค่า	`baz`	`baz`
`{firstnonnull(var1,var2,var3)}`	ไม่ได้ตั้งค่า	ไม่ได้ตั้งค่า	ไม่ได้ตั้งค่า	`null`
`{firstnonnull(var1)}`	ไม่ได้ตั้งค่า	ไม่มีข้อมูล	ไม่มีข้อมูล	`null`
`{firstnonnull(var1)}`	`foo`	ไม่มีข้อมูล	ไม่มีข้อมูล	`foo`
`{firstnonnull(var1,var2)}`	`""`	`bar`	ไม่มีข้อมูล	`""`
`{firstnonnull(var1,var2,'fallback value')}`	`null`	`null`	`fallback value`	`fallback value`

ฟังก์ชัน XPath

ใช้นิพจน์ XPath กับตัวแปร XML

ไวยากรณ์

xpath(xpath_expression,xml_string,[datatype])

อาร์กิวเมนต์

xpath_expression - นิพจน์ XPath

xml_string - ตัวแปรหรือสตริงที่มี XML

datatype - (ไม่บังคับ) ระบุประเภทการแสดงผลที่ต้องการของการค้นหา ซึ่งอาจเป็น Nodeset, Node, ตัวเลข, บูลีน, สตริง โดยมีค่าเริ่มต้นเป็น Nodeset ค่าเริ่มต้นมักจะเป็นตัวเลือกที่เหมาะสม

ตัวอย่างที่ 1

สมมติว่าตัวแปรบริบทเหล่านี้กำหนดสตริง XML และนิพจน์ XPath

xml = "<tag><tagid>250397</tagid><readerid>1</readerid><rssi>74</rssi><date>2019/06/15</date></tag>"
xpath = "/tag/tagid"

และใช้ฟังก์ชัน xpath() ในนโยบาย AssignMessage ดังนี้

<AssignMessage>
  <AssignVariable>
    <Name>extracted_tag</Name>
    <Template>{xpath(xpath,xml)}</Template>
  </AssignVariable>
</AssignMessage><

ฟังก์ชันจะแสดงผลค่า <tagid>250397</tagid> ค่านี้จะวางอยู่ในตัวแปรบริบทที่ชื่อว่า extracted_tag

ตัวอย่างที่ 2

หากต้องการเฉพาะค่าของโหนด ให้ใช้ฟังก์ชัน text() ดังนี้

<AssignMessage>
  <AssignVariable>
    <Name>extracted_tag</Name>
    <Template>{xpath('/tag/tagid/text()',xml)}</Template>
  </AssignVariable>
</AssignMessage>

การดำเนินการนี้ส่งผลให้ระบบตั้งค่าตัวแปรบริบท extracted_tag เป็น 250397

หากเลือกหลายโหนด ผลลัพธ์ของ xpath() จะเป็นค่าทั้งหมดของรายการที่เลือกซึ่งต่อด้วยคอมมา

ตัวอย่างที่ 3: เนมสเปซ XML

หากต้องการระบุเนมสเปซ ให้เพิ่มพารามิเตอร์เพิ่มเติมโดยให้พารามิเตอร์แต่ละรายการมีลักษณะเหมือน prefix:namespaceuri เช่น ฟังก์ชัน xpath() ที่เลือกองค์ประกอบย่อยของเนื้อหา SOAP อาจมีลักษณะดังนี้

<AssignMessage>
  <AssignVariable>
    <Name>soapns</Name>
    <Value>soap:http://schemas.xmlsoap.org/soap/envelope/</Value>
  </AssignVariable>
  <AssignVariable>
    <Name>xpathexpression</Name>
    <Value>/soap:Envelope/soap:Body/*</Value>
  </AssignVariable>
  <AssignVariable>
    <Name>extracted_element</Name>
    <Template>{xpath(xpathexpression,xml,soapns)}</Template>
  </AssignVariable>
</AssignMessage>

สำหรับเนมสเปซเพิ่มเติม คุณเพิ่มพารามิเตอร์ลงในฟังก์ชัน xpath() ได้สูงสุด 10 รายการ

คุณสามารถระบุนิพจน์ XPath แบบง่ายเป็นสตริงที่ล้อมรอบด้วยเครื่องหมายคำพูดเดี่ยว ดังนี้

{xpath('/tag/tagid/text()',xml)}

หากนิพจน์ XPath มีคำนำหน้าเนมสเปซ (และโคลอน) คุณจะต้องกำหนดนิพจน์ XPath นั้นให้กับตัวแปรและระบุชื่อตัวแปรแทนนิพจน์โดยตรง

{xpath(xpathexpression,xml,ns1)}

ตัวอย่างที่ 4: การระบุประเภทการแสดงผลที่ต้องการ

พารามิเตอร์ที่ 3 ที่ไม่บังคับซึ่งส่งผ่านไปยังฟังก์ชัน xpath() จะระบุประเภทการแสดงผลที่ต้องการของการค้นหา

การค้นหา XPath บางรายการอาจแสดงค่าตัวเลขหรือบูลีน เช่น ฟังก์ชัน count() จะแสดงผลตัวเลข นี่คือการค้นหา XPath ที่ถูกต้อง:

count(//Record/Fields/Pair)

การค้นหาที่ถูกต้องนี้แสดงบูลีน

count(//Record/Fields/Pair)>0

ในกรณีดังกล่าว ให้เรียกใช้ฟังก์ชัน xpath() ด้วยพารามิเตอร์ที่ 3 ที่ระบุประเภท

{xpath(expression,xml,'number')}
{xpath(expression,xml,'boolean')}

หากพารามิเตอร์ที่ 3 มีโคลอน ระบบจะตีความว่าเป็นอาร์กิวเมนต์เนมสเปซ หากไม่เป็นเช่นนั้น ระบบจะถือว่าเป็นประเภทการแสดงผลที่ต้องการ ในกรณีนี้ หากพารามิเตอร์ที่ 3 ไม่ใช่ค่าที่ถูกต้องค่าใดค่าหนึ่ง (ไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่) ฟังก์ชัน xpath() จะตั้งค่าเริ่มต้นให้แสดงผลชุดโหนด

ฟังก์ชันเส้นทาง JSON

ใช้นิพจน์เส้นทาง JSON กับตัวแปร JSON

ไวยากรณ์

jsonPath(json-path,json-var,want-array)

อาร์กิวเมนต์

(ต้องระบุ) json-path: (สตริง) นิพจน์เส้นทาง JSON
(ต้องระบุ) json-var: (สตริง) ตัวแปรโฟลว์หรือสตริงที่มี JSON
(ไม่บังคับ) want-array: (สตริง) หากตั้งค่าพารามิเตอร์นี้เป็น 'true' และหากชุดผลลัพธ์เป็นอาร์เรย์ ระบบจะแสดงผลองค์ประกอบอาร์เรย์ทั้งหมด หากตั้งค่าเป็นค่าอื่นหรือพารามิเตอร์นี้ละเว้นพารามิเตอร์นี้ จะแสดงผลเฉพาะองค์ประกอบที่ 0 ของอาร์เรย์ชุดผลลัพธ์ หากชุดผลลัพธ์ไม่ใช่อาร์เรย์ ระบบจะละเว้นพารามิเตอร์ที่ 3 (หากมี)

ตัวอย่างที่ 1

หากเป็นเทมเพลตข้อความ ให้ทำดังนี้

The address is {jsonPath($.results[?(@.name == 'Mae West')].address.line1,the_json_variable)}

และ the_json_variable ประกอบด้วย

{
  "results" : [
    {
      "address" : {
        "line1" : "18250 142ND AV NE",
        "city" : "Woodinville",
        "state" : "Washington",
        "zip" : "98072"
      },
      "name" : "Fred Meyer"
    },
    {
      "address" : {
        "line1" : "1060 West Addison Street",
        "city" : "Chicago",
        "state" : "Illinois",
        "zip" : "60613"
      },
      "name" : "Mae West"
    }
  ]
}

ผลลัพธ์ของฟังก์ชันคือ

The address is 1060 West Addison Street

โปรดทราบว่าในกรณีนี้ ชุดผลลัพธ์จะเป็นองค์ประกอบเดียว (ไม่ใช่อาร์เรย์ขององค์ประกอบ) หากชุดผลลัพธ์เป็นอาร์เรย์ ระบบจะแสดงผลเฉพาะองค์ประกอบที่ 0 ของอาร์เรย์ หากต้องการแสดงผลอาร์เรย์แบบเต็ม ให้เรียกใช้ฟังก์ชันที่มี 'true' เป็นพารามิเตอร์ที่ 3 ดังที่แสดงในตัวอย่างถัดไป

ตัวอย่างที่ 2

หากเป็นเทมเพลตข้อความ ให้ทำดังนี้

{jsonPath($.config.quota[?(@.operation=='ManageOrder')].appname,the_json_variable,'true')}

และ the_json_variable ประกอบด้วย

{
  "results" : [
     {
      "config": {
        "quota": [
          {
            "appname": "A",
            "operation": "ManageOrder",
            "value": "900"
          },
          {
            "appname": "B",
            "operation": "ManageOrder",
            "value": "1000"
          },
          {
            "appname": "B",
            "operation": "SubmitOrder",
            "value": "800"
          }
        ]
      }
    }
  ]
}

ผลลัพธ์ของฟังก์ชันคือ

['A','B']