หน้านี้ได้รับการแปลโดย 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 หากหาตัวแปรไม่ได้ ระบบจะแสดงสตริงว่าง

ตัวอย่าง

เมื่อเกินโควต้า เราขอแนะนำให้คุณส่งข้อความที่มีความหมายไปยังผู้โทร ช่วงเวลานี้ รูปแบบมักใช้กับ "กฎข้อผิดพลาด" เพื่อแสดงเอาต์พุตเพื่อให้ข้อมูลของผู้โทร เกี่ยวกับการละเมิดโควต้า นโยบาย "กำหนดข้อความ" ต่อไปนี้จะใช้เทมเพลตข้อความ เพื่อป้อนข้อมูลโควต้าแบบไดนามิกในองค์ประกอบ 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, Header, QueryParams, FormParams องค์ประกอบย่อย `<Add>`: ส่วนหัว, QueryParams, FormParams องค์ประกอบย่อย `<AssignVariable>`: `<Template>`
นโยบายเกี่ยวกับส่วนขยายไฮไลต์	`<Input>`
นโยบาย ExtractVariable	`<JsonPath>` ระบบไม่ยอมรับเทมเพลตข้อความสำหรับ `<XMLPath>`
นโยบาย GenerateJWS นโยบาย VerifyJWS	`<Payload>` (นโยบาย GenerateJWS เท่านั้น) `<AdditionalHeaders><Claim>` * องค์ประกอบเหล่านี้รองรับเทมเพลตข้อความเฉพาะเมื่อเป็น type=map
นโยบาย GenerateJWT นโยบาย VerifyJWT	`<AdditionalClaims><Claim>` `<AdditionalHeaders><Claim>` * องค์ประกอบเหล่านี้รองรับเทมเพลตข้อความเฉพาะเมื่อเป็น type=map
นโยบาย LDAP	`<SearchQuery>`
นโยบายการบันทึกข้อความ	`<Syslog><Message>` `<File><Message>`
นโยบายการตรวจสอบความถูกต้อง	องค์ประกอบ `<OASResource>`
นโยบาย RaiseFault	องค์ประกอบ `<Set>`: Payload, ContentType, Verb, Version, Path, StatusCode, ReasonPhrase, Headers, QueryParams, FormParams องค์ประกอบ `<Add>`: ส่วนหัว, QueryParams, FormParams
นโยบาย SAMLAssertion	`<Template>` * เมื่อลายเซ็นนโยบายคือ `<GenerateSAMLAssertion>` เท่านั้น
นโยบายข้อความไฮไลต์บริการ	องค์ประกอบ `<Set>`: Payload, ContentType, Verb, Version, Path, StatusCode, ReasonPhrase, /Headers, QueryParams, FormParams องค์ประกอบ `<Add>`: ส่วนหัว, QueryParams, FormParams `<HTTPTargetConnection>/<URL>`: โปรดทราบว่าส่วนแรกของสตริงต้องเป็น http หรือ https

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

องค์ประกอบ HTTPTargetConnection	องค์ประกอบย่อยที่รองรับเทมเพลตข้อความ
SSLInfo	เปิดใช้, KeyAlias, KeyStore, 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."
}

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

นโยบายการดึงข้อมูลตัวแปรที่ดึงข้อมูล 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 ฟังก์ชันของเทมเพลตข้อความช่วยให้คุณดำเนินการต่างๆ ที่เป็นประโยชน์ เช่น การแฮช การจัดการสตริง การใช้อักขระหลีกกับอักขระ และอื่นๆ ภายในเทมเพลตข้อความ

ตัวอย่างเช่น ในนโยบาย 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>

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

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

{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

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

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

ตัวอย่าง

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

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 - ค่าที่ใช้แทนที่นิพจน์ทั่วไปที่ตรงกันภายในสตริง

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

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

ไวยากรณ์

การทำงาน	คำอธิบาย
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 - ตัวแปรโฟลว์ของสตริงหรือสตริงที่มีค่าเวลา ค่านี้สามารถเป็นหน่วยเป็นวินาทีตั้งแต่ Epoch หรือมิลลิวินาทีตั้งแต่ 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 และแนะนำว่า การใช้งาน นอกจากนี้ NIST ยังแนะนำให้ผู้ใช้หยุดใช้ SHA-1 ซอฟต์แวร์ CMU ทางสถาบันวิศวกรรมศาสตร์แนะนำให้บุคคลหลีกเลี่ยงการใช้ MD5 ก่อนเป็นอันดับแรก ในทุกความจุในปี 2008

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

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

ตัวอย่าง

{random()}

ผลลัพธ์จะมีลักษณะดังนี้

5211338197474042880

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

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

ไวยากรณ์

xeger(regex)

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

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

ตัวอย่าง

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

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, โหนด, ตัวเลข, บูลีน, สตริง โดยมีค่าเริ่มต้นเป็น 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>

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

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

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

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

ไวยากรณ์

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

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

(ต้องระบุ) json-path: (สตริง) นิพจน์เส้นทาง JSON
(ต้องระบุ) json-var: (สตริง) ตัวแปรหรือสตริงโฟลว์ที่มี JSON
(ไม่บังคับ) want-array: (สตริง) หากเป็นเช่นนี้ พารามิเตอร์ได้รับการตั้งค่าเป็น 'true' และถ้าชุดผลลัพธ์เป็นอาร์เรย์ องค์ประกอบอาร์เรย์ทั้งหมด ส่งคืนแล้ว หากตั้งเป็นค่าอื่นหรือค่านี้ ละเว้นพารามิเตอร์ ระบบจะทำเพียง ระบบจะแสดงผลอีลิเมนต์ศูนย์ของอาร์เรย์ชุดผลลัพธ์ ถ้าชุดผลลัพธ์ไม่ใช่อาร์เรย์ ระบบจะไม่สนใจพารามิเตอร์ที่ 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']