Algoritmos

Laços de repetição (for e while): como repetir sem reescrever

Capa do artigo Laços de repetição (for e while): como repetir sem reescrever
Leitura com foco

Entenda o contexto.
Leve para a prática.

Neste artigo
  1. O que é um laço de repetição?
  2. Como funciona o while?
  3. Como funciona o for?
  4. O que são contador e acumulador?
  5. Como usar laços de repetição em Python, PHP e C?
  6. Para que servem break e continue?
  7. O que é o do-while?
  8. Como outras linguagens chamam os laços de repetição?
  9. Aí você pergunta: qual laço uso?
  10. O que é um laço infinito?
  11. Quais são os erros mais comuns com laços de repetição?
  12. Agora é com você!

Laço de repetição é o comando que faz o programa executar o mesmo bloco de instruções várias vezes, enquanto uma condição for verdadeira. Os dois laços que existem nas três linguagens deste blog se chamam while e for.

Este artigo junta duas peças que você já tem. Das variáveis vem o contador, que muda a cada volta. Da estrutura condicional vem o teste que decide se o laço continua. Com os laços, você passa a percorrer vetores e matrizes inteiros com poucas linhas.

Pense na pia depois do almoço. Ninguém escreve “lave o prato 1, lave o prato 2, lave o prato 3”. A instrução é uma só: enquanto houver prato sujo, lave um prato. Ela serve para 3 pratos ou para 30. Outra forma de repetir é a do treino: dê 10 voltas na quadra. Aqui você já sabe o número de voltas antes de começar. O while é a pia. O for é a quadra.

História em quadrinhos em três quadros: uma pessoa lava a pilha de pratos sujos, um por vez; com 3 e com 1 prato sujo a condição é verdadeira e a lavagem se repete; com 0, a repetição acaba
O while na pia: enquanto houver prato sujo, lave um prato.

O que é um laço de repetição?

Uma estrutura de repetição permite que uma sequência de comandos seja executada repetidamente, enquanto determinadas condições são satisfeitas. Cada execução do bloco é chamada de volta ou iteração. Os programas passam a maior parte do tempo repetindo tarefas, seja até que uma condição aconteça, seja por um número fixo de vezes.

Como funciona o while?

O while tem uma condição e um bloco, como o if. A diferença está no que acontece depois do bloco: o programa volta e testa a condição de novo.

  • A condição é avaliada no início de cada volta.
  • Se for verdadeira, o bloco é executado e o programa retorna ao teste.
  • Se for falsa, o laço termina. Se já for falsa na primeira vez, o bloco não é executado nenhuma vez.
Fluxograma do while: depois de i = 1, a condição i menor ou igual a 5 é testada; se verdadeira, o corpo mostra a volta, soma 1 em i e retorna ao teste; se falsa, o laço termina
O while é um if que volta. A seta de retorno é o que transforma a decisão em repetição.

Como funciona o for?

O for de C e de PHP reúne em uma linha as três coisas que todo laço com contador precisa: o início, a condição e o passo.

for (início; condição; passo)

for (n = 1; n <= 100; n++)
  • Início: executado uma única vez, antes da primeira volta.
  • Condição: testada no começo de cada volta. Enquanto for verdadeira, o laço continua.
  • Passo: executado no fim de cada volta. Normalmente atualiza o contador. O n++ é uma forma curta de escrever n = n + 1.

O for do Python é diferente: ele percorre os itens de uma sequência, na ordem em que aparecem. Para contar, usa-se a função range. ATENÇÃO: o ponto final do range nunca é incluído. range(5) gera 0, 1, 2, 3 e 4. Para ir de 1 a 100, escreve-se range(1, 101).

O que são contador e acumulador?

São dois papéis que uma variável pode ter dentro de um laço. O contador aumenta de 1 em 1 e responde “quantos?”. O acumulador soma um valor diferente a cada volta e responde “quanto deu no total?”. Os dois precisam de um valor inicial antes do laço, normalmente 0.

Tabela da soma de 1 a 5 com acumulador: a soma passa por 1, 3, 6, 10 e 15, e o laço termina quando n vale 6
A cada volta, o acumulador recebe o que já tinha mais o valor da vez.
Ver a animação do laço somando de 1 a 5
Animação de um laço somando de 1 a 5, com o teste da condição e o valor da soma a cada volta
O corpo é executado cinco vezes e a condição é testada seis: a última resposta é “não”.

Como usar laços de repetição em Python, PHP e C?

