Poznámka:
Přístup k této stránce vyžaduje autorizaci. Můžete se zkusit přihlásit nebo změnit adresáře.
Přístup k této stránce vyžaduje autorizaci. Můžete zkusit změnit adresáře.
Platí pro: Azure Logic Apps (Consumption + Standard)
U definic pracovních postupů v Azure Logic Apps a Power Automate získají některé výrazy hodnoty z akcí modulu runtime, které ještě nemusí existovat při spuštění pracovního postupu. K odkazování nebo zpracování hodnot v těchto výrazech můžete použít funkce výrazů poskytované jazykem definice pracovního postupu.
Note
Tato referenční příručka se týká Azure Logic Apps i Power Automate, ale existuje v dokumentaci k Azure Logic Apps. I když průvodce odkazuje konkrétně na pracovní postupy aplikací logiky, tyto funkce fungují pro oba toky v Power Automate a pracovních postupech v Azure Logic Apps. Další informace o funkcích a výrazech v Power Automate najdete v tématu Použití výrazů v podmínkách.
Hodnoty můžete například vypočítat pomocí matematických funkcí, jako je například funkce add(), pokud chcete součet z celých čísel nebo plovoucích hodnot. Tady jsou další ukázkové úlohy, které můžete s funkcemi provádět:
| Task | Syntaxe funkce | Result |
|---|---|---|
| Vrátit řetězec v malých písmenech. | toLower('<text>') Příklad: toLower('Hello') |
"hello" |
| Vrátí globálně jedinečný identifikátor (GUID). | guid() | "c2ecc88d-88c8-4096-912c-d6f2e2b138ce" |
Pokud chcete najít funkce založené na jejich obecném účelu, projděte si následující tabulky. Nebo podrobné informace o jednotlivých funkcích najdete v abecedním seznamu.
Funkce ve výrazech
Chcete-li ukázat, jak použít funkci ve výrazu, tento příklad ukazuje, jak můžete získat hodnotu z parametru customerName a přiřadit tuto hodnotu vlastnosti accountName pomocí funkce parameters() ve výrazu:
"accountName": "@parameters('customerName')"
Tady jsou některé další obecné způsoby použití funkcí ve výrazech:
| Task | Syntaxe funkce ve výrazu |
|---|---|
| Proveďte práci s položkou předáním této položky do funkce. | "@<functionName>(<item>)" |
1. Získejte hodnotu parametrName pomocí vnořené parameters() funkce. 2. Proveďte práci s výsledkem předáním této hodnoty do functionName. |
<@functionName>(parameters('<parameterName>')) |
| 1. Získá výsledek z vnořené vnitřní funkce functionName. 2. Předejte výsledek do vnější funkce functionName2. |
"@<functionName2>(<functionName(><item>))" |
| 1. Získá výsledek z functionName. 2. Vzhledem k tomu, že výsledkem je objekt s vlastností propertyName, získejte hodnotu této vlastnosti. |
"@<functionName>(<item>).<propertyName>" |
Funkce může například concat() jako parametry vzít dvě nebo více řetězcových hodnot. Tato funkce kombinuje tyto řetězce do jednoho řetězce. Můžete zadat řetězcové literály, například "Sophia" a "Owen", aby výsledkem byl kombinovaný řetězec "SophiaOwen".
"customerName": "@concat('Sophia', 'Owen')"
Nebo můžete získat řetězcové hodnoty z parametrů. Tento příklad používá funkci parameters() v každém parametru concat() a v parametrech firstName a lastName. Výsledné řetězce concat() pak předáte funkci, abyste získali kombinovaný řetězec, například "SophiaOwen":
"customerName": "@concat(parameters('firstName'), parameters('lastName'))"
V obou případech oba příklady přiřazují výsledek vlastnosti customerName .
Důležité informace o používání funkcí
Návrhář nevyhodnocuje výrazy modulu runtime, které se v době návrhu používají jako parametry funkce. Návrhář vyžaduje, aby všechny výrazy mohly být plně vyhodnoceny v době návrhu.
Parametry funkce se vyhodnocují zleva doprava.
V syntaxi definic parametrů otazník (?), který se zobrazí za parametrem, znamená, že parametr je nepovinný. Příklad: getFutureTime().
Výrazy funkcí, které se objevují v řádku společně s prostým textem, vyžadují ohraničení složenými závorkami ({}), aby byl použit interpolovaný formát výrazu. Tento formát pomáhá předcházet problémům při analýze. Pokud se výraz funkce nezobrazuje přímo jako obyčejný text, pak nejsou zapotřebí žádné složené závorky.
Následující příklad ukazuje správnou a nesprávnou syntaxi:
Správně:
"<text>/@{<function-name>('<parameter-name>')}/<text>"Nesprávná odpověď:
"<text>/@<function-name>('<parameter-name>')/<text>"Dobře:
"@<function-name>('<parameter-name>')"
Následující části uspořádají funkce na základě jejich obecného účelu nebo můžete tyto funkce procházet v abecedním pořadí.
Řetězcové funkce
Pro práci s řetězci můžete použít tyto řetězcové funkce a také některé funkce kolekce. Řetězcové funkce fungují jenom na řetězcích.
| String | Task |
|---|---|
| chunk | Rozdělte řetězec nebo kolekci na bloky stejné délky. |
| concat | Zkombinujte dva nebo více řetězců a vraťte sloučený řetězec. |
| endsWith | Zkontrolujte, jestli řetězec končí zadaným podřetězcem. |
| formatNumber | Vrátí číslo jako řetězec na základě zadaného formátu. |
| guid | Vygenerujte globálně jedinečný identifikátor (GUID) jako řetězec. |
| indexOf | Vrátit počáteční pozici podřetězce. |
| isFloat | Vrátí boolean, který určuje, zda je řetězec desetinné číslo. |
| isInt | Vrátí logickou hodnotu, která určuje, jestli je řetězec celé číslo. |
| lastIndexOf | Vrať počáteční pozici posledního výskytu podřetězce. |
| length | Vrátí počet položek v řetězci nebo poli. |
| nthIndexOf | Vrátí počáteční pozici nebo hodnotu indexu, kde sev řetězci zobrazí n. výskyt podřetězce. |
| replace | Nahraďte podřetězce zadaným řetězcem a vraťte aktualizovaný řetězec. |
| slice | Vrátí podřetězec určením počáteční a koncové pozice nebo hodnot. Viz také podřetěžce. |
| split | Vrátí pole, které obsahuje podřetězce oddělené čárkami, od většího řetězce založeného na zadaném znaku oddělovače v původním řetězci. |
| startsWith | Zkontrolujte, jestli řetězec začíná určitým podřetězcem. |
| substring | Vrátí znaky z řetězce počínaje zadanou pozicí. Viz také řez. |
| toLower | Vrátit řetězec v malých písmenech. |
| toUpper | Vrátí řetězec ve formátu velkými písmeny. |
| trim | Odstraňte počáteční a koncové prázdné znaky z řetězce a vraťte aktualizovaný řetězec. |
Funkce kolekcí
Pokud chcete pracovat s kolekcemi, obecně polemi, řetězci a někdy slovníky, můžete tyto funkce kolekce používat.
| Funkce Kolekce | Task |
|---|---|
| chunk | Rozdělte řetězec nebo kolekci na bloky stejné délky. |
| contains | Zkontrolujte, jestli kolekce obsahuje konkrétní položku. |
| empty | Zkontrolujte, jestli je kolekce prázdná. |
| first | Vrátí první položku z kolekce. |
| intersection | Vrátí kolekci, která obsahuje pouze společné položky v zadaných kolekcích. |
| item | Pokud se tato funkce zobrazí uvnitř opakující se akce nad polem, vrátí aktuální položku v poli během aktuální iterace akce. |
| join | Vrátí řetězec, který obsahuje všechny položky z pole oddělené zadaným znakem. |
| last | Vrátí poslední položku z kolekce. |
| length | Vrátí počet položek v řetězci nebo poli. |
| reverse | Obrácení pořadí položek v poli |
| skip | Odeberte položky z přední části kolekce a vraťte všechny ostatní položky. |
| sort | Seřaďte položky v kolekci. |
| take | Vrátí položky z přední části kolekce. |
| union | Vrátí kolekci, která obsahuje všechny položky ze zadaných kolekcí. |
Logické porovnávací funkce
Pokud chcete pracovat s podmínkami, porovnávat hodnoty a výsledky výrazů nebo vyhodnocovat různé druhy logiky, můžete použít tyto logické porovnávací funkce. Úplný odkaz na jednotlivé funkce najdete v abecedním seznamu.
Note
Pokud k porovnání hodnot používáte logické funkce nebo podmínky, hodnoty null se převedou na prázdné hodnoty řetězce (""). Chování podmínek se liší při porovnávání s prázdným řetězcem místo hodnoty null. Další informace najdete v řetězcové funkci.
| Logická funkce porovnání | Task |
|---|---|
| and | Zkontrolujte, jestli jsou všechny výrazy pravdivé. |
| equals | Zkontrolujte, jestli jsou obě hodnoty ekvivalentní. |
| greater | Zkontrolujte, jestli je první hodnota větší než druhá hodnota. |
| greaterOrEquals | Zkontrolujte, jestli je první hodnota větší nebo rovna druhé hodnotě. |
| if | Zkontrolujte, jestli je výraz pravdivý nebo nepravda. Na základě výsledku vrátí zadanou hodnotu. |
| isFloat | Vrátí boolean, který určuje, zda je řetězec desetinné číslo. |
| isInt | Vrátí logickou hodnotu, která určuje, jestli je řetězec celé číslo. |
| less | Zkontrolujte, jestli je první hodnota menší než druhá hodnota. |
| lessOrEquals | Zkontrolujte, jestli je první hodnota menší nebo rovna druhé hodnotě. |
| not | Zkontrolujte, jestli je výraz nepravda. |
| or | Zkontrolujte, jestli je alespoň jeden výraz pravdivý. |
Převodní funkce
Pokud chcete změnit typ nebo formát hodnoty, můžete použít tyto převodní funkce. Můžete například změnit hodnotu z logické hodnoty na celé číslo. Další informace o tom, jak Azure Logic Apps zpracovává typy obsahu během převodu, najdete v tématu Zpracování typů obsahu. Úplný odkaz na jednotlivé funkce najdete v abecedním seznamu.
Note
Azure Logic Apps automaticky nebo implicitně provádí kódování a dekódování base64, takže tyto převody nemusíte provádět ručně pomocí funkcí kódování a dekódování. Pokud však tyto funkce přesto použijete v návrhovém prostředí, může docházet k neočekávanému chování vykreslování. Toto chování má vliv pouze na viditelnost funkcí a ne na jejich účinek, pokud neupravíte hodnoty parametrů funkcí, které z kódu odeberou funkce a jejich efekty. Další informace naleznete v tématu Implicitní převody datových typů.
| Převodní funkce | Task |
|---|---|
| array | Vrátí pole z jednoho zadaného vstupu. Více vstupů naleznete v tématu createArray. |
| base64 | Vrátí verzi zakódovanou v base64 pro řetězec. |
| base64ToBinary | Vrátit binární verzi řetězce zakódovaného pomocí base64. |
| base64ToString | Vrátí textovou verzi pro řetězec, který je kódovaný v base64. |
| binary | Vrátit binární podobu zadané hodnoty. |
| bool | Vrátí logickou verzi pro vstupní hodnotu. |
| createArray | Vrátíme pole z více vstupů. |
| dataUri | Vrátí datový URI pro vstupní hodnotu. |
| dataUriToBinary | Vrátit binární verzi datového URI. |
| dataUriToString | Vrátí textovou reprezentaci pro datový URI. |
| decimal | Vrátí desetinné číslo pro desetinný řetězec. |
| decodeBase64 | Vrátí textovou verzi pro řetězec, který je kódovaný v base64. |
| decodeDataUri | Vrátit binární verzi datového URI. |
| decodeUriComponent | Vrátí řetězec, ve kterém jsou únikové znaky nahrazeny dekódovanými verzemi. |
| encodeUriComponent | Vrátí řetězec, který nahradí znaky, které nejsou bezpečné pro URL, escape sekvencemi. |
| float | Vrátí číslo s plovoucí čárkou pro danou hodnotu. |
| int | Vrátit celočíselnou verzi pro řetězec. |
| json | Vrátí hodnotu typu JSON (JavaScript Object Notation) nebo objekt pro řetězec nebo XML. |
| string | Vrátí textovou podobu pro zadanou hodnotu. |
| uriComponent | Vrátí verzi zakódovanou ve formátu URI pro vstupní hodnotu tím, že nebezpečné znaky pro URL nahradí escapovacími znaky. |
| uriComponentToBinary | Vrátí binární verzi řetězce kódovaného identifikátorem URI. |
| uriComponentToString | Vrátí textovou verzi pro URI-kódovaný řetězec. |
| xml | Vrátí verzi XML pro řetězec. |
Implicitní převody datových typů
Azure Logic Apps automaticky nebo implicitně převádí mezi některými datovými typy, takže tyto převody nemusíte provádět ručně. Pokud například použijete neřetězcové hodnoty, u kterých se řetězce očekávají jako vstupy, Azure Logic Apps automaticky převede neřetězcové hodnoty na řetězce.
Předpokládejme například, že trigger vrátí číselnou hodnotu jako výstup:
triggerBody()?['123']
Pokud použijete tento číselný výstup, ve kterém se očekává zadání řetězce, jako je adresa URL, Azure Logic Apps automaticky převede hodnotu na řetězec pomocí zápisu složených závorek ({}):
@{triggerBody()?['123']}
Kódování a dekódování Base64
Azure Logic Apps automaticky nebo implicitně provádí kódování nebo dekódování base64, takže tyto převody nemusíte provádět ručně pomocí odpovídajících funkcí:
base64(<value>)base64ToBinary(<value>)base64ToString(<value>)base64(decodeDataUri(<value>))concat('data:;base64,',<value>)concat('data:,',encodeUriComponent(<value>))decodeDataUri(<value>)
Note
Pokud při použití návrháře ručně přidáte některou z těchto funkcí, ať už přímo k spouštěči nebo akci, nebo pomocí editoru výrazů, když opustíte návrháře a následně se vrátíte, funkce zmizí z návrháře a zůstanou jen hodnoty parametrů. K tomuto chování dochází také v případě, že vyberete trigger nebo akci, která tuto funkci používá bez úprav hodnot parametrů funkce. Tento výsledek ovlivní jenom viditelnost funkce a ne efekt. V zobrazení kódu nemá tato funkce vliv. Pokud ale upravíte hodnoty parametrů funkce, funkce i její účinek se odeberou ze zobrazení kódu, takže zůstane za pouze hodnotami parametrů funkce.
Matematické funkce
Pokud chcete pracovat s celými čísly a plovoucími hodnotami, můžete použít tyto matematické funkce. Úplný odkaz na jednotlivé funkce najdete v abecedním seznamu.
| Matematické funkce | Task |
|---|---|
| add | Vrátí výsledek sčítání dvou čísel. |
| div | Vrátí výsledek dělení dvou čísel. |
| max | Vrátí nejvyšší hodnotu ze sady čísel nebo pole. |
| min | Vrátí nejnižší hodnotu ze sady čísel nebo pole. |
| mod | Vrátí zbytek z dělení dvou čísel. |
| mul | Vrátí součin od vynásobení dvou čísel. |
| rand | Vrátí náhodné celé číslo ze zadaného rozsahu. |
| range | Vrátí celočíselnou matici, která začíná zadaným celočíselnou hodnotou. |
| sub | Vrátí výsledek od odečtení druhého čísla od prvního čísla. |
Funkce pro datum a čas
K práci s daty a časy můžete použít tyto funkce data a času. Úplný odkaz na jednotlivé funkce najdete v abecedním seznamu.
| Funkce data nebo času | Task |
|---|---|
| addDays | Zvyšte počet dní v časovém razítku. |
| addHours | Přidejte hodiny k časovému razítku. |
| addMinutes | Přidejte minuty do časového razítka. |
| addSeconds | Přidejte sekundy do časového razítka. |
| addToTime | Přidejte zadané časové jednotky do časového razítka. Viz také getFutureTime. |
| convertFromUtc | Převeďte časové razítko z standardu UTC (Universal Time Coordinated) na cílové časové pásmo. |
| convertTimeZone | Převeďte časové razítko ze zdrojového časového pásma na cílové časové pásmo. |
| convertToUtc | Převeďte časové razítko ze zdrojového časového pásma na standard UTC (Universal Time Coordinated). |
| dateDifference | Vrátí rozdíl mezi dvěma daty jako časový interval. |
| dayOfMonth | Vrátí den součásti měsíce z časového razítka. |
| dayOfWeek | Vrátí součást dne v týdnu z časového razítka. |
| dayOfYear | Vrátí část dne v roce z časového razítka. |
| formatDateTime | Vrátí datum z časového razítka. |
| getFutureTime | Vrátí aktuální časové razítko a zadané časové jednotky. Viz také addToTime. |
| getPastTime | Vrátí aktuální časové razítko minus zadané časové jednotky. Viz také odečítáníFromTime. |
| parseDateTime | Vrátí časové razítko z řetězce, který obsahuje časové razítko. |
| startOfDay | Vrátí začátek dne podle časové značky. |
| startOfHour | Vrátí začátek hodiny na časovém razítku. |
| startOfMonth | Vrátit začátek měsíce pro časové razítko. |
| subtractFromTime | Odečte počet časových jednotek od časového razítka. Viz také getPastTime. |
| ticks | Vrátí hodnotu vlastnosti ticks pro zadané časové razítko. |
| utcNow | Vrátí aktuální časové razítko jako řetězec. |
Funkce pracovního postupu
Tyto funkce pracovního postupu vám můžou pomoct:
- Získejte podrobnosti o instanci pracovního postupu během běhu.
- Pracujte se vstupy používanými k vytváření instancí logických aplikací nebo workflowů.
- Odkazujte na výstupy z triggerů a akcí.
Můžete například odkazovat na výstupy z jedné akce a tato data použít v pozdější akci. Úplný odkaz na jednotlivé funkce najdete v abecedním seznamu.
| Pracovní postup | Task |
|---|---|
| action | Vrátí výstup aktuální akce za běhu nebo hodnoty z jiných dvojic názvů a hodnot JSON. Viz také akce. |
| actions | Vrátí výstup akce za běhu nebo hodnoty z jiných dvojic názvů a hodnot JSON. Viz také akce. |
| body | Vrátí výstup akce body během běhu programu. |
| formDataMultiValues | Vytvořte pole s hodnotami, které odpovídají názvu klíče ve výstupech akcí s daty formuláře nebo kódovanými formulářem . |
| formDataValue | Vrátí jednu hodnotu, která odpovídá názvu klíče ve výstupu s daty formuláře nebo kódovaným formulářem akce. |
| item | Pokud se tato funkce zobrazí uvnitř opakující se akce nad polem, vrátí aktuální položku v poli během aktuální iterace akce. |
| items | Pokud se tato funkce zobrazí uvnitř smyčky Foreach nebo Until, vrátí aktuální položku ze zadané smyčky. |
| iterationIndexes | Pokud se tato funkce zobrazí uvnitř smyčky Until, vrátí hodnotu indexu pro aktuální iteraci. Tuto funkci můžete použít uvnitř vnořených smyček Until. |
| listCallbackUrl | Vrátit "callback URL" pro vyvolání události nebo akce. |
| multipartBody | Získej tělo pro konkrétní část ve výstupu z akce, obsahující více částí. |
| outputs | Vrátí výstup akce za běhu. |
| parameters | Vrátí hodnotu parametru popsaného v definici pracovního postupu. |
| result | Vrátí vstupy a výstupy z akcí nejvyšší úrovně uvnitř zadané akce s vymezeným oborem, například For_each, Untila Scope. |
| trigger | Vrátí výstup triggeru během běhu programu, nebo z ostatních dvojic názvů a hodnot v JSONu. Viz také triggerOutputs a triggerBody. |
| triggerBody | Vrátí výstup triggeru body za běhu. Viz trigger. |
| triggerFormDataValue | Vrátí jednu hodnotu odpovídající názvu klíče ve výstupech aktivačních událostí s daty formuláře nebo kódovanými formulářem . |
| triggerMultipartBody | Vrátí tělo pro konkrétní část ve vícedílném výstupu spouštěče. |
| triggerFormDataMultiValues | Vytvořte pole, jehož hodnoty odpovídají názvu klíče ve výstupech aktivačních událostí zakódovaných veformulářových datech nebo ve formátu. |
| triggerOutputs | Vrátí výstup triggeru během spuštění nebo hodnoty z jiných dvojic názvů a hodnot JSON. Viz trigger. |
| variables | Vrátí hodnotu pro zadanou proměnnou. |
| workflow | Vrátí všechny podrobnosti o pracovním postupu během jeho provádění. |
Funkce analýzy identifikátoru URI
Pokud chcete pracovat s identifikátory URI (Uniform Resource Identifier) a získat různé hodnoty vlastností pro tyto identifikátory URI, můžete použít tyto funkce analýzy identifikátorů URI. Úplný odkaz na jednotlivé funkce najdete v abecedním seznamu.
| Funkce analýzy identifikátoru URI | Task |
|---|---|
| uriHost | Vrátit hodnotu host pro URI (Uniform Resource Identifier). |
| uriPath | Vrátit hodnotu path pro URI (Uniform Resource Identifier). |
| uriPathAndQuery | Vraťte hodnoty path a query pro identifikátor URI (Uniform Resource Identifier). |
| uriPort | Vrátit hodnotu port pro URI (Uniform Resource Identifier). |
| uriQuery | Vrátit hodnotu query pro URI (Uniform Resource Identifier). |
| uriScheme | Vrátit hodnotu scheme pro URI (Uniform Resource Identifier). |
Manipulační funkce: JSON a XML
Pokud chcete pracovat s objekty JSON a uzly XML, můžete použít tyto funkce pro manipulaci. Úplný odkaz na jednotlivé funkce najdete v abecedním seznamu.
| Funkce manipulace | Task |
|---|---|
| addProperty | Přidejte vlastnost a její hodnotu nebo dvojici name-value do objektu JSON a vraťte aktualizovaný objekt. |
| coalesce | Vrátí první hodnotu, která není null, z jednoho nebo více parametrů. |
| removeProperty | Odeberte vlastnost z objektu JSON a vraťte aktualizovaný objekt. |
| setProperty | Nastavte hodnotu vlastnosti objektu JSON a vraťte aktualizovaný objekt. |
| xpath | Zkontrolujte kód XML pro uzly nebo hodnoty, které odpovídají výrazu XPath (XML Path Language) a vrátí odpovídající uzly nebo hodnoty. |
---------------------------------
Všechny funkce – abecední seznam
V této části jsou uvedeny všechny dostupné funkce v abecedním pořadí.
A
akce
Vrátí výstup aktuální akce za běhu nebo hodnoty z jiných dvojic názvů a hodnot JSON, které můžete přiřadit k výrazu. Ve výchozím nastavení tato funkce odkazuje na celý objekt akce, ale volitelně můžete zadat vlastnost, jejíž hodnotu chcete. Viz také akce().
Funkci můžete použít action() pouze na těchto místech:
- Vlastnost
unsubscribepro akci webhook, aby byl přístup k výsledku původníhosubscribepožadavku lépe dostupný. - Vlastnost
trackedPropertiesakce - Podmínka
do-untilsmyčky pro akci
action()
action().outputs.body.<property>
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < vlastnost> | No | String | Název vlastnosti objektu akce, jehož hodnotu chcete: name, startTime, endTime, vstupy, výstupy, stav, kód, trackingId a clientTrackingId. Na webu Azure Portal najdete tyto vlastnosti tak, že si projdete podrobnosti konkrétní historie spuštění. Další informace najdete v tématu REST API – Akce spuštění pracovního postupu. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Akce-výstup> | Object | Výstup objektu JSON z aktuální akce nebo vlastnosti |
actions
Vrátí výstup akce za běhu nebo hodnoty z jiných dvojic názvů a hodnot JSON, které můžete přiřadit k výrazu. Ve výchozím nastavení funkce odkazuje na celý objekt akce, ale volitelně můžete zadat vlastnost, jejíž hodnotu chcete. Zkrácené verze najdete v části body(). Aktuální akci naleznete v části action().
Note
Dříve můžete použít actions() funkci nebo conditions prvek při určení, že akce běžela na základě výstupu jiné akce. Chcete-li však deklarovat explicitní závislosti mezi akcemi, musíte nyní použít vlastnost závislé akce runAfter .
Další informace o vlastnosti runAfter naleznete v tématu Zachycení a zpracování selhání pomocí vlastnosti runAfter.
actions('<actionName>')
actions('<actionName>').outputs.body.<property>
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < actionNázev> | Yes | String | Název objektu akce, jehož výstup chcete |
| < vlastnost> | No | String | Název vlastnosti objektu akce, jehož hodnotu chcete: name, startTime, endTime, vstupy, výstupy, stav, kód, trackingId a clientTrackingId. Na webu Azure Portal najdete tyto vlastnosti tak, že si projdete podrobnosti konkrétní historie spuštění. Další informace najdete v tématu REST API – Akce spuštění pracovního postupu. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Akce-výstup> | Object | Výstup objektu JSON ze zadané akce nebo vlastnosti |
Example
Tento příklad získá status hodnotu vlastnosti z akce X Get user při běhu:
actions('Get_user').outputs.body.status
A vrátí tento výsledek: "Succeeded"
add
Vrátí výsledek sčítání dvou čísel.
add(<summand_1>, <summand_2>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < >summand_1, <summand_2> | Yes | Celé číslo, plovoucí nebo smíšené | Čísla, která se mají sčítat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < výsledek-součet> | Celé číslo nebo plovoucí číslo | Výsledek sčítání zadaných čísel |
Example
Tento příklad sečte zadaná čísla:
add(1, 1.5)
A vrátí tento výsledek: 2.5
addDays
Zvyšte počet dní v časovém razítku.
addDays('<timestamp>', <days>, '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < Dny> | Yes | Integer | Počet kladných nebo záporných dnů, které se mají přidat |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Časové razítko plus zadaný počet dnů |
Příklad 1
Tento příklad přidá 10 dní do zadaného časového razítka:
addDays('2018-03-15T00:00:00Z', 10)
A vrátí tento výsledek: "2018-03-25T00:00:00.0000000Z"
Příklad 2
Tento příklad odečte pět dnů od zadaného časového razítka:
addDays('2018-03-15T00:00:00Z', -5)
A vrátí tento výsledek: "2018-03-10T00:00:00.0000000Z"
addHours
Přidejte hodiny k časovému razítku.
addHours('<timestamp>', <hours>, '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < hodiny> | Yes | Integer | Počet kladných nebo záporných hodin, které se mají přidat |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Časové razítko plus zadaný počet hodin |
Příklad 1
Tento příklad přidá 10 hodin do zadaného časového razítka:
addHours('2018-03-15T00:00:00Z', 10)
A vrátí tento výsledek: "2018-03-15T10:00:00.0000000Z"
Příklad 2
Tento příklad odečte pět hodin od zadaného časového razítka:
addHours('2018-03-15T15:00:00Z', -5)
A vrátí tento výsledek: "2018-03-15T10:00:00.0000000Z"
addMinutes
Přidejte minuty do časového razítka.
addMinutes('<timestamp>', <minutes>, '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < minuty> | Yes | Integer | Počet kladných nebo záporných minut, které se mají přidat |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Časové razítko plus zadaný počet minut |
Příklad 1
Tento příklad přidá 10 minut do zadaného časového razítka:
addMinutes('2018-03-15T00:10:00Z', 10)
A vrátí tento výsledek: "2018-03-15T00:20:00.0000000Z"
Příklad 2
Tento příklad odečte pět minut od zadaného časového razítka:
addMinutes('2018-03-15T00:20:00Z', -5)
A vrátí tento výsledek: "2018-03-15T00:15:00.0000000Z"
addProperty
Přidejte vlastnost a její hodnotu nebo dvojici name-value do objektu JSON a vraťte aktualizovaný objekt. Pokud vlastnost již existuje za běhu, funkce selže a vyvolá chybu.
addProperty(<object>, '<property>', <value>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < objekt> | Yes | Object | Objekt JSON, do kterého chcete přidat vlastnost |
| < vlastnost> | Yes | String | Název vlastnosti, která se má přidat |
| < hodnota> | Yes | Any | Hodnota vlastnosti |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < updated-object> | Object | Aktualizovaný objekt JSON se zadanou vlastností |
Chcete-li přidat nadřazenou vlastnost do existující vlastnosti, použijte setProperty() funkci, nikoli addProperty() funkci. V opačném případě vrátí funkce jako výstup pouze podřízený objekt.
setProperty(<object>, '<parent-property>', addProperty(<object>['<parent-property>'], '<child-property>', <value>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < objekt> | Yes | Object | Objekt JSON, do kterého chcete přidat vlastnost |
| < mateřské vlastnictví> | Yes | String | Název nadřazené vlastnosti, kam chcete přidat podřízenou vlastnost |
| < dětský majetek> | Yes | String | Název podřízené vlastnosti, která se má přidat |
| < hodnota> | Yes | Any | Hodnota nastavená pro zadanou vlastnost |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < updated-object> | Object | Aktualizovaný objekt JSON, jehož vlastnost jste nastavili |
Příklad 1
Tento příklad přidá middleName vlastnost do objektu JSON, který se převede z řetězce na JSON pomocí funkce JSON(). Objekt již obsahuje firstName vlastnosti a surName vlastnosti. Funkce přiřadí zadanou hodnotu nové vlastnosti a vrátí aktualizovaný objekt:
addProperty(json('{ "firstName": "Sophia", "lastName": "Owen" }'), 'middleName', 'Anne')
Tady je aktuální objekt JSON:
{
"firstName": "Sophia",
"surName": "Owen"
}
Tady je aktualizovaný objekt JSON:
{
"firstName": "Sophia",
"middleName": "Anne",
"surName": "Owen"
}
Příklad 2
Tento příklad přidá podřízenou middleName vlastnost do existující customerName vlastnosti v objektu JSON, který se převede z řetězce na JSON pomocí funkce JSON(). Funkce přiřadí zadanou hodnotu nové vlastnosti a vrátí aktualizovaný objekt:
setProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }'), 'customerName', addProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }')['customerName'], 'middleName', 'Anne'))
Tady je aktuální objekt JSON:
{
"customerName": {
"firstName": "Sophia",
"surName": "Owen"
}
}
Tady je aktualizovaný objekt JSON:
{
"customerName": {
"firstName": "Sophia",
"middleName": "Anne",
"surName": "Owen"
}
}
addSeconds
Přidejte sekundy do časového razítka.
addSeconds('<timestamp>', <seconds>, '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < sekundy> | Yes | Integer | Počet kladných nebo záporných sekund, které se mají přidat |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Časové razítko plus zadaný počet sekund |
Příklad 1
Tento příklad přidá 10 sekund do zadaného časového razítka:
addSeconds('2018-03-15T00:00:00Z', 10)
A vrátí tento výsledek: "2018-03-15T00:00:10.0000000Z"
Příklad 2
Tento příklad odečte pět sekund od zadaného časového razítka:
addSeconds('2018-03-15T00:00:30Z', -5)
A vrátí tento výsledek: "2018-03-15T00:00:25.0000000Z"
addToTime
Přidejte zadané časové jednotky do časového razítka. Viz také getFutureTime().
addToTime('<timestamp>', <interval>, '<timeUnit>', '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < interval> | Yes | Integer | Počet zadaných časových jednotek, které se mají přidat |
| < timeUnit> | Yes | String | Jednotka času, která se má použít s intervalem: "Second", "Minute", "Hour", "Day", "Week", "Month", "Year" |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Časové razítko plus zadaný počet časových jednotek |
Příklad 1
Tento příklad přidá jeden den do zadaného časového razítka:
addToTime('2018-01-01T00:00:00Z', 1, 'Day')
A vrátí tento výsledek: "2018-01-02T00:00:00.0000000Z"
Příklad 2
Tento příklad přidá jeden den do zadaného časového razítka:
addToTime('2018-01-01T00:00:00Z', 1, 'Day', 'D')
A vrátí výsledek pomocí volitelného formátu "D": "Tuesday, January 2, 2018"
and
Zkontrolujte, jestli jsou všechny výrazy pravdivé. Vrátí hodnotu true, pokud jsou všechny výrazy pravdivé, nebo vrátí hodnotu false, pokud je alespoň jeden výraz false.
and(<expression1>, <expression2>, ...)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < výraz1>, <výraz2>, ... | Yes | logický | Výrazy k ověření |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, pokud jsou splněny všechny výrazy. Vrátí hodnotu false, pokud je alespoň jeden výraz false. |
Příklad 1
Tyto příklady kontrolují, jestli jsou zadané logické hodnoty pravdivé:
and(true, true)
and(false, true)
and(false, false)
A vrátí tyto výsledky:
- První příklad: Oba výrazy jsou pravdivé, takže vrátí
true. - Druhý příklad: Jeden výraz je false, takže vrátí
false. - Třetí příklad: Oba výrazy jsou false, takže vrátí
false.
Příklad 2
Tyto příklady kontrolují, jestli jsou zadané výrazy pravdivé:
and(equals(1, 1), equals(2, 2))
and(equals(1, 1), equals(1, 2))
and(equals(1, 2), equals(1, 3))
A vrátí tyto výsledky:
- První příklad: Oba výrazy jsou pravdivé, takže vrátí
true. - Druhý příklad: Jeden výraz je false, takže vrátí
false. - Třetí příklad: Oba výrazy jsou false, takže vrátí
false.
pole
Vrátí pole z jednoho zadaného vstupu. Více vstupů najdete v tématu createArray().
array('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec pro vytvoření pole |
| Návratová hodnota | Typ | Description |
|---|---|---|
| [<hodnota>] | Array | Pole obsahující jeden zadaný vstup |
Example
Tento příklad vytvoří pole z řetězce "hello":
array('hello')
A vrátí tento výsledek: ["hello"]
B
base64
Vrátí verzi zakódovanou v base64 pro řetězec.
Note
Azure Logic Apps automaticky nebo implicitně provádí kódování a dekódování base64, takže tyto převody nemusíte provádět ručně pomocí funkcí kódování a dekódování. Pokud ale tyto funkce přesto používáte, může dojít k neočekávanému chování vykreslování v návrháři. Toto chování má vliv pouze na viditelnost funkcí a ne na jejich účinek, pokud neupravíte hodnoty parametrů funkcí, které z kódu odeberou funkce a jejich efekty. Další informace naleznete v tématu Kódování a dekódování Base64.
base64('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Vstupní řetězec |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < base64-string> | String | Verze kódovaná v base64 pro vstupní řetězec |
Example
Tento příklad převede řetězec "hello" na řetězec s kódováním base64:
base64('hello')
A vrátí tento výsledek: "aGVsbG8="
base64ToBinary
Vrátit binární verzi řetězce zakódovaného pomocí base64.
Note
Azure Logic Apps automaticky nebo implicitně provádí kódování a dekódování base64, takže tyto převody nemusíte provádět ručně pomocí funkcí kódování a dekódování. Pokud však tyto funkce přesto použijete v návrhovém prostředí, může docházet k neočekávanému chování vykreslování. Toto chování má vliv pouze na viditelnost funkcí a ne na jejich účinek, pokud neupravíte hodnoty parametrů funkcí, které z kódu odeberou funkce a jejich efekty. Další informace naleznete v tématu Kódování a dekódování Base64.
base64ToBinary('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec s kódováním base64 pro převod |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < binární-pro-base64-string> | String | Binární verze řetězce s kódováním base64 |
Example
Tento příklad převede řetězec s kódováním base64 "aGVsbG8=" na binární řetězec:
base64ToBinary('aGVsbG8=')
Předpokládejme například, že k odeslání požadavku používáte akci HTTP. Můžete použít base64ToBinary() k převodu řetězce s kódováním base64 na binární data a odeslání dat pomocí application/octet-stream typu obsahu v požadavku.
base64ToString
Vraťte textovou reprezentaci pro base64-kódovaný řetězec, čímž efektivně dekódujete řetězec base64. Tuto funkci použijte místo dekódováníBase64(), která je zastaralá.
Note
Azure Logic Apps automaticky nebo implicitně provádí kódování a dekódování base64, takže tyto převody nemusíte provádět ručně pomocí funkcí kódování a dekódování. Pokud však tyto funkce přesto použijete v návrhovém prostředí, může docházet k neočekávanému chování vykreslování. Toto chování má vliv pouze na viditelnost funkcí a ne na jejich účinek, pokud neupravíte hodnoty parametrů funkcí, které z kódu odeberou funkce a jejich efekty. Další informace naleznete v tématu Kódování a dekódování Base64.
base64ToString('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec kódovaný v base64 pro dekódování |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < dekódovaný řetězec base64> | String | Řetězcová verze pro řetězec zakódovaný pomocí Base64 |
Example
Tento příklad převede Base64 kódovaný řetězec "aGVsbG8=" na obyčejný text.
base64ToString('aGVsbG8=')
A vrátí tento výsledek: "hello"
binární
Vrátí řetězec zakódovaný pomocí base64 ve formátu binárního.
binary('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec který se má převést |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < binární pro vstupní hodnotu> | String | Binární verze s kódováním base64 pro zadaný řetězec |
Example
Například používáte akci HTTP, která vrací obrázek nebo videosoubor. Tuto hodnotu můžete použít binary() k převodu hodnoty na model obálky obsahu s kódováním base-64. Pak můžete obálku obsahu znovu použít v jiných akcích, například Compose.
Tento výraz funkce můžete použít k odeslání bajtů řetězců s typem application/octet-stream obsahu v požadavku.
body
Vrátí výstup akce body během běhu programu. Zkratka pro actions('<actionName>').outputs.body. Viz actions().
body('<actionName>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < actionNázev> | Yes | String | Název požadovaného body výstupu akce |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Akce-tělo-výstup> | String | Výstup body ze zadané akce |
Example
Tento příklad získá body výstup z Get user akce X:
body('Get_user')
A vrátí tento výsledek:
"body": {
"FullName": "Contoso Corporation",
"Location": "Generic Town, USA",
"Id": 283541717,
"UserName": "ContosoInc",
"FollowersCount": 172,
"Description": "Leading the way in transforming the digital workplace.",
"StatusesCount": 93,
"FriendsCount": 126,
"FavouritesCount": 46,
"ProfileImageUrl": "https://pbs.twimg.com/profile_images/908820389907722240/gG9zaHcd_400x400.jpg"
}
bool
Vrátí logickou verzi hodnoty.
bool(<value>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | Any | Hodnota k převodu na logickou hodnotu. |
Pokud používáte bool() s objektem, hodnota objektu musí být řetězec nebo celé číslo, které lze převést na logickou hodnotu.
| Návratová hodnota | Typ | Description |
|---|---|---|
true nebo false |
logický | Logická verze zadané hodnoty. |
Outputs
Tyto příklady ukazují různé podporované typy vstupu pro bool():
| Vstupní hodnota | Typ | Návratová hodnota |
|---|---|---|
bool(1) |
Integer | true |
bool(0) |
Integer | false |
bool(-1) |
Integer | true |
bool('true') |
String | true |
bool('false') |
String | false |
C
chunk
Rozdělte řetězec nebo pole na bloky se stejnou délkou.
chunk('<collection>', '<length>')
chunk([<collection>], '<length>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Řetězec nebo pole | Kolekce, která se má rozdělit |
| < délka> | Yes | Délka každého bloku dat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < sbírka> | Array | Pole datových fragmentů se zadanou délkou |
Příklad 1
Tento příklad rozdělí řetězec na bloky o délce 10:
chunk('abcdefghijklmnopqrstuvwxyz', 10)
A vrátí tento výsledek: ['abcdefghij', 'klmnopqrst', 'uvwxyz']
Příklad 2
Tento příklad rozdělí pole na bloky o délce 5.
chunk(createArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), 5)
A vrátí tento výsledek: [ [1,2,3,4,5], [6,7,8,9,10], [11,12] ]
sloučit
Vrátí první hodnotu, která není null, z jednoho nebo více parametrů. Prázdné řetězce, prázdné pole a prázdné objekty nemají hodnotu null.
coalesce(<object_1>, <object_2>, ...)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < >object_1, <object_2>, ... | Yes | Libovolná, můžou kombinovat typy | Jedna nebo více položek ke kontrole hodnoty null |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < První-ne-nulová položka> | Any | První položka nebo hodnota, která nemá hodnotu null. Pokud jsou všechny parametry null, vrátí tato funkce hodnotu null. |
Example
Tyto příklady vrátí první hodnotu, která není null ze zadaných hodnot, nebo null, pokud jsou všechny hodnoty null:
coalesce(null, true, false)
coalesce(null, 'hello', 'world')
coalesce(null, null, null)
A vrátí tyto výsledky:
- První příklad:
true - Druhý příklad:
"hello" - Třetí příklad:
null
concat
Zkombinujte dva nebo více řetězců a vraťte sloučený řetězec.
concat('<text1>', '<text2>', ...)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < text1>, <text2>, ... | Yes | String | Aspoň dva řetězce ke kombinování |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < text1text2...> | String | Řetězec vytvořený z kombinovaných vstupních řetězců. Poznámka: Délka výsledku nesmí překročit 104 857 600 znaků. |
Note
Azure Logic Apps automaticky nebo implicitně provádí kódování a dekódování base64, takže při použití concat() funkce s daty, která potřebují kódování nebo dekódování, nemusíte tyto převody provádět ručně:
concat('data:;base64,',<value>)concat('data:,',encodeUriComponent(<value>))
Pokud však tuto funkci přesto použijete v návrháři, může dojít k neočekávanému chování vykreslování v návrháři. Toto chování má vliv pouze na viditelnost funkce, a ne na efekt, pokud neupravíte hodnoty parametrů funkce, která funkci a efekt z kódu odebere. Další informace najdete v tématu Kódování a dekódování Base64.
Example
Tento příklad kombinuje řetězce "Hello" a "World":
concat('Hello', 'World')
A vrátí tento výsledek: "HelloWorld"
contains
Zkontrolujte, jestli kolekce obsahuje konkrétní položku. Vrátí hodnotu true při nalezení položky nebo vrátí hodnotu false, pokud nebyla nalezena. Tato funkce rozlišuje malá a velká písmena.
contains('<collection>', '<value>')
contains([<collection>], '<value>')
Konkrétně tato funkce funguje na těchto typech kolekcí:
- Řetězec pro vyhledání podřetězce
- Pole pro vyhledání hodnoty
- Slovník pro vyhledání klíče
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Řetězec, pole nebo slovník | Kolekce, kterou je třeba zkontrolovat |
| < hodnota> | Yes | String, Array nebo Dictionary, respektive | Položka, která se má najít |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, když se položka najde. Vrátí hodnotu false, pokud nebyla nalezena. |
Příklad 1
Tento příklad zkontroluje, zda řetězec "hello world" obsahuje podřetězec "world" a vrací hodnotu pravda.
contains('hello world', 'world')
Příklad 2
Tento příklad zkontroluje řetězec "hello world" pro podřetězce "universe" a vrátí hodnotu false:
contains('hello world', 'universe')
convertFromUtc
Převeďte časové razítko z standardu UTC (Universal Time Coordinated) na cílové časové pásmo.
convertFromUtc('<timestamp>', '<destinationTimeZone>', '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < destinationTimeZone> | Yes | String | Název cílového časového pásma. Názvy časových pásem najdete v části Výchozí časová pásma systému Microsoft Windows. |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < převedené časové razítko> | String | Časové razítko bylo převedeno na cílové časové pásmo, aniž by byl zahrnut offset časové zóny UTC. |
Příklad 1
Tento příklad převede časové razítko na zadané časové pásmo:
convertFromUtc('2018-01-01T08:00:00.0000000Z', 'Pacific Standard Time')
A vrátí tento výsledek: "2018-01-01T00:00:00.0000000"
Příklad 2
Tento příklad převede časové razítko na zadané časové pásmo a formát:
convertFromUtc('2018-01-01T08:00:00.0000000Z', 'Pacific Standard Time', 'D')
A vrátí tento výsledek: "Monday, January 1, 2018"
convertTimeZone
Převeďte časové razítko ze zdrojového časového pásma na cílové časové pásmo.
convertTimeZone('<timestamp>', '<sourceTimeZone>', '<destinationTimeZone>', '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < sourceTimeZone> | Yes | String | Název zdrojového časového pásma. Názvy časových pásem najdete v tématu Výchozí časová pásma systému Microsoft Windows, ale možná budete muset odebrat jakoukoli interpunkci z názvu časového pásma. |
| < destinationTimeZone> | Yes | String | Název cílového časového pásma. Názvy časových pásem najdete v tématu Výchozí časová pásma systému Microsoft Windows, ale možná budete muset odebrat jakoukoli interpunkci z názvu časového pásma. |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < převedené časové razítko> | String | Časové razítko převedeno na cílové časové pásmo |
Příklad 1
Tento příklad převede zdrojové časové pásmo na cílové časové pásmo:
convertTimeZone('2018-01-01T08:00:00.0000000Z', 'UTC', 'Pacific Standard Time')
A vrátí tento výsledek: "2018-01-01T00:00:00.0000000"
Příklad 2
Tento příklad převede časové pásmo na zadané časové pásmo a formát:
convertTimeZone('2018-01-01T80:00:00.0000000Z', 'UTC', 'Pacific Standard Time', 'D')
A vrátí tento výsledek: "Monday, January 1, 2018"
convertToUtc
Převeďte časové razítko ze zdrojového časového pásma na standard UTC (Universal Time Coordinated).
convertToUtc('<timestamp>', '<sourceTimeZone>', '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < sourceTimeZone> | Yes | String | Název zdrojového časového pásma. Názvy časových pásem najdete v tématu Výchozí časová pásma systému Microsoft Windows, ale možná budete muset odebrat jakoukoli interpunkci z názvu časového pásma. |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < převedené časové razítko> | String | Časové razítko se převedlo na UTC. |
Příklad 1
Tento příklad převede časové razítko na UTC:
convertToUtc('01/01/2018 00:00:00', 'Pacific Standard Time')
A vrátí tento výsledek: "2018-01-01T08:00:00.0000000Z"
Příklad 2
Tento příklad převede časové razítko na UTC:
convertToUtc('01/01/2018 00:00:00', 'Pacific Standard Time', 'D')
A vrátí tento výsledek: "Monday, January 1, 2018"
createArray
Vrátíme pole z více vstupů.
Informace o jednotlivých vstupních polích najdete v
createArray('<object1>', '<object2>', ...)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < objekt1>, <objekt2>, ... | Yes | Libovolná, ale ne smíšená | Nejméně dvě položky pro vytvoření pole |
| Návratová hodnota | Typ | Description |
|---|---|---|
| [<objekt1>, <objekt2>, ...] | Array | Pole vytvořené ze všech vstupních položek |
Example
Tento příklad vytvoří pole z těchto vstupů:
createArray('h', 'e', 'l', 'l', 'o')
A vrátí tento výsledek: ["h", "e", "l", "l", "o"]
D
dataUri
Vrátit URI (Uniform Resource Identifier) pro datový řetězec.
dataUri('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec který se má převést |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Data-uri> | String | Identifikátor URI dat pro vstupní řetězec |
Example
Tento příklad vytvoří identifikátor URI dat pro řetězec "hello":
dataUri('hello')
A vrátí tento výsledek: "data:text/plain;charset=utf-8;base64,aGVsbG8="
dataUriToBinary
Vrátí binární verzi identifikátoru URI (Data Uniform Resource Identifier).
Tuto funkci použijte místo dekódováníDataUri().
I když obě funkce fungují stejným způsobem, dataUriBinary() je preferováno.
dataUriToBinary('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Identifikátor URI dat, který se má převést |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Binary-for-data-uri> | String | Binární verze identifikátoru URI dat |
Example
Tento příklad vytvoří binární verzi pro tento identifikátor URI dat:
dataUriToBinary('data:text/plain;charset=utf-8;base64,aGVsbG8=')
A vrátí tento výsledek:
"01100100011000010111010001100001001110100111010001100101011110000111010000101111011100000 1101100011000010110100101101110001110110110001101101000011000010111001001110011011001010111 0100001111010111010101110100011001100010110100111000001110110110001001100001011100110110010 10011011000110100001011000110000101000111010101100111001101100010010001110011100000111101"
dataUriToString
Vraťte verzi řetězce pro identifikátor URI (jednotný zdrojový identifikátor) dat.
dataUriToString('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Identifikátor URI dat, který se má převést |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < string-for-data-uri> | String | Verze řetězce pro datový URI |
Example
Tento příklad vytvoří řetězec pro tento datový URI:
dataUriToString('data:text/plain;charset=utf-8;base64,aGVsbG8=')
A vrátí tento výsledek: "hello"
dateDifference
Vrátí rozdíl mezi dvěma časovými razítky jako časovým rozpětím. Tato funkce odečte startDate od endDate, a vrátí výsledek jako řetězcový formát časového razítka.
dateDifference('<startDate>', '<endDate>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Datum začátku> | Yes | String | Řetězec obsahující časové razítko |
| < konec Datum> | Yes | String | Řetězec obsahující časové razítko |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < časový rozsah> | String | Rozdíl mezi dvěma časovými razítky, což je časové razítko ve formátu řetězce. Pokud startDate je novější než endDate, výsledek je záporná hodnota. |
Example
Tento příklad odečte první hodnotu od druhé hodnoty:
dateDifference('2015-02-08', '2018-07-30')
A vrátí tento výsledek: "1268.00:00:00"
dayOfMonth
Vrátí den v měsíci z časového razítka.
dayOfMonth('<timestamp>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < den v měsíci> | Integer | Den v měsíci ze zadaného časového razítka |
Example
Tento příklad vrátí číslo pro den v měsíci z tohoto časového razítka:
dayOfMonth('2018-03-15T13:27:36Z')
A vrátí tento výsledek: 15
dayOfWeek
Vraťte den v týdnu z časového razítka.
dayOfWeek('<timestamp>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < den v týdnu> | Integer | Den v týdnu od zadaného časového razítka, kde je neděle 0, pondělí je 1 atd. |
Example
Tento příklad vrátí číslo pro den v týdnu z tohoto časového razítka:
dayOfWeek('2018-03-15T13:27:36Z')
A vrátí tento výsledek: 4
dayOfYear
Vrátí den v roce z časového razítka.
dayOfYear('<timestamp>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Den v roce> | Integer | Roční den ze zadané časové značky |
Example
Tento příklad vrátí číslo dne v roce z tohoto časového razítka:
dayOfYear('2018-03-15T13:27:36Z')
A vrátí tento výsledek: 74
desítkové číslo
Vrátí desetinné číslo v řetězci jako desítkové číslo. Tuto funkci můžete použít při práci s daty vyžadujícími desetinnou přesnost a také jako vstup pro logické porovnávací funkce a matematické funkce. Pokud chcete zachytit a zachovat přesnost při použití výsledku funkce decimal(), zabalte libovolný desetinný výstup s řetězcovou funkcí. Toto použití je znázorněno v následujících příkladech, kde můžete ztratit přesnost, pokud použijete desetinný výsledek jako číslo.
Note
Desetinná přesnost diskutovaná v kontextu pro tuto funkci a runtime Azure Logic Apps je stejná jako desetinná přesnost .NET.
decimal('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Desetinné číslo v řetězci |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < desetinný> | Desetinné číslo | Desetinné číslo vstupního řetězce |
Příklad 1
Tento příklad vytvoří desítkové číslo, které se použije jako číslo:
decimal('1.2345678912312131') // Returns 1.234567891231213.
Příklad 2
Tento příklad vytvoří desítkové číslo a pak převede výsledek na řetězec pro zachování přesnosti:
string(decimal('1.2345678912312131')) // Returns "1.2345678912312131".
Příklad 3
Tento příklad používá matematickou funkci na dvou desetinných číslech a výsledek použije jako číslo:
add(decimal('1.2345678912312131'), decimal('1.2345678912312131')) // Returns 2.469135782462426.
Příklad 4
Tento příklad používá matematickou funkci na dvou desetinných číslech a převede výsledek na řetězec pro zachování přesnosti:
string(add(decimal('1.2345678912312131'), decimal('1.2345678912312131'))) // Returns "2.4691357824624262".
decodeBase64 (zastaralé)
Tato funkce je zastaralá, proto místo toho použijte base64ToString().
decodeDataUri
Vrátí binární verzi identifikátoru URI (Data Uniform Resource Identifier). Zvažte použití dataUriToBinary() místo decodeDataUri(). I když obě funkce fungují stejným způsobem, dataUriToBinary() je preferováno.
Note
Azure Logic Apps automaticky nebo implicitně provádí kódování a dekódování base64, takže tyto převody nemusíte provádět ručně pomocí funkcí kódování a dekódování. Pokud však tyto funkce přesto použijete v návrhovém prostředí, může docházet k neočekávanému chování vykreslování. Toto chování má vliv pouze na viditelnost funkcí a ne na jejich účinek, pokud neupravíte hodnoty parametrů funkcí, které z kódu odeberou funkce a jejich efekty. Další informace naleznete v tématu Kódování a dekódování Base64.
decodeDataUri('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec datového URI pro dekódování |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Binary-for-data-uri> | String | Binární verze datového URI řetězce |
Example
Tento příklad vrátí binární verzi tohoto identifikátoru URI dat:
decodeDataUri('data:text/plain;charset=utf-8;base64,aGVsbG8=')
A vrátí tento výsledek: "hello"
decodeUriComponent
Vrátí řetězec, ve kterém jsou únikové znaky nahrazeny dekódovanými verzemi.
decodeUriComponent('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec s escape znaky k dekódování |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < dekódovaný identifikátor URI> | String | Aktualizovaný řetězec s dekódovanými escape znaky |
Example
Tento příklad nahradí escape znaky v tomto řetězci dekódovanými verzemi.
decodeUriComponent('https%3A%2F%2Fcontoso.com')
A vrátí tento výsledek: "https://contoso.com"
div
Vrátí výsledek dělení dvou čísel. Pokud chcete získat výsledek zbytku, podívejte se na mod().
div(<dividend>, <divisor>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < dividenda> | Yes | Celé číslo nebo plovoucí číslo | Číslo, které se má dělit dělitelem |
| < dělitel> | Yes | Celé číslo nebo plovoucí číslo | Číslo, které dělí dividendu, ale nemůže být nula |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Výsledek s podílem> | Celé číslo nebo plovoucí číslo | Výsledek vydělení prvního čísla druhým číslem. Pokud má typ Float buď dělenec, nebo dělitel, výsledek má typ Float. Poznámka: Pokud chcete převést výsledek float na celé číslo, zkuste vytvořit a volat funkci v Azure z aplikace logiky. |
Příklad 1
Oba příklady vrátí tuto hodnotu typu Integer: 2
div(10,5)
div(11,5)
Příklad 2
Oba příklady vrátí tuto hodnotu s typem Float: 2.2
div(11,5.0)
div(11.0,5)
E
encodeUriComponent
Vytvořte zakódovanou verzi identifikátoru URI (Uniform Resource Identifier) pro řetězec nahrazením znaků nebezpečných pro adresu URL únikovými znaky. Zvažte použití funkce uriComponent() místo encodeUriComponent(). I když obě funkce fungují stejným způsobem, uriComponent() je preferováno.
Note
Azure Logic Apps automaticky nebo implicitně provádí kódování a dekódování base64, takže tyto převody nemusíte provádět ručně pomocí funkcí kódování a dekódování. Pokud však tyto funkce přesto použijete v návrhovém prostředí, může docházet k neočekávanému chování vykreslování. Toto chování má vliv pouze na viditelnost funkcí a ne na jejich účinek, pokud neupravíte hodnoty parametrů funkcí, které z kódu odeberou funkce a jejich efekty. Další informace naleznete v tématu Kódování a dekódování Base64.
encodeUriComponent('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec, který se má převést na URI-kódovaný formát |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Encoded-uri> | String | Řetězec kódovaný ve formátu URI se znaky úniku |
Example
Tento příklad vytvoří verzi kódovanou identifikátorem URI pro tento řetězec:
encodeUriComponent('https://contoso.com')
A vrátí tento výsledek: "https%3A%2F%2Fcontoso.com"
empty
Zkontrolujte, jestli je kolekce prázdná. Vrátí hodnotu true, pokud je kolekce prázdná, nebo vrátí hodnotu false, pokud není prázdná.
empty('<collection>')
empty([<collection>])
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Řetězec, pole nebo objekt | Kolekce, kterou je třeba zkontrolovat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, pokud je kolekce prázdná. Vrátí hodnotu false, pokud není prázdná. |
Example
Tyto příklady kontrolují, jestli jsou zadané kolekce prázdné:
empty('')
empty('abc')
A vrátí tyto výsledky:
- První příklad: Předá prázdný řetězec, takže funkce vrátí
true. - Druhý příklad: Předá řetězec "abc", takže funkce vrátí
false.
endsWith
Zkontrolujte, jestli řetězec končí určitým podřetězcem. Vrátí hodnotu true při nalezení podřetězce nebo vrátí hodnotu false, pokud nebyl nalezen. Tato funkce nerozlišuje malá a velká písmena.
endsWith('<text>', '<searchText>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec, který chcete zkontrolovat |
| < searchText> | Yes | String | Koncový podřetězec k nalezení |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí true při nalezení koncového podřetězce. Vrátí hodnotu false, pokud nebyla nalezena. |
Příklad 1
Tento příklad zkontroluje, jestli řetězec "hello world" končí řetězcem "world":
endsWith('hello world', 'world')
A vrátí tento výsledek: true
Příklad 2
Tento příklad zkontroluje, jestli řetězec "hello world" končí řetězcem "universe":
endsWith('hello world', 'universe')
A vrátí tento výsledek: false
equals
Zkontrolujte, jestli jsou obě hodnoty, výrazy nebo objekty ekvivalentní. Vrátí hodnotu true, pokud jsou obě ekvivalentní, nebo vrátí hodnotu false, pokud nejsou ekvivalentní.
equals('<object1>', '<object2>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < objekt1>, <objekt2> | Yes | Various | Hodnoty, výrazy nebo objekty pro porovnání |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, pokud jsou obě ekvivalentní. Vrátí hodnotu false, pokud není ekvivalentní. |
Example
Tyto příklady kontrolují, jestli jsou zadané vstupy ekvivalentní.
equals(true, 1)
equals('abc', 'abcd')
A vrátí tyto výsledky:
- První příklad: Obě hodnoty jsou ekvivalentní, takže funkce vrátí
true. - Druhý příklad: Obě hodnoty nejsou ekvivalentní, takže funkce vrátí
false.
F
first
Vrátí první položku z řetězce nebo pole.
first('<collection>')
first([<collection>])
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Řetězec nebo pole | Kolekce, kde najít první položku |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < První sběrná položka> | Any | První položka v kolekci |
Example
V těchto příkladech najdete první položku v těchto kolekcích:
first('hello')
first(createArray(0, 1, 2))
Vrátí tyto výsledky:
- První příklad:
"h" - Druhý příklad:
0
float
Převést textový řetězec pro číslo s plovoucí desetinnou čárkou na skutečné číslo s plovoucí desetinnou čárkou. Tuto funkci můžete použít jenom při předávání vlastních parametrů do aplikace, například pracovního postupu v Logic App nebo toku Power Automate. Pokud chcete převést řetězce s plovoucí desetinnou čárkou reprezentované ve formátech specifických pro národní prostředí, můžete volitelně zadat kód národního prostředí RFC 4646.
float('<value>', '<locale>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec, který má platné číslo s plovoucí čárkou pro převod. Minimální a maximální hodnoty jsou stejné jako limity pro datový typ float. |
| < dějiště> | No | String | Kód národního prostředí RFC 4646, který se má použít. Pokud není zadáno, použije se výchozí národní prostředí. Pokud národní prostředí není platná hodnota, vygeneruje se chyba, že zadané národní prostředí není platné nebo nemá přidružené národní prostředí. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Float-value> | Float | Číslo s plovoucí desetinnou čárkou pro zadaný řetězec. Minimální a maximální hodnoty jsou stejné jako limity pro datový typ float. |
Příklad 1
Tento příklad vytvoří řetězcovou reprezentaci pro toto číslo s plovoucí desetinnou:
float('10,000.333')
A vrátí tento výsledek: 10000.333
Příklad 2
Tento příklad vytvoří verzi řetězce pro toto číslo s plovoucí desetinnou čárkou ve stylu němčiny:
float('10.000,333', 'de-DE')
A vrátí tento výsledek: 10000.333
Příklad 3
Příklady neočekávaně platných vstupů:
float('12,3,4,5678') //Returns 12345678
float('1234567,8+') //Returns 12345678
float('12345,6,78,-') //Returns -12345678
float('-12,345,678,') //Returns -12345678
float('12345678.-') //Returns -12345678
float('.12345678') //Returns 0.12345678
formatDateTime
Vrátí časové razítko v zadaném formátu.
formatDateTime('<timestamp>', '<format>'?, '<locale>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. |
| < dějiště> | No | String | Národní prostředí, které se má použít Pokud není zadáno, hodnota je en-us. Pokud národní prostředí není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < přeformátované časové razítko> | String | Aktualizované časové razítko v zadaném formátu a národním prostředí, pokud je zadané. |
Examples
formatDateTime('03/15/2018') // Returns '2018-03-15T00:00:00.0000000'.
formatDateTime('03/15/2018 12:00:00', 'yyyy-MM-ddTHH:mm:ss') // Returns '2018-03-15T12:00:00'.
formatDateTime('01/31/2016', 'dddd MMMM d') // Returns 'Sunday January 31'.
formatDateTime('01/31/2016', 'dddd MMMM d', 'fr-fr') // Returns 'dimanche janvier 31'.
formatDateTime('01/31/2016', 'dddd MMMM d', 'fr-FR') // Returns 'dimanche janvier 31'.
formatDateTime('01/31/2016', 'dddd MMMM d', 'es-es') // Returns 'domingo enero 31'.
formDataMultiValues
Vrátí pole s hodnotami, které odpovídají názvu klíče ve výstupu s daty formuláře nebo kódovanými formuláři akce.
formDataMultiValues('<actionName>', '<key>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < actionNázev> | Yes | String | Akce, jejíž výstup má požadovanou hodnotu klíče. |
| < klíč> | Yes | String | Název klíče, jehož hodnotu chcete získat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| [<pole s klíčovými hodnotami>] | Array | Pole se všemi hodnotami, které odpovídají zadanému klíči |
Example
Tento příklad vytvoří pole z hodnoty klíče "Subject" ve výstupu form-data nebo formulářově zakódovaného výstupu zadané akce.
formDataMultiValues('Send_an_email', 'Subject')
A vrátí text předmětu v poli, například: ["Hello world"]
formDataValue
Vrátí jednu hodnotu, která odpovídá názvu klíče ve výstupu s daty formuláře nebo kódovaným formulářem akce. Pokud funkce najde více než jednu shodu, vyvolá funkce chybu.
formDataValue('<actionName>', '<key>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < actionNázev> | Yes | String | Akce, jejíž výstup má požadovanou hodnotu klíče. |
| < klíč> | Yes | String | Název klíče, jehož hodnotu chcete získat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < klíč-hodnota> | String | Hodnota v zadaném klíči |
Example
Tento příklad vytvoří řetězec z hodnoty klíče "Subject" ve výstupu zadané akce s daty formuláře nebo formulářově zakódovaným výstupem.
formDataValue('Send_an_email', 'Subject')
A vrátí text objektu jako řetězec, například: "Hello world"
formatNumber
Vrátí číslo jako řetězec založený na zadaném formátu.
formatNumber(<number>, <format>, <locale>?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < číslo> | Yes | Celé číslo nebo Double | Hodnota, kterou chcete formátovat. |
| < formát> | Yes | String | Složený formátovací řetězec, který určuje formát, který chcete použít. Podporované řetězce číselného formátu naleznete v části Standardní řetězce číselného formátu, které jsou podporovány number.ToString(<format>, <locale>). |
| < dějiště> | No | String | Nastavení zeměpisné oblasti, které má být použito podle podpory number.ToString(<format>, <locale>). Pokud není zadáno, hodnota je en-us. Pokud národní prostředí není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < formátované číslo> | String | Zadané číslo jako řetězec ve formátu, který jste zadali. Tuto návratovou hodnotu můžete přetypovat na int nebo float. |
Příklad 1
Předpokládejme, že chcete číslo naformátovat 1234567890. Tento příklad naformátuje toto číslo jako řetězec "1 234 567 890,00".
formatNumber(1234567890, '#,##0.00', 'en-US')
*Příklad 2"
Předpokládejme, že chcete číslo naformátovat 1234567890. Tento příklad naformátuje číslo na řetězec 1.234.567.890 00.
formatNumber(1234567890, '#,##0.00', 'is-IS')
Příklad 3
Předpokládejme, že chcete číslo naformátovat 17.35. Tento příklad naformátuje číslo na řetězec "$17,35".
formatNumber(17.35, 'C2')
Příklad 4
Předpokládejme, že chcete číslo naformátovat 17.35. Tento příklad naformátuje číslo na řetězec "17,35 kr".
formatNumber(17.35, 'C2', 'is-IS')
G
getFutureTime
Vrátí aktuální časové razítko a zadané časové jednotky.
getFutureTime(<interval>, <timeUnit>, <format>?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < interval> | Yes | Integer | Počet časových jednotek, které se mají přidat |
| < timeUnit> | Yes | String | Jednotka času, která se má použít s intervalem: "Second", "Minute", "Hour", "Day", "Week", "Month", "Year" |
| < formát> | No | String | Buď specifikátor jednoho formátu , nebo vlastní vzor formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba, že zadaný formát není platný a musí to být řetězec číselného formátu. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Aktuální časové razítko plus zadaný počet časových jednotek |
Příklad 1
Předpokládejme, že aktuální časové razítko je "2018-03-01T00:00:00.000000Z". Tento příklad přidá do tohoto časového razítka pět dnů:
getFutureTime(5, 'Day')
A vrátí tento výsledek: "2018-03-06T00:00:00.0000000Z"
Příklad 2
Předpokládejme, že aktuální časové razítko je "2018-03-01T00:00:00.000000Z". Tento příklad přidá pět dnů a převede výsledek na formát "D":
getFutureTime(5, 'Day', 'D')
A vrátí tento výsledek: "Tuesday, March 6, 2018"
getPastTime
Vrátí aktuální časové razítko minus zadané časové jednotky.
getPastTime(<interval>, <timeUnit>, <format>?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < interval> | Yes | Integer | Počet zadaných časových jednotek, které se mají odečíst |
| < timeUnit> | Yes | String | Jednotka času, která se má použít s intervalem: "Second", "Minute", "Hour", "Day", "Week", "Month", "Year" |
| < formát> | No | String | Buď specifikátor jednoho formátu , nebo vlastní vzor formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba, že zadaný formát není platný a musí to být řetězec číselného formátu. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Aktuální časové razítko minus zadaný počet časových jednotek |
Příklad 1
Předpokládejme, že aktuální časové razítko je "2018-02-01T00:00:00.000000Z". Tento příklad odečte pět dnů od tohoto časového razítka:
getPastTime(5, 'Day')
A vrátí tento výsledek: "2018-01-27T00:00:00.0000000Z"
Příklad 2
Předpokládejme, že aktuální časové razítko je "2018-02-01T00:00:00.000000Z". Tento příklad odečte pět dnů a převede výsledek na formát "D":
getPastTime(5, 'Day', 'D')
A vrátí tento výsledek: "Saturday, January 27, 2018"
greater
Zkontrolujte, jestli je první hodnota větší než druhá hodnota. Vrátí hodnotu true, pokud je první hodnota větší nebo vrátí hodnotu false, pokud je menší.
greater(<value>, <compareTo>)
greater('<value>', '<compareTo>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | Celé číslo, float nebo řetězec | První hodnota, která zkontroluje, jestli je větší než druhá hodnota |
| < compareTo> | Yes | Celé číslo, Float nebo String | Porovnávací hodnota |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, pokud je první hodnota větší než druhá hodnota. Vrátí hodnotu false, pokud je první hodnota rovna nebo menší než druhá hodnota. |
Example
Tyto příklady kontrolují, jestli je první hodnota větší než druhá hodnota:
greater(10, 5)
greater('apple', 'banana')
Vrátí tyto výsledky:
- První příklad:
true - Druhý příklad:
false
greaterOrEquals
Zkontrolujte, jestli je první hodnota větší nebo rovna druhé hodnotě. Vrátí hodnotu true, pokud je první hodnota větší nebo rovna, nebo vrátí hodnotu false, pokud je první hodnota menší.
greaterOrEquals(<value>, <compareTo>)
greaterOrEquals('<value>', '<compareTo>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | Celé číslo, float nebo řetězec | První hodnota, která zkontroluje, jestli je větší nebo rovna druhé hodnotě |
| < compareTo> | Yes | Celé číslo, Float nebo String | Porovnávací hodnota |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, pokud je první hodnota větší nebo rovna druhé hodnotě. Vrátí hodnotu false, pokud je první hodnota menší než druhá hodnota. |
Example
Tyto příklady kontrolují, jestli je první hodnota větší nebo rovna druhé hodnotě:
greaterOrEquals(5, 5)
greaterOrEquals('apple', 'banana')
Vrátí tyto výsledky:
- První příklad:
true - Druhý příklad:
false
guid
Vygenerujte globálně jedinečný identifikátor (GUID) jako řetězec, například "c2ecc88d-88c8-4096-912c-d6f2e2b138ce":
guid()
Můžete také zadat jiný formát identifikátoru GUID než výchozí formát "D", což je 32 číslic oddělených pomlčkami.
guid('<format>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < formát> | No | String | Specifikátor jednoho formátu pro vrácený identifikátor GUID. Ve výchozím nastavení je formát "D", ale můžete použít "N", "D", "B", "P" nebo "X". |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Hodnota GUID> | String | Náhodně vygenerovaný identifikátor GUID |
Example
Tento příklad vygeneruje stejný identifikátor GUID, ale jako 32 číslic oddělených pomlčkami a uzavřených v závorkách:
guid('P')
A vrátí tento výsledek: "(c2ecc88d-88c8-4096-912c-d6f2e2b138ce)"
I
if
Zkontrolujte, jestli je výraz pravdivý nebo nepravda. Na základě výsledku vrátí zadanou hodnotu. Parametry se vyhodnocují zleva doprava.
if(<expression>, <valueIfTrue>, <valueIfFalse>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < výraz> | Yes | logický | Výraz, který se má zkontrolovat |
| < valueIfTrue> | Yes | Any | Hodnota, která se má vrátit, když je výraz pravdivý |
| < valueIfFalse> | Yes | Any | Hodnota, která se má vrátit, když je výraz nepravdivý |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < zadaná návratová hodnota> | Any | Zadaná hodnota, která se vrátí na základě toho, jestli je výraz pravdivý nebo nepravda |
Example
Tento příklad vrátí hodnotu "yes" , protože zadaný výraz vrátí hodnotu true.
V opačném případě příklad vrátí "no".
if(equals(1, 1), 'yes', 'no')
indexOf
Vrátí počáteční pozici nebo hodnotu indexu podřetězce. Tato funkce nerozlišuje malá a velká písmena a indexy začínají číslem 0.
indexOf('<text>', '<searchText>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec, který obsahuje podřetězec, který je k vyhledání |
| < searchText> | Yes | String | Podřetězec k nalezení |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < index-value> | Integer | Počáteční pozice nebo hodnota indexu pro zadaný podřetězdec. Pokud se řetězec nenajde, vraťte číslo -1. |
Example
Tento příklad najde počáteční hodnotu indexu pro podřetězce "world" v řetězci "hello world":
indexOf('hello world', 'world')
A vrátí tento výsledek: 6
int
Převeďte textovou reprezentaci celého čísla na skutečné celé číslo.
int('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězcová verze celého čísla, která se má převést. Minimální a maximální hodnoty jsou stejné jako limity pro datový typ celé číslo. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < celočíselný výsledek> | Integer | Celočíselná verze zadaného řetězce. Minimální a maximální hodnoty jsou stejné jako limity pro datový typ celé číslo. |
Example
Tento příklad vytvoří celočíselnou verzi řetězce "10":
int('10')
A vrátí tento výsledek: 10
isFloat
Vrátí booleovskou hodnotu, pokud řetězec představuje číslo s plovoucí řádovou čárkou. Ve výchozím nastavení tato funkce používá invariantní kulturu pro formát s plovoucí desetinnou čárkou. Pokud chcete identifikovat čísla s plovoucí desetinnou čárkou reprezentovaná v jiných formátech specifických pro místní nastavení, můžete volitelně zadat kód národního prostředí RFC 4646.
isFloat('<string>', '<locale>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec, který chcete prozkoumat |
| < dějiště> | No | String | Kód národního prostředí RFC 4646, který se má použít |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Booleanův výsledek> | logický | Logická hodnota označující, jestli je řetězec reálné číslo |
Příklad 1
Tento příklad zkontroluje, zda je řetězec číslem s plovoucí desetinnou čárkou v invariantní kultuře:
isFloat('10,000.00')
A vrátí tento výsledek: true
Příklad 2
Tento příklad zkontroluje, jestli je řetězec číslo s plovoucí čárkou v německém místním prostředí.
isFloat('10.000,00', 'de-DE')
A vrátí tento výsledek: true
isInt
Vrátí logickou hodnotu, která určuje, jestli je řetězec celé číslo.
isInt('<string>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < řetězec> | Yes | String | Řetězec, který chcete prozkoumat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Booleanův výsledek> | logický | Logická hodnota označující, jestli je řetězec celé číslo |
Example
Tento příklad zkontroluje, jestli je řetězec celé číslo:
isInt('10')
A vrátí tento výsledek: true
položka
Při opakování akce na poli vraťte aktuální položku z pole během probíhající iterace akce. Můžete také získat hodnoty z vlastností dané položky.
item()
| Návratová hodnota | Typ | Description |
|---|---|---|
| < current-array-item> | Any | Aktuální položka v poli pro aktuální iteraci akce |
Example
Tento příklad získá body prvek z aktuální zprávy pro akci "Send_an_email" uvnitř aktuální iterace smyčky for-each:
item().body
items
Vrátí aktuální položku z každé iterace v cyklu for-each. Použijte tuto funkci uvnitř smyčky for-each.
items('<loopName>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < loopName> | Yes | String | "Název cyklu for-each" |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < položka> | Any | Položka z aktuálního cyklu v zadané smyčce pro každý prvek |
Example
Tento příklad získá aktuální položku ze zadané smyčky typu for-each.
items('myForEachLoopName')
iterationIndexes
Vrátí hodnotu indexu pro aktuální iteraci uvnitř smyčky Until. Tuto funkci můžete použít uvnitř vnořených smyček Until.
iterationIndexes('<loopName>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < loopName> | Yes | String | Název smyčky Until |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < index> | Integer | Hodnota indexu pro aktuální iteraci uvnitř zadané smyčky Until |
Example
Tento příklad vytvoří proměnnou čítače a během každé iterace ve smyčce Until ji zvýší o jednu, dokud hodnota čítače nedosáhne pěti. Příklad také vytvoří proměnnou, která sleduje aktuální index pro každou iteraci. Během každé iterace ve smyčce Until příklad zvýší hodnotu čítače a pak přiřadí hodnotu čítače aktuální hodnotě indexu a pak zvýší hodnotu čítače. V této smyčce odkazuje tento příklad na aktuální index iterace pomocí iterationIndexes funkce:
iterationIndexes('Until_Max_Increment')
{
"actions": {
"Create_counter_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "myCounter",
"type": "Integer",
"value": 0
}
]
},
"runAfter": {}
},
"Create_current_index_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "myCurrentLoopIndex",
"type": "Integer",
"value": 0
}
]
},
"runAfter": {
"Create_counter_variable": [ "Succeeded" ]
}
},
"Until_Max_Increment": {
"type": "Until",
"actions": {
"Assign_current_index_to_counter": {
"type": "SetVariable",
"inputs": {
"name": "myCurrentLoopIndex",
"value": "@variables('myCounter')"
},
"runAfter": {
"Increment_variable": [ "Succeeded" ]
}
},
"Compose": {
"inputs": "'Current index: ' @{iterationIndexes('Until_Max_Increment')}",
"runAfter": {
"Assign_current_index_to_counter": [
"Succeeded"
]
},
"type": "Compose"
},
"Increment_variable": {
"type": "IncrementVariable",
"inputs": {
"name": "myCounter",
"value": 1
},
"runAfter": {}
}
},
"expression": "@equals(variables('myCounter'), 5)",
"limit": {
"count": 60,
"timeout": "PT1H"
},
"runAfter": {
"Create_current_index_variable": [ "Succeeded" ]
}
}
}
}
J
json
Vrátí hodnotu typu JSON (JavaScript Object Notation), objekt nebo pole objektů pro řetězec nebo XML.
json('<value>')
json(xml('value'))
Important
Bez schématu XML, které definuje strukturu výstupu, může funkce vracet výsledky, kde se struktura výrazně liší od očekávaného formátu v závislosti na vstupu.
Díky tomuto chování tato funkce není vhodná pro scénáře, ve kterých musí výstup vyhovovat dobře definovanému kontraktu, například v důležitých obchodních systémech nebo řešeních.
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | Řetězec nebo XML | Řetězec nebo XML pro převod |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Výsledek JSON> | Nativní typ, objekt nebo pole JSON | Hodnota nativního typu JSON, objekt nebo pole objektů ze vstupního řetězce nebo XML. - Pokud předáte XML, který má jeden podřízený prvek v kořenovém elementu, vrátí funkce jeden objekt JSON pro tento podřízený prvek. - Pokud předáte XML, který má v kořenovém elementu více podřízených prvků, vrátí funkce pole obsahující objekty JSON pro tyto podřízené prvky. – Pokud je řetězec null, vrátí funkce prázdný objekt. |
Příklad 1
Tento příklad převede tento řetězec na hodnotu JSON:
json('[1, 2, 3]')
A vrátí tento výsledek: [1, 2, 3]
Příklad 2
Tento příklad převede tento řetězec na JSON:
json('{"fullName": "Sophia Owen"}')
A vrátí tento výsledek:
{
"fullName": "Sophia Owen"
}
Příklad 3
Tento příklad používá funkce json() a xml() k převodu XML, který má jeden podřízený prvek v kořenovém elementu, na objekt JSON pojmenovaný person pro tento podřízený prvek.
json(xml('<?xml version="1.0"?> <root> <person id="1"> <name>Sophia Owen</name> <occupation>Engineer</occupation> </person> </root>'))
A vrátí tento výsledek:
{
"?xml": {
"@version": "1.0"
},
"root": {
"person": {
"@id": "1",
"name": "Sophia Owen",
"occupation": "Engineer"
}
}
}
Příklad 4
Tento příklad používá json() funkce a xml() funkce k převodu XML, které má v kořenovém elementu více podřízených elementů, na pole s názvem person, které obsahuje objekty JSON pro tyto podřízené elementy.
json(xml('<?xml version="1.0"?> <root> <person id="1"> <name>Sophia Owen</name> <occupation>Engineer</occupation> </person> <person id="2"> <name>John Doe</name> <occupation>Engineer</occupation> </person> </root>'))
A vrátí tento výsledek:
{
"?xml": {
"@version": "1.0"
},
"root": {
"person": [
{
"@id": "1",
"name": "Sophia Owen",
"occupation": "Engineer"
},
{
"@id": "2",
"name": "John Doe",
"occupation": "Engineer"
}
]
}
}
intersection
Vrátí kolekci, která obsahuje pouze společné položky v zadaných kolekcích. Aby se položka zobrazila ve výsledku, musí se zobrazit ve všech kolekcích předaných této funkci. Pokud má jedna nebo více položek stejný název, zobrazí se ve výsledku poslední položka s tímto názvem.
intersection([<collection1>], [<collection2>], ...)
intersection('<collection1>', '<collection2>', ...)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka1>, <kolekce2>, ... | Yes | Matice nebo objekt, ale ne obojí | Kolekce, ze kterých chcete jenom společné položky |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < společné položky> | Pole nebo objekt, respektive | Kolekce, která obsahuje pouze společné položky v zadaných kolekcích |
Example
Tento příklad najde společné položky v těchto polích:
intersection(createArray(1, 2, 3), createArray(101, 2, 1, 10), createArray(6, 8, 1, 2))
A vrátí pole pouze s těmito položkami: [1, 2]
připojit
Vrátí řetězec, který obsahuje všechny položky z pole a má každý znak oddělený oddělovačem.
join([<collection>], '<delimiter>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Array | Pole, které obsahuje položky ke spojení |
| < oddělovač> | Yes | String | Oddělovač, který se zobrazí mezi jednotlivými znaky ve výsledném řetězci |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < char1><oddělovač><char2><oddělovač>... | String | Výsledný řetězec vytvořený ze všech položek v zadaném poli. Poznámka: Délka výsledku nesmí překročit 104 857 600 znaků. |
Example
Tento příklad vytvoří řetězec ze všech položek v tomto poli se zadaným znakem jako oddělovačem:
join(createArray('a', 'b', 'c'), '.')
A vrátí tento výsledek: "a.b.c"
L
last
Vrátí poslední položku z kolekce.
last('<collection>')
last([<collection>])
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Řetězec nebo pole | Kolekce, kde najít poslední položku |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Poslední sbírka předmětů> | Řetězec nebo pole | Poslední položka v kolekci |
Example
V těchto příkladech najdete poslední položku v těchto kolekcích:
last('abcd')
last(createArray(0, 1, 2, 3))
A vrátí tyto výsledky:
- První příklad:
"d" - Druhý příklad:
3
lastIndexOf
Vrátí počáteční pozici nebo index pro poslední výskyt řetězce. Tato funkce nerozlišuje malá a velká písmena a indexy začínají číslem 0.
lastIndexOf('<text>', '<searchText>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec, který obsahuje podřetězec, který je k vyhledání |
| < searchText> | Yes | String | Podřetězec k nalezení |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < end-index-value> | Integer | Počáteční pozice nebo hodnota indexu pro poslední výskyt zadaného podřetězdce. |
Pokud je hodnota řetězce nebo podřetězce prázdná, dojde k následujícímu chování:
Pokud je hodnota řetězce prázdná, funkce vrátí
-1.Pokud jsou hodnoty řetězce i podřetězce prázdné, funkce vrátí
0.Pokud je hodnota podřetězce prázdná, vrátí funkce délku řetězce minus 1.
Examples
Tento příklad najde počáteční hodnotu indexu pro poslední výskyt podřetězce podřetězce world v řetězci hello world hello world. Vrácený výsledek je 18:
lastIndexOf('hello world hello world', 'world')
V tomto příkladu chybí parametr podřetězce a vrátí hodnotu 22 , protože hodnota vstupního řetězce (23) minus 1 je větší než 0.
lastIndexOf('hello world hello world', '')
length
Vrátí počet položek v kolekci.
length('<collection>')
length([<collection>])
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Řetězec nebo pole | Kolekce s položkami, které se mají spočítat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < délka nebo počet> | Integer | Počet položek v kolekci |
Example
Tyto příklady spočítají počet položek v těchto kolekcích:
length('abcd')
length(createArray(0, 1, 2, 3))
A vrátit tento výsledek: 4
less
Zkontrolujte, jestli je první hodnota menší než druhá hodnota. Vrátí hodnotu true, pokud je první hodnota menší nebo vrátí hodnotu false, pokud je první hodnota větší.
less(<value>, <compareTo>)
less('<value>', '<compareTo>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | Celé číslo, float nebo řetězec | První hodnota, která zkontroluje, jestli je menší než druhá hodnota |
| < compareTo> | Yes | Celé číslo, Float nebo String | Položka porovnání |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, pokud je první hodnota menší než druhá hodnota. Vrátí hodnotu false, pokud je první hodnota rovna nebo větší než druhá hodnota. |
Example
Tyto příklady kontrolují, jestli je první hodnota menší než druhá hodnota.
less(5, 10)
less('banana', 'apple')
Vrátí tyto výsledky:
- První příklad:
true - Druhý příklad:
false
lessOrEquals
Zkontrolujte, jestli je první hodnota menší nebo rovna druhé hodnotě. Vrátí hodnotu true, pokud je první hodnota menší nebo rovna, nebo vrátí hodnotu false, pokud je první hodnota více.
lessOrEquals(<value>, <compareTo>)
lessOrEquals('<value>', '<compareTo>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | Celé číslo, float nebo řetězec | První hodnota, která zkontroluje, zda je menší než nebo rovna druhé hodnotě |
| < compareTo> | Yes | Celé číslo, Float nebo String | Položka porovnání |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, pokud je první hodnota menší nebo rovna druhé hodnotě. Vrátí hodnotu false, pokud je první hodnota větší než druhá hodnota. |
Example
Tyto příklady kontrolují, jestli je první hodnota menší nebo rovna druhé hodnotě.
lessOrEquals(10, 10)
lessOrEquals('apply', 'apple')
Vrátí tyto výsledky:
- První příklad:
true - Druhý příklad:
false
listCallbackUrl
Vrátit "callback URL" pro vyvolání události nebo akce. Tato funkce funguje pouze s triggery a akcemi pro typy konektorů HttpWebhook a ApiConnectionWebhook , ale ne s typy Manual, Recurrence, HTTP a APIConnection .
listCallbackUrl()
| Návratová hodnota | Typ | Description |
|---|---|---|
| < adresa URL zpětného volání> | String | Adresa URL zpětného volání pro spouštěč nebo akci |
Example
Tento příklad ukazuje ukázkovou adresu URL zpětného volání, kterou tato funkce může vrátit:
"https://prod-01.westus.logic.azure.com:443/workflows/<*workflow-ID*>/triggers/manual/run?api-version=2016-10-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=<*signature-ID*>"
M
max
Vrátí nejvyšší hodnotu ze seznamu nebo pole s čísly, která jsou na obou koncích inkluzivní.
max(<number1>, <number2>, ...)
max([<number1>, <number2>, ...])
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < číslo1>, <číslo2>, ... | Yes | Celé číslo, Float nebo obojí | Sada čísel, ze kterých chcete získat nejvyšší hodnotu |
| [<číslo1>, <číslo2>, ...] | Yes | Pole – celé číslo, Float, nebo obojí | Matice čísel, ze kterých chcete získat nejvyšší hodnotu |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < max-value> | Celé číslo nebo plovoucí číslo | Nejvyšší hodnota v zadané matici nebo množině čísel |
Example
Tyto příklady získají nejvyšší hodnotu ze sady čísel a pole:
max(1, 2, 3)
max(createArray(1, 2, 3))
A vrátit tento výsledek: 3
min
Vrátí nejnižší hodnotu ze sady čísel nebo pole.
min(<number1>, <number2>, ...)
min([<number1>, <number2>, ...])
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < číslo1>, <číslo2>, ... | Yes | Celé číslo, Float nebo obojí | Množina čísel, ze kterých chcete nejnižší hodnotu |
| [<číslo1>, <číslo2>, ...] | Yes | Pole – celé číslo, Float, nebo obojí | Matice čísel, ze kterých chcete nejnižší hodnotu |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Minimální hodnota> | Celé číslo nebo plovoucí číslo | Nejnižší hodnota ve specifikované sadě čísel nebo specifikovaném poli |
Example
Tyto příklady získají nejnižší hodnotu v množině čísel a poli:
min(1, 2, 3)
min(createArray(1, 2, 3))
A vrátit tento výsledek: 1
mod
Vrátí zbytek z dělení dvou čísel. Pokud chcete získat celočíselnou hodnotu, podívejte se na div().
mod(<dividend>, <divisor>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < dividenda> | Yes | Celé číslo nebo plovoucí číslo | Číslo, které se má dělit dělitelem |
| < dělitel> | Yes | Celé číslo nebo plovoucí číslo | Číslo, které dělí dividendu, ale nemůže být nula |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < modulo-result> | Celé číslo nebo plovoucí číslo | Zbytek od vydělení prvního čísla druhým číslem |
Příklad 1
Tento příklad vydělí první číslo druhým číslem:
mod(3, 2)
A vrátí tento výsledek: 1
Příklad 2
Tento příklad ukazuje, že pokud jedna nebo obě hodnoty jsou záporné, výsledek odpovídá znaménku dividendy:
mod(-5, 2)
mod(4, -3)
Příklad vrátí tyto výsledky:
- První příklad:
-1 - Druhý příklad:
1
mul
Vrátí součin od vynásobení dvou čísel.
mul(<multiplicand1>, <multiplicand2>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < multiplikand1> | Yes | Celé číslo nebo plovoucí číslo | Číslo, které se má vynásobit násobením2 |
| < multiplicand2> | Yes | Celé číslo nebo plovoucí číslo | Číslo, které násobí násobek1 |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < výsledek produktu> | Celé číslo nebo plovoucí číslo | Součin prvního čísla a druhého čísla |
Example
Tyto příklady násobí první číslo druhým číslem:
mul(1, 2)
mul(1.5, 2)
Vrátí tyto výsledky:
- První příklad:
2 - Druhý příklad
3
multipartBody
Získej tělo pro konkrétní část ve výstupu z akce, obsahující více částí.
multipartBody('<actionName>', <index>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < actionNázev> | Yes | String | Název akce, která má výstup s více částmi |
| < index> | Yes | Integer | Hodnota indexu požadované části |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < tělo> | String | Tělo pro zadanou část |
N
not
Zkontrolujte, jestli je výraz nepravda. Vrátí hodnotu true, pokud je výraz nepravda, nebo vrátí hodnotu false, pokud je true.
not(<expression>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < výraz> | Yes | logický | Výraz, který se má zkontrolovat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, pokud je výraz false. Vrátí hodnotu false, pokud je výraz pravdivý. |
Příklad 1
Tyto příklady kontrolují, jestli jsou zadané výrazy nepravdivé:
not(false)
not(true)
Vrátí tyto výsledky:
- První příklad: Výraz je false, takže funkce vrátí
true. - Druhý příklad: Výraz je pravdivý, takže funkce vrátí
false.
Příklad 2
Tyto příklady kontrolují, jestli jsou zadané výrazy nepravdivé:
not(equals(1, 2))
not(equals(1, 1))
Vrátí tyto výsledky:
- První příklad: Výraz je false, takže funkce vrátí
true. - Druhý příklad: Výraz je pravdivý, takže funkce vrátí
false.
nthIndexOf
Vrátí počáteční pozici nebo hodnotu indexu, kde sev řetězci zobrazí n. výskyt podřetězce.
nthIndexOf('<text>', '<searchText>', <occurrence>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec obsahující podřetězec, který se má najít |
| < searchText> | Yes | String | Podřetězec k nalezení |
| < výskyt> | Yes | Integer | Číslo určující n. výskyt podřetězce, který se má najít. Pokud je výskyt záporný, začněte hledat od konce. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < index-value> | Integer | Počáteční pozice nebo hodnota indexu pro n. výskyt zadaného podřetězce. Pokud podřetězce není nalezen nebo menší než n výskytů podřetězce existuje, vraťte -1. |
Examples
nthIndexOf('123456789123465789', '1', 1) // Returns `0`.
nthIndexOf('123456789123465789', '1', 2) // Returns `9`.
nthIndexOf('123456789123465789', '12', 2) // Returns `9`.
nthIndexOf('123456789123465789', '6', 4) // Returns `-1`.
O
or
Zkontrolujte, jestli je alespoň jeden výraz pravdivý. Vrátí hodnotu True, pokud je alespoň jeden výraz pravdivý, nebo vrátí hodnotu false, pokud jsou všechny hodnoty false.
or(<expression1>, <expression2>, ...)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < výraz1>, <výraz2>, ... | Yes | logický | Výrazy k ověření |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, pokud je alespoň jeden výraz pravdivý. Vrátí hodnotu false, pokud jsou všechny výrazy false. |
Příklad 1
Tyto příklady kontrolují, jestli je alespoň jeden výraz pravdivý:
or(true, false)
or(false, false)
Vrátí tyto výsledky:
- První příklad: Alespoň jeden výraz je pravdivý, takže funkce vrátí
true. - Druhý příklad: Oba výrazy jsou false, takže funkce vrátí
false.
Příklad 2
Tyto příklady kontrolují, jestli je alespoň jeden výraz pravdivý:
or(equals(1, 1), equals(1, 2))
or(equals(1, 2), equals(1, 3))
Vrátí tyto výsledky:
- První příklad: Alespoň jeden výraz je pravdivý, takže funkce vrátí
true. - Druhý příklad: Oba výrazy jsou false, takže funkce vrátí
false.
outputs
Vrátí výstupy akce za běhu.
outputs('<actionName>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < actionNázev> | Yes | String | Název požadovaného výstupu akce |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < výstup> | String | Výstup ze zadané akce |
Example
Tento příklad získá výstup z X akce Get user:
outputs('Get_user')
A vrátí tento výsledek:
{
"statusCode": 200,
"headers": {
"Pragma": "no-cache",
"Vary": "Accept-Encoding",
"x-ms-request-id": "a916ec8f52211265d98159adde2efe0b",
"X-Content-Type-Options": "nosniff",
"Timing-Allow-Origin": "*",
"Cache-Control": "no-cache",
"Date": "Mon, 09 Apr 2018 18:47:12 GMT",
"Set-Cookie": "ARRAffinity=b9400932367ab5e3b6802e3d6158afffb12fcde8666715f5a5fbd4142d0f0b7d;Path=/;HttpOnly;Domain=twitter-wus.azconn-wus.p.azurewebsites.net",
"X-AspNet-Version": "4.0.30319",
"X-Powered-By": "ASP.NET",
"Content-Type": "application/json; charset=utf-8",
"Expires": "-1",
"Content-Length": "339"
},
"body": {
"FullName": "Contoso Corporation",
"Location": "Generic Town, USA",
"Id": 283541717,
"UserName": "ContosoInc",
"FollowersCount": 172,
"Description": "Leading the way in transforming the digital workplace.",
"StatusesCount": 93,
"FriendsCount": 126,
"FavouritesCount": 46,
"ProfileImageUrl": "https://pbs.twimg.com/profile_images/908820389907722240/gG9zaHcd_400x400.jpg"
}
}
P
parameters
Vrátí hodnotu parametru popsaného v definici pracovního postupu.
parameters('<parameterName>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < parametr Název> | Yes | String | Název parametru, jehož hodnotu chcete |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < parametrová hodnota> | Any | Hodnota zadaného parametru |
Example
Předpokládejme, že máte tuto hodnotu JSON:
{
"fullName": "Sophia Owen"
}
Tento příklad získá hodnotu pro zadaný parametr:
parameters('fullName')
A vrátí tento výsledek: "Sophia Owen"
parseDateTime
Vrátí časové razítko z řetězce, který obsahuje časové razítko.
parseDateTime('<timestamp>', '<locale>'?, '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < dějiště> | No | String | Národní prostředí, které se má použít Pokud není zadáno, výchozí národní prostředí je en-us. Pokud národní prostředí není platná hodnota, vygeneruje se chyba. |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud není zadaný formát, zkuste analyzovat více formátů, které jsou kompatibilní se zadaným národním prostředím. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < parsed-timestamp> | String | Analyzované časové razítko ve formátu "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. |
Examples
parseDateTime('20/10/2014', 'fr-fr') // Returns '2014-10-20T00:00:00.0000000'.
parseDateTime('20 octobre 2010', 'fr-FR') // Returns '2010-10-20T00:00:00.0000000'.
parseDateTime('martes 20 octubre 2020', 'es-es') // Returns '2020-10-20T00:00:00.0000000'.
parseDateTime('21052019', 'fr-fr', 'ddMMyyyy') // Returns '2019-05-21T00:00:00.0000000'.
parseDateTime('20190521', 'fr-fr', 'yyyyMMdd') // Returns '2019-05-21T00:00:00.0000000'.
parseDateTime('10/20/2014 15h', 'en-US', 'MM/dd/yyyy HH\h') // Returns '2014-10-20T15:00:00.0000000'.
R
rand
Vrátí náhodné celé číslo ze zadaného rozsahu, které je inkluzivní pouze na počátečním konci.
rand(<minValue>, <maxValue>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < minValue> | Yes | Integer | Nejnižší celé číslo v rozsahu |
| < maxValue> | Yes | Integer | Celé číslo, které následuje za nejvyšším celým číslem v rozsahu, který může funkce vrátit |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < náhodný výsledek> | Integer | Náhodné celé číslo vrácené ze zadaného rozsahu |
Example
Tento příklad získá náhodné celé číslo ze zadaného rozsahu s výjimkou maximální hodnoty:
rand(1, 5)
A vrátí jedno z těchto čísel jako výsledek: 1, 2, 3, nebo 4
oblast
Vrátí celočíselnou matici, která začíná zadaným celočíselnou hodnotou.
range(<startIndex>, <count>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < startIndex> | Yes | Integer | Celočíselná hodnota, která spouští matici jako první položku |
| < počítat> | Yes | Integer | Počet celých čísel v poli Hodnota count parametru musí být kladné celé číslo, které nepřesahuje 100 000. Poznámka: Součet startIndex hodnot count nesmí překročit 2 147 483 647. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| [<rozsah-výsledek>] | Array | Pole s celými čísly počínaje zadaným indexem |
Example
Tento příklad vytvoří celočíselnou matici, která začíná zadaným indexem a má zadaný počet celých čísel:
range(1, 4)
A vrátí tento výsledek: [1, 2, 3, 4]
removeProperty
Odeberte z objektu vlastnost a vraťte aktualizovaný objekt. Pokud vlastnost, kterou se pokusíte odebrat, neexistuje, vrátí funkce původní objekt.
removeProperty(<object>, '<property>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < objekt> | Yes | Object | Objekt JSON, ze kterého chcete odebrat vlastnost |
| < vlastnost> | Yes | String | Název vlastnosti, která se má odebrat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < updated-object> | Object | Aktualizovaný objekt JSON bez zadané vlastnosti |
Chcete-li odebrat podřízenou vlastnost z existující vlastnosti, použijte tuto syntaxi:
removeProperty(<object>['<parent-property>'], '<child-property>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < objekt> | Yes | Object | Objekt JSON, jehož vlastnost chcete odebrat |
| < mateřské vlastnictví> | Yes | String | Název nadřazené vlastnosti s podřízenou vlastností, kterou chcete odebrat |
| < dětský majetek> | Yes | String | Název podřízené vlastnosti, kterou chcete odstranit |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < updated-object> | Object | Aktualizovaný objekt JSON, jehož podřízenou komponentu jste odebrali |
Příklad 1
Tento příklad odebere middleName vlastnost z objektu JSON, který se převede z řetězce na JSON pomocí funkce JSON() a vrátí aktualizovaný objekt:
removeProperty(json('{ "firstName": "Sophia", "middleName": "Anne", "surName": "Owen" }'), 'middleName')
Tady je aktuální objekt JSON:
{
"firstName": "Sophia",
"middleName": "Anne",
"surName": "Owen"
}
Tady je aktualizovaný objekt JSON:
{
"firstName": "Sophia",
"surName": "Owen"
}
Příklad 2
Tento příklad odebere middleName podřízenou customerName vlastnost z nadřazené vlastnosti v objektu JSON, který se převede z řetězce na JSON pomocí funkce JSON() a vrátí aktualizovaný objekt:
removeProperty(json('{ "customerName": { "firstName": "Sophia", "middleName": "Anne", "surName": "Owen" } }')['customerName'], 'middleName')
Tady je aktuální objekt JSON:
{
"customerName": {
"firstName": "Sophia",
"middleName": "Anne",
"surName": "Owen"
}
}
Tady je aktualizovaný objekt JSON:
{
"customerName": {
"firstName": "Sophia",
"surName": "Owen"
}
}
nahradit
Nahraďte podřetězce zadaným řetězcem a vraťte výsledný řetězec. Tato funkce rozlišuje malá a velká písmena.
replace('<text>', '<oldText>', '<newText>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec, který obsahuje podřetězec k nahrazení. |
| < oldText> | Yes | String | Podřetězec, který se má zaměnit |
| < newText> | Yes | String | Náhradní řetězec |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizovaný text> | String | Aktualizovaný řetězec po nahrazení podřetězce Pokud se podřetězec nenajde, vraťte původní řetězec. |
Example
Tento příklad najde podřetězec „starý“ v „starém řetězci“ a nahradí „starý“ slovem „nový“.
replace('the old string', 'old', 'new')
A vrátí tento výsledek: "the new string"
result
Vrátí výsledky z akcí nejvyšší úrovně v zadané akci s vymezeným oborem, jako je For_eachakce, Untilakce nebo Scopeakce. Funkce result() přijímá jeden parametr, což je název oboru, a vrátí pole, které obsahuje informace z akcí první úrovně v daném oboru. Tyto objekty akce zahrnují stejné atributy jako atributy vrácené actions() funkcí, jako je počáteční čas akce, čas ukončení, stav, vstupy, ID korelace a výstupy.
Note
Tato funkce vrací informace pouze z akcí první úrovně v akci s vymezeným oborem, a ne z hlubších vnořených akcí, jako jsou akce přepínače nebo podmínky.
Pomocí této funkce můžete například získat výsledky neúspěšných akcí, abyste mohli diagnostikovat a zpracovávat výjimky. Další informace naleznete v části Získání kontextu a výsledků selhání.
result('<scopedActionName>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < scopedActionName> | Yes | String | Název akce s vymezeným oborem, ve které chcete vstupy a výstupy z akcí nejvyšší úrovně v daném oboru |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < array-object> | Maticový objekt | Pole, které obsahuje pole vstupů a výstupů z každé akce nejvyšší úrovně uvnitř zadaného oboru |
Example
Tento příklad vrátí vstupy a výstupy z každé iterace akce HTTP uvnitř For_each smyčky pomocí result() funkce v Compose akci:
{
"actions": {
"Compose": {
"inputs": "@result('For_each')",
"runAfter": {
"For_each": [
"Succeeded"
]
},
"type": "compose"
},
"For_each": {
"actions": {
"HTTP": {
"inputs": {
"method": "GET",
"uri": "https://httpstat.us/200"
},
"runAfter": {},
"type": "Http"
}
},
"foreach": "@triggerBody()",
"runAfter": {},
"type": "Foreach"
}
}
}
Tady je postup, jak může vrácené pole vypadat, kde vnější outputs objekt obsahuje vstupy a výstupy z každé iterace akcí uvnitř For_each akce.
[
{
"name": "HTTP",
"outputs": [
{
"name": "HTTP",
"inputs": {
"uri": "https://httpstat.us/200",
"method": "GET"
},
"outputs": {
"statusCode": 200,
"headers": {
"X-AspNetMvc-Version": "5.1",
"Access-Control-Allow-Origin": "*",
"Cache-Control": "private",
"Date": "Tue, 20 Aug 2019 22:15:37 GMT",
"Set-Cookie": "ARRAffinity=0285cfbea9f2ee7",
"Server": "Microsoft-IIS/10.0",
"X-AspNet-Version": "4.0.30319",
"X-Powered-By": "ASP.NET",
"Content-Length": "0"
},
"startTime": "2019-08-20T22:15:37.6919631Z",
"endTime": "2019-08-20T22:15:37.95762Z",
"trackingId": "6bad3015-0444-4ccd-a971-cbb0c99a7.....",
"clientTrackingId": "085863526764.....",
"code": "OK",
"status": "Succeeded"
}
},
{
"name": "HTTP",
"inputs": {
"uri": "https://httpstat.us/200",
"method": "GET"
},
"outputs": {
"statusCode": 200,
"headers": {
"X-AspNetMvc-Version": "5.1",
"Access-Control-Allow-Origin": "*",
"Cache-Control": "private",
"Date": "Tue, 20 Aug 2019 22:15:37 GMT",
"Set-Cookie": "ARRAffinity=0285cfbea9f2ee7",
"Server": "Microsoft-IIS/10.0",
"X-AspNet-Version": "4.0.30319",
"X-Powered-By": "ASP.NET",
"Content-Length": "0"
},
"startTime": "2019-08-20T22:15:37.6919631Z",
"endTime": "2019-08-20T22:15:37.95762Z",
"trackingId": "9987e889-981b-41c5-aa27-f3e0e59bf69.....",
"clientTrackingId": "085863526764.....",
"code": "OK",
"status": "Succeeded"
}
}
]
}
]
reverse
Obrácení pořadí položek v kolekci Při použití této funkce s funkcí sort() můžete seřadit kolekci v sestupném pořadí.
reverse([<collection>])
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Array | Kolekce, která se má vrátit zpět |
| Návratová hodnota | Typ | Description |
|---|---|---|
| [<aktualizovaná sbírka>] | Array | Obrácená kolekce |
Example
Tento příklad obrátí pole celých čísel:
reverse(createArray(0, 1, 2, 3))
A vrátí toto pole: [3,2,1,0]
S
setProperty
Nastavte hodnotu vlastnosti objektu JSON a vraťte aktualizovaný objekt. Pokud vlastnost, kterou se pokusíte nastavit, neexistuje, vlastnost se přidá do objektu. Pokud chcete přidat novou vlastnost, použijte funkci addProperty().
setProperty(<object>, '<property>', <value>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < objekt> | Yes | Object | Objekt JSON, jehož vlastnost chcete nastavit |
| < vlastnost> | Yes | String | Název existující nebo nové vlastnosti, která se má nastavit |
| < hodnota> | Yes | Any | Hodnota nastavená pro zadanou vlastnost |
Chcete-li nastavit podřízenou vlastnost v podřízeném objektu, použijte místo toho vnořené setProperty() volání. V opačném případě vrátí funkce jako výstup pouze podřízený objekt.
setProperty(<object>, '<parent-property>', setProperty(<object>['parentProperty'], '<child-property>', <value>))
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < objekt> | Yes | Object | Objekt JSON, jehož vlastnost chcete nastavit |
| < mateřské vlastnictví> | Yes | String | Název nadřazené vlastnosti s podřízenou vlastností, kterou chcete nastavit |
| < dětský majetek> | Yes | String | Název podřízené vlastnosti, kterou je třeba nastavit |
| < hodnota> | Yes | Any | Hodnota nastavená pro zadanou vlastnost |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < updated-object> | Object | Aktualizovaný objekt JSON, jehož vlastnost jste nastavili |
Příklad 1
Tento příklad nastaví surName vlastnost v objektu JSON, který se převede z řetězce na JSON pomocí funkce JSON(). Funkce přiřadí zadanou hodnotu vlastnosti a vrátí aktualizovaný objekt:
setProperty(json('{ "firstName": "Sophia", "surName": "Owen" }'), 'surName', 'Hartnett')
Tady je aktuální objekt JSON:
{
"firstName": "Sophia",
"surName": "Owen"
}
Tady je aktualizovaný objekt JSON:
{
"firstName": "Sophia",
"surName": "Hartnett"
}
Příklad 2
Tento příklad nastaví podřízenou surName vlastnost customerName nadřazené vlastnosti v objektu JSON, který se převede z řetězce na JSON pomocí funkce JSON(). Funkce přiřadí zadanou hodnotu vlastnosti a vrátí aktualizovaný objekt:
setProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }'), 'customerName', setProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }')['customerName'], 'surName', 'Hartnett'))
Tady je aktuální objekt JSON:
{
"customerName": {
"firstName": "Sophie",
"surName": "Owen"
}
}
Tady je aktualizovaný objekt JSON:
{
"customerName": {
"firstName": "Sophie",
"surName": "Hartnett"
}
}
přeskočit
Odeberte položky z přední části kolekce a vraťte všechny ostatní položky.
skip([<collection>], <count>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Array | Kolekce, jejíž položky chcete odebrat |
| < počítat> | Yes | Integer | Kladné celé číslo pro počet položek, které se mají odebrat na přední straně |
| Návratová hodnota | Typ | Description |
|---|---|---|
| [<aktualizovaná sbírka>] | Array | Aktualizovaná kolekce po odebrání zadaných položek |
Example
Tento příklad odebere jednu položku, číslo 0, zepředu zadaného pole:
skip(createArray(0, 1, 2, 3), 1)
A vrátí toto pole se zbývajícími položkami: [1,2,3]
oblast
Vrátí podřetězec určením počáteční a koncové pozice nebo hodnot. Viz také podřetěžce().
slice('<text>', <startIndex>, <endIndex>?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec obsahující podřetězec, který se má najít |
| < startIndex> | Yes | Integer | Nulová počáteční pozice nebo hodnota, odkud začít hledat podřetězec - Pokud je hodnota startIndex větší než délka řetězce, vrátí prázdný řetězec. - Pokud je hodnota startIndex záporná, začněte hledat na hodnotě indexu, která je součtem délky řetězce a parametru startIndex. |
| < endIndex> | No | Integer | Koncová pozice nebo nulová hodnota, kde se má ukončit hledání podřetězce. Znak umístěný na koncové hodnotě indexu není součástí hledání. – Pokud endIndex není zadán nebo větší než délka řetězce, vyhledejte až na konec řetězce. - Pokud je hodnota endIndex záporná, ukončete vyhledávání na hodnotě indexu, kterou součet délky řetězce a endIndex. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < výsledek řezu> | String | Nový řetězec obsahující nalezený podřetězce |
Examples
slice('Hello World', 2) // Returns 'llo World'.
slice('Hello World', 30) // Returns ''.
slice('Hello World', 10, 2) // Returns ''.
slice('Hello World', 0) // Returns 'Hello World'.
slice('Hello World', 2, 5) // Returns 'llo'.
slice('Hello World', 6, 20) // Returns 'World'.
slice('Hello World', -2) // Returns 'ld'.
slice('Hello World', 3, -1) // Returns 'lo Worl'.
slice('Hello World', 3, 3) // Returns ''.
řadit
Seřaďte položky v kolekci. Objekty kolekce můžete třídit pomocí libovolného klíče, který obsahuje primitivní datový typ podporovaný jazykem Workflow Definition Language, například int, float, string nebo bool.
sort([<collection>], <sortBy>?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Array | Kolekce s položkami, které se mají seřadit |
| < sortBy> | No | String | Klíč, který se má použít k řazení objektů kolekce |
| Návratová hodnota | Typ | Description |
|---|---|---|
| [<aktualizovaná sbírka>] | Array | Seřazená kolekce |
Příklad 1
Tento příklad seřadí pole celých čísel:
sort(createArray(2, 1, 0, 3))
A vrátí toto pole: [0,1,2,3]
Příklad 2
Tento příklad seřadí pole objektů podle klíče:
sort(createArray(json('{ "first": "Amalie", "last": "Rose" }'), json('{ "first": "Elise", "last": "Renee" }')), 'last')
A vrátí toto pole: [{ "first": "Elise", "last": "Renee" }, {"first": "Amalie", "last": "Rose" }')]
rozdělit
Vrátí pole obsahující podřetězce oddělené čárkami na základě zadaného znaku oddělovače v původním řetězci.
split('<text>', '<delimiter>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec, který se má oddělit do podřetězců na základě zadaného oddělovače v původním řetězci |
| < oddělovač> | Yes | String | Znak v původním řetězci, který se má použít jako oddělovač |
| Návratová hodnota | Typ | Description |
|---|---|---|
| [<podřetěžk1,podřetěžk2><>,...] | Array | Pole obsahující podřetězce z původního řetězce oddělené čárkami |
Příklad 1
Tento příklad vytvoří pole s podřetězci ze zadaného řetězce na základě zadaného znaku jako oddělovače:
split('a_b_c', '_')
A vrátí toto pole jako výsledek: ["a","b","c"]
Příklad 2
Tento příklad vytvoří pole s jedním prvkem, pokud v řetězci neexistuje žádný oddělovač:
split('a_b_c', ' ')
A vrátí toto pole jako výsledek: ["a_b_c"]
startOfDay
Vrátí začátek dne podle časové značky.
startOfDay('<timestamp>', '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Zadané časové razítko, ale začíná na nulové hodině pro daný den. |
Example
Tento příklad najde začátek dne pro toto časové razítko:
startOfDay('2018-03-15T13:30:30Z')
A vrátí tento výsledek: "2018-03-15T00:00:00.0000000Z"
startOfHour
Vrátí začátek hodiny na časovém razítku.
startOfHour('<timestamp>', '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Zadané časové razítko, počínající nultou minutou pro hodinu |
Example
Tento příklad najde začátek hodiny pro toto časové razítko:
startOfHour('2018-03-15T13:30:30Z')
A vrátí tento výsledek: "2018-03-15T13:00:00.0000000Z"
startOfMonth
Vrátit začátek měsíce pro časové razítko.
startOfMonth('<timestamp>', '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Zadané časové razítko, ale začíná prvním dnem v měsíci na nulové hodině |
Příklad 1
Tento příklad vrátí začátek měsíce pro toto časové razítko:
startOfMonth('2018-03-15T13:30:30Z')
A vrátí tento výsledek: "2018-03-01T00:00:00.0000000Z"
Příklad 2
Tento příklad vrátí začátek měsíce v zadaném formátu pro toto časové razítko:
startOfMonth('2018-03-15T13:30:30Z', 'yyyy-MM-dd')
A vrátí tento výsledek: "2018-03-01"
startsWith
Zkontrolujte, jestli řetězec začíná určitým podřetězcem. Vrátí hodnotu true při nalezení podřetězce nebo vrátí hodnotu false, pokud nebyl nalezen. Tato funkce nerozlišuje malá a velká písmena.
startsWith('<text>', '<searchText>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec, který chcete zkontrolovat |
| < searchText> | Yes | String | Počáteční řetězec, který se má najít |
| Návratová hodnota | Typ | Description |
|---|---|---|
| pravda nebo lež | logický | Vrátí hodnotu true, pokud je nalezen počáteční podřetězec. Vrátí hodnotu false, pokud nebyla nalezena. |
Příklad 1
Tento příklad zkontroluje, jestli řetězec "hello world" začíná podřetězcem "hello":
startsWith('hello world', 'hello')
A vrátí tento výsledek: true
Příklad 2
Tento příklad zkontroluje, jestli řetězec "hello world" začíná podřetězcem "greetings":
startsWith('hello world', 'greetings')
A vrátí tento výsledek: false
řetězec
Vrátí verzi řetězce pro danou hodnotu.
string(<value>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | Any | Hodnota, kterou chcete převést. Pokud je tato hodnota null nebo je vyhodnocena jako null, hodnota se převede na prázdnou hodnotu řetězce (""). Pokud například přiřadíte řetězcovou proměnnou neexistující vlastnosti, ke které můžete přistupovat pomocí operátoru ? , hodnota null se převede na prázdný řetězec. Porovnání hodnoty null ale není stejné jako porovnání prázdného řetězce. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < řetězcová hodnota> | String | Textová verze pro zadanou hodnotu. Pokud je parametr hodnoty null nebo se vyhodnotí jako null, vrátí se tato hodnota jako prázdná hodnota řetězce (""). |
Příklad 1
Tento příklad vytvoří textovou verzi tohoto čísla.
string(10)
A vrátí tento výsledek: "10"
Příklad 2
Tento příklad vytvoří řetězec pro zadaný objekt JSON a použije zpětné lomítko (\) jako řídicí znak pro uvozovky (").
string( { "name": "Sophie Owen" } )
A vrátí tento výsledek: "{ \\"name\\": \\"Sophie Owen\\" }"
sub
Vrátí výsledek od odečtení druhého čísla od prvního čísla.
sub(<minuend>, <subtrahend>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < menšenec> | Yes | Celé číslo nebo plovoucí číslo | Číslo, od kterého se má odečíst subtrahend |
| < menšitel> | Yes | Celé číslo nebo plovoucí číslo | Číslo, které se má odečíst od minuendu |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < výsledek> | Celé číslo nebo plovoucí číslo | Výsledek od odečtení druhého čísla od prvního čísla |
Example
Tento příklad odečte druhé číslo od prvního čísla:
sub(10.3, .3)
A vrátí tento výsledek: 10
substring
Vrátí znaky z řetězce, počínaje zadanou pozicí nebo indexem. Hodnoty indexu začínají číslem 0. Viz také řez().
substring('<text>', <startIndex>, <length>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec, jehož znaky chcete |
| < startIndex> | Yes | Integer | Kladné číslo, které se rovná nebo větší než 0, které chcete použít jako počáteční pozici nebo hodnotu indexu |
| < délka> | No | Integer | Pozitivní počet znaků, které chcete v podřetězci |
Note
Ujistěte se, že součet z přidání hodnot parametru startIndex a length je menší než délka řetězce, který zadáte pro textový parametr. V opačném případě se zobrazí chyba, na rozdíl od podobných funkcí v jiných jazycích, kde je výsledkem podřetězce od startIndex na konec řetězce. Parametr length je volitelný a pokud není zadaný, funkce substring() přebírá všechny znaky začínající od startIndex na konec řetězce.
| Návratová hodnota | Typ | Description |
|---|---|---|
| < výsledek podřetědce> | String | Podřetězce se zadaným počtem znaků počínaje zadaným umístěním indexu ve zdrojovém řetězci |
Example
Tento příklad vytvoří podřetězec s pěti znaky ze zadaného řetězce počínaje hodnotou indexu 6:
substring('hello world', 6, 5)
A vrátí tento výsledek: "world"
subtractFromTime
Odečte počet časových jednotek od časového razítka. Viz také getPastTime.
subtractFromTime('<timestamp>', <interval>, '<timeUnit>', '<format>'?)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec obsahující časové razítko |
| < interval> | Yes | Integer | Počet zadaných časových jednotek, které se mají odečíst |
| < timeUnit> | Yes | String | Jednotka času, která se má použít s intervalem: "Second", "Minute", "Hour", "Day", "Week", "Month", "Year" |
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizované časové razítko> | String | Časové razítko minus zadaný počet časových jednotek |
Příklad 1
Tento příklad odečte jeden den od tohoto časového razítka:
subtractFromTime('2018-01-02T00:00:00Z', 1, 'Day')
A vrátí tento výsledek: "2018-01-01T00:00:00.0000000Z"
Příklad 2
Tento příklad odečte jeden den od tohoto časového razítka:
subtractFromTime('2018-01-02T00:00:00Z', 1, 'Day', 'D')
A vrátí tento výsledek pomocí volitelného formátu "D": "Monday, January, 1, 2018"
T
take
Vrátí položky z přední části kolekce.
take('<collection>', <count>)
take([<collection>], <count>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka> | Yes | Řetězec nebo pole | Kolekce, jejíž položky chcete |
| < počítat> | Yes | Integer | Kladné celé číslo pro počet požadovaných položek z přední části |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < podmnožina> nebo [<podmnožina>] | Řetězec nebo pole | Řetězec nebo pole se zadaným počtem položek převzatých z přední části původní kolekce |
Example
Tyto příklady získají zadaný počet položek z přední části těchto kolekcí:
take('abcde', 3)
take(createArray(0, 1, 2, 3, 4), 3)
Vrátí tyto výsledky:
- První příklad:
"abc" - Druhý příklad:
[0, 1, 2]
ticks
Vrátí počet tiků, což jsou intervaly po 100 nanosekundách, od 1. ledna 0001 12:00:00 půlnoci až po zadané časové razítko (jinak známé jako DateTime.Ticks v jazyce C#). Další informace naleznete v tomto tématu: DateTime.Ticks – vlastnost (Systém).
ticks('<timestamp>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < časová značka> | Yes | String | Řetězec pro časové razítko |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < ticks-number> | Integer | Počet tiků od zadaného časového razítka |
toLower
Vrátit řetězec v malých písmenech. Pokud znak v řetězci nemá malá písmena verze, zůstane tento znak ve vráceném řetězci beze změny.
toLower('<text>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec, který má být vrácen ve formátu malých písmen |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < malá písmena> | String | Původní text ve formátu malými písmeny |
Example
Tento příklad převede tento řetězec na malá písmena:
toLower('Hello World')
A vrátí tento výsledek: "hello world"
toUpper
Vrátí řetězec ve formátu velkými písmeny. Pokud znak v textovém řetězci nemá verzi velkého písmena, daný znak zůstane ve vráceném řetězci beze změny.
toUpper('<text>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec, který se má vrátit ve formátu velkých písmen |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < velká písmena – text> | String | Původní řetězec ve velkých písmenech |
Example
Tento příklad převede tento řetězec na velká písmena:
toUpper('Hello World')
A vrátí tento výsledek: "HELLO WORLD"
aktivační událost
Vrátí výstup triggeru za běhu nebo hodnoty z jiných dvojic názvů a hodnot JSON, které můžete přiřadit k výrazu.
Uvnitř vstupů triggeru tato funkce vrátí výstup z předchozího spuštění.
Uvnitř podmínky triggeru vrátí tato funkce výstup z aktuálního spuštění.
Ve výchozím nastavení funkce odkazuje na celý objekt triggeru, ale volitelně můžete zadat vlastnost, jejíž hodnotu chcete. Tato funkce má také k dispozici zkrácené verze, viz triggerOutputs() a triggerBody().
trigger()
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Trigger-output> | String | Výstup spouštěcího mechanismu při běhu aplikace |
triggerBody
Vrátí výstup triggeru body za běhu. Zkratka pro trigger().outputs.body. Viz trigger().
triggerBody()
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Výstup spouštěcího těla> | String | Výstup body ze spouštěče |
triggerFormDataMultiValues
Vrátí pole s hodnotami, které odpovídají názvu klíče ve výstupu s daty formuláře nebo kódovanými formulářem triggeru.
triggerFormDataMultiValues('<key>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < klíč> | Yes | String | Název klíče, jehož hodnotu chcete získat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| [<pole s klíčovými hodnotami>] | Array | Pole se všemi hodnotami, které odpovídají zadanému klíči |
Example
Tento příklad vytvoří pole z hodnoty klíče "feedUrl" ve výstupu dat formuláře nebo ve formou kódovaném výstupu triggeru RSS.
triggerFormDataMultiValues('feedUrl')
A vrátí toto pole jako příklad výsledku: ["https://feeds.a.dj.com/rss/RSSMarketsMain.xml"]
triggerFormDataValue
Vrátí řetězec s jednou hodnotou, která odpovídá názvu klíče ve výstupu formuláře nebo ve výstupu s kódováním formuláře triggeru. Pokud funkce najde více než jednu shodu, vyvolá funkce chybu.
triggerFormDataValue('<key>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < klíč> | Yes | String | Název klíče, jehož hodnotu chcete získat |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < klíč-hodnota> | String | Hodnota v zadaném klíči |
Example
Tento příklad vytvoří řetězec z hodnoty klíče "feedUrl" ve výstupu formulářových dat nebo formátovaného formuláře z RSS triggeru:
triggerFormDataValue('feedUrl')
A vrátí tento řetězec jako příklad výsledku: "https://feeds.a.dj.com/rss/RSSMarketsMain.xml"
triggerMultipartBody
Vrátí obsah pro konkrétní část ve výstupu triggery, který obsahuje více částí.
triggerMultipartBody(<index>)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < index> | Yes | Integer | Hodnota indexu požadované části |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < tělo> | String | Tělo pro zadanou část ve více částovém výstupu spouštěče |
triggerOutputs
Vrátí výstup triggeru během spuštění nebo hodnoty z jiných dvojic názvů a hodnot JSON. Zkratka pro trigger().outputs. Viz trigger().
triggerOutputs()
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Trigger-output> | String | Výstup spouštěcího mechanismu při běhu aplikace |
stříhat
Odstraňte počáteční a koncové prázdné znaky z řetězce a vraťte aktualizovaný řetězec.
trim('<text>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < Text> | Yes | String | Řetězec s úvodními a koncovými bílými mezerami, které je třeba odstranit. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizovánText> | String | Aktualizovaná verze původního řetězce bez počáteční nebo koncové mezery |
Example
Tento příklad odebere úvodní a koncové mezery z řetězce "Hello World".
trim(' Hello World ')
A vrátí tento výsledek: "Hello World"
U
sjednocení
Vrátí kolekci, která obsahuje všechny položky ze zadaných kolekcí. Chcete-li se zobrazit ve výsledku, může se položka zobrazit v libovolné kolekci předané této funkci. Pokud má jedna nebo více položek stejný název, zobrazí se ve výsledku poslední položka s tímto názvem.
union('<collection1>', '<collection2>', ...)
union([<collection1>], [<collection2>], ...)
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < sbírka1>, <kolekce2>, ... | Yes | Matice nebo objekt, ale ne obojí | Kolekce, ze kterých chcete všechny položky |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktualizovaná kolekce> | Pole nebo objekt, respektive | Kolekce se všemi položkami ze zadaných kolekcí – žádné duplicity |
Example
Tento příklad získá všechny položky z těchto kolekcí:
union(createArray(1, 2, 3), createArray(1, 2, 10, 101))
A vrátí tento výsledek: [1, 2, 3, 10, 101]
uriComponent
Vytvořte zakódovanou verzi identifikátoru URI (Uniform Resource Identifier) pro řetězec nahrazením znaků nebezpečných pro adresu URL únikovými znaky. Místo kódováníUriComponent()použijte tuto funkci. I když obě funkce fungují stejným způsobem, uriComponent() je preferováno.
uriComponent('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec, který se má převést na URI-kódovaný formát |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Encoded-uri> | String | Řetězec kódovaný ve formátu URI se znaky úniku |
Example
Tento příklad vytvoří verzi kódovanou identifikátorem URI pro tento řetězec:
uriComponent('https://contoso.com')
A vrátí tento výsledek: "https%3A%2F%2Fcontoso.com"
uriComponentToBinary
Vrátí binární verzi pro součást identifikátoru URI (Uniform Resource Identifier).
uriComponentToBinary('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec kódovaný identifikátorem URI pro převod |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < binary-for-encoded-uri> | String | Binární verze řetězce kódovaného identifikátorem URI. Binární obsah je kódován base64 a reprezentován $content. |
Example
Tento příklad vytvoří binární verzi pro tento řetězec kódovaný identifikátorem URI:
uriComponentToBinary('https%3A%2F%2Fcontoso.com')
A vrátí tento výsledek: "aHR0cHM6Ly9jb250b3NvLmNvbQ=="
uriComponentToString
Vrátí verzi řetězce pro řetězec kódovaný identifikátorem URI (Uniform Resource Identifier), který efektivně dekóduje řetězec kódovaný identifikátorem URI.
uriComponentToString('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec kódovaný identifikátorem URI pro dekódování |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < dekódovaný identifikátor URI> | String | Dekódovaná verze řetězce kódovaného identifikátorem URI |
Example
Tento příklad vytvoří dekódovanou verzi řetězce pro tento řetězec kódovaný identifikátorem URI:
uriComponentToString('https%3A%2F%2Fcontoso.com')
A vrátí tento výsledek: "https://contoso.com"
uriHost
Vrátit hodnotu host pro URI (Uniform Resource Identifier).
uriHost('<uri>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < identifikátor uri> | Yes | String | Identifikátor URI, jehož host hodnotu chcete |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < hodnota hostitele> | String | Hodnota host zadaného identifikátoru URI |
Example
Tento příklad najde hodnotu pro tuto URI: host
uriHost('https://www.localhost.com:8080')
A vrátí tento výsledek: "www.localhost.com"
uriPath
Vrátit hodnotu path pro URI (Uniform Resource Identifier).
uriPath('<uri>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < identifikátor uri> | Yes | String | Identifikátor URI, jehož path hodnotu chcete |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Hodnota cesty> | String | Hodnota path zadaného identifikátoru URI. Pokud path nemá hodnotu, vraťte znak "/". |
Example
Tento příklad najde hodnotu pro tuto URI: path
uriPath('https://www.contoso.com/catalog/shownew.htm?date=today')
A vrátí tento výsledek: "/catalog/shownew.htm"
uriPathAndQuery
Vraťte hodnoty path a query pro identifikátor URI (Uniform Resource Identifier).
uriPathAndQuery('<uri>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < identifikátor uri> | Yes | String | Identifikátor URI, jehož path a query hodnoty chcete |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < Path-query-value> | String | Hodnoty path a query pro zadaný identifikátor URI. Pokud path nezadáte hodnotu, vrátí znak "/". |
Example
Tento příklad určí hodnoty path a query pro tento URI:
uriPathAndQuery('https://www.contoso.com/catalog/shownew.htm?date=today')
A vrátí tento výsledek: "/catalog/shownew.htm?date=today"
uriPort
Vrátit hodnotu port pro URI (Uniform Resource Identifier).
uriPort('<uri>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < identifikátor uri> | Yes | String | Identifikátor URI, jehož port hodnotu chcete |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < hodnota portu> | Integer | Hodnota port zadaného identifikátoru URI. Pokud port nezadáte hodnotu, vraťte výchozí port protokolu. |
Example
Tento příklad vrátí hodnotu port pro tuto URI:
uriPort('https://www.localhost:8080')
A vrátí tento výsledek: 8080
uriQuery
Vrátit hodnotu query pro URI (Uniform Resource Identifier).
uriQuery('<uri>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < identifikátor uri> | Yes | String | Identifikátor URI, jehož query hodnotu chcete |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < dotazová hodnota> | String | Hodnota query zadaného identifikátoru URI |
Example
Tento příklad vrátí hodnotu query pro tuto URI:
uriQuery('https://www.contoso.com/catalog/shownew.htm?date=today')
A vrátí tento výsledek: "?date=today"
uriScheme
Vrátit hodnotu scheme pro URI (Uniform Resource Identifier).
uriScheme('<uri>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < identifikátor uri> | Yes | String | Identifikátor URI, jehož scheme hodnotu chcete |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < scheme-value> | String | Hodnota scheme zadaného identifikátoru URI |
Example
Tento příklad vrátí hodnotu scheme pro tuto URI:
uriScheme('https://www.contoso.com/catalog/shownew.htm?date=today')
A vrátí tento výsledek: "http"
utcNow
Vraťte aktuální časové razítko.
utcNow('<format>')
Volitelně můžete zadat jiný formát pomocí parametru <formátu> .
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < formát> | No | String | Řetězec číselného formátu, který je specifikátorem jednoho formátu nebo vlastním vzorem formátu. Výchozí formát časového razítka je "o" (rrrr-MM-ddTHH:mm:ss.fffffffK), který odpovídá normě ISO 8601 a zachovává informace o časovém pásmu. Pokud formát není platná hodnota, vygeneruje se chyba. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < aktuální časové razítko> | String | Aktuální datum a čas |
Examples
utcNow() // Returns 2025-09-25T05:18:31.3384797Z
utcNow('u') // Returns 2025-09-25 05:18:31Z
utcNow('U') // Returns Thursday, September 25, 2025 5:18:31 AM
utcNow('d') // Returns 9/25/2025
utcNow('D') // Returns Thursday, September 25, 2025
utcNow('t') // Returns 5:18 AM
utcNow('T') // Returns 5:18:31 AM
utcNow('y') // Returns September 2025
utcNow('yyyy') // Returns 2025
utcNow('ddd, d MMM yyyy') // Returns Thu, 25 Sep 2025
V
variables
Vrátí hodnotu pro zadanou proměnnou.
variables('<variableName>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < variableName> | Yes | String | Název proměnné, jejíž hodnotu chcete použít. |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < proměnná-hodnota> | Any | Hodnota pro zadanou proměnnou |
Example
Předpokládejme, že aktuální hodnota proměnné "numItems" je 20. Tento příklad získá celočíselnou hodnotu pro tuto proměnnou:
variables('numItems')
A vrátí tento výsledek: 20
W
pracovní postup
Vrátí všechny podrobnosti o pracovním postupu během jeho provádění.
workflow().<property>
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < vlastnost> | No | String | Název vlastnosti pracovního postupu, jejíž hodnotu chcete Ve výchozím nastavení má objekt pracovního postupu tyto vlastnosti: name, type, id, location, run, a tags. - Hodnota run vlastnosti je objekt JSON, který obsahuje tyto vlastnosti: name, typea id. – Vlastnost tags je objekt JSON, který obsahuje značky přidružené k vaší aplikaci logiky v Azure Logic Apps nebo tok v Power Automate a hodnoty těchto značek. Další informace o značkách v prostředcích Azure najdete v tématu Označování prostředků, skupin prostředků a předplatných pro logickou organizaci v Azure. Poznámka: Ve výchozím nastavení nemá aplikace logiky žádné značky, ale tok Power Automate má značky flowDisplayName a environmentName značky. |
Příklad 1
Tento příklad vrátí název aktuálního spuštění pracovního postupu:
workflow().run.name
Příklad 2
Pokud používáte Power Automate, můžete vytvořit @workflow() výraz, který pomocí tags výstupní vlastnosti získá hodnoty z vlastnosti toku flowDisplayName nebo environmentName.
Můžete například posílat vlastní e-mailová oznámení ze samotného toku, která odkazují zpět na váš tok. Tato oznámení můžou obsahovat odkaz HTML, který obsahuje zobrazované jméno toku v názvu e-mailu a následující syntaxi:
<a href=https://flow.microsoft.com/manage/environments/@{workflow()['tags']['environmentName']}/flows/@{workflow()['name']}/details>Open flow @{workflow()['tags']['flowDisplayName']}</a>
X
xml
Vrátí verzi XML pro řetězec, který obsahuje objekt JSON.
xml('<value>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < hodnota> | Yes | String | Řetězec s objektem JSON pro převod Objekt JSON musí mít pouze jednu kořenovou vlastnost, což nemůže být pole. Zpětné lomítko (\) použijte jako řídicí znak uvozovek ("). |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < xml-verze> | Object | Kódovaný kód XML pro zadaný řetězec nebo objekt JSON |
Příklad 1
Tento příklad převede řetězec na XML:
xml('<name>Sophia Owen</name>')
A vrátí tento výsledek XML:
<name>Sophia Owen</name>
Příklad 2
Tento příklad vytvoří verzi XML pro tento řetězec, který obsahuje objekt JSON:
xml(json('{ "name": "Sophia Owen" }'))
A vrátí tento výsledek XML:
<name>Sophia Owen</name>
Příklad 3
Předpokládejme, že máte tento objekt JSON:
{
"person": {
"name": "Sophia Owen",
"city": "Seattle"
}
}
Tento příklad vytvoří XML pro řetězec, který obsahuje tento objekt JSON:
xml(json('{"person": {"name": "Sophia Owen", "city": "Seattle"}}'))
A vrátí tento výsledek XML:
<person>
<name>Sophia Owen</name>
<city>Seattle</city>
<person>
Příklad 4
Funkce xml() očekává buď objekt, nebo řetězec obsahující platný KÓD XML. Funkce nepřijímá nezpracované pole jako vstup.
Pokud jsou data řetězcem JSON, můžete pomocí json() funkce před předáním výsledku xml() funkci převést řetězec na objekt JSON, například:
xml(
json('{"root":{"array":[
{ "ID": 1, "Name": "James" },
{ "ID": 2, "Name": "John" },
{ "ID": 3, "Name": "Sam" }
]}}')
)
Pokud máte pole JSON, podobně jako v následujícím příkladu, máte tři možnosti.
[
{ "ID": 1, "Name": "James" },
{ "ID": 2, "Name": "John" },
{ "ID": 3, "Name": "Sam" }
]
Možnost 1: Uložte pole JSON v akci Vytvořit s názvem Compose1. Pak pomocí outputs() funkce vrátíte objekt JSON z Compose1.
{
"root": { "array": @{outputs('Compose1')} }
}
Vrácený objekt JSON uložte v jiné akci s názvem Compose2. Pak můžete pomocí xml()outputs() funkcí vytvořit XML z výstupu objektu JSON z Compose2, například:
xml(outputs('Compose2'))
Možnost 2: Uložte pole JSON v akci Vytvořit s názvem Compose1. Pak pomocí outputs()funkcí , , concat()json()a xml() funkce vytvořit XML z výstupu objektu JSON, například:
xml(
json(
concat(
'{"root":{"array":',
outputs('Compose1'),
'}}'
)
)
)
Možnost 3: Uložte pole JSON v akci Vytvořit s názvem Compose1. Pak můžete pomocí outputs()funkce , , json()addProperty()a xml() funkce vytvořit XML z výstupu objektu JSON, například:
xml(
addProperty(
json('{}'),
'root',
addProperty(
json('{}'),
'array',
outputs('Compose1')
)
)
)
Všechny příklady, které zahrnují příklad řetězcových dat JSON a možnosti 1 až 3, vrátí následující výsledek XML:
<root>
<array>
<ID>1</ID>
<Name>James</Name>
</array>
<array>
<ID>2</ID>
<Name>John</Name>
</array>
<array>
<ID>3</ID>
<Name>Sam</Name>
</array>
</root>
xpath
Zkontrolujte kód XML pro uzly nebo hodnoty, které odpovídají výrazu XPath (XML Path Language) a vrátí odpovídající uzly nebo hodnoty. Výraz XPath nebo jen XPath vám pomůže procházet strukturu dokumentu XML, abyste mohli vybrat uzly nebo výpočetní hodnoty v obsahu XML.
Note
V aplikacích logiky Consumption a Standard používají všechny funkční výrazy knihovnu .NET XPath. Výrazy XPath jsou kompatibilní s podkladovou knihovnou .NET a podporují pouze výraz, který podporuje podkladová knihovna .NET.
xpath('<xml>', '<xpath>')
| Parameter | Required | Typ | Description |
|---|---|---|---|
| < xml> | Yes | Any | Řetězec XML pro vyhledávání uzlů nebo hodnot, které odpovídají hodnotě výrazu XPath |
| < xpath> | Yes | Any | Výraz XPath použitý k vyhledání odpovídajících uzlů NEBO hodnot XML |
| Návratová hodnota | Typ | Description |
|---|---|---|
| < xml-node> | jazyk XML | Uzel XML, pokud pouze jeden uzel odpovídá zadanému výrazu XPath |
| < hodnota> | Any | Hodnota z uzlu XML, pokud pouze jedna hodnota odpovídá zadanému výrazu XPath |
| [<xml-node1>, <xml-node2>, ...] -or- [<hodnota1>, <hodnota2>, ...] | Array | Pole s uzly XML nebo hodnotami, které odpovídají zadanému výrazu XPath |
Příklad 1
Předpokládejme, že máte tento 'items' řetězec XML:
<?xml version="1.0"?>
<produce>
<item>
<name>Gala</name>
<type>apple</type>
<count>20</count>
</item>
<item>
<name>Honeycrisp</name>
<type>apple</type>
<count>10</count>
</item>
</produce>
Tento příklad předá výraz XPath, aby našel uzly, '/produce/item/name/text()'které odpovídají <name></name> uzlu v 'items' řetězci XML, a vrátí pole s těmito hodnotami uzlu:
xpath(xml(parameters('items')), '/produce/item/name/text()')
Příklad také používá funkci parameters() k získání řetězce 'items' XML a převodu řetězce do formátu XML pomocí funkce xml().
Tady je pole výsledků naplněné hodnotami uzlů, které odpovídají <name></name>:
[ Gala, Honeycrisp ]
Příklad 2
Na základě příkladu 1 tento příklad předává výraz XPath '/produce/item/name[1]' k nalezení prvního prvku name, který je podřízený elementu item.
xpath(xml(parameters('items')), '/produce/item/name[1]')
Tady je výsledek: Gala
Příklad 3
Následující příklad k příkladu 1 předá výraz XPath '/produce/item/name[last()]', aby našel poslední prvek name, který je podřízený elementu item.
xpath(xml(parameters('items')), '/produce/item/name[last()]')
Tady je výsledek: Honeycrisp
Příklad 4
V tomto příkladu předpokládejme, že řetězec XML items obsahuje atributy expired='true' a expired='false':
<?xml version="1.0"?>
<produce>
<item>
<name expired='true'>Gala</name>
<type>apple</type>
<count>20</count>
</item>
<item>
<name expired='false'>Honeycrisp</name>
<type>apple</type>
<count>10</count>
</item>
</produce>
Tento příklad předá výraz XPath, '//name[@expired]', aby vyhledal všechny prvky name, které mají atribut expired.
xpath(xml(parameters('items')), '//name[@expired]')
Tady je výsledek: [ Gala, Honeycrisp ]
Příklad 5
V tomto příkladu předpokládejme, že řetězec items XML obsahuje pouze tento atribut: expired = 'true'
<?xml version="1.0"?>
<produce>
<item>
<name expired='true'>Gala</name>
<type>apple</type>
<count>20</count>
</item>
<item>
<name>Honeycrisp</name>
<type>apple</type>
<count>10</count>
</item>
</produce>
Tento příklad předá výraz XPath '//name[@expired = 'true']' a vyhledá všechny elementy name, které mají atribut expired = 'true'.
xpath(xml(parameters('items')), '//name[@expired = 'true']')
Tady je výsledek: [ Gala ]
Příklad 6
V tomto příkladu předpokládejme, že items řetězec XML obsahuje také tyto atributy:
expired='true' price='12'expired='false' price='40'
<?xml version="1.0"?>
<produce>
<item>
<name expired='true' price='12'>Gala</name>
<type>apple</type>
<count>20</count>
</item>
<item>
<name expired='false' price='40'>Honeycrisp</name>
<type>apple</type>
<count>10</count>
</item>
</produce>
Tento příklad předá výraz XPath, '//name[@price>35]', k nalezení všech prvků name, které mají price > 35.
xpath(xml(parameters('items')), '//name[@price>35]')
Tady je výsledek: Honeycrisp
Příklad 7
V tomto příkladu předpokládejme, že items váš řetězec XML je stejný jako v příkladu 1:
<?xml version="1.0"?>
<produce>
<item>
<name>Gala</name>
<type>apple</type>
<count>20</count>
</item>
<item>
<name>Honeycrisp</name>
<type>apple</type>
<count>10</count>
</item>
</produce>
Tento příklad najde uzly, které odpovídají <count></count> uzlu, a přidá tyto hodnoty uzlů pomocí sum() funkce:
xpath(xml(parameters('items')), 'sum(/produce/item/count)')
Tady je výsledek: 30
Příklad 8
V tomto příkladu předpokládejme, že máte tento řetězec XML, který obsahuje obor názvů dokumentu XML: xmlns="https://contoso.com"
<?xml version="1.0"?><file xmlns="https://contoso.com"><location>Paris</location></file>
Tyto výrazy používají buď výraz XPath, /*[name()="file"]/*[name()="location"] nebo /*[local-name()="file" and namespace-uri()="https://contoso.com"]/*[local-name()="location"], k vyhledání uzlů, které odpovídají <location></location> uzlu. Tyto příklady ukazují syntaxi, kterou používáte v návrháři nebo v editoru výrazů:
xpath(xml(body('Http')), '/*[name()="file"]/*[name()="location"]')xpath(xml(body('Http')), '/*[local-name()="file" and namespace-uri()="https://contoso.com"]/*[local-name()="location"]')
Tady je výsledný uzel, který odpovídá <location></location> uzlu:
<location xmlns="https://contoso.com">Paris</location>
Important
Pokud pracujete v zobrazení kódu, pro únik dvojitých uvozovek (") použijte znak zpětného lomítka (\). Pokud například serializujete výraz jako JSON řetězec, musíte použít únikové znaky. Pokud ale pracujete v návrháři nebo editoru výrazů, nemusíte ručně vkládat uvozovky, protože zpětné lomítko je automaticky přidáno do podkladového definice, například:
Zobrazení kódu:
xpath(xml(body('Http')), '/*[name()=\"file\"]/*[name()=\"location\"]')Editor výrazů:
xpath(xml(body('Http')), '/*[name()="file"]/*[name()="location"]')
Příklad 9
Podobně jako v příkladu 8, tento příklad používá výraz XPath 'string(/*[name()="file"]/*[name()="location"])' na vyhledání hodnoty v uzlu <location></location>.
xpath(xml(body('Http')), 'string(/*[name()="file"]/*[name()="location"])')
Tady je výsledek: Paris
Další kroky
Další informace o jazyce definice pracovního postupu