Política de IA no Trabalho: Guia das 8 Seções Essenciais
Sem política de IA no trabalho, sua empresa arrisca vazamento de dados e não conformidade. Veja as 8 seções essenciais para uma governança de IA segura.

Todo fluxo de Power Automate que cresce sem controle tem o mesmo sintoma: uma sequência de ações de “Inicializar variável”, “Definir variável” e “Condição” que poderia ter sido resolvida em uma única expressão. O motivo quase sempre é o mesmo: quem monta o fluxo não sabe que a função existe, ou não lembra da sintaxe exata na hora de escrever.
O Power Automate usa a Workflow Definition Language, a mesma linguagem de expressões dos Azure Logic Apps, para tudo que não é uma ação de conector. Ela tem mais de 140 funções distribuídas em nove categorias, todas documentadas pela Microsoft, mas espalhadas em uma única página longa, sem categorização fácil de escanear. Este guia organiza essas funções por finalidade, com sintaxe e link direto para a referência oficial, para consulta rápida enquanto você edita uma expressão no fluxo.
Cada ação adicionada a um fluxo tem custo. Custo de execução (mais chamadas, mais tempo, mais chance de throttling em conectores premium), custo de manutenção (mais passos para outra pessoa entender) e custo de licenciamento em cenários onde a ação dispara uma chamada a um conector premium desnecessário. Uma expressão bem escrita substitui, com frequência, três ou quatro ações por uma única linha dentro de um campo já existente.
Um exemplo comum: extrair o domínio de um e-mail. A abordagem por ações usa split em uma ação de composição, depois um índice, depois outra composição para montar o resultado. A abordagem por expressão resolve em uma linha:
split(triggerBody()?['Email'], '@')[1]Isso não significa que expressão é sempre superior a ação. Fluxos muito densos em expressões aninhadas ficam ilegíveis para quem não domina a sintaxe, e depurar uma expressão longa dentro do editor do Power Automate é mais difícil do que inspecionar a saída de várias ações pequenas no histórico de execução. A recomendação prática é usar expressão para transformações pontuais de dado (formatar, extrair, comparar, converter) e manter ações separadas para passos que representam uma decisão de negócio relevante, algo que alguém vai querer localizar rápido ao revisar o fluxo.
O editor de expressões fica disponível em qualquer campo dinâmico do fluxo, acessível pelo ícone de raio ou digitando diretamente entre chaves. No modo texto do fluxo (Editar em modo avançado, disponível ao exportar o fluxo como código ou usar o editor do Power Automate for desktop e do Copilot Studio), a sintaxe segue o padrão @{funcao(parametros)}. Dentro do editor visual padrão, basta digitar o nome da função e o Intellisense sugere os parâmetros esperados.
A documentação oficial completa da Workflow Definition Language, com todas as funções, parâmetros e exemplos atualizados pela Microsoft, está na referência de funções para expressões no Azure Logic Apps e Power Automate. As tabelas abaixo linkam direto para a seção correspondente dessa página.
Manipulam strings: recorte, concatenação, busca de substring, mudança de caixa. São as mais usadas em fluxos que tratam entrada de formulário, e-mail ou arquivo, onde o dado raramente chega já formatado do jeito que o próximo passo espera.
| Função | O que faz | Sintaxe |
|---|---|---|
| chunk | Divide uma string ou coleção em blocos de tamanho igual | chunk(collection, length) |
| concat | Junta duas ou mais strings em uma só | concat(text1, text2, ...) |
| endsWith | Verifica se a string termina com o texto informado | endsWith(text, searchText) |
| formatNumber | Converte um número em string usando um formato específico | formatNumber(number, format, locale) |
| guid | Gera um identificador único global (GUID) como string | guid(format) |
| indexOf | Retorna a posição inicial de uma substring | indexOf(text, searchText) |
| isFloat | Verifica se uma string representa um número decimal | isFloat(value, locale) |
| isInt | Verifica se uma string representa um número inteiro | isInt(string) |
| lastIndexOf | Retorna a posição da última ocorrência de uma substring | lastIndexOf(text, searchText) |
| length | Conta os caracteres de uma string ou itens de uma coleção | length(collection) |
| nthIndexOf | Retorna a posição da n-ésima ocorrência de uma substring | nthIndexOf(text, searchText, occurrence) |
| replace | Substitui uma substring por outra dentro do texto | replace(text, oldText, newText) |
| slice | Retorna um trecho de texto entre duas posições | slice(text, startIndex, endIndex) |
| split | Divide o texto em um array a partir de um delimitador | split(text, delimiter) |
| startsWith | Verifica se a string começa com o texto informado | startsWith(text, searchText) |
| substring | Retorna caracteres a partir de uma posição, com tamanho definido | substring(text, startIndex, length) |
| toLower | Converte o texto para minúsculas | toLower(text) |
| toUpper | Converte o texto para maiúsculas | toUpper(text) |
| trim | Remove espaços em branco no início e no fim do texto | trim(text) |
Uma pegadinha frequente com substring e slice: os índices são baseados em zero e um valor de início maior que o comprimento da string gera erro em tempo de execução, não retorna vazio. Se o dado de origem pode variar de tamanho (nome de arquivo, e-mail sem domínio), combine com length dentro de uma verificação antes de fatiar, ou use if para tratar o caso em que a string é mais curta que o esperado.
Atuam sobre arrays: filtrar, ordenar, combinar, dividir. Ganham relevância em fluxos que processam listas do SharePoint, resultados de uma consulta ao Dataverse ou arrays retornados por uma chamada HTTP a uma API externa.
| Função | O que faz | Sintaxe |
|---|---|---|
| chunk | Divide uma coleção em partes de tamanho igual | chunk(collection, length) |
| contains | Verifica se a coleção contém determinado item | contains(collection, value) |
| empty | Verifica se a coleção está vazia | empty(collection) |
| first | Retorna o primeiro item de uma coleção | first(collection) |
| intersection | Retorna os itens em comum entre as coleções informadas | intersection(collection1, collection2, ...) |
| item | Retorna o item atual dentro de um loop | item() |
| join | Concatena os itens de um array em uma string, com delimitador | join(collection, delimiter) |
| last | Retorna o último item de uma coleção | last(collection) |
| length | Conta os itens de um array | length(collection) |
| reverse | Inverte a ordem dos itens de um array | reverse(collection) |
| skip | Remove uma quantidade de itens do início e retorna o restante | skip(collection, count) |
| sort | Ordena os itens de uma coleção | sort(collection, sortBy) |
| take | Retorna os primeiros N itens de uma coleção | take(collection, count) |
| union | Combina os itens de múltiplas coleções, removendo duplicados | union(collection1, collection2, ...) |
Uma decisão de arquitetura relevante aqui: filter como ação nativa do Power Automate já resolve boa parte do que se tentaria fazer combinando contains e intersection em expressão. Quando o filtro depende de uma condição simples sobre um array vindo de uma ação anterior, use a ação Filtrar array, que gera um log de execução legível. Reserve as funções de coleção em expressão para transformações que a ação nativa não cobre, como cruzar dois arrays de origens diferentes.
Constroem a lógica condicional que, de outra forma, exigiria várias ações de Condição aninhadas. São a base de qualquer expressão dentro de um campo de “Condição” configurado em modo avançado.
| Função | O que faz | Sintaxe |
|---|---|---|
| and | Retorna verdadeiro se todas as expressões forem verdadeiras | and(expression1, expression2, ...) |
| equals | Verifica se dois valores são iguais | equals(object1, object2) |
| greater | Verifica se o primeiro valor é maior que o segundo | greater(value, compareTo) |
| greaterOrEquals | Verifica se o primeiro valor é maior ou igual ao segundo | greaterOrEquals(value, compareTo) |
| if | Retorna um valor ou outro conforme uma expressão booleana | if(expression, valueIfTrue, valueIfFalse) |
| isFloat | Verifica se uma string representa um decimal | isFloat(value, locale) |
| isInt | Verifica se uma string representa um inteiro | isInt(string) |
| less | Verifica se o primeiro valor é menor que o segundo | less(value, compareTo) |
| lessOrEquals | Verifica se o primeiro valor é menor ou igual ao segundo | lessOrEquals(value, compareTo) |
| not | Inverte o resultado de uma expressão booleana | not(expression) |
| or | Retorna verdadeiro se pelo menos uma expressão for verdadeira | or(expression1, expression2, ...) |
if aninhado substitui bem uma cadeia de Condições quando o resultado é um valor simples (texto, número, booleano) a ser usado em outro campo. Quando o resultado de cada ramificação é uma sequência de ações diferentes, mantenha a ação Condição nativa: aninhar mais de dois ou três níveis de if numa única expressão produz uma string difícil de revisar e praticamente impossível de depurar a olho nu.
Convertem entre tipos e formatos: texto, número, binário, base64, URI, JSON, XML. Essenciais em qualquer fluxo que troca dado com uma API REST, processa anexos ou lê arquivo.
| Função | O que faz | Sintaxe |
|---|---|---|
| array | Converte um valor único em array | array(value) |
| base64 | Codifica uma string em base64 | base64(value) |
| base64ToBinary | Converte uma string base64 em binário | base64ToBinary(value) |
| base64ToString | Converte uma string base64 em texto plano | base64ToString(value) |
| binary | Converte um valor em representação binária | binary(value) |
| bool | Converte um valor em booleano | bool(value) |
| createArray | Cria um array a partir dos valores informados | createArray(object1, object2, ...) |
| dataUri | Retorna o URI de dados de um valor | dataUri(value) |
| dataUriToBinary | Converte um URI de dados em binário | dataUriToBinary(value) |
| dataUriToString | Converte um URI de dados em texto plano | dataUriToString(value) |
| decimal | Converte uma string decimal em número decimal | decimal(value) |
| decodeBase64 | Decodifica uma string base64 em texto plano | decodeBase64(value) |
| decodeDataUri | Converte um URI de dados em binário | decodeDataUri(value) |
| decodeUriComponent | Decodifica um componente de URI | decodeUriComponent(value) |
| encodeUriComponent | Codifica um valor como componente de URI | encodeUriComponent(value) |
| float | Converte um valor em número de ponto flutuante | float(value) |
| int | Converte uma string em número inteiro | int(value) |
| json | Interpreta uma string ou XML como JSON | json(value) |
| string | Converte um valor em string | string(value) |
| uriComponent | Codifica um valor como componente de URI | uriComponent(value) |
| uriComponentToBinary | Converte um componente de URI em binário | uriComponentToBinary(value) |
| uriComponentToString | Converte um componente de URI em texto plano | uriComponentToString(value) |
| xml | Converte uma string em XML | xml(value) |
A função json merece atenção especial: é o caminho mais direto para parsear a resposta de uma chamada HTTP sem precisar de uma ação separada de Analisar JSON. A troca é que, sem o schema declarado que a ação Analisar JSON exige, o Intellisense não sugere as propriedades internas, e você precisa conhecer a estrutura do payload de antemão ou consultar a documentação da API de origem.
Operações aritméticas básicas e geração de intervalos numéricos. Curtas, mas frequentes em cálculo de paginação, distribuição de carga entre lotes e geração de índices para loops.
| Função | O que faz | Sintaxe |
|---|---|---|
| add | Soma dois números | add(number1, number2) |
| div | Divide dois números | div(dividend, divisor) |
| max | Retorna o maior valor de um conjunto ou array | max(number1, number2, ...) |
| min | Retorna o menor valor de um conjunto ou array | min(number1, number2, ...) |
| mod | Retorna o resto de uma divisão | mod(dividend, divisor) |
| mul | Multiplica dois números | mul(number1, number2) |
| rand | Gera um número inteiro aleatório dentro de um intervalo | rand(minValue, maxValue) |
| range | Cria um array de inteiros a partir de um número inicial | range(startIndex, count) |
| sub | Subtrai dois números | sub(number1, number2) |
São, na prática, a categoria com mais chance de erro silencioso em produção, porque o Power Automate trabalha internamente em UTC. Um fluxo que soma dias ou horas sem converter para o fuso do usuário final envia notificação no horário errado, e o erro só aparece quando alguém reclama, não durante o teste no editor.
| Função | O que faz | Sintaxe |
|---|---|---|
| addDays | Adiciona dias a um timestamp | addDays(timestamp, days, format) |
| addHours | Adiciona horas a um timestamp | addHours(timestamp, hours, format) |
| addMinutes | Adiciona minutos a um timestamp | addMinutes(timestamp, minutes, format) |
| addSeconds | Adiciona segundos a um timestamp | addSeconds(timestamp, seconds, format) |
| addToTime | Adiciona uma unidade de tempo específica a um timestamp | addToTime(timestamp, interval, timeUnit, format) |
| convertFromUtc | Converte um timestamp UTC para o fuso de destino | convertFromUtc(timestamp, destinationTimeZone, format) |
| convertTimeZone | Converte um timestamp entre dois fusos horários | convertTimeZone(timestamp, sourceTimeZone, destinationTimeZone, format) |
| convertToUtc | Converte um timestamp de um fuso local para UTC | convertToUtc(timestamp, sourceTimeZone, format) |
| dayOfMonth | Retorna o dia do mês de um timestamp | dayOfMonth(timestamp) |
| dayOfWeek | Retorna o dia da semana de um timestamp | dayOfWeek(timestamp) |
| dayOfYear | Retorna o dia do ano de um timestamp | dayOfYear(timestamp) |
| formatDateTime | Formata um timestamp conforme o padrão informado | formatDateTime(timestamp, format, locale) |
| getFutureTime | Retorna a hora atual mais um intervalo de tempo | getFutureTime(interval, timeUnit, format) |
| getPastTime | Retorna a hora atual menos um intervalo de tempo | getPastTime(interval, timeUnit, format) |
| parseDateTime | Converte uma string em timestamp | parseDateTime(timestamp, locale, format) |
| startOfDay | Retorna o início do dia de um timestamp | startOfDay(timestamp, format) |
| startOfHour | Retorna o início da hora de um timestamp | startOfHour(timestamp, format) |
| startOfMonth | Retorna o início do mês de um timestamp | startOfMonth(timestamp, format) |
| subtractFromTime | Subtrai uma unidade de tempo de um timestamp | subtractFromTime(timestamp, interval, timeUnit, format) |
| ticks | Retorna o valor em ticks de um timestamp | ticks(timestamp) |
| utcNow | Retorna o timestamp atual em UTC | utcNow(format) |
A dupla convertFromUtc e convertTimeZone resolve o problema de fuso, mas exige o nome exato do fuso horário no formato aceito pelo Windows (por exemplo, E. South America Standard Time para o horário de Brasília), não o nome IANA usado em outras plataformas. Errar essa string não gera erro de sintaxe, gera conversão silenciosamente incorreta, porque a função ignora fuso não reconhecido e mantém UTC.
Acessam o contexto de execução do próprio fluxo: saída de uma ação anterior, corpo do gatilho, valor de uma variável, índice de iteração dentro de um loop. São a categoria mais usada, ainda que de forma invisível, porque o editor do Power Automate gera boa parte dessas expressões automaticamente quando você seleciona um conteúdo dinâmico na interface.
| Função | O que faz | Sintaxe |
|---|---|---|
| action | Retorna a saída da ação atual | action().property |
| actionBody | Retorna o corpo da saída de uma ação específica | actionBody('actionName') |
| actionOutputs | Retorna a saída de uma ação em tempo de execução | actionOutputs('actionName') |
| actions | Retorna a saída de uma ação ou um par nome-valor do JSON | actions('actionName').property |
| body | Retorna o corpo de saída de uma ação | body('actionName') |
| formDataMultiValues | Cria um array com os valores correspondentes a uma chave | formDataMultiValues('actionName', 'key') |
| formDataValue | Retorna o valor correspondente a uma chave | formDataValue('actionName', 'key') |
| item | Retorna o item atual em um loop Apply to each | item() |
| items | Retorna o item atual em um loop nomeado | items('loopName') |
| iterationIndexes | Retorna o índice atual dentro de um loop Until | iterationIndexes('loopName') |
| listCallbackUrl | Retorna a URL de callback de um gatilho ou ação | listCallbackUrl() |
| multipartBody | Retorna o corpo de uma parte de uma saída multipart | multipartBody('actionName', index) |
| outputs | Retorna a saída completa de uma ação | outputs('actionName') |
| parameters | Retorna o valor de um parâmetro do fluxo | parameters('parameterName') |
| result | Retorna entradas e saídas de uma ação com escopo | result('scopedActionName') |
| trigger | Retorna a saída do gatilho do fluxo | trigger().property |
| triggerBody | Retorna o corpo de saída do gatilho | triggerBody() |
| triggerFormDataValue | Retorna o valor de uma chave nas saídas do gatilho | triggerFormDataValue('key') |
| triggerFormDataMultiValues | Cria um array com os valores de uma chave do gatilho | triggerFormDataMultiValues('key') |
| triggerMultipartBody | Retorna o corpo de uma parte da saída do gatilho | triggerMultipartBody(index) |
| triggerOutputs | Retorna a saída completa do gatilho | triggerOutputs() |
| variables | Retorna o valor de uma variável do fluxo | variables('variableName') |
| workflow | Retorna detalhes sobre o próprio fluxo | workflow().property |
A diferença entre body('actionName') e outputs('actionName') confunde bastante gente: body retorna só a propriedade body da saída da ação, outputs retorna a saída inteira, incluindo cabeçalhos e status code de uma chamada HTTP, por exemplo. Se você precisa validar o status de uma resposta HTTP antes de seguir, é outputs, não body, que traz essa informação.
Quebram uma URI em seus componentes. Usadas com frequência em fluxos que recebem um link (de um item do SharePoint, de um e-mail, de um webhook) e precisam extrair só uma parte dele, como o host para validação de domínio ou a query string para ler parâmetros.
| Função | O que faz | Sintaxe |
|---|---|---|
| uriHost | Retorna o host de uma URI | uriHost(uri) |
| uriPath | Retorna o caminho de uma URI | uriPath(uri) |
| uriPathAndQuery | Retorna caminho e query string de uma URI | uriPathAndQuery(uri) |
| uriPort | Retorna a porta de uma URI | uriPort(uri) |
| uriQuery | Retorna a query string de uma URI | uriQuery(uri) |
| uriScheme | Retorna o esquema (http, https) de uma URI | uriScheme(uri) |
Editam objetos JSON e navegam em XML sem precisar reconstruir o objeto inteiro em uma ação separada. Particularmente úteis quando o fluxo precisa enriquecer um payload antes de enviá-lo a uma API, adicionando ou removendo uma propriedade pontual.
| Função | O que faz | Sintaxe |
|---|---|---|
| addProperty | Adiciona uma propriedade e seu valor a um objeto JSON | addProperty(object, property, value) |
| coalesce | Retorna o primeiro valor não nulo entre os parâmetros informados | coalesce(value1, value2, ...) |
| removeProperty | Remove uma propriedade de um objeto JSON | removeProperty(object, property) |
| setProperty | Define o valor de uma propriedade em um objeto JSON | setProperty(object, property, value) |
| xpath | Retorna nós ou valores que correspondem a um XPath | xpath(xml, path) |
coalesce resolve um padrão que, sem ela, vira uma torre de if aninhado: pegar o primeiro valor preenchido entre vários campos opcionais de um formulário. Em vez de if(empty(campoA), if(empty(campoB), campoC, campoB), campoA), a expressão fica coalesce(campoA, campoB, campoC), mais curta e muito mais fácil de auditar depois.
Nenhuma equipe de automação memoriza 140 funções. O ganho real de ter essa lista organizada por categoria é outro: quando você sente que uma transformação está exigindo ações demais, a primeira pergunta vira “existe uma função para isso” em vez de “que ação eu adiciono agora”. Isso muda o hábito de construção do fluxo, e fluxos construídos com esse hábito tendem a ter menos ações, menos pontos de falha e menos consumo desnecessário de conectores premium.
Vale também documentar, dentro do próprio fluxo, expressões que combinam três ou mais funções aninhadas. Um comentário na ação, ou um nome descritivo na variável que recebe o resultado, economiza tempo de quem vai dar manutenção seis meses depois e não tem a lógica da expressão fresca na cabeça.
Se o seu fluxo já cresceu a ponto de virar um emaranhado de condições e variáveis, ou se a dúvida é sobre onde a lógica de negócio deveria morar (no fluxo, num conector customizado, num Power Automate Desktop, numa Function do Azure), essa é uma conversa de arquitetura que vale a pena ter antes de continuar empilhando ações.
Sem política de IA no trabalho, sua empresa arrisca vazamento de dados e não conformidade. Veja as 8 seções essenciais para uma governança de IA segura.
Copilot Cowork e Work IQ chegam ao Microsoft 365 Copilot: entenda a escolha de modelo, os novos plugins e o que muda no papel do usuário corporativo.
Copilot in SharePoint passa a criar sites, páginas e arquivos Office sozinho. Veja o que muda e como ajustar a governança de conteúdo antes de liberar o acesso.