Guida di riferimento alle funzioni nelle espressioni per i flussi di lavoro in App per la logica di Azure e Power Automate

Si applica a: Azure Logic Apps (Consumo + Standard)

Per la definizione dei flussi di lavoro in App per la logica di Azure e Power Automate, alcune espressioni ottengono i rispettivi valori da azioni di runtime che potrebbero non esistere all'inizio dell'esecuzione del flusso di lavoro. To reference or process the values in these expressions, you can use expression functions provided by the Workflow Definition Language.

For example, you can calculate values by using math functions, such as the add() function, when you want the sum from integers or floats. Ecco altri esempi di attività che possono essere eseguite con le funzioni:

Per trovare le funzioni in base all'utilizzo generico, esaminare le tabelle seguenti. Or, for detailed information about each function, see the alphabetical list.

Funzioni nelle espressioni

To show how to use a function in an expression, this example shows how you can get the value from the customerName parameter and assign that value to the accountName property by using the parameters() function in an expression:

"accountName": "@parameters('customerName')"

Di seguito sono indicati altri modi generali per l'uso delle funzioni nelle espressioni:

Ad esempio, la funzione concat() può accettare due o più valori di stringa come parametri. Questa funzione combina queste stringhe in un'unica stringa. È possibile passare valori letterali di stringa, ad esempio, "Sophia" e "Owen", in modo da ottenere una stringa combinata, ovvero "SophiaOwen":

"customerName": "@concat('Sophia', 'Owen')"

In alternativa, è possibile ottenere i valori delle stringhe dai parametri. Questo esempio usa la funzione parameters() in ogni parametro concat() e i parametri firstName e lastName. Si passano quindi le stringhe risultanti alla funzione concat() in modo da ottenere una stringa combinata, ad esempio "SophiaOwen":

"customerName": "@concat(parameters('firstName'), parameters('lastName'))"

In entrambi i casi, gli esempi assegnano il risultato alla proprietà customerName.

Considerazioni sull'uso delle funzioni

• La finestra di progettazione non valuta le espressioni di runtime usate come parametri di funzione in fase di progettazione. La finestra di progettazione richiede che tutte le espressioni possano essere valutate completamente in fase di progettazione.

• I parametri della funzione sono valutati da sinistra a destra.

• Nella sintassi per le definizioni dei parametri, un punto interrogativo (?) visualizzato dopo un parametro indica che il parametro è facoltativo. For example, see getFutureTime().

• Le espressioni di funzione visualizzate inline con testo normale richiedono invece di racchiudere parentesi graffe ({}) per usare il formato interpolato dell'espressione. Questo formato consente di evitare problemi di analisi. Se l'espressione di funzione non viene visualizzata inline con testo normale, non sono necessarie parentesi graffe.

  L'esempio seguente mostra la sintassi corretta e errata:

  Correct: "<text>/@{<function-name>('<parameter-name>')}/<text>"

  Incorrect: "<text>/@<function-name>('<parameter-name>')/<text>"

  OK: "@<function-name>('<parameter-name>')"

The following sections organize functions based on their general purpose, or you can browse these functions in alphabetical order.

String functions

To work with strings, you can use these string functions and also some collection functions. Le funzioni di stringa funzionano solo sulle stringhe.

Collection functions

Per eseguire operazioni con le raccolte, generalmente matrici, stringhe e talvolta dizionari, è possibile usare queste funzioni di raccolta.

Funzioni di confronto logico

Per eseguire operazioni con le condizioni, confrontare i valori e i risultati delle espressioni o valutare vari tipi di logica, è possibile usare queste funzioni di confronto logico. For the full reference about each function, see the alphabetical list.

Conversion functions

Per modificare il tipo o il formato di un valore, è possibile usare queste funzioni di conversione. Ad esempio, è possibile modificare un valore da booleano a intero. Per altre informazioni su come App per la logica di Azure gestisce i tipi di contenuto durante la conversione, vedere Gestire i tipi di contenuto. For the full reference about each function, see the alphabetical list.

Conversioni implicite del tipo di dati

App per la logica di Azure converte automaticamente o in modo implicito tra alcuni tipi di dati, quindi non è necessario eseguire manualmente queste conversioni. Ad esempio, se si usano valori non stringa in cui le stringhe sono previste come input, App per la logica di Azure converte automaticamente i valori non stringa in stringhe.

Si supponga, ad esempio, che un trigger restituisca un valore numerico come output:

triggerBody()?['123']

Se si usa questo output numerico in cui è previsto l'input stringa, ad esempio un URL, App per la logica di Azure converte automaticamente il valore in una stringa usando la notazione parentesi graffe ({}):

@{triggerBody()?['123']}

Codifica e decodifica Base64

App per la logica di Azure esegue automaticamente o in modo implicito la codifica o la decodifica base64, pertanto non è necessario eseguire manualmente queste conversioni usando le funzioni corrispondenti:

• base64(<value>)
• base64ToBinary(<value>)
• base64ToString(<value>)
• base64(decodeDataUri(<value>))
• concat('data:;base64,',<value>)
• concat('data:,',encodeUriComponent(<value>))
• decodeDataUri(<value>)

Math functions

Per eseguire operazioni con numeri interi o float, è possibile usare queste funzioni matematiche. For the full reference about each function, see the alphabetical list.

Funzioni di data e ora

Per eseguire operazioni con date e ore, è possibile usare queste funzioni di data e ora. For the full reference about each function, see the alphabetical list.

Workflow functions

Queste funzioni del flusso di lavoro consentono di eseguire queste operazioni:

• Ottenere dettagli su un'istanza del flusso di lavoro al momento dell'esecuzione.
• Eseguire operazioni con gli input usati per creare istanze di app per la logica o dei flussi.
• Fare riferimento agli output da azioni e trigger.

Ad esempio, è possibile fare riferimento agli output di un'azione e usare i dati in un'azione successiva. For the full reference about each function, see the alphabetical list.

Funzioni di analisi URI

Per eseguire operazioni con URI (Uniform Resource Identifier) e ottenere vari valori di proprietà per questi URI, è possibile usare queste funzioni di analisi dell'URI. For the full reference about each function, see the alphabetical list.

Funzioni di manipolazione: JSON & XML

Per eseguire operazioni con gli oggetti JSON e i nodi XML, è possibile usare queste funzioni di manipolazione. For the full reference about each function, see the alphabetical list.

---------------------------------

Tutte le funzioni in ordine alfabetico

Questa sezione elenca tutte le funzioni disponibili in ordine alfabetico.

A

action

Return the current action's output at runtime, or values from other JSON name-and-value pairs, which you can assign to an expression. Per impostazione predefinita, questa funzione fa riferimento all'intero oggetto azione, ma è possibile specificare una proprietà con il valore desiderato. See also actions().

È possibile usare la funzione action() solo in queste posizioni:

• Proprietà unsubscribe per un'azione webhook, in modo che sia possibile accedere al risultato dalla richiesta subscribe originale
• Proprietà trackedProperties per un'azione
• Condizione di ciclo do-until per un'azione

action()
action().outputs.body.<property>

actions

Restituisce l'output di un'azione in fase di esecuzione oppure i valori di altre coppie nome-valore JSON che è possibile assegnare a un'espressione. Per impostazione predefinita, questa funzione fa riferimento all'intero oggetto azione, ma è possibile specificare una proprietà con il valore desiderato. For shorthand versions, see body(). For the current action, see action().

actions('<actionName>')
actions('<actionName>').outputs.body.<property>

Example

Questo esempio ottiene il valore della status proprietà dall'azione Get user X in fase di esecuzione:

actions('Get_user').outputs.body.status

E viene restituito questo risultato: "Succeeded"

add

Restituisce il risultato della somma di due numeri.

add(<summand_1>, <summand_2>)

Example

Questo esempio somma i numeri specificati:

add(1, 1.5)

E viene restituito questo risultato: 2.5

addDays

Aggiungere giorni a un timestamp.

addDays('<timestamp>', <days>, '<format>'?)

Example 1

Questo esempio aggiunge 10 giorni al timestamp specificato:

addDays('2018-03-15T00:00:00Z', 10)

E viene restituito questo risultato: "2018-03-25T00:00:00.0000000Z"

Example 2

Questo esempio sottrae cinque giorni dal timestamp specificato:

addDays('2018-03-15T00:00:00Z', -5)

E viene restituito questo risultato: "2018-03-10T00:00:00.0000000Z"

addHours

Aggiungere ore a un timestamp.

addHours('<timestamp>', <hours>, '<format>'?)

Example 1

Questo esempio aggiunge 10 ore al timestamp specificato:

addHours('2018-03-15T00:00:00Z', 10)

E viene restituito questo risultato: "2018-03-15T10:00:00.0000000Z"

Example 2

Questo esempio sottrae cinque ore dal timestamp specificato:

addHours('2018-03-15T15:00:00Z', -5)

E viene restituito questo risultato: "2018-03-15T10:00:00.0000000Z"

addMinutes

Aggiungere minuti a un timestamp.

addMinutes('<timestamp>', <minutes>, '<format>'?)

Example 1

