Criar variáveis para armazenar e gerenciar valores nos Aplicativos Lógicos do Azure

Aplica-se a: Aplicativos Lógicos do Azure (Consumo + Padrão)

Este guia de instruções mostra como criar e trabalhar com variáveis para armazenar e usar valores no seu fluxo de trabalho do aplicativo lógico. Por exemplo, as variáveis podem ajudar você a acompanhar o número de vezes que um loop é executado. Para iterar em uma matriz ou verificar uma matriz em busca de um item específico, você pode usar uma variável para referenciar o número de índice de cada item da matriz.

Você pode criar variáveis para tipos de dados, como inteiro, float, booliano, cadeia de caracteres, matriz e objeto. Depois de criar uma variável, você pode executar outras tarefas, por exemplo:

• Obter ou consultar o valor da variável.
• Aumentar ou diminuir a variável em um valor constante, também conhecido como incremento e decremento.
• Atribuir um valor diferente para a variável.
• Inserir ou acrescentar o valor da variável como o último item de uma cadeia de caracteres ou uma matriz.

As variáveis existem e são globais apenas dentro da instância de fluxo de trabalho que as cria. Além disso, elas persistem em quaisquer iterações de loop dentro de uma instância de fluxo de trabalho. Ao referenciar uma variável, use o nome dela como o token, não o nome da ação, que é a maneira habitual de referenciar as saídas de uma ação.

Importante

Por padrão, as iterações em um loop Para cada são executadas em paralelo. Ao usar variáveis em loops, execute o loop sequencialmente para que as variáveis retornem resultados previsíveis.

Pré-requisitos

• Uma conta e uma assinatura do Azure. Se você não tem uma assinatura, inscreva-se em uma conta gratuita do Azure.

• Um fluxo de trabalho de aplicativo lógico no qual você deseja criar a variável e um gatilho que inicia o fluxo de trabalho.

  Antes de adicionar ações para criar e trabalhar com variáveis, o fluxo de trabalho deve começar com um gatilho como a primeira etapa no fluxo de trabalho. Para obter mais informações, confira Adicionar um gatilho ou ação para criar um fluxo de trabalho.

As etapas a seguir usam o portal do Azure, mas com a extensão apropriada do Aplicativos Lógicos do Azure, você também pode usar as seguintes ferramentas para criar fluxos de trabalho de aplicativos lógicos:

• Fluxos de trabalho de Consumo: Visual Studio Code
• Fluxos de trabalho padrão: Visual Studio Code

Algumas etapas diferem um pouco com base em se você tem um fluxo de trabalho de Consumo ou Standard.

Inicializar variável

Você pode criar uma variável e declarar seu tipo de dados e o valor inicial, usando uma única ação em seu fluxo de trabalho. Você só pode declarar variáveis no nível global, não em escopos, condições e loops.

1. No portal do Azure, abra o fluxo de trabalho do aplicativo de lógica no designer.

2. No designer, siga estas etapas gerais para fluxos de trabalho de Consumo ou Standard para adicionar uma ação chamada Inicializar variáveis.

3. Forneça as seguintes informações sobre sua variável:

   Propriedade	Obrigatório	Valor	Descrição
   Nome	Sim	< nome da variável>	O nome da variável a ser inicializada
   Tipo	Sim	< tipo de variável>	O tipo de dados para a variável
   Valor	Não	< valor-inicial>	O valor inicial da variável Dica: embora seja opcional, defina o valor como uma melhor prática para que você sempre saiba o valor inicial da variável.

   Para criar mais de uma variável por vez, selecione Adicionar uma Variável.

   O exemplo a seguir mostra os valores iniciais desta variável de amostra:

   

4. Continue adicionando as ações desejadas para seu cenário. Quando terminar, selecione Salvar na barra de ferramentas do designer.

Se você alternar do designer para o modo de exibição de código, o exemplo a seguir mostrará como a ação Inicializar variáveis aparece em sua definição de fluxo de trabalho, que está no formato JavaScript Object Notation (JSON):

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [ 
            {
               "name": "Count",
               "type": "Integer",
               "value": 0
            }
         ]
      },
      "runAfter": {}
   }
}

Os exemplos a seguir mostram outros tipos de variáveis:

Variável booliana

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

Variável float

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

Variável de cadeia de caracteres

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

Variável de objeto

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

Matriz com inteiros

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

Matriz com cadeias de caracteres

"actions": {
   "Initialize_variable": {
      "type": "InitializeVariable",
      "inputs": {
         "variables": [
            {
               "name": "myArrayVariable",
               "type": "array",
               "value": ["red", "orange", "yellow"]
            }
         ]
      },
      "runAfter": {}
   }
},

