Vòng lặp lồng nhau

Các vòng lặp tổng hợp cho phép bạn lặp lại các nhiệm vụ trong các lô. Ví dụ, nướng ba lô của sáu chiếc bánh xếp hoặc gán vũ khí cho người chơi trong hai đội.

Cách vòng lặp lồng nhau chạy

Khi vòng lặp được xếp chồng, các kịch bản di chuyển dòng theo dòng cho đến khi đến vòng lặp tiếp theo.Vòng lặp bên trong sẽ chạy cho đến khi điều kiện được đáp ứng trước khi trở lại vòng lặp bên ngoài.

Logic vòng lặp lồng nhau

Sơ đồ sau đây cho thấy các bước một vòng lặp thực hiện.

Vòng lặp ngoài: mã chạy dòng-bởi-dòng cho đến khi nó đến vòng lặp nội bộ.:
Vòng lặp bên ngoài: mã chạy dòng-bởi-dòng cho đến khi nó đến vòng lặp bên trong.:
Vòng lặp ngoài: mã chạy dòng-bởi-dòng cho đến khi nó đến vòng lặp nội bộ.

Ví dụ vòng lặp lồng nhau

Vòng lặp lồng nhau có thể có vẻ hơi trừu tượng, vì vậy ví dụ hình ảnh có thể giúp đỡ.Với bài tập này, sao chép và dán một kịch bản mẫu và chạy nó trong Studio.Tập lệnh này sẽ tạo các tháp của các bộ phận.Vòng lặp bên ngoài sẽ kiểm soát số lượng bộ phận cần tạo, trong khi vòng lặp bên trong sẽ tạo lô thực tế.

Tạo một kịch bản mới trong ServerScriptService có tên PartMaker. Sao chép mã bên dưới.


local numberOfBatches = 7
local partsPerBatch = 5
local partsMade = 0

-- Tạo một khối duy nhất
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

-- Vòng lặp bên ngoài
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))

  -- Vòng lặp bên trong
  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

Xem khi kịch bản tạo một lô khác các bộ phận màu.Sau khi đi qua một lô, nó sẽ tạm dừng trong 2 giây.Tuyên bố in trong vòng lặp ngoài sẽ chỉ chạy một lần mỗi khi hoàn thành vòng lặp bên trong.

Nested cho tháp vòng lặp

Mỗi vòng lặp có bộ mã riêng, vì vậy có thể chịu trách nhiệm cho các nhiệm vụ khác nhau.Một điều mà vòng lặp lồng nhau có thể làm là thay đổi vị trí mà một đối tượng xuất hiện để tạo một tháp giống như trong video này.Có ba vòng lặp khác nhau, mỗi vòng một để kiểm soát nơi dọc theo chiều rộng, chiều dài và chiều cao của tháp khối xuất hiện.

Lập trình một kịch bản tạo khối

Để thực hành vòng lặp lồng nhau, bạn sẽ tạo một kịch bản tạo một tháp của khối.Đối với kịch bản tháp khối, trước tiên mã hóa một chức năng tạo ra một khối duy nhất.Tháp sẽ được xây dựng bằng cách lặp lại chức năng này.

Thiết lập kịch bản

Đối với kịch bản tháp khối, trước tiên mã hóa một chức năng tạo ra một khối duy nhất. Tháp sẽ được xây dựng bằng cách lặp lại chức năng này.

Xóa kịch bản PartMaker hoặc vô hiệu hóa nó (trong tính năng của kịch bản, kiểm tra Bị vô hiệu hóa).Nếu bạn không, sẽ có hai kịch bản làm các bộ phận cùng một lúc tại cùng một địa điểm.
Tạo một kịch bản mới có tên TowerBuilder. Thêm các biến cho kích thước của tháp và kích thước khối ở phía trên.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Lưu ý cách các biến trên được tất cả đều viết hoa.Chúng được gọi là biến số , hoặc biến cố định không thay đổi.Để phân biệt chúng khỏi các biến sẽ được thay đổi trong kịch bản, hãy nhập chúng bằng các chữ cái và dấu gạch ngang.

Thêm một chức năng địa phương có tên là makeCube() tạo một khối hình vuông duy nhất bằng cách sử dụng CUBE_SIZE .


local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Tạo khối riêng lẻ
local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
end

Đặt màu của khối thành một biến sẽ được cập nhật trong vòng lặp lồng nhau.


local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
  cube.Color = currentColor
end

Cuối cùng, cha cube mới vào không gian làm việc để nó xuất hiện.


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

Trong mã Roblox, một lần một đối tượng được tạo bởi kịch bản, nó được khuyến nghị để cha nó vào kết thúccùng.Thay đổi một ví dụ trước khi có một vật thể vật lý trong thế giới trò chơi nhanh hơn.

Xuất hiện theo các hướng khác nhau

Để tạo một tháp, hãy tạo các khối ở các điểm cụ thể bằng cách đặt các thuộc tính X, Y, Z của mỗi khối mới. X và Z nằm cạnh nhau. Y là lên và xuống.

Trong makeCube(), thêm các tham số cho spawnX, spawnY và spawnZ. Những con số này sẽ đặt vị trí sinh sản của mỗi khối mới.


-- Tạo khối riêng lẻ
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

Bên trong chức năng, đặt thuộc tính CFrame của khối lập phương thành một CFrame mới bằng cách sử dụng spawnX , spawnY , spawnZ các tham số.


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