O programa tem seis trechos numerados: while, for com acumulador, contador, break, continue e um laço dentro de outro.

Python:

# Laços de repetição: while, for, break e continue

# 1. while: repete enquanto a condição for verdadeira
i = 1
while i <= 5:
    print("volta", i)
    i = i + 1                       # sem esta linha, o laço nunca termina

# 2. for: o mesmo contador, com início, limite e passo em uma linha só
soma = 0
for n in range(1, 101):             # de 1 a 100; o 101 fica de fora
    soma = soma + n                 # acumulador: guarda o total parcial
print("soma de 1 a 100:", soma)

# 3. contador: quantos valores passam em um teste
notas = [7.5, 4.0, 9.0, 6.0, 3.5, 8.0]
aprovados = 0
for nota in notas:
    if nota >= 6:
        aprovados = aprovados + 1
print("aprovados:", aprovados, "de", len(notas))

# 4. break: sai do laço antes do fim
numero = 50
while True:
    if numero % 7 == 0:
        break
    numero = numero + 1
print("primeiro múltiplo de 7 a partir de 50:", numero)

# 5. continue: pula o resto desta volta e vai para a próxima
linha = ""
for n in range(1, 11):
    if n % 3 == 0:
        continue
    linha = linha + str(n) + " "
print("de 1 a 10 sem os múltiplos de 3:", linha)

# 6. laço dentro de laço: para cada linha, todas as colunas
for linha_tabela in range(1, 4):
    texto = ""
    for coluna in range(1, 4):
        texto = texto + "%d x %d = %d   " % (linha_tabela, coluna, linha_tabela * coluna)
    print(texto)

PHP:

<?php
// Laços de repetição: while, for, break e continue

// 1. while: repete enquanto a condição for verdadeira
$i = 1;
while ($i <= 5) {
    echo "volta $i\n";
    $i = $i + 1;                    // sem esta linha, o laço nunca termina
}

// 2. for: o mesmo contador, com início, limite e passo em uma linha só
$soma = 0;
for ($n = 1; $n <= 100; $n++) {     // de 1 a 100
    $soma = $soma + $n;             // acumulador: guarda o total parcial
}
echo "soma de 1 a 100: $soma\n";

// 3. contador: quantos valores passam em um teste
$notas = [7.5, 4.0, 9.0, 6.0, 3.5, 8.0];
$aprovados = 0;
foreach ($notas as $nota) {
    if ($nota >= 6) {
        $aprovados = $aprovados + 1;
    }
}
echo "aprovados: $aprovados de " . count($notas) . "\n";

// 4. break: sai do laço antes do fim
$numero = 50;
while (true) {
    if ($numero % 7 == 0) {
        break;
    }
    $numero = $numero + 1;
}
echo "primeiro múltiplo de 7 a partir de 50: $numero\n";

// 5. continue: pula o resto desta volta e vai para a próxima
$linha = "";
for ($n = 1; $n <= 10; $n++) {
    if ($n % 3 == 0) {
        continue;
    }
    $linha = $linha . $n . " ";
}
echo "de 1 a 10 sem os múltiplos de 3: $linha\n";

// 6. laço dentro de laço: para cada linha, todas as colunas
for ($linha_tabela = 1; $linha_tabela <= 3; $linha_tabela++) {
    $texto = "";
    for ($coluna = 1; $coluna <= 3; $coluna++) {
        $texto = $texto . sprintf("%d x %d = %d   ", $linha_tabela, $coluna, $linha_tabela * $coluna);
    }
    echo $texto . "\n";
}

C:

/* Laços de repetição: while, for, break e continue */
#include <stdio.h>

