Criações

Laços aninhados

*Este conteúdo é traduzido por IA (Beta) e pode conter erros. Para ver a página em inglês, clique aqui.

Aninhar laços permite que você repita tarefas em lotes. Por exemplo, assar três lotes de seis cupcakes ou atribuir armas a jogadores em duas equipes.

Como os laços aninhados funcionam

Quando os laços estão aninhados, os scripts vão linha por linha até alcançar o próximo laço. O laço interno será executado até que sua condição seja atendida antes de retornar ao laço externo.

Lógica do laço aninhado

O diagrama a seguir mostra as etapas que um laço percorre.

  • Laço externo: o código é executado linha por linha até alcançar o laço interno.
  • Laço externo: o código é executado linha por linha até alcançar o laço interno.
  • Laço externo: o código é executado linha por linha até alcançar o laço interno.

Exemplo de laço aninhado

Laços aninhados podem parecer um pouco abstratos, então um exemplo visual pode ajudar. Para este exercício, copie e cole um script de amostra e execute-o no Studio. Este script criará torres de partes. O laço externo controlará quantas partes devem ser feitas, enquanto o laço interno criará o lote real.

  1. Crie um novo script em ServerScriptService chamado PartMaker. Copie o código abaixo.

    local numberOfBatches = 7

    local partsPerBatch = 5

    local partsMade = 0

    

    -- Faz um único cubo

    local function createPart()

      local part = Instance.new("Part")

      part.Size = Vector3.new(2, 2, 2)

      part.CFrame = CFrame.new(20, 0, 20)

      part.Color = currentColor

      part.Parent = workspace

    end

    

    -- Laço externo

    for partBatch = 1, numberOfBatches do

      print("Top outer loop: part batch " .. partBatch)

      currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

    

      -- Laço interno

      for partNumber = 1, partsPerBatch do

        createPart()

        print("Inner loop: part " .. partNumber)

        partsMade += 1

        task.wait(0.5)

      end

    

      print("Bottom outer loop: " .. partsMade .. " parts made so far.")

    

      task.wait(2)

    end

  2. Observe enquanto o script gera um lote diferente de partes coloridas. Depois de passar por um lote, ele fará uma pausa de 2 segundos. A instrução de impressão no laço externo será executada apenas uma vez por laço interno concluído.

Torre de laço for aninhado

Cada laço tem seu próprio conjunto de códigos, portanto, pode ser responsável por tarefas diferentes. Uma coisa que os laços aninhados podem fazer é mudar a colocação de onde um objeto é gerado para criar uma torre como a do vídeo. Existem três laços diferentes, um para controlar onde ao longo da largura, comprimento e altura da torre o cubo é gerado.

Código de um script gerador de cubos

Para praticar laços aninhados, você fará um script que cria uma torre de cubos. Para o script da torre de cubos, primeiro codifique uma função que gere um único cubo. A torre será construída chamando repetidamente essa função.

Configurar o script

Para o script da torre de cubos, primeiro codifique uma função que gere um único cubo. A torre será construída chamando repetidamente essa função.

  1. Exclua o script PartMaker ou desative-o (nas propriedades do script, marque a opção Disabled). Se você não fizer isso, haverá dois scripts gerando partes ao mesmo tempo no mesmo lugar.

  2. Crie um novo script chamado TowerBuilder. Adicione variáveis para o tamanho da torre e o tamanho do cubo no topo.

    local TOWER_SIZE = 4

    local CUBE_SIZE = 2

  3. Adicione uma função local chamada makeCube() que cria um único cubo quadrado usando CUBE_SIZE.

    local TOWER_SIZE = 4

    local CUBE_SIZE = 2

    

    -- Cria cubos individuais

    local function makeCube()

      local cube = Instance.new("Part")

      cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)

    end

  4. Configure a cor do cubo para uma variável que será atualizada nos laços aninhados.

    local function makeCube()

      local cube = Instance.new("Part")

      cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)

      cube.Color = currentColor

    end

  5. Por último, adicione o novo cubo ao workspace para que ele apareça.

    local function makeCube()

        local cube = Instance.new("Part")

        cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)

        cube.Color = currentColor

        cube.Parent = workspace

    end