Trong Roblox, CFrame là một loại dữ liệu được sử dụng để lưu vị trí và hướng 3D. Nó được sử dụng để đặt các vật thể trong một thế giới.

Xuất hiện với vòng lặp lồng nhau

Tập lệnh sẽ có tổng cộng ba vòng lặp, mỗi vòng một cho chiều dài, chiều rộng và chiều cao của tháp.Để hoàn thành toàn bộ tầng trước khi di chuyển lên trên, bắt đầu bằng cách đặt điểm Y trong vòng lặp đầu tiên, cuối cùng.

Dưới chức năng makeCube(), Tạo một vòng lặp for để đặt cách cao mỗi cục bùng phát.
- Biến điều khiển : heightIndex = 1
- Điểm cuối : TOWER_SIZE
- Bên trong vòng lặp, thêm: local spawnY = (heightIndex - 1) * CUBE_SIZE
```
-- Xây dựng tháp
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
Tính toán cho spawnY đảm bảo khối đầu tiên xuất hiện ở độ cao mặt đất và sau đó di chuyển qua không gian của một khối duy nhất mỗi lần.Cấp độ mặt đất là ở 0, đó là lý do tại sao 1 cần phải trừ khỏi heightIndex .

Với vòng lặp đầu tiên cho chiều cao đã kết thúc, bắt đầu vào vòng thứ hai.Bên trong vòng lặp đầu tiên, thêm một vòng lặp mới cho nơi để đặt khối dọc theo chiều cao của tháp.

Biến điều khiển : lengthIndex = 1
Điểm cuối : TOWER_SIZE
Bên trong vòng lặp này thêm: 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

Khi làm việc với vòng lặp lồng nhau, việc đảm bảo mã được phân cách tốt là điều quan trọng. Điều này giúp làm cho mã của bạn dễ đọc và được tổ chức.

Bên trong vòng lặp thứ hai , thêm một vòng lặp thứ ba cho vòng lặp của tháp chiều rộng .Trong vòng lặp cuối cùng này, gọi makeCube() và truyền các tham số X,Y, Z.

Biến điều khiển : widthIndex = 1
Điểm cuối : TOWER_SIZE
Bên trong vòng lặp thêm:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Thời gian chờ 0,25 để bạn có thể xem tháp được xây dựng.


-- Xây dựng tháp
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

Để mỗi tầng trở thành một màu ngẫu nhiên, thay đổi currentColor thành số ngẫu nhiên RGB trong vòng lặp tương tự mà bạn tạo ra một tầng mới.


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

Chạy dự án và chờ đợi để xem một tháp đầy đủ đã được tạo ra mà không có bất kỳ lỗi nào trong cửa sổ Thành phẩm.

Thử thách tùy chọn

Dưới đây là các thách thức tự hướng khác nhau sử dụng vòng lặp lồng nhau theo cách khác nhau. Hãy thử và lập trình riêng trước khi xem giải pháp.

Phai mờ các bộ phận

Khi tháp được xây dựng, các bộ phận sẽ biến mất trong suốt từ bên trái sang bên phải.

Giải pháp mã là dưới đây.


local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- Tạo khối riêng lẻ
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 -- Bộ trong suốt đặt
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- Xây dựng tháp
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 --Cập nhật mỗi vòng lặp bắt đầu tại 0

        for widthIndex = 1, TOWER_SIZE do
            local spawnZ = widthIndex * CUBE_SIZE
            makeCube(spawnX, spawnY, spawnZ)
            task.wait(0.05)
        end
    end
end

Mưa xuống các đối tượng

Thay vì các bộ phận, hãy thử tạo một đối tượng thực. Ví dụ ở đây sử dụng bánh xếp.

Bởi chính sở hữu, xem xem bạn có thể:

Tạo một đối tượng từ các bộ phận cơ bản. Hãy chắc chắn để hàn tất cả các bộ phận lại với nhau để đối tượng không bị rơi ra.
Đặt đối tượng vào ServerStorage
Sửa lại PartMaker được tìm thấy trong Vòng lặp lồng nhau Ví dụ để sử dụng đối tượng của bạn thay vì các bộ phận.

Một mẫu được hiển thị ở đây.

Một giải pháp mã sử dụng bánh xếp được bao gồm.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

--Tạo một chiếc bánh xếp duy nhất
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


-- Vòng lặp bên ngoài
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))

    -- Vòng lặp bên trong
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Inner loop: cupcake " .. cupcakeNumber)
        -- Bánh muffin theo dõi đã nướng
        cupcakesBaked += 1
        task.wait(0.5)
    end

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

Tổng quát

Để hoàn thành các nhiệm vụ phức tạp hơn, các lập trình viên sẽ thấy hữu ích khi kết hợp nhiều vòng lặp, thậm chí cả các loại vòng lặp khác nhau.Tất cả các vòng lặp có thể được lồng nhau, có nghĩa là một vòng lặp nằm bên trong một vòng lặp khác.Vòng lặp lồng nhau tuân theo cùng một logic như bất kỳ vòng lặp nào khác.Nó bắt đầu trong vòng lặp đầu tiên, bên ngoài nhất, chạy các nhiệm vụ thông qua các vòng lặp bên trong, và sau đó chu kỳ trở lại vòng lặp đầu tiên nếu có hiện hànhdụng.

Trên trang này