int main(void) {
    /* 1. while: repete enquanto a condição for verdadeira */
    int i = 1;
    while (i <= 5) {
        printf("volta %d\n", i);
        i = i + 1;                  /* sem esta linha, o laço nunca termina */
    }

    /* 2. for: o mesmo contador, com início, limite e passo em uma linha só */
    int soma = 0;
    for (int n = 1; n <= 100; n++) {    /* de 1 a 100 */
        soma = soma + n;                /* acumulador: guarda o total parcial */
    }
    printf("soma de 1 a 100: %d\n", soma);

    /* 3. contador: quantos valores passam em um teste */
    double notas[] = {7.5, 4.0, 9.0, 6.0, 3.5, 8.0};
    int quantidade = 6, aprovados = 0;
    for (int k = 0; k < quantidade; k++) {
        if (notas[k] >= 6) {
            aprovados = aprovados + 1;
        }
    }
    printf("aprovados: %d de %d\n", aprovados, quantidade);

    /* 4. break: sai do laço antes do fim */
    int numero = 50;
    while (1) {
        if (numero % 7 == 0) {
            break;
        }
        numero = numero + 1;
    }
    printf("primeiro múltiplo de 7 a partir de 50: %d\n", numero);

    /* 5. continue: pula o resto desta volta e vai para a próxima */
    printf("de 1 a 10 sem os múltiplos de 3: ");
    for (int n = 1; n <= 10; n++) {
        if (n % 3 == 0) {
            continue;
        }
        printf("%d ", n);
    }
    printf("\n");

    /* 6. laço dentro de laço: para cada linha, todas as colunas */
    for (int linha = 1; linha <= 3; linha++) {
        for (int coluna = 1; coluna <= 3; coluna++) {
            printf("%d x %d = %d   ", linha, coluna, linha * coluna);
        }
        printf("\n");
    }
    return 0;
}

Saída:

volta 1
volta 2
volta 3
volta 4
volta 5
soma de 1 a 100: 5050
aprovados: 4 de 6
primeiro múltiplo de 7 a partir de 50: 56
de 1 a 10 sem os múltiplos de 3: 1 2 4 5 7 8 10 
1 x 1 = 1   1 x 2 = 2   1 x 3 = 3   
2 x 1 = 2   2 x 2 = 4   2 x 3 = 6   
3 x 1 = 3   3 x 2 = 6   3 x 3 = 9   

Mesma saída nas três linguagens. Foque no conceito, e não na linguagem!

No trecho 3, repare que Python e PHP percorrem a lista de notas diretamente, sem falar em posição. O PHP tem um comando próprio para isso, o foreach. Em C, o laço percorre os índices de 0 a 5 e busca cada nota pela posição.

No trecho 6, o laço de dentro dá suas três voltas completas para cada volta do laço de fora. São 3 x 3 = 9 execuções do bloco mais interno. Sacou? É assim que se percorre uma matriz.

Para que servem break e continue?

  • break: encerra o laço na hora, e a execução passa para o primeiro comando depois dele. No trecho 4, não se sabe de antemão quantas voltas serão necessárias. O laço roda até achar o 56 e sai.
  • continue: pula o restante da volta atual e segue para a próxima. No trecho 5, os múltiplos de 3 são pulados, mas o laço continua até o 10.

Quando há laços aninhados, o break sai apenas do laço mais interno em que ele está.

O que é o do-while?

C e PHP têm um terceiro laço. No do-while, a condição é verificada no fim de cada volta, e não no começo. A consequência é que o bloco sempre é executado pelo menos uma vez.

/* do-while: o bloco é executado antes do teste */
#include <stdio.h>

int main(void) {
    int tentativas = 0;
    int senha = 0;
    do {
        tentativas = tentativas + 1;
        senha = senha + 1234;       /* simula a senha digitada em cada tentativa */
        printf("tentativa %d: senha %d\n", tentativas, senha);
    } while (senha != 3702);
    printf("acertou depois de %d tentativas\n", tentativas);

    int contador = 10;
    while (contador < 5) {          /* a condição já começa falsa: nenhuma volta */
        printf("while: nunca aparece\n");
    }
    do {                            /* o teste vem no fim: uma volta acontece */
        printf("do-while: executou uma vez com contador = %d\n", contador);
    } while (contador < 5);
    return 0;
}

Saída:

tentativa 1: senha 1234
tentativa 2: senha 2468
tentativa 3: senha 3702
acertou depois de 3 tentativas
do-while: executou uma vez com contador = 10

A última linha mostra a diferença. Com contador valendo 10, a condição contador < 5 é falsa desde o início. O while não deu nenhuma volta. O do-while deu uma.

Em Python, os comandos de repetição são o while e o for. O efeito de “executar e depois testar” se consegue com while True e um break, como no trecho 4.

Como outras linguagens chamam os laços de repetição?

Python, PHP e C usam quase os mesmos nomes: while, for e do-while. Em outras linguagens usadas no mercado, o laço ganha outros nomes, e algumas regras mudam junto. As sete linguagens abaixo estão na lista da pesquisa de 2026 do Stack Overflow com desenvolvedores. O Kotlin é a linguagem que o Google recomenda para começar um app Android, e o VBA, que roda dentro do Excel e dos outros programas do Office, usa o mesmo For … Next e o mesmo Do … Loop do Visual Basic.