Gerar em direções diferentes

Para criar uma torre, gere cubos em pontos específicos definindo as propriedades X, Y, Z de cada novo cubo. X e Z são lado a lado. Y é para cima e para baixo.

  1. Na função makeCube(), adicione parâmetros para spawnX, spawnY e spawnZ. Esses números definirão a localização de geração de cada novo cubo.

    -- Cria cubos individuais

    local function makeCube(spawnX, spawnY, spawnZ)

        local cube = Instance.new("Part")

        cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)

        cube.Color = currentColor

        cube.Parent = workspace

    end

  2. Dentro da função, defina a propriedade CFrame do cubo para um novo CFrame usando os parâmetros spawnX, spawnY, spawnZ.

    local function makeCube(spawnX, spawnY, spawnZ)

        local cube = Instance.new("Part")

        cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)

        cube.Color = currentColor

        cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)

        cube.Parent = workspace

    end

Gerar com laços aninhados

O script terá três laços no total, um para o comprimento, um para a largura e um para a altura da torre. Para completar um andar inteiro antes de subir, comece definindo a coordenada Y no primeiro laço externo.

  1. Sob a função makeCube(), crie um laço for para definir quão alto cada cubo será gerado.

    • Variável de controle: heightIndex = 1
    • Ponto final: TOWER_SIZE
    • Dentro do laço, adicione: local spawnY = (heightIndex - 1) * CUBE_SIZE
    -- Constrói a torre

    for heightIndex = 1, TOWER_SIZE do

        local spawnY = (heightIndex - 1) * CUBE_SIZE

    end

  2. Com o primeiro laço para altura concluído, comece no segundo. Dentro do primeiro laço for, adicione um novo laço for para onde colocar o cubo ao longo do comprimento da torre.

    • Variável de controle: lengthIndex = 1
    • Ponto final: TOWER_SIZE
    • Dentro desse laço adicione: local spawnX = lengthIndex * CUBE_SIZE
    for heightIndex = 1, TOWER_SIZE do

        local spawnY = (heightIndex - 1) * CUBE_SIZE

    

        for lengthIndex = 1, TOWER_SIZE do

            local spawnX = lengthIndex * CUBE_SIZE

        end

    end

  3. Dentro do segundo laço, adicione um terceiro laço for para a largura da torre. Neste laço final, chame makeCube() e passe os parâmetros X, Y, Z.

    • Variável de controle: widthIndex = 1
    • Ponto final: TOWER_SIZE
    • Dentro do laço adicione:
      • local spawnZ = widthIndex * CUBE_SIZE
      • makeCube(spawnX, spawnY, spawnZ)
      • Um tempo de espera de 0.25 para que você possa ver a torre ser construída.
    -- Constrói a torre

    for heightIndex = 1, TOWER_SIZE do

        local spawnY = (heightIndex - 1) * CUBE_SIZE

    

        for lengthIndex = 1, TOWER_SIZE do

            local spawnX = lengthIndex * CUBE_SIZE

    

            for widthIndex = 1, TOWER_SIZE do

                local spawnZ = widthIndex * CUBE_SIZE

                makeCube(spawnX, spawnY, spawnZ)

                task.wait(0.25)

            end

        end

    end

  4. Para que cada andar tenha uma cor aleatória, mude currentColor para números RGB aleatórios no mesmo laço em que você cria um novo andar.

    for heightIndex = 1, TOWER_SIZE do

        local spawnY = (heightIndex - 1) * CUBE_SIZE

        currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

        for lengthIndex = 1, TOWER_SIZE do

            local spawnX = lengthIndex * CUBE_SIZE

            for widthIndex = 1, TOWER_SIZE do

                local spawnZ = widthIndex * CUBE_SIZE

                makeCube(spawnX, spawnY, spawnZ)

                task.wait(0.25)

            end

        end

    end

  5. Execute o projeto e aguarde para ver que uma torre completa foi criada sem erros na janela de Saída.