Questo esempio aggiunge 10 minuti al timestamp specificato:

addMinutes('2018-03-15T00:10:00Z', 10)

E viene restituito questo risultato: "2018-03-15T00:20:00.0000000Z"

Example 2

Questo esempio sottrae cinque minuti dal timestamp specificato:

addMinutes('2018-03-15T00:20:00Z', -5)

E viene restituito questo risultato: "2018-03-15T00:15:00.0000000Z"

addProperty

Aggiunge una proprietà e il suo valore o una coppia nome-valore a un oggetto JSON e restituisce l'oggetto aggiornato. Se la proprietà esiste già nel runtime, la funzione ha esito negativo e genera un errore.

addProperty(<object>, '<property>', <value>)

Per aggiungere una proprietà padre a una proprietà esistente, usare la setProperty() funzione , non la addProperty() funzione . Altrimenti, la funzione restituisce solo l'oggetto figlio come output.

setProperty(<object>, '<parent-property>', addProperty(<object>['<parent-property>'], '<child-property>', <value>)

Example 1

This example adds the middleName property to a JSON object, which is converted from a string to JSON by using the JSON() function. L'oggetto include già le proprietà firstName e surName. La funzione assegna il valore specificato alla nuova proprietà e restituisce l'oggetto aggiornato:

addProperty(json('{ "firstName": "Sophia", "lastName": "Owen" }'), 'middleName', 'Anne')

Ecco l'oggetto JSON corrente:

{
   "firstName": "Sophia",
   "surName": "Owen"
}

Ecco l'oggetto JSON aggiornato:

{
   "firstName": "Sophia",
   "middleName": "Anne",
   "surName": "Owen"
}

Example 2

This example adds the middleName child property to the existing customerName property in a JSON object, which is converted from a string to JSON by using the JSON() function. La funzione assegna il valore specificato alla nuova proprietà e restituisce l'oggetto aggiornato:

setProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }'), 'customerName', addProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }')['customerName'], 'middleName', 'Anne'))

Ecco l'oggetto JSON corrente:

{
   "customerName": {
      "firstName": "Sophia",
      "surName": "Owen"
   }
}

Ecco l'oggetto JSON aggiornato:

{
   "customerName": {
      "firstName": "Sophia",
      "middleName": "Anne",
      "surName": "Owen"
   }
}

addSeconds

Aggiungere secondi a un timestamp.

addSeconds('<timestamp>', <seconds>, '<format>'?)

Example 1

Questo esempio aggiunge 10 secondi al timestamp specificato:

addSeconds('2018-03-15T00:00:00Z', 10)

E viene restituito questo risultato: "2018-03-15T00:00:10.0000000Z"

Example 2

Questo esempio sottrae cinque secondi dal timestamp specificato:

addSeconds('2018-03-15T00:00:30Z', -5)

E viene restituito questo risultato: "2018-03-15T00:00:25.0000000Z"

addToTime

Aggiungere le unità di tempo specificate a un timestamp. See also getFutureTime().

addToTime('<timestamp>', <interval>, '<timeUnit>', '<format>'?)

Example 1

Questo esempio aggiunge un giorno al timestamp specificato:

addToTime('2018-01-01T00:00:00Z', 1, 'Day')

E viene restituito questo risultato: "2018-01-02T00:00:00.0000000Z"

Example 2

Questo esempio aggiunge un giorno al timestamp specificato:

addToTime('2018-01-01T00:00:00Z', 1, 'Day', 'D')

E restituisce il risultato usando il formato "D" facoltativo: "Tuesday, January 2, 2018"

and

Verifica se tutte le espressioni sono true. Restituisce true se tutte le espressioni sono true o false se almeno un'espressione è false.

and(<expression1>, <expression2>, ...)

Example 1

Questi esempi verificano se i valori booleani specificati sono tutti true:

and(true, true)
and(false, true)
and(false, false)

E vengono restituiti questi risultati:

• Primo esempio: entrambe le espressioni sono true, quindi restituisce true.
• Secondo esempio: una espressione è false, quindi restituisce false.
• Terzo esempio: entrambe le espressioni sono false, quindi restituisce false.

Example 2

Questi esempi verificano se le espressioni specificate sono tutte true:

and(equals(1, 1), equals(2, 2))
and(equals(1, 1), equals(1, 2))
and(equals(1, 2), equals(1, 3))

E vengono restituiti questi risultati:

• Primo esempio: entrambe le espressioni sono true, quindi restituisce true.
• Secondo esempio: una espressione è false, quindi restituisce false.
• Terzo esempio: entrambe le espressioni sono false, quindi restituisce false.

array

Restituisce una matrice da un singolo input specificato. For multiple inputs, see createArray().

array('<value>')

Example

Questo esempio crea una matrice dalla stringa "hello":

array('hello')

E viene restituito questo risultato: ["hello"]

B

base64

Restituisce la versione di una stringa con codifica base64.

base64('<value>')

Example

Questo esempio converte la stringa "hello" in una stringa con codifica base64:

base64('hello')

E viene restituito questo risultato: "aGVsbG8="

base64ToBinary

Restituisce la versione binaria di una stringa con codifica base64.

base64ToBinary('<value>')

Example

Questo esempio converte la stringa "aGVsbG8=" con codifica base64 in una stringa binaria:

base64ToBinary('aGVsbG8=')

Si supponga, ad esempio, di usare un'azione HTTP per inviare una richiesta. È possibile usare base64ToBinary() per convertire una stringa con codifica Base64 in dati binari e inviare tali dati usando il application/octet-stream tipo di contenuto nella richiesta.

base64ToString

Restituisce la versione stringa di una stringa con codifica base64, decodificando in modo efficace la stringa base64. Use this function rather than decodeBase64(), which is deprecated.

base64ToString('<value>')

Example

Questo esempio converte la stringa "aGVsbG8=" con codifica base64 in una semplice stringa:

base64ToString('aGVsbG8=')

E viene restituito questo risultato: "hello"

binary

Restituisce la versione binaria con codifica Base64 di una stringa.

binary('<value>')

Example

Ad esempio, si usa un'azione HTTP che restituisce un'immagine o un file video. È possibile usare binary() per convertire il valore in un modello di busta di contenuto con codifica base 64. È quindi possibile riutilizzare la busta contenuto in altre azioni, ad esempio Compose. È possibile usare questa espressione di funzione per inviare i byte stringa con il application/octet-stream tipo di contenuto nella richiesta.

body

Restituisce l'oggetto body di output di un'azione in fase di esecuzione. Sintassi abbreviata per actions('<actionName>').outputs.body. See actions().

body('<actionName>')

Example

Questo esempio ottiene l'output body dall'azione Get user X:

body('Get_user')

E viene restituito questo risultato:

"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

Restituisce la versione booleana di un valore.

bool(<value>)

Se si usa bool() con un oggetto , il valore dell'oggetto deve essere una stringa o un numero intero che può essere convertito in booleano.

Outputs

Questi esempi mostrano i diversi tipi di input supportati per bool():

C

chunk

Dividere una stringa o una matrice in blocchi di lunghezza uguale.

chunk('<collection>', '<length>')
chunk([<collection>], '<length>')

Example 1

Questo esempio suddivide una stringa in blocchi di lunghezza 10:

chunk('abcdefghijklmnopqrstuvwxyz', 10)

E viene restituito questo risultato: ['abcdefghij', 'klmnopqrst', 'uvwxyz']

Example 2

Questo esempio suddivide una matrice in blocchi di lunghezza 5.

chunk(createArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), 5)

E viene restituito questo risultato: [ [1,2,3,4,5], [6,7,8,9,10], [11,12] ]

coalesce

Restituisce il primo valore non Null da uno o più parametri. Stringhe vuote, matrici vuote e oggetti vuoti sono non null.

coalesce(<object_1>, <object_2>, ...)

Example

Questi esempi restituiscono il primo valore non Null dai valori specificati oppure Null quando tutti i valori sono Null:

coalesce(null, true, false)
coalesce(null, 'hello', 'world')
coalesce(null, null, null)

E vengono restituiti questi risultati:

• Primo esempio: true
• Secondo esempio: "hello"
• Terzo esempio: null

concat

Combina due o più stringhe e restituisce la stringa combinata.

concat('<text1>', '<text2>', ...)

Example

Questo esempio combina le stringhe "Hello" e "World":

concat('Hello', 'World')

E viene restituito questo risultato: "HelloWorld"

contains

Verifica se una raccolta include un elemento specifico. Restituisce true se l'elemento viene trovato o false se non viene trovato. Questa funzione fa distinzione tra maiuscole e minuscole.

contains('<collection>', '<value>')
contains([<collection>], '<value>')

In particolare, questa funzione può essere usata con questi tipi di raccolta:

• A string to find a substring
• An array to find a value
• A dictionary to find a key

Example 1

Questo esempio verifica la stringa "hello world" per cercare la sottostringa "world" e restituisce true:

contains('hello world', 'world')

Example 2

Questo esempio verifica la stringa "hello world" per cercare la sottostringa "universe" e restituisce false:

contains('hello world', 'universe')