Obter o valor de uma variável

Para recuperar ou fazer referência ao conteúdo de uma variável, você pode usar a variables() função no designer de fluxo de trabalho e no editor de exibição de código. Ao referenciar uma variável, use o nome dela como o token, não o nome da ação, que é a maneira habitual de referenciar as saídas de uma ação.

Por exemplo, a expressão a seguir obtém os itens da variável de matriz que você cria neste guia usando a função variables(). A função string() retorna o conteúdo da variável no formato de cadeia de caracteres: "1, 2, 3, red".

@{string(variables('myArrayVariable'))}

Incrementar variável

Para aumentar ou incrementar uma variável por um valor constante específico, adicione a ação Incrementar variável ao seu fluxo de trabalho. Essa ação só funciona com variáveis de inteiro e float.

1. No designer, siga estas etapas gerais para fluxos de trabalho de Consumo ou Standard para adicionar uma ação chamada Incrementar variável.

2. Forneça as seguintes informações para esta ação:

   Propriedade	Obrigatório	Valor	Descrição
   Nome	Sim	< nome da variável>	O nome da variável para incrementar
   Valor	Não	< valor de incremento>	O valor usado para incrementar a variável. O valor padrão é 1. Dica: embora seja opcional, defina esse valor como uma melhor prática para que você sempre saiba o valor específico para incrementar sua variável.

   O exemplo a seguir mostra os valores de amostra para esta ação:

   

3. Quando terminar, salve o fluxo de trabalho. Selecione Salvar na barra de ferramentas do designer.

Se você alternar do designer para a exibição de código, o exemplo a seguir mostra como a ação Incrementar variável aparece na definição do fluxo de trabalho, que está no formato JSON:

"actions": {
   "Increment_variable": {
      "type": "IncrementVariable",
      "inputs": {
         "name": "Count",
         "value": 1
      },
      "runAfter": {}
   }
},

Exemplo: criar contador de loops

As variáveis são usadas normalmente para contar o número de vezes que um loop é executado. Este exemplo mostra como criar e usar variáveis para essa tarefa criando um loop que conta os anexos em um email.

1. Na página portal do Azure, crie seu recurso de aplicativo lógico com um fluxo de trabalho em branco. Adicione um gatilho que verifica se há novos emails e anexos.

   Este exemplo usa o gatilho do Outlook do Office 365 para Quando um novo email é recebido. Você pode configurar esse gatilho para ser acionado somente quando o email tiver anexos. No entanto, você pode usar qualquer conector que verifica a existência de novos emails com anexos, como o conector do Outlook.com.

2. No gatilho, para verificar se há anexos e transmiti-los para o fluxo de trabalho do aplicativo lógico, selecione Sim nas propriedades a seguir:

   • Somente com Anexo
   • Incluir Anexos

   

3. Adicione a ação Inicializar variáveis para criar uma variável de inteiro chamada Count que tem um valor inicial definido como 0.

4. No designer, siga estas etapas gerais para fluxos de trabalho de Consumo ou Standard para adicionar uma ação chamada loop Para cada.

5. No loop, selecione dentro da caixa chamada Selecionar uma Saída das Etapas Anteriores para exibir as opções de entrada. Selecione o ícone de raio para exibir a lista de conteúdo dinâmico. Na lista, em Quando um novo email chegar, selecione Anexos.

   

   A propriedade Anexos passa uma matriz que contém os anexos de email da saída do gatilho para o loop do fluxo de trabalho para iterar.

6. No loop For each, selecione Adicionar uma ação.

7. Siga estas etapas gerais para fluxo de trabalho de Consumo ou Standard para adicionar uma ação chamada Incrementar variável ao loop.

   Observação

   Verifique se a ação Incrementar variável aparece dentro do loop. Se a ação aparecer fora do loop, arraste a ação para o loop.

8. Na ação Incrementar variável, na lista Nome, selecione a variável Count. Defina a propriedade Value como 1.

   

9. No loop, adicione qualquer ação que envia a você o número de anexos. Em sua ação, inclua o valor da variável Count, por exemplo:

   

10. Quando terminar, salve o fluxo de trabalho. Selecione Salvar na barra de ferramentas do designer.

Testar seu fluxo de trabalho

1. Para disparar manualmente o fluxo de trabalho, na barra de ferramentas do designer, selecione Executar>Executar para executar manualmente o fluxo de trabalho.