O programa faz as mesmas três coisas nas sete linguagens: repete uma frase 3 vezes, conta de 5 até 1 e repete a senha do do-while até acertar. Troque de linguagem nas abas do quadro de código.

// Laços de repetição em Go: só existe o for
package main

import "fmt"

func main() {
    // Repetir 3 vezes: for range 3 (Go 1.22 ou mais novo)
    for range 3 {
        fmt.Print("Toc! ")
    }
    fmt.Println("Quem é?")

    // Contar de 5 até 1: for só com a condição é o while do Go
    i := 5
    for i >= 1 {
        fmt.Print(i, " ")
        i--
    }
    fmt.Println("Fogo!")

    // Repetir até acertar: for sem condição é laço sem fim, e o break encerra
    tentativas := 0
    senha := 0
    for {
        tentativas++
        senha += 1234 // simula a senha digitada em cada tentativa
        fmt.Printf("tentativa %d: senha %d\n", tentativas, senha)
        if senha == 3702 {
            break
        }
    }
    fmt.Printf("acertou depois de %d tentativas\n", tentativas)
}
// Laços de repetição em Kotlin: repeat, downTo e do-while
fun main() {
    // Repetir 3 vezes: repeat é uma função, não uma palavra reservada
    repeat(3) {
        print("Toc! ")
    }
    println("Quem é?")

    // Contar de 5 até 1: o intervalo 5 downTo 1 conta para trás
    for (i in 5 downTo 1) {
        print("$i ")
    }
    println("Fogo!")

    // Repetir até acertar: o mesmo do-while do C
    var tentativas = 0
    var senha = 0
    do {
        tentativas++
        senha += 1234 // simula a senha digitada em cada tentativa
        println("tentativa $tentativas: senha $senha")
    } while (senha != 3702)
    println("acertou depois de $tentativas tentativas")
}
// Laços de repetição em Rust: for com intervalos e loop com valor
fn main() {
    // Repetir 3 vezes: 0..3 vai de 0 a 2 (o 3 fica de fora)
    for _ in 0..3 {
        print!("Toc! ");
    }
    println!("Quem é?");

    // Contar de 5 até 1: 1..=5 inclui o 5, e rev() inverte a ordem
    for i in (1..=5).rev() {
        print!("{i} ");
    }
    println!("Fogo!");

    // Repetir até acertar: loop é o laço sem fim, e o break devolve um valor
    let mut vez = 0;
    let mut senha = 0;
    let tentativas = loop {
        vez += 1;
        senha += 1234; // simula a senha digitada em cada tentativa
        println!("tentativa {vez}: senha {senha}");
        if senha == 3702 {
            break vez;
        }
    };
    println!("acertou depois de {tentativas} tentativas");
}
# Laços de repetição em Ruby: times, downto e until

# Repetir 3 vezes: times é um método do número 3
3.times do
  print "Toc! "
end
puts "Quem é?"

# Contar de 5 até 1: downto, outro método do número
5.downto(1) do |i|
  print i, " "
end
puts "Fogo!"

# Repetir até acertar: until repete enquanto a condição for falsa
tentativas = 0
senha = 0
until senha == 3702
  tentativas += 1
  senha += 1234 # simula a senha digitada em cada tentativa
  puts "tentativa #{tentativas}: senha #{senha}"
end
puts "acertou depois de #{tentativas} tentativas"
' Laços de repetição em Visual Basic: For ... Next e Do ... Loop
Module Lacos
    Sub Main()
        ' Repetir 3 vezes: For ... To ... Next
        For i As Integer = 1 To 3
            Console.Write("Toc! ")
        Next
        Console.WriteLine("Quem é?")

        ' Contar de 5 até 1: Step -1 faz o contador descer
        For i As Integer = 5 To 1 Step -1
            Console.Write(i & " ")
        Next
        Console.WriteLine("Fogo!")

        ' Repetir até acertar: Loop Until testa no fim, como o do-while
        Dim tentativas As Integer = 0
        Dim senha As Integer = 0
        Do
            tentativas = tentativas + 1
            senha = senha + 1234 ' simula a senha digitada em cada tentativa
            Console.WriteLine("tentativa " & tentativas & ": senha " & senha)
        Loop Until senha = 3702
        Console.WriteLine("acertou depois de " & tentativas & " tentativas")
    End Sub
End Module
// Laços de repetição em Delphi: for ... downto e repeat ... until
program Lacos;