convertFromUtc

Converte un timestamp da UTC (Universal Time Coordinated) al fuso orario di destinazione.

convertFromUtc('<timestamp>', '<destinationTimeZone>', '<format>'?)

Example 1

Questo esempio converte un timestamp nel fuso orario specificato:

convertFromUtc('2018-01-01T08:00:00.0000000Z', 'Pacific Standard Time')

E viene restituito questo risultato: "2018-01-01T00:00:00.0000000"

Example 2

Questo esempio converte un timestamp nel fuso orario e nel formato specificati:

convertFromUtc('2018-01-01T08:00:00.0000000Z', 'Pacific Standard Time', 'D')

E viene restituito questo risultato: "Monday, January 1, 2018"

convertTimeZone

Converte un timestamp dal fuso orario di origine al fuso orario di destinazione.

convertTimeZone('<timestamp>', '<sourceTimeZone>', '<destinationTimeZone>', '<format>'?)

Example 1

Questo esempio converte il fuso orario di origine nel fuso orario di destinazione:

convertTimeZone('2018-01-01T08:00:00.0000000Z', 'UTC', 'Pacific Standard Time')

E viene restituito questo risultato: "2018-01-01T00:00:00.0000000"

Example 2

Questo esempio converte un fuso orario nel fuso orario e nel formato specificati:

convertTimeZone('2018-01-01T80:00:00.0000000Z', 'UTC', 'Pacific Standard Time', 'D')

E viene restituito questo risultato: "Monday, January 1, 2018"

convertToUtc

Converte un timestamp dal fuso orario di origine a UTC (Universal Time Coordinated).

convertToUtc('<timestamp>', '<sourceTimeZone>', '<format>'?)

Example 1

Questo esempio converte un timestamp nell'ora UTC:

convertToUtc('01/01/2018 00:00:00', 'Pacific Standard Time')

E viene restituito questo risultato: "2018-01-01T08:00:00.0000000Z"

Example 2

Questo esempio converte un timestamp nell'ora UTC:

convertToUtc('01/01/2018 00:00:00', 'Pacific Standard Time', 'D')

E viene restituito questo risultato: "Monday, January 1, 2018"

createArray

Restituisce una matrice da più input. For single input arrays, see array().

createArray('<object1>', '<object2>', ...)

Example

Questo esempio crea una matrice da questi input:

createArray('h', 'e', 'l', 'l', 'o')

E viene restituito questo risultato: ["h", "e", "l", "l", "o"]

D

dataUri

Restituisce un URI (Uniform Resource Identifier) di dati per una stringa.

dataUri('<value>')

Example

Questo esempio crea un URI di dati per la stringa "hello":

dataUri('hello')

E viene restituito questo risultato: "data:text/plain;charset=utf-8;base64,aGVsbG8="

dataUriToBinary

Restituisce la versione binaria di un URI (Uniform Resource Identifier) di dati. Use this function rather than decodeDataUri(). Anche se entrambe le funzioni hanno un comportamento analogo, è preferibile usare dataUriBinary().

dataUriToBinary('<value>')

Example

Questo esempio crea una versione binaria di questo URI di dati:

dataUriToBinary('data:text/plain;charset=utf-8;base64,aGVsbG8=')

E viene restituito questo risultato:

"01100100011000010111010001100001001110100111010001100101011110000111010000101111011100000 1101100011000010110100101101110001110110110001101101000011000010111001001110011011001010111 0100001111010111010101110100011001100010110100111000001110110110001001100001011100110110010 10011011000110100001011000110000101000111010101100111001101100010010001110011100000111101"

dataUriToString

Restituisce la versione stringa di un URI (Uniform Resource Identifier) di dati.

dataUriToString('<value>')

Example

Questo esempio crea una stringa per questo URI di dati:

dataUriToString('data:text/plain;charset=utf-8;base64,aGVsbG8=')

E viene restituito questo risultato: "hello"

dateDifference

Restituisce la differenza tra due timestamp come intervallo di tempo. Questa funzione sottrae startDate da endDatee restituisce il risultato come timestamp in formato stringa.

dateDifference('<startDate>', '<endDate>')

Example

In questo esempio viene sottratto il primo valore dal secondo valore:

dateDifference('2015-02-08', '2018-07-30')

E viene restituito questo risultato: "1268.00:00:00"

dayOfMonth

Restituisce il giorno del mese da un timestamp.

dayOfMonth('<timestamp>')

Example

Questo esempio restituisce il numero del giorno del mese da questo timestamp:

dayOfMonth('2018-03-15T13:27:36Z')

E viene restituito questo risultato: 15

dayOfWeek

Restituisce il giorno della settimana da un timestamp.

dayOfWeek('<timestamp>')

Example

Questo esempio restituisce il numero del giorno della settimana da questo timestamp:

dayOfWeek('2018-03-15T13:27:36Z')

E viene restituito questo risultato: 4

dayOfYear

Restituisce il giorno dell'anno da un timestamp.

dayOfYear('<timestamp>')

Example

Questo esempio restituisce il numero del giorno dell'anno da questo timestamp:

dayOfYear('2018-03-15T13:27:36Z')

E viene restituito questo risultato: 74

decimal

Restituisce un numero decimale in una stringa come numero decimale. È possibile usare questa funzione quando si usano dati che richiedono precisione decimale e anche come input per funzioni di confronto logiche e funzioni matematiche. To capture and preserve precision when you use the result from the decimal() function, wrap any decimal output with the string function. Questo utilizzo è illustrato negli esempi seguenti in cui è possibile perdere precisione se si usa il risultato decimale come numero.

decimal('<value>')

Example 1

In questo esempio viene creato un separatore decimale usato come numero:

decimal('1.2345678912312131') // Returns 1.234567891231213.

Example 2

Questo esempio crea un decimale e quindi converte il risultato in una stringa per la conservazione della precisione:

string(decimal('1.2345678912312131')) // Returns "1.2345678912312131".

Example 3

Questo esempio usa una funzione matematica su due numeri decimali e usa il risultato come numero:

add(decimal('1.2345678912312131'), decimal('1.2345678912312131')) // Returns 2.469135782462426.

Example 4

Questo esempio usa una funzione matematica su due numeri decimali e converte il risultato in una stringa per la conservazione della precisione:

string(add(decimal('1.2345678912312131'), decimal('1.2345678912312131'))) // Returns "2.4691357824624262".

decodeBase64 (deprecated)

This function is deprecated, so use base64ToString() instead.

decodeDataUri

Restituisce la versione binaria di un URI (Uniform Resource Identifier) di dati. Consider using dataUriToBinary(), rather than decodeDataUri(). Anche se entrambe le funzioni hanno un comportamento analogo, è preferibile usare dataUriToBinary().

decodeDataUri('<value>')

Example

Questo esempio crea la versione binaria per questo URI di dati:

decodeDataUri('data:text/plain;charset=utf-8;base64,aGVsbG8=')

E viene restituito questo risultato: "hello"

decodeUriComponent

Restituisce una stringa che sostituisce i caratteri di escape con le versioni decodificate.

decodeUriComponent('<value>')

Example

Questo esempio sostituisce i caratteri di escape in questa stringa con le versioni decodificate:

decodeUriComponent('https%3A%2F%2Fcontoso.com')

E viene restituito questo risultato: "https://contoso.com"

div

Restituisce il risultato della divisione di due numeri. To get the remainder result, see mod().

div(<dividend>, <divisor>)

Example 1

Entrambi gli esempi restituiscono questo valore con tipo Integer: 2

div(10,5)
div(11,5)

Example 2

Entrambi gli esempi restituiscono questo valore con tipo Float: 2.2

div(11,5.0)
div(11.0,5)

E

encodeUriComponent

Restituisce la versione con codifica URI (Uniform Resource Identifier) per una stringa sostituendo i caratteri non sicuri per gli URL con caratteri di escape. Consider using uriComponent(), rather than encodeUriComponent(). Anche se entrambe le funzioni hanno un comportamento analogo, è preferibile usare uriComponent().

encodeUriComponent('<value>')

Example

Questo esempio crea una versione con codifica URI per questa stringa:

encodeUriComponent('https://contoso.com')

E viene restituito questo risultato: "https%3A%2F%2Fcontoso.com"

empty

Verifica se una raccolta è vuota. Restituisce true se la raccolta è vuota o false se non lo è.

empty('<collection>')
empty([<collection>])

Example

Questi esempi verificano se le raccolte specificate sono vuote:

empty('')
empty('abc')

E vengono restituiti questi risultati:

• Primo esempio: passa una stringa vuota, quindi la funzione restituisce true.
• Secondo esempio: passa la stringa "abc", quindi la funzione restituisce false.

endsWith

Verifica se una stringa termina con una sottostringa specifica. Restituisce true se la sottostringa viene trovata o false se non viene trovata. Per questa funzione non viene applicata la distinzione tra maiuscole e minuscole.

endsWith('<text>', '<searchText>')

Example 1

Questo esempio verifica se la stringa "hello world" termina con la stringa "world":

endsWith('hello world', 'world')

E viene restituito questo risultato: true

