Nota
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
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:
- Obtener o hacer referencia al valor de la variable.
- Aumentar o disminuir la variable por un valor constante, también conocido como incremento y decremento.
- Asignar un valor diferente a la variable.
- Insertar o anexar el valor de la variable como el último elemento en una cadena o una 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 obtener más información, consulte Adición de un desencadenador o una acción para crear un flujo de trabajo.
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
Algunos pasos difieren ligeramente en función de si tiene un flujo de trabajo de Consumo o Estándar.
Inicializar la 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 se pueden declarar variables en el nivel global, y no en los ámbitos, condiciones y bucles.
En Azure Portal abra el flujo de trabajo de la aplicación lógica en el diseñador.
En el diseñador, siga estos pasos generales para los flujos de trabajo Consumo o Estándar a fin de agregar una acción denominada Inicializar variables.
Especifique la siguiente información acerca de la variable:
Propiedad Obligatorio Valor Descripción Nombre Sí < nombre de variable> Nombre de la variable que se va a inicializar Tipo Sí < tipo variable> El tipo de datos de la variable Valor No < valor-inicial> 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.Para crear más de una variable a la vez, seleccione Agregar una variable.
En el ejemplo siguiente se muestran los valores iniciales de esta variable de ejemplo:
Continúe agregando las acciones que desee para 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, en el ejemplo siguiente, se muestra cómo aparece la acción Inicializar variables en la definición de flujo de trabajo, que se encuentra en formato de notación de objetos JavaScript (JSON):
"actions": {
"Initialize_variable": {
"type": "InitializeVariable",
"inputs": {
"variables": [
{
"name": "Count",
"type": "Integer",
"value": 0
}
]
},
"runAfter": {}
}
}
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 variables() función en el diseñador de flujo de trabajo y el editor de vistas de código. 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.
Por ejemplo, la expresión siguiente 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 las variables de enteros y flotantes.
En el diseñador, siga estos pasos generales para los flujos de trabajo Consumo o Estándar para agregar una acción denominada Incrementar variable.
A continuación, proporcione la siguiente información para esta acción:
Propiedad Obligatorio Valor Descripción Nombre Sí < nombre de variable> El nombre de la variable que se va a incrementar Valor No < valor de incremento> El valor que se usa 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 un contador de bucle
Las variables se usan habitualmente 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 con un flujo de trabajo en blanco. Agregue un desencadenador que compruebe si hay correos electrónicos y datos adjuntos nuevos.
En este ejemplo usaremos el desencadenador de Office 365 Outlook cuando llegue un nuevo correo electrónico. Puede configurar este desencadenador para que solo active cuando el correo electrónico tenga datos adjuntos. Sin embargo, puede usar cualquier conector que compruebe si hay correos electrónicos con datos adjuntos nuevos; por ejemplo, el conector de 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
- Include Attachments (Incluir datos adjuntos)
Agregue la acción Inicializar variables para crear una variable de entero denominada Contar que tenga un valor inicial establecido en 0.
En el diseñador, siga estos pasos generales para los flujos de trabajo Consumo o Estándar a fin de agregar una acción denominada un bucle For each.
En el bucle, seleccione dentro del cuadro denominado Seleccionar una salida de pasos anteriores para ver las opciones de entrada. Seleccione el icono de rayo para ver la lista de contenido dinámico. En la lista, en Cuando llegue un nuevo correo electrónico, seleccione Datos 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 un flujo de trabajo Consumo o Estándar a fin de 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 Valor en 1.
En el bucle, agregue cualquier acción que le envíe la cantidad de datos adjuntos. En la acción, incluya el valor de la variable Recuento como, por ejemplo:
Cuando haya terminado, guarde el flujo de trabajo. En la barra de herramientas del diseñador, seleccione Save (Guardar).
Pruebe el flujo de trabajo
Para desencadenar manualmente el flujo de trabajo, en la barra de herramientas del diseñador, seleccione Ejecutar>Ejecutar para ejecutar manualmente el flujo de trabajo.
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" ]
}
}
},
Reducir 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 las variables de enteros y flotantes.
En la tabla siguiente se describe la información de la acción Reducir variable:
| Propiedad | Obligatorio | Valor | Descripción |
|---|---|---|---|
| Nombre | Sí | < nombre de variable> | El nombre de la variable que se va a reducir |
| Valor | No | < valor de decremento> | El valor para reducir la variable. El valor predeterminado es uno. Sugerencia: aunque es opcional, establezca este valor como procedimiento recomendado para que sepa siempre el valor específico para reducir la 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": {}
}
},
Establecer la variable
Para asignar un valor diferente a una variable existente, siga los pasos para incrementar una variable; tendrá que realizar lo siguiente:
Buscar y seleccionar la acción Establecer variable.
Proporcionar el nombre de la variable y el valor que quiere asignar. Tanto el nuevo valor como la variable deben tener los mismos tipos de datos. El valor es necesario 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 | Obligatorio | Valor | Descripción |
|---|---|---|---|
| Nombre | Sí | < nombre de variable> | El nombre de la variable que se va a establecer |
| Valor | Sí | < new-value> | El valor al que quiere asignar la variable. Ambos deben tener los mismos tipos 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:
Seleccione el bucle para ver el panel de información y, luego, seleccione Configuración.
En la sección General, en Control de simultaneidad, cambie la configuración de Desactivado a Activado.
Arrastre el control deslizante 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 la variable
En cuanto a las variables que almacenan cadenas o matrices, puede insertar o anexar el valor de una variable como el último elemento de esas matrices o cadenas. 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 la variable de matriz
Proporcione el valor que se anexa como el último elemento de la cadena o matriz. Este valor es necesario.
En la tabla siguiente se describe la información de las acciones Anexar a...:
| Propiedad | Obligatorio | Valor | Descripción |
|---|---|---|---|
| Nombre | Sí | < nombre de variable> | El nombre de la variable que se va a establecer |
| Valor | Sí | < append-value> | El valor que quiere anexar, que puede ser de 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" ]
}
}
},