var
  i, tentativas, senha: Integer;

begin
  // Repetir 3 vezes: for ... to ... do
  for i := 1 to 3 do
    Write('Toc! ');
  WriteLn('Quem é?');

  // Contar de 5 até 1: downto faz o contador descer
  for i := 5 downto 1 do
    Write(i, ' ');
  WriteLn('Fogo!');

  // Repetir até acertar: repeat ... until testa no fim
  tentativas := 0;
  senha := 0;
  repeat
    tentativas := tentativas + 1;
    senha := senha + 1234; // simula a senha digitada em cada tentativa
    WriteLn('tentativa ', tentativas, ': senha ', senha);
  until senha = 3702;
  WriteLn('acertou depois de ', tentativas, ' tentativas');
end.
      * Laços de repetição em COBOL: o verbo PERFORM
       IDENTIFICATION DIVISION.
       PROGRAM-ID. LACOS.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 I          PIC 9.
       01 TENTATIVAS PIC 9 VALUE 0.
       01 SENHA      PIC 9(4) VALUE 0.
       PROCEDURE DIVISION.
      * Repetir 3 vezes: PERFORM ... TIMES, sem contador
           PERFORM 3 TIMES
               DISPLAY "Toc! " WITH NO ADVANCING
           END-PERFORM
           DISPLAY "Quem é?"
      * Contar de 5 até 1: VARYING ... BY -1 desce de 1 em 1
           PERFORM VARYING I FROM 5 BY -1 UNTIL I < 1
               DISPLAY I " " WITH NO ADVANCING
           END-PERFORM
           DISPLAY "Fogo!"
      * Repetir até acertar: WITH TEST AFTER testa no fim
           PERFORM WITH TEST AFTER UNTIL SENHA = 3702
               ADD 1 TO TENTATIVAS
               ADD 1234 TO SENHA
               DISPLAY "tentativa " TENTATIVAS ": senha " SENHA
           END-PERFORM
           DISPLAY "acertou depois de " TENTATIVAS " tentativas"
           STOP RUN.

Saída:

Toc! Toc! Toc! Quem é?
5 4 3 2 1 Fogo!
tentativa 1: senha 1234
tentativa 2: senha 2468
tentativa 3: senha 3702
acertou depois de 3 tentativas

Mesma saída nas sete linguagens. Foque no conceito, e não na linguagem!

O que muda é o nome de cada ideia:

  • Repetir um número fixo de vezes: repeat(3) no Kotlin, 3.times no Ruby e PERFORM 3 TIMES no COBOL, sem variável de contador. No Kotlin, repeat é uma função da biblioteca padrão, e no Ruby, times é um método do próprio número. O Go passou a aceitar for range 3 na versão 1.22.
  • Um nome só para tudo: o Go não tem while nem do-while. O for só com a condição faz o papel do while, e o for sem condição nenhuma repete sem fim, até um break.
  • Contar para trás: 5 downTo 1 no Kotlin, 5.downto(1) no Ruby, (1..=5).rev() no Rust, Step -1 no Visual Basic, downto no Delphi e BY -1 no COBOL.
  • Repetir até: o until do Ruby, o Loop Until do Visual Basic, o repeat … until do Delphi e o UNTIL do COBOL repetem até a condição ficar verdadeira. O Loop Until, o repeat … until e o WITH TEST AFTER testam no fim, como o do-while. O until do Ruby testa no começo, como o while.
  • Laço que devolve um valor: no Rust, loop repete sem fim, e o break pode levar um valor para fora. No programa, o número de tentativas sai do próprio laço.

ATENÇÃO: o until inverte a condição. No do-while do C, senha != 3702 diz quando continuar. No until, a condição diz quando parar: senha = 3702. Copie a condição do C sem inverter e o programa erra sem avisar. No Visual Basic, Loop Until senha <> 3702 para depois da primeira tentativa e imprime “acertou depois de 1 tentativas” com a senha errada. No Ruby, until senha != 3702 nem entra no laço e imprime “acertou depois de 0 tentativas”.

ATENÇÃO: o mesmo 1..5 não dá o mesmo número de voltas em todas. No Kotlin e no Ruby, 1..5 vai de 1 a 5: são 5 voltas. No Rust, 1..5 para no 4: são 4 voltas, e para incluir o 5 você escreve 1..=5, como na contagem regressiva do programa. Para deixar o último de fora, o Kotlin usa 1..<5 e o Ruby usa três pontos, 1...5. Sacou? Quem troca de linguagem sem conferir isso erra por um.