Example 2

Questo esempio verifica se la stringa "hello world" termina con la stringa "universe":

endsWith('hello world', 'universe')

E viene restituito questo risultato: false

equals

Verifica se entrambi i valori, le espressioni o gli oggetti sono equivalenti. Restituisce true se entrambi gli elementi sono equivalenti o false se non lo sono.

equals('<object1>', '<object2>')

Example

Questi esempi verificano se gli input specificati sono equivalenti.

equals(true, 1)
equals('abc', 'abcd')

E vengono restituiti questi risultati:

• Primo esempio: entrambi i valori sono equivalenti, quindi la funzione restituisce true.
• Secondo esempio: entrambi i valori non sono equivalenti, quindi la funzione restituisce false.

F

first

Restituisce il primo elemento di una stringa o una matrice.

first('<collection>')
first([<collection>])

Example

Questi esempi trovano il primo elemento in queste raccolte:

first('hello')
first(createArray(0, 1, 2))

E vengono restituiti questi risultati:

• Primo esempio: "h"
• Secondo esempio: 0

float

Converte una versione stringa per un numero a virgola mobile in un numero a virgola mobile effettivo. È possibile usare questa funzione solo quando si passano parametri personalizzati a un'app, ad esempio un flusso di lavoro dell'app per la logica o un flusso di Power Automate. Per convertire stringhe a virgola mobile rappresentate in formati specifici delle impostazioni locali, è possibile specificare facoltativamente un codice delle impostazioni locali RFC 4646.

float('<value>', '<locale>'?)

Example 1

Questo esempio crea una versione stringa per questo numero a virgola mobile:

float('10,000.333')

E viene restituito questo risultato: 10000.333

Example 2

In questo esempio viene creata una versione stringa per questo numero a virgola mobile in stile tedesco:

float('10.000,333', 'de-DE')

E viene restituito questo risultato: 10000.333

formatDateTime

Restituisce un timestamp nel formato specificato.

formatDateTime('<timestamp>', '<format>'?, '<locale>'?)

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

Return an array with values that match a key name in an action's form-data or form-encoded output.

formDataMultiValues('<actionName>', '<key>')

Example

Questo esempio crea una matrice dal valore della chiave "Subject" nell'output di dati del modulo o codifica per il modulo dell'azione specificata:

formDataMultiValues('Send_an_email', 'Subject')

E restituisce il testo dell'oggetto in una matrice, ad esempio: ["Hello world"]

formDataValue

Return a single value that matches a key name in an action's form-data or form-encoded output. Se la funzione trova più corrispondenze, genera un errore.

formDataValue('<actionName>', '<key>')

Example

Questo esempio crea una stringa dal valore della chiave "Subject" nell'output di dati del modulo o codifica per il modulo dell'azione specificata:

formDataValue('Send_an_email', 'Subject')

E restituisce il testo dell'oggetto come stringa, ad esempio: "Hello world"

formatNumber

Restituisce un numero come stringa in base al formato specificato.

formatNumber(<number>, <format>, <locale>?)

Example 1

Si supponga di voler formattare il numero 1234567890. Questo esempio formatta il numero come stringa "1.234.567.890,00".

formatNumber(1234567890, '#,##0.00', 'en-US')

*Example 2"

Si supponga di voler formattare il numero 1234567890. Questo esempio formatta il numero come stringa "1.234.567.890,00".

formatNumber(1234567890, '#,##0.00', 'is-IS')

Example 3

Si supponga di voler formattare il numero 17.35. Questo esempio formatta il numero come stringa "$17,35".

formatNumber(17.35, 'C2')

Example 4

Si supponga di voler formattare il numero 17.35. Questo esempio formatta il numero come stringa "17,35 kr".

formatNumber(17.35, 'C2', 'is-IS')

G

getFutureTime

Restituisce il timestamp corrente più le unità di tempo specificate.

getFutureTime(<interval>, <timeUnit>, <format>?)

Example 1

Si supponga che il timestamp corrente sia "2018-03-01T00:00:00.0000000Z". Questo esempio aggiunge cinque giorni al timestamp:

getFutureTime(5, 'Day')

E viene restituito questo risultato: "2018-03-06T00:00:00.0000000Z"

Example 2

Si supponga che il timestamp corrente sia "2018-03-01T00:00:00.0000000Z". Questo esempio aggiunge cinque giorni e converte il risultato nel formato "D":

getFutureTime(5, 'Day', 'D')

E viene restituito questo risultato: "Tuesday, March 6, 2018"

getPastTime

Restituisce il timestamp corrente meno le unità di tempo specificate.

getPastTime(<interval>, <timeUnit>, <format>?)

Example 1

Si supponga che il timestamp corrente sia "2018-02-01T00:00:00.0000000Z". Questo esempio sottrae cinque giorni dal timestamp:

getPastTime(5, 'Day')

E viene restituito questo risultato: "2018-01-27T00:00:00.0000000Z"

Example 2

Si supponga che il timestamp corrente sia "2018-02-01T00:00:00.0000000Z". Questo esempio sottrae cinque giorni e converte il risultato nel formato "D":

getPastTime(5, 'Day', 'D')

E viene restituito questo risultato: "Saturday, January 27, 2018"

greater

Verifica se il primo valore è maggiore del secondo valore. Restituisce true se il primo valore è maggiore o false se è minore.

greater(<value>, <compareTo>)
greater('<value>', '<compareTo>')

Example

Questi esempi verificano se il primo valore è maggiore del secondo:

greater(10, 5)
greater('apple', 'banana')

E vengono restituiti questi risultati:

• Primo esempio: true
• Secondo esempio: false

greaterOrEquals

Verifica se il primo valore è maggiore o uguale al secondo valore. Restituisce true se il primo valore è maggiore o uguale o false se è minore.

greaterOrEquals(<value>, <compareTo>)
greaterOrEquals('<value>', '<compareTo>')

Example

Questi esempi verificano se il primo valore è maggiore o uguale al secondo:

greaterOrEquals(5, 5)
greaterOrEquals('apple', 'banana')

E vengono restituiti questi risultati:

• Primo esempio: true
• Secondo esempio: false

guid

Genera un identificatore univoco globale (GUID) sotto forma di stringa, ad esempio "c2ecc88d-88c8-4096-912c-d6f2e2b138ce":

guid()

È anche possibile specificare un formato per il GUID diverso da quello predefinito, "D", che è costituito da 32 cifre separate da trattini.

guid('<format>')

Example

Questo esempio genera lo stesso GUID, ma in formato a 32 cifre, separate da trattini e racchiuse tra parentesi:

guid('P')

E viene restituito questo risultato: "(c2ecc88d-88c8-4096-912c-d6f2e2b138ce)"

I

if

Verifica se un'espressione è true o false. In base al risultato, restituisce un valore specificato. I parametri sono valutati da sinistra a destra.

if(<expression>, <valueIfTrue>, <valueIfFalse>)

Example

Questo esempio restituisce "yes" perché l'espressione specificata restituisce true. In caso contrario, l'esempio restituisce "no":

if(equals(1, 1), 'yes', 'no')

indexOf

Restituisce la posizione iniziale o il valore di indice di una sottostringa. Questa funzione non fa distinzione tra maiuscole e minuscole e gli indici iniziano con il numero 0.

indexOf('<text>', '<searchText>')

Example

Questo esempio trova il valore di indice iniziale della sottostringa "world" nella stringa "hello world":

indexOf('hello world', 'world')

E viene restituito questo risultato: 6

int

Convertire la versione stringa per un numero intero in un numero intero effettivo.

int('<value>')

Example

Questo esempio crea una versione integer per la stringa "10":

int('10')

E viene restituito questo risultato: 10

isFloat

Restituisce un valore booleano che indica se una stringa è un numero a virgola mobile. Per impostazione predefinita, questa funzione usa le impostazioni cultura invarianti per il formato a virgola mobile. Per identificare i numeri a virgola mobile rappresentati in altri formati specifici delle impostazioni locali, è possibile specificare facoltativamente un codice delle impostazioni locali RFC 4646.

isFloat('<string>', '<locale>'?)

Example 1

In questo esempio viene verificato se una stringa è un numero a virgola mobile nelle impostazioni cultura invarianti:

isFloat('10,000.00')

E viene restituito questo risultato: true

Example 2

In questo esempio viene verificato se una stringa è un numero a virgola mobile nelle impostazioni locali tedesche:

isFloat('10.000,00', 'de-DE')

E viene restituito questo risultato: true

isInt

Restituisce un valore booleano che indica se una stringa è un numero intero.

isInt('<string>')

Example

In questo esempio viene verificato se una stringa è un numero intero:

isInt('10')

E viene restituito questo risultato: true

item

Quando la funzione viene usata all'interno di un'azione ripetuta su una matrice, restituisce l'elemento corrente nella matrice durante l'iterazione corrente dell'azione. È anche possibile ottenere i valori dalle proprietà dell'elemento.

item()

Example

Questo esempio ottiene l'elemento body dal messaggio corrente per l'azione "Send_an_email" all'interno dell'iterazione corrente di un ciclo for-each:

