Loops

Como um loop roda

No canvas um loop é uma moldura: o nó do loop em cima, o corpo dentro, uma tampa embaixo. Quando a execução chega nele, o loop calcula a lista e percorre o corpo uma vez por elemento — cada iteração com a própria cópia do estado, então duas iterações rodando ao mesmo tempo nunca sobrescrevem as saídas uma da outra. Quando todas as iterações terminam, o flow continua abaixo da tampa.

A saída do loop é uma lista com uma entrada por iteração: a saída do último passo do corpo naquela iteração. Os resultados mantêm a ordem da lista de entrada, não importa qual iteração termine primeiro.

Escolha o que percorrer

1. 1
   Adicione o loop

   Clique num + e escolha Laço (Para cada item). A moldura chega vazia; o + de dentro adiciona passos ao corpo.

   InícioEnviar relatório
2. 2
   Defina os Items

   No painel do loop, Items tem três fontes: Static value (uma lista JSON digitada, como [3, 1, 2]), From Node (uma lista na saída de um passo anterior, ou do Início) e Expression (JavaScript que devolve uma lista).

3. 3
   Preencha o corpo

   Adicione dentro da moldura os passos a repetir e ligue as entradas deles ao elemento atual (próxima seção).

Ligado com From Node a um passo SQL, o loop percorre as rows da consulta sozinho — você aponta para o passo, não para rows — e o painel lista as colunas de cada linha: Cada linha: id · email · First Name. Uma expressão pode moldar a lista antes: nodes.fetchOrders.output.orders.filter((o) => o.total > 0).

Usando o item dentro do corpo

Um passo do corpo liga uma entrada com From node → o loop e escolhe o que precisa da iteração atual:

def main(email: str, first_name: str, position: int = 0):
    return {"to": email, "greeting": f"Hi {first_name}!", "position": position}

Ligado como email ← item.email, first_name ← item["First Name"] e position ← index, o passo roda uma vez por linha. Uma linha sem um campo é dado, não erro: essa entrada fica sem valor, então vale o padrão — e se ela for obrigatória, o passo falha indicando a iteração, the item of iteration 4 has no field 'email'.

Loops aninhados

Num loop dentro de um loop, item é o elemento do loop de dentro. Para alcançar o de fora, ligue From node → o loop de fora → item.name, ou, numa expressão, leia loops.<loopId>.item e loops.<loopId>.index. Expressões no corpo também enxergam iter — o mesmo par como { value, index }; o editor lembra com // neste loop: item, index, iter.

Em sequência, em paralelo ou enquanto

A configuração Execução do loop decide como as iterações são agendadas:

• Em sequência (padrão) — uma volta de cada vez, na ordem. Use quando cada item depende do anterior, ou quando um serviço não pode ser chamado duas vezes ao mesmo tempo.
• Em paralelo — até De uma vez voltas rodam juntas, no máximo 20 (Limitado a 20 voltas de uma vez.). Elas rodam em ondas; os resultados continuam na ordem da entrada.
• Enquanto — sem lista: o corpo se repete com item = 0, 1, 2… até Parar o loop quando ser verdadeiro, No máximo 100 vezes por padrão (até 1.000). Sem condição de parada a execução falha.

Parar o loop quando

Parar o loop quando é uma expressão opcional verificada após cada iteração, na ordem do índice, com result (a saída daquela iteração), item e index. Na primeira vez que for verdadeira o loop termina ali, e a saída guarda as iterações até essa, inclusive. Num loop em paralelo, iterações da mesma onda podem já ter rodado; os resultados delas são descartados, então a saída nunca depende de quantas rodaram juntas.

result.found === true        // stop at the first match
index >= 9                    // at most ten iterations

Quando uma iteração falha

Uma iteração que falha faz o loop falhar: as iterações que já estão rodando terminam, nenhuma onda nova começa, e a falha informada é a primeira pelo índice — sempre a mesma, como quer que o tempo tenha caído. Um passo com continuar em caso de erro nas configurações de execução deixa as outras iterações seguirem.

Lendo uma execução de loop

O cabeçalho do loop conta a própria história durante e depois da execução: 120 itens · 5 por vez, 37 de 120 prontos, depois as contagens — 118 ok, 2 com falha, ignorados, do cache. Quando algo falhou, uma pílula pula entre as falhas: Próxima falha · #41 · 1 de 2.

• As setas e o seletor no nó do loop escolhem qual iteração o canvas mostra — cada passo do corpo é redesenhado com o status, as entradas e a saída daquela iteração.
• A aba Iterações do loop é uma tabela — Item, Status, Duração — com o filtro Só com falha. Um loop longo carrega as linhas conforme você rola (Carregando esta iteração…).
• A Linha do tempo da execução desenha uma faixa por iteração rodando ao mesmo tempo, então um loop em paralelo mostra as ondas.

Limites e regras

• Loops em paralelo rodam no máximo 20 iterações de uma vez; um valor maior é limitado.
• Loops Enquanto repetem no máximo 1.000 vezes (100 por padrão) e precisam de Parar o loop quando.
• A lista de um loop precisa ser uma lista: ligar a um objeto ou a um número faz o loop falhar.
• Um loop sobre um resultado grande demais para passar entre passos lê as linhas do armazenamento, página por página (resultados grandes).