Aí você pergunta: qual laço uso?

  • for: quando você sabe quantas voltas serão, ou quando vai percorrer uma lista do começo ao fim.
  • while: quando a quantidade de voltas depende do que acontece durante a execução, e o teste precisa ser feito antes da primeira volta.
  • do-while: quando o bloco precisa rodar uma vez antes de o teste fazer sentido.

Um for com contador pode ser reescrito como while. O trecho 1 do programa é um for escrito à mão: início antes do laço, condição no while e passo na última linha do bloco.

O que é um laço infinito?

É o laço cuja condição nunca fica falsa. O programa entra na repetição e não sai mais. ATENÇÃO: algo dentro do bloco precisa ser capaz de mudar o resultado da condição. No trecho 1, é a linha i = i + 1. Apague essa linha e o programa imprimirá “volta 1” sem parar.

Em C existe uma armadilha: o ponto e vírgula logo depois da condição, como em while (a < 10); seguido do bloco. O ponto e vírgula encerra o comando ali, o laço fica sem corpo e a variável nunca muda.

Nem todo laço sem fim é erro. O while True do trecho 4 é proposital, e a saída é garantida pelo break. O problema é o laço infinito que você não planejou.

Quais são os erros mais comuns com laços de repetição?

  • Esquecer de atualizar a variável da condição. É assim que nasce o laço infinito.
  • Errar por um. Trocar <= por < faz o laço dar uma volta a menos. Em Python, esquecer que o range não inclui o ponto final dá o mesmo resultado.
  • Não dar valor inicial ao contador ou ao acumulador. A soma precisa começar em 0.
  • Zerar o acumulador dentro do laço. Se soma = 0 estiver dentro do bloco, o total recomeça a cada volta.
  • Colocar ponto e vírgula depois do while ou do for em C. O laço fica sem corpo.
  • Confundir break com continue. O break sai do laço. O continue só pula uma volta.
  • Usar continue antes de atualizar o contador em um while. A volta é pulada, o contador não muda e o laço trava.

Agora é com você!

No papel:

  • Faça a tabela de n e soma para o laço que soma os números de 1 a 6. O total deve ser 21.
  • Quantas vezes a mensagem aparece em for (i = 0; i < 10; i = i + 2)? Liste os valores de i.
  • No laço while do trecho 1, o que muda na saída se a condição for i < 5?

No computador:

  • Mostre a tabuada do 7, de 7 x 1 até 7 x 10.
  • Some apenas os números pares de 1 a 100. O resultado deve ser 2550.
  • Dada a lista de notas do artigo, calcule a média usando um acumulador e um contador.

Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!

Até o próximo artigo!

Confiança Sempre!!!

Fontes:

Sobre quem escreve

Walmir Silva

Olá! Sou Walmir, engenheiro de software com MBA em Engenharia de Software e o cérebro por trás do GrowthCode e autor do livro "Além do Código".

Se você acha que programação é apenas sobre escrever código, prepare-se para expandir seus horizontes. Aqui, nós vamos além do código e exploramos as interseções fascinantes entre tecnologia, negócios, artes e filosofia.

Você está em busca de crescimento na carreira? Quer se destacar em um mercado competitivo? Almeja uma vida mais rica em conhecimento e realização? Então você chegou ao lugar certo. No GrowthCode, oferecemos insights profundos, estratégias comprovadas e um toque de sabedoria filosófica para catalisar seu crescimento pessoal e profissional.

Ver todos os artigos →

Continue a conversa

Compartilhe sua perspectiva

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Encontre sua próxima resposta

O que você quer aprender?

Preferências de cookies

Os cookies opcionais começam desligados. Você pode mudar a escolha a qualquer momento por esta tela.

NecessáriosSempre ativos

Guardam a sua escolha de cookies e mantêm o site funcionando. Não são usados para publicidade.

Contam visitas e mostram como o site é usado: Google Analytics e Microsoft Clarity, carregados pelo Google Tag Manager. Como esse contêiner também carrega tags de publicidade, as estatísticas só são ativadas junto com Publicidade e marketing.

Exibem anúncios do Google AdSense e medem campanhas e e-mails: pixels da Meta e do TikTok e o Mautic.

Permite que o Google escolha anúncios com base nos seus interesses. Desligado, os anúncios aparecem sem personalização. Depende de Publicidade e marketing.

Também é possível bloquear cookies nas configurações do navegador. Detalhes na Política de privacidade.