item().body

items

Restituisce l'elemento corrente da ogni ciclo in un ciclo for-each. Usare questa funzione all'interno del ciclo for-each.

items('<loopName>')

Example

Questo esempio ottiene l'elemento corrente dal ciclo for-each specificato:

items('myForEachLoopName')

iterationIndexes

Restituisce il valore di indice per l'iterazione corrente all'interno del ciclo Until. È possibile usare questa funzione all'interno di cicli Until annidati.

iterationIndexes('<loopName>')

Example

Questo esempio crea una variabile contatore e la incrementa di uno durante ogni iterazione in un ciclo Until fino a quando il valore del contatore non raggiunge cinque. L'esempio crea anche una variabile che tiene traccia dell'indice corrente per ogni iterazione. Durante ogni iterazione nel ciclo Until, l'esempio incrementa il valore del contatore e quindi assegna il valore del contatore al valore di indice corrente e quindi incrementa il valore del contatore. Nel ciclo questo esempio fa riferimento all'indice di iterazione corrente usando la funzione iterationIndexes:

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

Restituisce il valore del tipo JSON (JavaScript Object Notation), l'oggetto o la matrice di oggetti per una stringa o XML.

json('<value>')
json(xml('value'))

Example 1

Questo esempio converte questa stringa in un valore JSON:

json('[1, 2, 3]')

E viene restituito questo risultato: [1, 2, 3]

Example 2

Questo esempio converte questa stringa in JSON:

json('{"fullName": "Sophia Owen"}')

E viene restituito questo risultato:

{
  "fullName": "Sophia Owen"
}

Example 3

Questo esempio usa le json() funzioni e xml() per convertire xml con un singolo elemento figlio nell'elemento radice in un oggetto JSON denominato person per l'elemento figlio:

json(xml('<?xml version="1.0"?> <root> <person id="1"> <name>Sophia Owen</name> <occupation>Engineer</occupation> </person> </root>'))

E viene restituito questo risultato:

{
   "?xml": { 
      "@version": "1.0" 
   },
   "root": {
      "person": {
         "@id": "1",
         "name": "Sophia Owen",
         "occupation": "Engineer"
      }
   }
}

Example 4

Questo esempio usa le json() funzioni e xml() per convertire xml con più elementi figlio nell'elemento radice in una matrice denominata person che contiene oggetti JSON per tali elementi figlio:

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>'))

E viene restituito questo risultato:

{
   "?xml": {
      "@version": "1.0"
   },
   "root": {
      "person": [
         {
            "@id": "1",
            "name": "Sophia Owen",
            "occupation": "Engineer"
         },
         {
            "@id": "2",
            "name": "John Doe",
            "occupation": "Engineer"
         }
      ]
   }
}

intersection

Return a collection that has only the common items across the specified collections. Per essere incluso nel risultato, un elemento deve essere presente in tutte le raccolte passate alla funzione. Se uno o più elementi hanno lo stesso nome, nel risultato viene incluso l'ultimo elemento con tale nome.

intersection([<collection1>], [<collection2>], ...)
intersection('<collection1>', '<collection2>', ...)

Example

Questo esempio trova gli elementi comuni tra queste matrici:

intersection(createArray(1, 2, 3), createArray(101, 2, 1, 10), createArray(6, 8, 1, 2))

And returns an array with only these items: [1, 2]

join

Return a string that has all the items from an array and has each character separated by a delimiter.

join([<collection>], '<delimiter>')

Example

Questo esempio crea una stringa da tutti gli elementi in questa matrice usando il carattere specificato come delimitatore:

join(createArray('a', 'b', 'c'), '.')

E viene restituito questo risultato: "a.b.c"

L

last

Restituisce l'ultimo elemento di una raccolta.

last('<collection>')
last([<collection>])

Example

Questi esempi trovano l'ultimo elemento in queste raccolte:

last('abcd')
last(createArray(0, 1, 2, 3))

E vengono restituiti questi risultati:

• Primo esempio: "d"
• Secondo esempio: 3

lastIndexOf

Restituire la posizione iniziale o il valore di indice per l'ultima occorrenza di una sottostringa. Questa funzione non fa distinzione tra maiuscole e minuscole e gli indici iniziano con il numero 0.

lastIndexOf('<text>', '<searchText>')

Se il valore stringa o sottostringa è vuoto, si verifica il comportamento seguente:

• Se solo il valore stringa è vuoto, la funzione restituisce -1.

• Se i valori stringa e sottostringa sono entrambi vuoti, la funzione restituisce 0.

• Se solo il valore della sottostringa è vuoto, la funzione restituisce la lunghezza della stringa meno 1.

Examples

In questo esempio viene trovato il valore di indice iniziale per l'ultima occorrenza della sottostringa della sottostringa world nella stringa hello world hello world. Il risultato restituito è 18:

lastIndexOf('hello world hello world', 'world')

In questo esempio manca il parametro di sottostringa e restituisce un valore perché 22 il valore della stringa di input (23) meno 1 è maggiore di 0.

lastIndexOf('hello world hello world', '')

length

Restituisce il numero di elementi in una raccolta.

length('<collection>')
length([<collection>])

Example

Questi esempi contano il numero di elementi in queste raccolte:

length('abcd')
length(createArray(0, 1, 2, 3))

E viene restituito questo risultato: 4

less

Verifica se il primo valore è minore del secondo valore. Restituisce true se il primo valore è minore o false se è maggiore.

less(<value>, <compareTo>)
less('<value>', '<compareTo>')

Example

Questi esempi verificano se il primo valore è minore del secondo.

less(5, 10)
less('banana', 'apple')

E vengono restituiti questi risultati:

• Primo esempio: true
• Secondo esempio: false

lessOrEquals

Verifica se il primo valore è minore o uguale al secondo valore. Restituisce true se il primo valore è minore o uguale o false se è maggiore.

lessOrEquals(<value>, <compareTo>)
lessOrEquals('<value>', '<compareTo>')

Example

Questi esempi verificano se il primo valore è minore o uguale al secondo valore.

lessOrEquals(10, 10)
lessOrEquals('apply', 'apple')

E vengono restituiti questi risultati:

• Primo esempio: true
• Secondo esempio: false

listCallbackUrl

Restituisce l'"URL di callback" che chiama un trigger o un'azione. This function works only with triggers and actions for the HttpWebhook and ApiConnectionWebhook connector types, but not the Manual, Recurrence, HTTP, and APIConnection types.

listCallbackUrl()

Example

Questo esempio mostra un URL di callback di esempio che questa funzione potrebbe restituire:

"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

Restituisce il valore più alto di un elenco o una matrice con numeri che includono gli estremi.

max(<number1>, <number2>, ...)
max([<number1>, <number2>, ...])

Example

Questi esempi ottengono il valore più alto dal set di numeri e dalla matrice:

max(1, 2, 3)
max(createArray(1, 2, 3))

E viene restituito questo risultato: 3

min

Restituisce il valore più basso di un set di numeri o una matrice.

min(<number1>, <number2>, ...)
min([<number1>, <number2>, ...])

Example

Questi esempi ottengono il valore più basso nel set di numeri e nella matrice:

min(1, 2, 3)
min(createArray(1, 2, 3))

E viene restituito questo risultato: 1

mod

Restituisce il resto della divisione di due numeri. To get the integer result, see div().

mod(<dividend>, <divisor>)

Example 1

Questo esempio divide il primo numero per il secondo numero:

mod(3, 2)

E viene restituito questo risultato: 1

Example 2

Questo esempio mostra che se uno o entrambi i valori sono negativi, il risultato corrisponde al segno del dividendo:

mod(-5, 2)
mod(4, -3)

L'esempio restituisce questi risultati:

• Primo esempio: -1
• Secondo esempio: 1

mul

Restituisce il prodotto della moltiplicazione di due numeri.

mul(<multiplicand1>, <multiplicand2>)

Example

Questi esempi moltiplicano il primo numero per il secondo numero:

mul(1, 2)
mul(1.5, 2)

E vengono restituiti questi risultati:

• Primo esempio: 2
• Secondo esempio: 3

multipartBody

Restituisce il corpo per una parte specifica dell'output di un'azione con più parti.

multipartBody('<actionName>', <index>)

N

not

Verifica se un'espressione è false. Restituisce true se l'espressione è false o false se è true.

not(<expression>)

Example 1

Questi esempi verificano se le espressioni specificate sono false:

not(false)
not(true)

E vengono restituiti questi risultati:

• Primo esempio: l'espressione è false, quindi la funzione restituisce true.
• Secondo esempio: l'espressione è true, quindi la funzione restituisce false.

Example 2

Questi esempi verificano se le espressioni specificate sono false:

not(equals(1, 2))
not(equals(1, 1))

E vengono restituiti questi risultati:

• Primo esempio: l'espressione è false, quindi la funzione restituisce true.
• Secondo esempio: l'espressione è true, quindi la funzione restituisce false.

nthIndexOf

Return the starting position or index value where the nth occurrence of a substring appears in a string.

nthIndexOf('<text>', '<searchText>', <occurrence>)

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