2. Envie um email com um ou mais anexos para a conta de email usada neste exemplo.

   Esta etapa dispara o gatilho de fluxo de trabalho, que cria e executa uma instância de fluxo de trabalho. Como resultado, o fluxo de trabalho envia uma mensagem ou email mostrando o número de anexos no email enviado por você.

Se você alternar do designer para a exibição de código, o exemplo a seguir mostra como o loopPara cada aparece com a ação Incrementar variável na definição do fluxo de trabalho, que está no 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" ]
      }
   }
},

Diminuir variável

Para diminuir ou decrescer uma variável com um valor constante específico, siga as etapas para incrementar uma variável, exceto pelo fato de adicionar a ação Decrescer variável em seu fluxo de trabalho. Essa ação só funciona com variáveis de inteiro e float.

A tabela a seguir descreve as informações para a ação Decrescer variável:

Propriedade	Obrigatório	Valor	Descrição
Nome	Sim	< nome da variável>	O nome da variável para diminuir
Valor	Não	< decrement-value>	O valor para diminuição da variável. O valor padrão é um. Dica: embora seja opcional, defina esse valor como uma melhor prática para sempre conhecer o valor específico para diminuir da variável.

Se você alternar do designer para a exibição de código, o exemplo a seguir mostra como a ação Decrescer variável aparece na definição do fluxo de trabalho, que está no formato JSON:

"actions": {
   "Decrement_variable": {
      "type": "DecrementVariable",
      "inputs": {
         "name": "Count",
         "value": 1
      },
      "runAfter": {}
   }
},

Definir variável

Para atribuir um valor diferente a uma variável existente, execute as etapas para incrementar uma variável, com as exceções a seguir:

1. Localize e selecione a ação Definir variável.

2. Fornecer o nome da variável e o valor que você deseja atribuir. O novo valor e a variável devem ter o mesmo tipo de dados. O valor é necessário porque essa ação não tem um valor padrão.

A tabela a seguir descreve as informações para a ação Definir variável:

Propriedade	Obrigatório	Valor	Descrição
Nome	Sim	< nome da variável>	O nome da variável para alterar
Valor	Sim	< new-value>	O valor que você quer atribuir à variável. Ambos devem ter o mesmo tipo de dados.

Observação

A menos que você esteja aumentando ou diminuindo variáveis, a alteração de variáveis dentro de loops pode criar resultados inesperados, pois os loops são executados em paralelo, ou simultaneamente, por padrão. Para esses casos, tente definir o loop para executar em sequência. Por exemplo, quando você quiser consultar o valor da variável dentro do loop, e espera o mesmo valor no início e no término dessa instância de loop, execute estas etapas para alterar como o loop é executado:

1. Selecione o loop para exibir o painel de informações e, em seguida, selecione Configurações.

2. Na seção Geral, em Controle de Simultaneidade, altere a configuração de Desativado para Ativado.

3. Arraste o controle deslizante de Grau de paralelismo para 1.

Se você alternar do designer para a exibição de código, o exemplo a seguir mostra como a ação Definir variável aparece na definição do fluxo de trabalho, que está no formato JSON:

O exemplo a seguir altera o valor atual da variável Count para outro 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" ]
      }
   }
},

Acrescentar à variável

Para variáveis que armazenam cadeias de caracteres ou matrizes, você pode inserir ou acrescentar o valor de uma variável como o último item nessas cadeias de caracteres ou matrizes. Você pode seguir as etapas para incrementar uma variável com as seguintes exceções:

1. Localize e selecionar uma dessas ações com base em se a variável é uma cadeia de caracteres ou uma matriz:

   • Acrescentar à variável de cadeia de caracteres
   • Acrescentar à variável de matriz

2. Forneça o valor para acrescentar como o último item na cadeia de caracteres ou matriz. Esse valor é necessário.

A tabela a seguir descreve as informações das ações Acrescentar a...:

Propriedade	Obrigatório	Valor	Descrição
Nome	Sim	< nome da variável>	O nome da variável para alterar
Valor	Sim	< anexar-valor>	O valor que você deseja acrescentar, que pode ser de qualquer tipo

Se você alternar do designer para a exibição de código, o exemplo a seguir mostra como a ação Acrescentar à variável de matriz aparece na definição do fluxo de trabalho, que está no formato JSON.

O exemplo a seguir cria uma variável de matriz e adiciona outro valor como o último item na matriz. O resultado é uma variável atualizada que contém 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" ]
      }
   }
},

Conteúdo relacionado

• Conectores gerenciados dos Aplicativos Lógicos do Azure
• Conectores internos de Aplicativos Lógicos do Azure