Leer en inglés

Compartir a través de

Creación de variables para almacenar y administrar valores en Azure Logic Apps

  • Artículo

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

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:

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.

  1. En Azure Portal, abra el flujo de trabajo en el diseñador.

  2. En el diseñador, siga estos pasos generales para agregar una acción denominada Inicializar variable.

  3. Especifique la siguiente información acerca de la variable:

    Propiedad Necesario Valor Descripción
    Nombre Sí < variable-name> El nombre de la variable a inicializar
    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:

    Captura de pantalla que muestra Azure Portal, el flujo de trabajo del consumidor y la acción denominada Inicializar variable.

  4. 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):

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

JSON 
"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "myBooleanVariable",
               "type": "boolean",
               "value": false
            }
         ]
      },
      "runAfter": {}
   }
},

Variable Float

JSON 
"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "myFloatVariable",
               "type": "float",
               "value": 1.99999
            }
         ]
      },
      "runAfter": {}
   }
},

Variable de cadena

JSON 
"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "myStringVariable",
               "type": "string",
               "value": "lorem ipsum"
            }
         ]
      },
      "runAfter": {}
   }
},

Variable de objeto

JSON 
"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "MyObjectVariable",
               "type": "object",
               "value": {
                  "ProductItem": {
                     "Name": "myProductName",
                     "ProductID": "000000"
                  }
               }
            }
         ]
      },
      "runAfter": {}
   }
},

Matriz con enteros

JSON 
"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "myArrayVariable",
               "type": "array",
               "value": [1, 2, 3]
            }
         ]
      },
      "runAfter": {}
   }
},

Matriz con cadenas

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

JSON 
@{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.

  1. En el diseñador del flujo de trabajo, siga estos pasos generales para agregar una acción denominada Incrementar variable.

  2. 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:

    Captura de pantalla que muestra Azure Portal, el flujo de trabajo de Consumo y la acción denominada Incrementar variable.

  3. 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:

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.

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

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

    Captura de pantalla que muestra Azure Portal, el flujo de trabajo de Consumo y las propiedades seleccionadas para buscar e incluir archivos adjuntos.

  3. Agregue la acción Inicializar variable para crear una variable de entero denominada Count que tenga un valor inicial establecido en 0.

  4. Para recorrer en iteración cada archivo adjunto, siga estos pasos generales para agregar una acción denominada bucle For each.

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

    Captura de pantalla que muestra el flujo de trabajo de Consumo, el bucle For each, la lista de contenido dinámico abierta y la salida Adjuntos seleccionada.

    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.

  6. En el bucle Para cada uno, seleccione Agregar una acción.

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

  8. En la acción Incrementar variable de la lista Nombre, seleccione la variable Recuento. Establezca la propiedad Value en 1.

    Captura de pantalla que muestra el flujo de trabajo de Consumo con la variable seleccionada denominada Recuento.

  9. 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:

    Captura de pantalla muestra el flujo de trabajo de Consumo y una acción que envía resultados.

  10. Cuando haya terminado, guarde el flujo de trabajo. En la barra de herramientas del diseñador, seleccione Save (Guardar).

Prueba del flujo de trabajo

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

  2. 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:

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 < decrement-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:

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:

  1. Encuentre y seleccione en su lugar la acción Establecer variable.

  2. 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:

  1. En el bucle, busque y abra su configuración.

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

  3. 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:

JSON 
"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:

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

  2. 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"].

JSON 
"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" ]
      }
   }
},

Pasos siguientes