Verifica se almeno un'espressione è vera. Restituisce true se almeno un'espressione è true o false se tutte le espressioni sono false.

or(<expression1>, <expression2>, ...)

Example 1

Questi esempi verificano se almeno un'espressione è true:

or(true, false)
or(false, false)

E vengono restituiti questi risultati:

• Primo esempio: almeno un'espressione è true, quindi la funzione restituisce true.
• Secondo esempio: entrambe le espressioni sono false, quindi la funzione restituisce false.

Example 2

Questi esempi verificano se almeno un'espressione è true:

or(equals(1, 1), equals(1, 2))
or(equals(1, 2), equals(1, 3))

E vengono restituiti questi risultati:

• Primo esempio: almeno un'espressione è true, quindi la funzione restituisce true.
• Secondo esempio: entrambe le espressioni sono false, quindi la funzione restituisce false.

outputs

Restituisce l'output di un'azione nel runtime.

outputs('<actionName>')

Example

Questo esempio ottiene l'output dall'azione Get userX :

outputs('Get_user')

E viene restituito questo risultato:

{
  "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

Restituisce il valore per un parametro descritto nella definizione del flusso di lavoro.

parameters('<parameterName>')

Example

Si supponga di avere questo valore JSON:

{
  "fullName": "Sophia Owen"
}

Questo esempio ottiene il valore per il parametro specificato:

parameters('fullName')

E viene restituito questo risultato: "Sophia Owen"

parseDateTime

Restituisce il timestamp da una stringa contenente un timestamp.

parseDateTime('<timestamp>', '<locale>'?, '<format>'?)

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

Restituisce un valore intero casuale da un intervallo specificato, che include solo l'estremo inziale.

rand(<minValue>, <maxValue>)

Example

Questo esempio ottiene un valore intero casuale dall'intervallo specificato, escluso il valore massimo:

rand(1, 5)

E restituisce uno di questi numeri come risultato: 1, 2, 3 o 4

range

Restituisce una matrice di valori interi che inizia da un valore intero specificato.

range(<startIndex>, <count>)

Example

Questo esempio crea una matrice di valori interi che inizia dall'indice specificato e include il numero di valori interi specificato:

range(1, 4)

E viene restituito questo risultato: [1, 2, 3, 4]

removeProperty

Rimuove una proprietà da un oggetto e restituisce l'oggetto aggiornato. Se la proprietà che si tenta di rimuovere non esiste, la funzione restituisce l'oggetto originale.

removeProperty(<object>, '<property>')

Per rimuovere una proprietà figlio da una proprietà esistente, usare questa sintassi:

removeProperty(<object>['<parent-property>'], '<child-property>')

Example 1

This example removes the middleName property from a JSON object, which is converted from a string to JSON by using the JSON() function, and returns the updated object:

removeProperty(json('{ "firstName": "Sophia", "middleName": "Anne", "surName": "Owen" }'), 'middleName')

Ecco l'oggetto JSON corrente:

{
   "firstName": "Sophia",
   "middleName": "Anne",
   "surName": "Owen"
}

Ecco l'oggetto JSON aggiornato:

{
   "firstName": "Sophia",
   "surName": "Owen"
}

Example 2

This example removes the middleName child property from a customerName parent property in a JSON object, which is converted from a string to JSON by using the JSON() function, and returns the updated object:

removeProperty(json('{ "customerName": { "firstName": "Sophia", "middleName": "Anne", "surName": "Owen" } }')['customerName'], 'middleName')

Ecco l'oggetto JSON corrente:

{
   "customerName": {
      "firstName": "Sophia",
      "middleName": "Anne",
      "surName": "Owen"
   }
}

Ecco l'oggetto JSON aggiornato:

{
   "customerName": {
      "firstName": "Sophia",
      "surName": "Owen"
   }
}

replace

Sostituisce una sottostringa con la stringa specificata e restituisce la stringa risultante. Questa funzione fa distinzione tra maiuscole e minuscole.

replace('<text>', '<oldText>', '<newText>')

Example

Questo esempio trova la sottostringa "old" in "the old string" e sostituisce "old" con "new":

replace('the old string', 'old', 'new')

E viene restituito questo risultato: "the new string"

result

Restituisce i risultati delle azioni di primo livello nell'azione con ambito specificata, ad esempio un'azione For_each, Untilo Scope . La result() funzione accetta un singolo parametro, ovvero il nome dell'ambito, e restituisce una matrice che contiene informazioni dalle azioni di primo livello nell'ambito. Questi oggetti azione includono gli stessi attributi degli attributi restituiti dalla actions() funzione, ad esempio l'ora di inizio dell'azione, l'ora di fine, lo stato, gli input, gli ID di correlazione e gli output.

Ad esempio, è possibile usare questa funzione per ottenere i risultati da azioni non riuscite in modo da poter diagnosticare e gestire le eccezioni. Per altre informazioni, vedere Ottenere il contesto e i risultati per gli errori.

result('<scopedActionName>')

Example

Questo esempio restituisce gli input e gli output di ogni iterazione di un'azione HTTP all'interno di un For_each ciclo usando la result() funzione nell'azione Compose :

{
   "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"
      }
   }
}

Ecco come può apparire la matrice restituita di esempio, dove l'oggetto outputs esterno contiene gli input e gli output di ogni iterazione delle azioni all'interno dell'azione For_each.

[
   {
      "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

Invertire l'ordine degli elementi in una raccolta. When you use this function with sort(), you can sort a collection in descending order.

reverse([<collection>])

Example

Questo esempio inverte una matrice di numeri interi:

reverse(createArray(0, 1, 2, 3))

E restituisce questa matrice: [3,2,1,0]

S

setProperty

Imposta il valore per la proprietà dell'oggetto JSON e restituisce l'oggetto aggiornato. Se la proprietà che si tenta di impostare non esiste,viene aggiunta all'oggetto. To add a new property, use the addProperty() function.

setProperty(<object>, '<property>', <value>)

Per impostare la proprietà figlio in un oggetto figlio, usare invece una chiamata setProperty() annidata. Altrimenti, la funzione restituisce solo l'oggetto figlio come output.

setProperty(<object>, '<parent-property>', setProperty(<object>['parentProperty'], '<child-property>', <value>))

Example 1

This example sets the surName property in a JSON object, which is converted from a string to JSON by using the JSON() function. La funzione assegna il valore specificato alla proprietà e restituisce l'oggetto aggiornato:

setProperty(json('{ "firstName": "Sophia", "surName": "Owen" }'), 'surName', 'Hartnett')

Ecco l'oggetto JSON corrente:

{
   "firstName": "Sophia",
   "surName": "Owen"
}

Ecco l'oggetto JSON aggiornato:

{
   "firstName": "Sophia",
   "surName": "Hartnett"
}

Example 2

This example sets the surName child property for the customerName parent property in a JSON object, which is converted from a string to JSON by using the JSON() function. La funzione assegna il valore specificato alla proprietà e restituisce l'oggetto aggiornato:

setProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }'), 'customerName', setProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }')['customerName'], 'surName', 'Hartnett'))

Ecco l'oggetto JSON corrente:

{
   "customerName": {
      "firstName": "Sophie",
      "surName": "Owen"
   }
}

Ecco l'oggetto JSON aggiornato:

{
   "customerName": {
      "firstName": "Sophie",
      "surName": "Hartnett"
   }
}

skip

Rimuove gli elementi dall'inizio di una raccolta e restituisce tutti gli altri elementi.

skip([<collection>], <count>)

Example

Questo esempio rimuove un elemento, il numero 0, dall'inizio della matrice specificata:

skip(createArray(0, 1, 2, 3), 1)

E restituisce la matrice con gli elementi rimanenti: [1,2,3]

slice

Restituisce una sottostringa specificando la posizione iniziale e finale o il valore. See also substring().

slice('<text>', <startIndex>, <endIndex>?)

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 ''.

sort

Ordinare gli elementi in una raccolta. È possibile ordinare gli oggetti raccolta usando qualsiasi chiave contenente un tipo semplice.

sort([<collection>], <sortBy>?)

Example 1

In questo esempio viene ordinata una matrice di numeri interi:

sort(createArray(2, 1, 0, 3))

E restituisce questa matrice: [0,1,2,3]

Example 2

In questo esempio viene ordinata una matrice di oggetti in base alla chiave:

sort(createArray(json('{ "first": "Amalie", "last": "Rose" }'), json('{ "first": "Elise", "last": "Renee" }')), 'last')

