嵌套循环 | 文档 - Roblox 创作者中心

嵌套循环允许您批量重复任务。例如，烘焙三批六个杯子蛋糕，或将武器分配给两个团队的玩家。

嵌套循环是如何运行的

当循环被嵌套时，脚本会逐行执行，直到到达下一个循环。内层循环将在满足其条件之前运行，然后返回到外层循环。

嵌套循环逻辑

下图显示了循环所需的步骤。

外层循环：代码逐行运行，直到到达内层循环。
外层循环：代码逐行运行，直到到达内层循环。
外层循环：代码逐行运行，直到到达内层循环。

嵌套循环示例

嵌套循环在概念上可能有些抽象，因此一个可视化示例可以帮助理解。对于这个练习，复制并粘贴一个示例脚本，并在 Studio 中运行它。该脚本将创建部件的塔楼。外层循环将控制要制作的部件数量，而内层循环将创建实际的批次。

在 ServerScriptService 中创建一个名为 PartMaker 的新脚本。复制以下代码。


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

-- 制作一个立方体
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

-- 外层循环
for partBatch = 1, numberOfBatches do
  print("顶部外层循环：部件批次 " .. partBatch)
  currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

  -- 内层循环
  for partNumber = 1, partsPerBatch do
    createPart()
    print("内层循环：部件 " .. partNumber)
    partsMade += 1
    task.wait(0.5)
  end

  print("底部外层循环：到目前为止制作了 " .. partsMade .. " 个部件。")

  task.wait(2)
end

观察脚本如何生成不同批次的彩色部件。在完成一个批次后，它将暂停 2 秒。外层循环中的打印语句只会在每个完成的内层循环中运行一次。

嵌套 for 循环塔

每个循环都有自己的代码集，因此可以负责不同的任务。嵌套循环的一项功能是改变对象生成的位置，从而创建像视频中那样的塔。这有三个不同的循环，每个循环控制立方体在塔的宽度、长度和高度上的生成位置。

编写立方体生成脚本

为了练习嵌套循环，您将编写一个创建立方体塔的脚本。对于立方体塔脚本，首先编写一个生成单个立方体的函数。塔将通过重复调用此函数来构建。

设置脚本

对于立方体塔脚本，首先编写一个生成单个立方体的函数。塔将通过重复调用此函数来构建。

删除 PartMaker 脚本或禁用它（在脚本属性中，勾选 Disabled）。如果不这样做，将会有两个脚本同时在同一位置生成部件。
创建一个名为 TowerBuilder 的新脚本。在顶部添加塔的大小和立方体的大小变量。
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
注意上面的变量都是大写的。这些被称为常量，即不会改变的变量。为了将它们与在脚本中会改变的变量区分开，使用大写和下划线来书写。

添加一个名为 makeCube() 的局部函数，该函数使用 CUBE_SIZE 创建一个单个正方体立方体。


local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- 创建单个立方体
local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
end

将立方体的颜色设置为一个变量，以便在嵌套循环中进行更新。


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

最后，将新立方体的父级设置为工作区，以使其显示。


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

在 Roblox 代码中，一旦通过脚本创建了一个对象，建议在最后再将其父级设置。这在 3D 世界中有物理对象之前进行实例的更改更快。

在不同方向生成

要创建塔楼，可以通过设置每个新立方体的 X、Y、Z 属性在特定点生成立方体。X 和 Z 表示左右，Y 表示上下。

在 makeCube() 中，添加 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.Parent = workspace
end

在函数内部，将立方体的 CFrame 属性设置为使用 spawnX、spawnY、spawnZ 参数的新 CFrame。


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

在 Roblox 中，CFrame 是一种用于存储三维位置和方向的数据类型。它用于将对象放置在世界中。

使用嵌套循环生成

该脚本总共有三个循环，分别控制塔的长度、宽度和高度。为了在向上移动之前完成整个楼层，首先在最外层循环中设置 Y 坐标。

在 makeCube() 函数下方，创建一个 for 循环以设置每个立方体生成的高度。
- 控制变量：heightIndex = 1
- 结束点：TOWER_SIZE
- 在循环内部，添加：local spawnY = (heightIndex - 1) * CUBE_SIZE
```
-- 构建塔楼
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
spawnY 的计算确保第一个立方体在地面高度生成，并且每次移动一个立方体的空间。地面水平为 0，因此需要从 heightIndex 中减去 1。

第一个高度循环完成后，开始第二个。在第一个 for 循环内，添加一个新的 for 循环，以确定在哪里放置立方体沿着塔的长度。

控制变量：lengthIndex = 1
结束点：TOWER_SIZE
在该循环内部添加：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

在处理嵌套循环时，确保代码良好缩进是很重要的。这有助于使代码可读且有条理。

在第二个循环内部，添加一个第三个 for 循环来处理塔的宽度。在这个最后的循环中，调用 makeCube() 并传入 X、Y、Z 参数。

控制变量：widthIndex = 1
结束点：TOWER_SIZE
在循环内部添加：
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- 等待 0.25 秒，以便您可以观察塔楼构建过程。


-- 构建塔楼
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

为了让每一层都有随机颜色，在创建新楼层的同一循环中将 currentColor 更改为随机的 RGB 数字。


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

运行项目，等待查看完整的塔楼已创建而不会在输出窗口中出现任何错误。

可选挑战

以下是不同的自我指导挑战，使用嵌套循环以不同方式。尝试在查看解决方案之前自己编码。

渐变消失的部件

随着塔楼的构建，使部件从左到右渐变透明。

代码解决方案如下。


local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- 创建单个立方体
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 -- 设置透明度
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- 构建塔楼
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 -- 每次循环从 0 开始更新

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

从天而降的物体

尝试生成实际的物体，而不是部件。下面的示例使用杯子蛋糕。

您可以尝试：

从基础部件创建一个物体。确保焊接所有部件，以便物体不会散架。
将该物体放入 ServerStorage 中。
修改在嵌套循环示例中找到的 PartMaker 除了使用您的物体，其他均与部件相同。

此处显示了一个示例。

包含杯子蛋糕的代码解决方案如下。


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

-- 制作一个杯子蛋糕
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

-- 外层循环
for cupcakeBatch = 1, numberOfBatches do
    print("顶部外层循环：杯子蛋糕批次 " .. 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))

    -- 内层循环
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("内层循环：杯子蛋糕 " .. cupcakeNumber)
        -- 追踪烘焙的杯子蛋糕数量
        cupcakesBaked += 1
        task.wait(0.5)
    end

    print("底部外层循环：到目前为止烘焙了 " .. cupcakesBaked .. " 个杯子蛋糕。")
end

总结

为了完成更复杂的任务，程序员发现结合多个循环，甚至不同类型的循环是很有帮助的。所有循环都可以嵌套，这意味着一个循环在另一个循环内部。嵌套循环遵循与任何其他循环相同的逻辑。它从第一个外层循环开始，通过内层循环完成任务，然后在适用的情况下循环回第一个循环。