Creación de variables para almacenar y administrar valores en Azure Logic Apps
Se aplica a: Azure Logic Apps (consumo + estándar)
En esta guía paso a paso se muestra cómo crear y trabajar con variables que se usan para almacenar y usar valores en el flujo de trabajo de la aplicación lógica. Por ejemplo, las variables pueden ayudarle a hacer un seguimiento del número de veces que se ejecuta un bucle. Al iterar una matriz o al comprobar una matriz para buscar un elemento específico, puede usar una variable para hacer referencia al número de índice de cada elemento de la matriz.
Puede crear variables para tipos de datos como, por ejemplo, "entero", "float", "booleano", "cadena", "matriz" y "objeto". Después de crear una variable, puede realizar otras tareas, por ejemplo:
- Obtenga o haga referencia al valor de la variable.
- Aumentar o disminuir la variable en un valor constante, también conocido como incremento y decremento.
- Asigne un valor distinto a la variable.
- Insertar o anexar el valor de la variable como el último elemento en una cadena o matriz.
Las variables solo existen y son globales en la instancia del flujo de trabajo que las crea. Además, persisten en todas las iteraciones de bucle de una instancia del flujo de trabajo. Cuando se hace referencia a una variable, debe usar el nombre de la variable como token, y no el nombre de la acción; este último se usa de forma habitual para hacer referencia a los resultados de la acción.
Importante
De forma predeterminada, las iteraciones de un bucle For each se ejecutan en paralelo. Cuando se usan variables en bucles, ejecute el bucle secuencialmente para que las variables devuelvan resultados predecibles.
Requisitos previos
Una cuenta y una suscripción de Azure. Si aún no tiene una, regístrese para obtener una cuenta de Azure gratuita.
Este es un flujo de trabajo de la aplicación lógica donde quiere crear la variable y un desencadenador que inicie el flujo de trabajo.
Antes de poder agregar acciones para crear y trabajar con variables, debe iniciar el flujo de trabajo con un desencadenador como primer paso del flujo de trabajo. Para más información, consulte Compilación de un flujo de trabajo con un desencadenador o acciones.
Aunque en los siguientes pasos se usa Azure Portal, también puede usar las siguientes herramientas para crear flujos de trabajo de aplicaciones lógicas si usa la extensión Azure Logic Apps adecuada:
- Flujos de trabajo de Consumo: Visual Studio Code
- Flujos de trabajo estándar: Visual Studio Code
En función de si tiene un flujo de trabajo de Consumo o Estándar, siga los pasos correspondientes:
Inicializar variable
Puede crear una variable y declarar el tipo de datos y el valor inicial de la misma mediante una sola acción del flujo de trabajo. Solo puede declarar variables a nivel global, no dentro de ámbitos, condiciones y bucles.
En Azure Portal, abra el flujo de trabajo en el diseñador.
En el diseñador, siga estos pasos generales para agregar una acción denominada Inicializar variable.
Especifique la siguiente información acerca de la variable:
Propiedad Necesario Valor Descripción Nombre Sí <variable-name> El nombre de la variable que se va a incrementar Tipo Sí <variable-type> El tipo de datos de la variable Valor No <start-value> Valor inicial de la variable
Sugerencia: aunque es opcional, establezca este valor como procedimiento recomendado para que sepa siempre el valor inicial de la variable.En el ejemplo siguiente se muestran los valores iniciales de esta variable de ejemplo:
A continuación, agregue las acciones que quiera tener en su escenario. Cuando esté listo, seleccione Guardar en la barra de herramientas del diseñador.
Si cambia del diseñador a la vista de código, el siguiente ejemplo muestra cómo aparece la acción Inicializar variable en la definición del flujo de trabajo, que está en formato de notación de objetos JavaScript (JSON):
"actions": {
"Initialize_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "Count",
"type": "Integer",
"value": 0
}
]
},
"runAfter": {}
}
},
Nota:
Aunque la acción Inicializar variable tiene un objeto "variables" que está estructurado como una matriz, la acción solo puede crear una variable a la vez. Cada nueva variable requiere una acción Inicializar variable individual.
En los ejemplos siguientes se muestran otros tipos de variables:
Variable booleana
"actions": {
"Initialize_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "myBooleanVariable",
"type": "boolean",
"value": false
}
]
},
"runAfter": {}
}
},
Variable Float
"actions": {
"Initialize_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "myFloatVariable",
"type": "float",
"value": 1.99999
}
]
},
"runAfter": {}
}
},
Variable de cadena
"actions": {
"Initialize_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "myStringVariable",
"type": "string",
"value": "lorem ipsum"
}
]
},
"runAfter": {}
}
},
Variable de objeto
"actions": {
"Initialize_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "MyObjectVariable",
"type": "object",
"value": {
"ProductItem": {
"Name": "myProductName",
"ProductID": "000000"
}
}
}
]
},
"runAfter": {}
}
},
Matriz con enteros
"actions": {
"Initialize_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "myArrayVariable",
"type": "array",
"value": [1, 2, 3]
}
]
},
"runAfter": {}
}
},
Matriz con cadenas
"actions": {
"Initialize_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "myArrayVariable",
"type": "array",
"value": ["red", "orange", "yellow"]
}
]
},
"runAfter": {}
}
},
Obtener el valor de una variable
Para recuperar o hacer referencia al contenido de una variable, puede usar la función variables() del diseñador del flujo de trabajo y el editor de la vista de código. Cuando haga referencia a una variable, utilice el nombre de la variable como token, no el nombre de la acción, que es la forma habitual de hacer referencia a los resultados de una acción.
Por ejemplo, la siguiente expresión obtiene los elementos de la variable de matriz que se crea en esta guía mediante la función variables(). La función string() devuelve el contenido de la variable en formato de cadena: "1, 2, 3, red"
@{string(variables('myArrayVariable'))}
Incrementar variable
Para aumentar o incrementar una variable con un valor constante específico, agregue la acción Incrementar variable al flujo de trabajo. Esta acción solo funciona con variables enteras y flotantes.
En el diseñador del flujo de trabajo, siga estos pasos generales para agregar una acción denominada Incrementar variable.
A continuación, proporcione la siguiente información para esta acción:
Propiedad Necesario Valor Descripción Nombre Sí <variable-name> Nombre de la variable que se incrementará Valor No <increment-value> El valor utilizado para incrementar la variable. El valor predeterminado es 1.
Sugerencia: aunque es opcional, establezca este valor como procedimiento recomendado para que sepa siempre el valor específico para incrementar la variable.En el ejemplo siguiente se muestran los valores de ejemplo de esta acción:
Cuando haya terminado, guarde el flujo de trabajo. En la barra de herramientas del diseñador, seleccione Save (Guardar).
Si cambia del diseñador a la vista de código, el siguiente ejemplo muestra cómo aparece la acción Incrementar variable en la definición del flujo de trabajo, que está en formato JSON:
"actions": {
"Increment_variable": {
"type": "IncrementVariable",
"inputs": {
"name": "Count",
"value": 1
},
"runAfter": {}
}
},
Ejemplo: crear contador de bucles
Las variables se utilizan comúnmente para contar el número de veces que se ejecuta un bucle. En este ejemplo se muestra cómo puede crear y usar variables para esta tarea, mediante la creación de un bucle que cuente los datos adjuntos de un correo electrónico.
En Azure Portal, cree el recurso de aplicación lógica Consumo con un flujo de trabajo en blanco. Agregue un desencadenador que compruebe si hay nuevos correos electrónicos y cualquier archivo adjunto.
En este ejemplo usaremos el desencadenador de Office 365 Outlook cuando llegue un nuevo correo electrónico. Puede configurar este disparador para que se active solo cuando el correo electrónico tenga archivos adjuntos. Sin embargo, puede usar cualquier conector que busque nuevos correos electrónicos con archivos adjuntos, como el conector Outlook.com.
Para que el desencadenador compruebe si hay datos adjuntos y los pase al flujo de trabajo, seleccione Sí en estas propiedades:
- Solo con datos adjuntos
- Incluir datos adjuntos
Agregue la acción Inicializar variable para crear una variable de entero denominada Count que tenga un valor inicial establecido en
0.Para recorrer en iteración cada archivo adjunto, siga estos pasos generales para agregar una acción denominada bucle For each.
En el bucle, seleccione dentro del cuadro denominado Seleccionar una salida de los pasos anteriores. Cuando aparezca la lista de contenido dinámico, en Cuando llega un nuevo correo electrónico, seleccione Adjuntos.
La propiedad Attachments pasa una matriz que contiene los datos adjuntos de correo electrónico de la salida del desencadenador hacia el bucle, para que el flujo de trabajo pueda recorrerse en iteración.
En el bucle Para cada uno, seleccione Agregar una acción.
Siga estos pasos generales para agregar una acción denominada Incrementar variable al bucle.
Nota:
Asegúrese de que la acción Incrementar variable aparezca dentro del bucle. Si la acción aparece fuera del bucle, arrástrela al mismo.
En la acción Incrementar variable de la lista Nombre, seleccione la variable Recuento. Establezca la propiedad Value en
1.
Debajo del bucle, agregue cualquier acción que le envíe la cantidad de archivos adjuntos. En su acción, incluya el valor de la variable Contar, por ejemplo:
Cuando haya terminado, guarde el flujo de trabajo. En la barra de herramientas del diseñador, seleccione Save (Guardar).
Prueba del flujo de trabajo
Para desencadenar manualmente el flujo de trabajo, siga el paso correspondiente:
Flujo de trabajo de consumo
En la barra de herramientas del flujo de trabajo del diseñador, seleccione Ejecutar desencadenador>Ejecutar para iniciar manualmente el flujo de trabajo.
Flujo de trabajo Estándar
En el menú del flujo de trabajo, seleccione Información general. En la barra de herramientas, seleccione Ejecutar>Ejecutar.
Envíe un correo electrónico con uno o varios datos adjuntos a la cuenta de correo electrónico que usó en este ejemplo.
Este paso activa el desencadenador de flujo de trabajo, que crea y ejecuta una instancia de flujo de trabajo. Como resultado, el flujo de trabajo envía un mensaje o un correo electrónico que muestra el número de datos adjuntos del correo electrónico que envió.
Si cambia del diseñador a la vista de código, el siguiente ejemplo muestra cómo aparece el bucle For each junto con la acción Incrementar variable en la definición del flujo de trabajo, que está en formato JSON:
"actions": {
"For_each": {
"type": "Foreach",
"actions": {
"Increment_variable": {
"type": "IncrementVariable",
"inputs": {
"name": "Count",
"value": 1
},
"runAfter": {}
}
},
"foreach": "@triggerBody()?['Attachments']",
"runAfter": {
"Initialize_variable": [ "Succeeded" ]
}
}
},
Decrementar variable
Para disminuir o reducir una variable con un valor constante específico, siga los pasos para incrementar una variable, excepto si en su lugar agrega la acción Reducir variable a su flujo de trabajo. Esta acción solo funciona con variables enteras y flotantes.
En la tabla siguiente se describe la información de la acción Reducir variable:
| Propiedad | Necesario | Valor | Descripción |
|---|---|---|---|
| Nombre | Sí | <variable-name> | Nombre de la variable que se decrementará |
| Valor | No | <increment-value> | El valor utilizado para decrementar la variable. El valor predeterminado es uno. Consejo: aunque es opcional, establezca este valor como práctica recomendada para que siempre sepa el valor específico para decrementar su variable. |
Si cambia del diseñador a la vista de código, el siguiente ejemplo muestra cómo aparece la acción Reducir variable en la definición del flujo de trabajo, que está en formato JSON:
"actions": {
"Decrement_variable": {
"type": "DecrementVariable",
"inputs": {
"name": "Count",
"value": 1
},
"runAfter": {}
}
},
Establecimiento de la variable
Para asignar un valor diferente a una variable existente, siga los pasos para incrementar una variable; tendrá que realizar lo siguiente:
Encuentre y seleccione en su lugar la acción Establecer variable.
Proporcione el nombre de la variable y el valor que desea asignar. Tanto el nuevo valor como la variable deben tener el mismo tipo de datos. El valor es obligatorio porque esta acción no tiene un valor predeterminado.
En la tabla siguiente se describe la información de la acción Establecer variable:
| Propiedad | Necesario | Valor | Descripción |
|---|---|---|---|
| Nombre | Sí | <variable-name> | Nombre de la variable que se cambiará |
| Valor | Sí | <new-value> | Valor que quiere asignar a la variable. Ambos deben tener el mismo tipo de datos. |
Nota
A menos que esté incrementando o reduciendo variables, el cambio de variables dentro de los bucles podría crear resultados inesperados, porque los bucles se ejecutan en paralelo o de forma simultánea, de manera predeterminada. Para estos casos, intente configurar el bucle para que se ejecute secuencialmente. Por ejemplo, cuando quiera hacer referencia al valor de la variable dentro del bucle y esperar el mismo valor al inicio y al final de esa instancia de bucle, siga estos pasos para cambiar la forma en que se ejecuta el bucle:
En el bucle, busque y abra su configuración.
Según el tipo de flujo de trabajo, siga los pasos correspondientes:
Consumo: cambie el valor de Control de simultaneidad de Desactivado a Activado.
Estándar: en General, cambie la opción Control de simultaneidad de Desactivado a Activado.
Arrastre el control deslizante Degree of Parallelism (Grado de paralelismo) a 1.
Si cambia del diseñador a la vista de código, el siguiente ejemplo muestra cómo aparece la acción Establecer variable en la definición del flujo de trabajo, que está en formato JSON:
En el siguiente ejemplo se cambia el valor actual de la variable Count a otro valor:
"actions": {
"Initialize_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [ {
"name": "Count",
"type": "Integer",
"value": 0
} ]
},
"runAfter": {}
},
"Set_variable": {
"type": "SetVariable",
"inputs": {
"name": "Count",
"value": 100
},
"runAfter": {
"Initialize_variable": [ "Succeeded" ]
}
}
},
Anexar a variable
Para las variables que almacenan cadenas o matrices, puede insertar o anexar el valor de una variable como último elemento de esas cadenas o matrices. Puede seguir los pasos para incrementar una variable con las excepciones siguientes:
Busque y seleccione una de estas acciones en función de si la variable es una cadena o una matriz:
- Anexar a la variable de cadena
- Anexar a variable matriz
Proporcione el valor para agregar como último elemento de la cadena o matriz. Se requiere un valor.
En la tabla siguiente se describe la información de las acciones Anexar a...:
| Propiedad | Necesario | Valor | Descripción |
|---|---|---|---|
| Nombre | Sí | <variable-name> | Nombre de la variable que se cambiará |
| Valor | Sí | <append-value> | El valor que desea anexar, que puede tener cualquier tipo |
Si cambia del diseñador a la vista de código, el siguiente ejemplo muestra cómo aparece la acción Anexar a la variable de matriz en la definición del flujo de trabajo, que está en formato JSON.
En el siguiente ejemplo se crea una variable de matriz y se agrega otro valor como el último elemento de la matriz. El resultado es una variable actualizada que contiene esta matriz: [1,2,3,"red"].
"actions": {
"Initialize_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [ {
"name": "myArrayVariable",
"type": "Array",
"value": [1, 2, 3]
} ]
},
"runAfter": {}
},
"Append_to_array_variable": {
"type": "AppendToArrayVariable",
"inputs": {
"name": "myArrayVariable",
"value": "red"
},
"runAfter": {
"Initialize_variable": [ "Succeeded" ]
}
}
},