E restituisce questa matrice: [{ "first": "Elise", "last": "Renee" }, {"first": "Amalie", "last": "Rose" }')]

split

Restituisce una matrice che contiene le sottostringhe, separate da virgole, in base al carattere delimitatore specificato nella stringa originale.

split('<text>', '<delimiter>')

Example 1

Questo esempio crea una matrice con le sottostringhe della stringa specificata in base al carattere specificato come delimitatore:

split('a_b_c', '_')

E restituisce questa matrice come risultato: ["a","b","c"]

Example 2

Questo esempio crea una matrice con un singolo elemento quando non esiste alcun delimitatore nella stringa:

split('a_b_c', ' ')

E restituisce questa matrice come risultato: ["a_b_c"]

startOfDay

Restituisce l'inizio del giorno per un timestamp.

startOfDay('<timestamp>', '<format>'?)

Example

Questo esempio trova l'inizio del giorno per questo timestamp:

startOfDay('2018-03-15T13:30:30Z')

E viene restituito questo risultato: "2018-03-15T00:00:00.0000000Z"

startOfHour

Restituisce l'inizio dell'ora per un timestamp.

startOfHour('<timestamp>', '<format>'?)

Example

Questo esempio trova l'inizio dell'ora per questo timestamp:

startOfHour('2018-03-15T13:30:30Z')

E viene restituito questo risultato: "2018-03-15T13:00:00.0000000Z"

startOfMonth

Restituisce l'inizio del mese per un timestamp.

startOfMonth('<timestamp>', '<format>'?)

Example 1

Questo esempio restituisce l'inizio del mese per questo timestamp:

startOfMonth('2018-03-15T13:30:30Z')

E viene restituito questo risultato: "2018-03-01T00:00:00.0000000Z"

Example 2

Questo esempio restituisce l'inizio del mese nel formato specificato per questo timestamp:

startOfMonth('2018-03-15T13:30:30Z', 'yyyy-MM-dd')

E viene restituito questo risultato: "2018-03-01"

startsWith

Verifica se una stringa inizia con una sottostringa specifica. Restituisce true se la sottostringa viene trovata o false se non viene trovata. Per questa funzione non viene applicata la distinzione tra maiuscole e minuscole.

startsWith('<text>', '<searchText>')

Example 1

Questo esempio verifica se la stringa "hello world" inizia con la sottostringa "hello":

startsWith('hello world', 'hello')

E viene restituito questo risultato: true

Example 2

Questo esempio verifica se la stringa "hello world" inizia con la sottostringa "greetings":

startsWith('hello world', 'greetings')

E viene restituito questo risultato: false

string

Restituisce la versione stringa di un valore.

string(<value>)

Example 1

Questo esempio crea la versione stringa per questo numero:

string(10)

E viene restituito questo risultato: "10"

Example 2

Questo esempio crea una stringa per l'oggetto JSON specificato e usa il carattere barra rovesciata () come carattere di escape per le virgolette doppie (").

string( { "name": "Sophie Owen" } )

E viene restituito questo risultato: "{ \\"name\\": \\"Sophie Owen\\" }"

sub

Restituisce il risultato della sottrazione del secondo numero dal primo.

sub(<minuend>, <subtrahend>)

Example

Questo esempio sottrae il secondo numero dal primo:

sub(10.3, .3)

E viene restituito questo risultato: 10

substring

Restituisce i caratteri di una stringa, partendo dalla posizione o dall'indice specificato. I valori di Indice iniziano con il numero 0. See also slice().

substring('<text>', <startIndex>, <length>)

Example

Questo esempio crea una sottostringa di cinque caratteri dalla stringa specificata, a partire dal valore di indice 6:

substring('hello world', 6, 5)

E viene restituito questo risultato: "world"

subtractFromTime

Sottrae un numero di unità di tempo da un timestamp. See also getPastTime.

subtractFromTime('<timestamp>', <interval>, '<timeUnit>', '<format>'?)

Example 1

Questo esempio sottrae un giorno dal timestamp:

subtractFromTime('2018-01-02T00:00:00Z', 1, 'Day')

E viene restituito questo risultato: "2018-01-01T00:00:00.0000000Z"

Example 2

Questo esempio sottrae un giorno dal timestamp:

subtractFromTime('2018-01-02T00:00:00Z', 1, 'Day', 'D')

E restituisce questo risultato usando il formato "D" facoltativo: "Monday, January, 1, 2018"

T

take

Restituisce gli elementi dall'inizio di una raccolta.

take('<collection>', <count>)
take([<collection>], <count>)

Example

Questi esempi ottengono il numero specificato di elementi presi dall'inizio di queste raccolte:

take('abcde', 3)
take(createArray(0, 1, 2, 3, 4), 3)

E vengono restituiti questi risultati:

• Primo esempio: "abc"
• Secondo esempio: [0, 1, 2]

ticks

Restituisce il numero di tick, ovvero intervalli di 100 nanosecondi, a partire dal 1° gennaio, 0001 12:00:00 mezzanotte (o DateTime.Ticks in C#) fino al timestamp specificato. Per altre informazioni, vedere questo argomento: Proprietà DateTime.Ticks (System).

ticks('<timestamp>')

toLower

Restituisce una stringa in formato minuscolo. Se un carattere nella stringa non ha un equivalente minuscolo, viene incluso senza modifiche nella stringa restituita.

toLower('<text>')

Example

Questo esempio converte questa stringa in caratteri minuscoli:

toLower('Hello World')

E viene restituito questo risultato: "hello world"

toUpper

Restituisce una stringa in formato maiuscolo. Se un carattere nella stringa non ha un equivalente maiuscolo, viene incluso senza modifiche nella stringa restituita.

toUpper('<text>')

Example

Questo esempio converte questa stringa in caratteri maiuscoli:

toUpper('Hello World')

E viene restituito questo risultato: "HELLO WORLD"

trigger

Restituisce l'output di un trigger in fase di esecuzione oppure i valori di altre coppie nome-valore JSON che è possibile assegnare a un'espressione.

• All'interno degli input di un trigger, questa funzione restituisce l'output dell'esecuzione precedente.

• All'interno di una condizione di un trigger, questa funzione restituisce l'output dell'esecuzione precedente.

Per impostazione predefinita, questa funzione fa riferimento all'intero oggetto trigger, ma è possibile specificare una proprietà con il valore desiderato. Also, this function has shorthand versions available, see triggerOutputs() and triggerBody().

trigger()

triggerBody

Restituisce l'oggetto body di output di un trigger in fase di esecuzione. Sintassi abbreviata per trigger().outputs.body. See trigger().

triggerBody()

triggerFormDataMultiValues

Return an array with values that match a key name in a trigger's form-data or form-encoded output.

triggerFormDataMultiValues('<key>')

Example

Questo esempio crea una matrice dal valore della chiave "feedUrl" nell'output di dati del modulo o codifica per il modulo di un trigger RSS:

triggerFormDataMultiValues('feedUrl')

E restituisce questa matrice come risultato di esempio: ["https://feeds.a.dj.com/rss/RSSMarketsMain.xml"]

triggerFormDataValue

Return a string with a single value that matches a key name in a trigger's form-data or form-encoded output. Se la funzione trova più corrispondenze, genera un errore.

triggerFormDataValue('<key>')

Example

Questo esempio crea una stringa dal valore della chiave "feedUrl" nell'output di dati del modulo o codifica per il modulo di un trigger RSS:

triggerFormDataValue('feedUrl')

E restituisce questa stringa come risultato di esempio: "https://feeds.a.dj.com/rss/RSSMarketsMain.xml"

triggerMultipartBody

Restituisce il corpo per una parte specifica dell'output di un trigger con più parti.

triggerMultipartBody(<index>)

triggerOutputs

Restituisce l'output di un trigger in fase di esecuzione o i valori di altre coppie nome-valore JSON. Sintassi abbreviata per trigger().outputs. See trigger().

triggerOutputs()

trim

Rimuove gli spazi iniziali e finali da una stringa e restituisce la stringa aggiornata.

trim('<text>')

Example

Questo esempio rimuove gli spazi iniziali e finali dalla stringa " Hello World ":

trim(' Hello World  ')

E viene restituito questo risultato: "Hello World"

U

union

Return a collection that has all the items from the specified collections. Per essere incluso nel risultato, un elemento può essere presente in qualsiasi raccolta passata alla funzione. Se uno o più elementi hanno lo stesso nome, nel risultato viene incluso l'ultimo elemento con tale nome.

union('<collection1>', '<collection2>', ...)
union([<collection1>], [<collection2>], ...)

Example

This example gets all the items from these collections:

union(createArray(1, 2, 3), createArray(1, 2, 10, 101))

E viene restituito questo risultato: [1, 2, 3, 10, 101]

uriComponent

Restituisce la versione con codifica URI (Uniform Resource Identifier) per una stringa sostituendo i caratteri non sicuri per gli URL con caratteri di escape. Use this function rather than encodeUriComponent(). Anche se entrambe le funzioni hanno un comportamento analogo, è preferibile usare uriComponent().

uriComponent('<value>')

Example

Questo esempio crea una versione con codifica URI per questa stringa:

uriComponent('https://contoso.com')

E viene restituito questo risultato: "https%3A%2F%2Fcontoso.com"

uriComponentToBinary

Restituisce la versione binaria di un componente di un URI (Uniform Resource Identifier).

uriComponentToBinary('<value>')

Example

Questo esempio crea la versione binaria per questa stringa con codifica URI:

uriComponentToBinary('https%3A%2F%2Fcontoso.com')

E viene restituito questo risultato: "aHR0cHM6Ly9jb250b3NvLmNvbQ=="

uriComponentToString

Restituisce la versione stringa di una stringa con codifica URI (Uniform Resource Identifier), decodificando in modo efficace la stringa con codifica URI.

uriComponentToString('<value>')

Example

Questo esempio crea la versione stringa decodificata per questa stringa con codifica URI:

uriComponentToString('https%3A%2F%2Fcontoso.com')

E viene restituito questo risultato: "https://contoso.com"

uriHost

Restituisce il valore host per un URI (Uniform Resource Identifier).

uriHost('<uri>')

Example

Questo esempio trova il valore host per questo URI:

uriHost('https://www.localhost.com:8080')

E viene restituito questo risultato: "www.localhost.com"

uriPath

Restituisce il valore path per un URI (Uniform Resource Identifier).

uriPath('<uri>')

Example

Questo esempio trova il valore path per questo URI:

uriPath('https://www.contoso.com/catalog/shownew.htm?date=today')

E viene restituito questo risultato: "/catalog/shownew.htm"

uriPathAndQuery

Restituisce i valori path e query per un URI (Uniform Resource Identifier).

uriPathAndQuery('<uri>')

Example

Questo esempio trova i valori path e query per questo URI:

uriPathAndQuery('https://www.contoso.com/catalog/shownew.htm?date=today')

E viene restituito questo risultato: "/catalog/shownew.htm?date=today"

uriPort

Restituisce il valore port per un URI (Uniform Resource Identifier).

uriPort('<uri>')

Example

Questo esempio restituisce il valore port per questo URI:

uriPort('https://www.localhost:8080')

E viene restituito questo risultato: 8080

uriQuery

Restituisce il valore query per un URI (Uniform Resource Identifier).

uriQuery('<uri>')

Example

Questo esempio restituisce il valore query per questo URI:

uriQuery('https://www.contoso.com/catalog/shownew.htm?date=today')

E viene restituito questo risultato: "?date=today"

uriScheme

Restituisce il valore scheme per un URI (Uniform Resource Identifier).

uriScheme('<uri>')

Example

Questo esempio restituisce il valore scheme per questo URI:

uriScheme('https://www.contoso.com/catalog/shownew.htm?date=today')

E viene restituito questo risultato: "http"

utcNow

Restituisce il timestamp corrente.

utcNow('<format>')

Optionally, you can specify a different format with the <format> parameter.

Example 1

Si supponga che oggi sia il 15 aprile 2018 alle ore 13:00. Questo esempio ottiene il timestamp corrente:

utcNow()

E viene restituito questo risultato: "2018-04-15T13:00:00.0000000Z"

Example 2

Si supponga che oggi sia il 15 aprile 2018 alle ore 13:00. Questo esempio ottiene il timestamp corrente usando il formato "D" facoltativo:

utcNow('D')

E viene restituito questo risultato: "Sunday, April 15, 2018"

V

variables

Restituisce il valore per una variabile specificata.

variables('<variableName>')

Example

Si supponga che il valore corrente per una variabile "numItems" sia 20. Questo esempio ottiene il valore intero per questa variabile:

variables('numItems')

E viene restituito questo risultato: 20

W

workflow

Restituisce tutti i dettagli del flusso di lavoro stesso in fase di esecuzione.

workflow().<property>

Example 1

Questo esempio restituisce il nome dell'esecuzione corrente di un flusso di lavoro:

workflow().run.name

Example 2

Se si usa Power Automate, è possibile creare un'espressione @workflow() che usa la tags proprietà di output per ottenere i valori dalla proprietà o flowDisplayName del environmentName flusso.

Ad esempio, è possibile inviare notifiche di posta elettronica personalizzate dal flusso stesso che si collegano di nuovo al flusso. Queste notifiche possono includere un collegamento HTML che contiene il nome visualizzato del flusso nel titolo del messaggio di posta elettronica e segue questa sintassi:

<a href=https://flow.microsoft.com/manage/environments/@{workflow()['tags']['environmentName']}/flows/@{workflow()['name']}/details>Open flow @{workflow()['tags']['flowDisplayName']}</a>

X

xml

Restituisce la versione XML di una stringa contenente un oggetto JSON.

xml('<value>')

Example 1

In questo esempio la stringa viene convertita in XML:

xml('<name>Sophia Owen</name>')

E viene restituito questo elemento XML:

<name>Sophia Owen</name>

Example 2

Questo esempio crea la versione XML per questa stringa, che contiene un oggetto JSON:

xml(json('{ "name": "Sophia Owen" }'))

E viene restituito questo elemento XML:

<name>Sophia Owen</name>

Example 3

Si supponga di avere questo oggetto JSON:

{
  "person": {
    "name": "Sophia Owen",
    "city": "Seattle"
  }
}

Questo esempio crea la versione XML per una stringa contenente questo oggetto JSON:

xml(json('{"person": {"name": "Sophia Owen", "city": "Seattle"}}'))

E viene restituito questo elemento XML:

<person>
  <name>Sophia Owen</name>
  <city>Seattle</city>
<person>

xpath

Verifica nel codice XML la presenza di nodi o valori che corrispondono a un'espressione XPath (XML Path Language) e restituisce i nodi o i valori corrispondenti. Un'espressione XPath, o semplicemente "XPath", aiuta a spostarsi nella struttura del documento XML in modo che sia possibile selezionare i nodi o i valori di calcolo nel contenuto XML.

xpath('<xml>', '<xpath>')

Example 1

Si supponga di avere questa 'items' stringa 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>

In questo esempio viene passata l'espressione XPath, '/produce/item/name/text()', per trovare i nodi che corrispondono al <name></name> nodo nella 'items' stringa XML e restituisce una matrice con tali valori di nodo:

xpath(xml(parameters('items')), '/produce/item/name/text()')

The example also uses the parameters() function to get the XML string from 'items' and convert the string to XML format by using the xml() function.

Ecco la matrice di risultati popolata con i valori dei nodi che corrispondono <name></name>a :

[ Gala, Honeycrisp ]

Example 2

Nell'esempio 1 questo esempio passa nell'espressione XPath , '/produce/item/name[1]', per trovare il primo name elemento figlio dell'elemento item .

xpath(xml(parameters('items')), '/produce/item/name[1]')

Ecco il risultato: Gala

Example 3

Nell'esempio 1 questo esempio passa l'espressione XPath , '/produce/item/name[last()]', per trovare l'ultimo name elemento figlio dell'elemento item .

xpath(xml(parameters('items')), '/produce/item/name[last()]')

Ecco il risultato: Honeycrisp

Example 4

In questo esempio si supponga che la items stringa XML contenga anche gli attributi expired='true' e 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>

In questo esempio viene passata l'espressione XPath, '//name[@expired]', per trovare tutti gli name elementi con l'attributo expired :

xpath(xml(parameters('items')), '//name[@expired]')

Ecco il risultato: [ Gala, Honeycrisp ]

Example 5

In questo esempio si supponga che la items stringa XML contenga solo questo attributo, 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>

In questo esempio viene passata l'espressione XPath, '//name[@expired = 'true']', per trovare tutti gli name elementi con l'attributo , expired = 'true':

xpath(xml(parameters('items')), '//name[@expired = 'true']')

Ecco il risultato: [ Gala ]

Example 6

In questo esempio si supponga che la items stringa XML contenga anche questi attributi:

• 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>

In questo esempio viene passata l'espressione XPath, '//name[@price>35]', per trovare tutti gli name elementi con price > 35:

xpath(xml(parameters('items')), '//name[@price>35]')

Ecco il risultato: Honeycrisp

Example 7

In questo esempio si supponga che la items stringa XML sia uguale a quella dell'esempio 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>

Questo esempio trova nodi che corrispondono al <count></count> nodo e aggiunge tali valori di nodo con la sum() funzione :

xpath(xml(parameters('items')), 'sum(/produce/item/count)')

Ecco il risultato: 30

Example 8

In questo esempio si supponga di avere questa stringa XML, che include lo spazio dei nomi del documento XML, xmlns="https://contoso.com":

<?xml version="1.0"?><file xmlns="https://contoso.com"><location>Paris</location></file>

Queste espressioni usano un'espressione XPath o /*[name()="file"]/*[name()="location"]/*[local-name()="file" and namespace-uri()="https://contoso.com"]/*[local-name()="location"], per trovare nodi che corrispondono al <location></location> nodo. Questi esempi illustrano la sintassi usata nella finestra di progettazione o nell'editor di espressioni:

• xpath(xml(body('Http')), '/*[name()="file"]/*[name()="location"]')
• xpath(xml(body('Http')), '/*[local-name()="file" and namespace-uri()="https://contoso.com"]/*[local-name()="location"]')

Ecco il nodo del risultato che corrisponde al nodo <location></location>:

<location xmlns="https://contoso.com">Paris</location>

Example 9

Nell'esempio 8 questo esempio usa l'espressione XPath , 'string(/*[name()="file"]/*[name()="location"])', per trovare il valore nel <location></location> nodo :

xpath(xml(body('Http')), 'string(/*[name()="file"]/*[name()="location"])')

Ecco il risultato: Paris

Next steps

Leggere altre informazioni sul linguaggio di definizione del flusso di lavoro