Desafios opcionais

Abaixo estão diferentes desafios autodirigidos que usam laços aninhados de maneiras diferentes. Tente codificar por conta própria antes de olhar a solução.

Partes que desaparecem

Enquanto a torre é construída, faça com que as partes desapareçam em transparência da esquerda para a direita.

A solução do código é a seguir.

local TOWER_SIZE = 6

local CUBE_SIZE = 2



-- Cria cubos individuais

local function makeCube(spawnX, spawnY, spawnZ)

    local cube = Instance.new("Part")

    cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)

    cube.Color = currentColor

    cube.Transparency = cubeTransparency -- Define a transparência

    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)

    cube.Parent = workspace

end



-- Constrói a torre

for heightIndex = 1, TOWER_SIZE do

    local spawnY = (heightIndex - 1) * CUBE_SIZE

    currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))



    for lengthIndex = 1, TOWER_SIZE do

        local spawnX = lengthIndex * CUBE_SIZE

        cubeTransparency = (lengthIndex - 1) * 0.10 -- Atualiza a cada laço começando de 0



        for widthIndex = 1, TOWER_SIZE do

            local spawnZ = widthIndex * CUBE_SIZE

            makeCube(spawnX, spawnY, spawnZ)

            task.wait(0.05)

        end

    end

end

Deixar os objetos caírem

Em vez de partes, tente gerar um objeto real. O exemplo aqui usou cupcakes.

Por conta própria, veja se você consegue:

  • Criar um objeto a partir de partes básicas. Certifique-se de soldar todas as partes juntas para que o objeto não se desfaça.
  • Colocar o objeto no ServerStorage.
  • Modificar o PartMaker encontrado no Exemplo de Laço Aninhado para usar seu objeto em vez de partes.

Uma amostra é mostrada aqui.

Uma solução de código usando cupcakes está incluída.

local numberOfBatches = 30

local cupcakesPerBatch = 6



local cupcakesBaked = 0



-- Faz um único cupcake

local function makeCupcake()

    local ServerStorage = game:GetService("ServerStorage")

    local cupcake = ServerStorage.Cupcake:Clone()

    local cup = cupcake.Cup

    local frosting = cupcake.Frosting

    cupcake:SetPrimaryPartCFrame(CFrame.new(0, 20, 0) * CFrame.Angles(0, 0, -90))

    frosting.Color = frostingColor

    cup.Color = cupColor

    cupcake.Parent = workspace

end





-- Laço externo

for cupcakeBatch = 1, numberOfBatches do

    print("Top outer loop: cupcake batch " .. cupcakeBatch)

    frostingColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

    cupColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))



    -- Laço interno

    for cupcakeNumber = 1, cupcakesPerBatch do

        makeCupcake()

        print("Inner loop: cupcake " .. cupcakeNumber)

        -- Rastrear cupcakes assados

        cupcakesBaked += 1

        task.wait(0.5)

    end



    print("Bottom outer loop: " .. cupcakesBaked .. " cupcakes baked so far.")

end

Resumo

Para realizar tarefas mais complexas, os programadores acharão útil combinar múltiplos laços, e até mesmo diferentes tipos de laços. Todos os laços podem ser aninhados, o que significa que um laço está dentro de outro. Laços aninhados seguem a mesma lógica que qualquer outro laço. Começa no primeiro laço externo, executa tarefas através dos laços internos e, em seguida, ciclando de volta ao primeiro laço, se aplicável.

Anterior
Avançar
©2026 Roblox Corporation, Roblox, o logotipo Roblox e Powering Imagination estão entre nossas marcas registradas e não registradas nos EUA e em outros países.
Termos·Privacidade·Acessibilidade·Suporte
Português (Brasil)