Geschachtelte Schleifen | Dokumentation

Das Schachteln von Schleifen erlaubt es Ihnen, Aufgaben in Gruppen zu wiederholen. Zum Beispiel beim Backen von drei Gruppen von sechs Cupcakes oder beim Zuweisen von Waffen an Spieler in zwei Teams.

Wie geschachtelte Schleifen ablaufen

Wenn Schleifen geschachtelt sind, gehen Skripte Zeile für Zeile, bis sie die nächste Schleife erreichen. Die innere Schleife wird so lange ausgeführt, bis ihre Bedingung erfüllt ist, bevor sie zur äußeren Schleife zurückkehrt.

Logik der geschachtelten Schleifen

Das folgende Diagramm zeigt die Schritte, die eine Schleife durchläuft.

Äußere Schleife: Code wird Zeile für Zeile ausgeführt, bis sie die innere Schleife erreicht.
Äußere Schleife: Code wird Zeile für Zeile ausgeführt, bis sie die innere Schleife erreicht.
Äußere Schleife: Code wird Zeile für Zeile ausgeführt, bis sie die innere Schleife erreicht.

Beispiel für geschachtelte Schleifen

Geschachtelte Schleifen können etwas abstrakt erscheinen, daher kann ein visuelles Beispiel hilfreich sein. Für diese Übung kopieren und fügen Sie ein Beispielskript ein und führen es im Studio aus. Dieses Skript erstellt Türme aus Teilen. Die äußere Schleife steuert, wie viele Teile erstellt werden, während die innere Schleife die tatsächliche Gruppe erstellt.

Erstellen Sie ein neues Skript in ServerScriptService mit dem Namen PartMaker. Kopieren Sie den folgenden Code.


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

-- Erstellt einen einzelnen Würfel
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

-- Äußere Schleife
for partBatch = 1, numberOfBatches do
  print("Obere äußere Schleife: Teilgruppe " .. partBatch)
  currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))

  -- Innere Schleife
  for partNumber = 1, partsPerBatch do
    createPart()
    print("Innere Schleife: Teil " .. partNumber)
    partsMade += 1
    task.wait(0.5)
  end

  print("Untere äußere Schleife: " .. partsMade .. " Teile bisher erstellt.")

  task.wait(2)
end

Sehen Sie zu, wie das Skript eine andere Gruppe von farbigen Teilen erzeugt. Nachdem eine Gruppe durchlaufen wurde, pausiert es für 2 Sekunden. Die Druckanweisung in der äußeren Schleife wird nur einmal für jede abgeschlossene innere Schleife ausgeführt.

Geschachtelter For-Schleifen-Turm

Jede Schleife hat ihren eigenen Satz von Code, sodass sie für verschiedene Aufgaben verantwortlich sein kann. Eine Sache, die geschachtelte Schleifen tun können, ist, die Platzierung zu ändern, wo ein Objekt erscheint, um einen Turm wie in diesem Video zu erstellen. Es gibt drei verschiedene Schleifen, eine für die Steuerung der Breite, Länge und Höhe des Turms, an dem der Würfel erscheint.

Ein Würfelherstellungsskript codieren

Um geschachtelte Schleifen zu üben, erstellen Sie ein Skript, das einen Turm aus Würfeln erzeugt. Für das Würfelturm-Skript codieren Sie zuerst eine Funktion, die einen einzelnen Würfel erzeugt. Der Turm wird durch wiederholtes Aufrufen dieser Funktion gebaut.

Skript einrichten

Für das Würfelturm-Skript codieren Sie zuerst eine Funktion, die einen einzelnen Würfel erzeugt. Der Turm wird durch wiederholtes Aufrufen dieser Funktion gebaut.

Löschen Sie das PartMaker-Skript oder deaktivieren Sie es (in den Skripteigenschaften die Option Deaktiviert aktivieren). Wenn Sie dies nicht tun, werden zwei Skripte gleichzeitig am selben Ort Teile erstellen.
Erstellen Sie ein neues Skript mit dem Namen TowerBuilder. Fügen Sie Variablen für die Turmhöhe und die Würfelgröße oben hinzu.
```
local TOWER_SIZE = 4
local CUBE_SIZE = 2
```
Beachten Sie, dass die obigen Variablen alle in Großbuchstaben geschrieben sind. Diese werden als Konstanten bezeichnet, oder Variablen, die sich nicht ändern. Um sie von Variablen zu unterscheiden, die innerhalb des Skripts geändert werden, schreiben Sie sie in Großbuchstaben und mit Unterstrichen.

Fügen Sie eine lokale Funktion makeCube() hinzu, die einen einzelnen quadratischen Würfel mit CUBE_SIZE erstellt.


local TOWER_SIZE = 4
local CUBE_SIZE = 2

-- Erstellt einzelne Würfel
local function makeCube()
  local cube = Instance.new("Part")
  cube.Size = Vector3.new(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE)
end

Setzen Sie die Farbe des Würfels auf eine Variable, die in den geschachtelten Schleifen aktualisiert wird.


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

Schließlich ordnen Sie den neuen Würfel dem Arbeitsbereich zu, damit er sichtbar wird.


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

In Roblox-Code wird empfohlen, ein Objekt, das durch ein Skript erstellt wurde, am Ende zuzuordnen. Es ist schneller, Änderungen an einer Instanz vorzunehmen, bevor es ein physisches Objekt in der 3D-Welt gibt.

In verschiedene Richtungen spawnen

Um einen Turm zu erstellen, platzieren Sie Würfel an bestimmten Punkten, indem Sie die X-, Y-, Z-Eigenschaften jedes neuen Würfels festlegen. X und Z sind nebeneinander. Y ist nach oben und unten.

Fügen Sie in makeCube() Parameter für spawnX, spawnY und spawnZ hinzu. Diese Zahlen setzen den Spawnort jedes neuen Würfels.


-- Erstellt einzelne Würfel
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

Setzen Sie innerhalb der Funktion die CFrame-Eigenschaft des Würfels auf ein neues CFrame unter Verwendung der spawnX, spawnY, spawnZ-Parameter.


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

In Roblox ist CFrame ein Datentyp, der verwendet wird, um die 3D-Position und -Ausrichtung zu speichern. Es wird verwendet, um Objekte in einer Welt zu platzieren.

Mit geschachtelten Schleifen spawnen

Das Skript hat insgesamt drei Schleifen, eine für die Länge, die Breite und die Höhe des Turms. Um eine gesamte Etage abzuschließen, bevor man nach oben geht, beginnen Sie mit der Festlegung der Y-Koordinate in der ersten äußeren Schleife.

Erstellen Sie unter der Funktion makeCube() eine for-Schleife, um festzulegen, wie hoch jeder Würfel spawnt.
- Steuerungsvariable: heightIndex = 1
- Endpunkt: TOWER_SIZE
- Fügen Sie innerhalb der Schleife hinzu: local spawnY = (heightIndex - 1) * CUBE_SIZE
```
-- Baut den Turm
for heightIndex = 1, TOWER_SIZE do
    local spawnY = (heightIndex - 1) * CUBE_SIZE
end
```
Die Berechnung für spawnY stellt sicher, dass der erste Würfel in der Höhe des Bodens spawnt und dann jedes Mal über den Platz eines einzelnen Würfels bewegt wird. Der Boden ist auf 0, weshalb 1 von heightIndex subtrahiert werden muss.

Nachdem die erste Schleife für die Höhe abgeschlossen ist, beginnen Sie mit der zweiten. Fügen Sie innerhalb der ersten for-Schleife eine neue for-Schleife hinzu für den Ort, an dem der Würfel entlang der Länge des Turms platziert werden soll.

Steuerungsvariable: lengthIndex = 1
Endpunkt: TOWER_SIZE
Fügen Sie innerhalb dieser Schleife hinzu: 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

Achten Sie beim Arbeiten mit geschachtelten Schleifen darauf, dass der Code gut eingerückt ist. Dies hilft, Ihren Code lesbar und organisiert zu halten.

Fügen Sie innerhalb der zweiten Schleife eine dritte for-Schleife für die Breite des Turms hinzu. In dieser letzten Schleife rufen Sie makeCube() auf und übergeben die X-, Y-, Z-Parameter.

Steuerungsvariable: widthIndex = 1
Endpunkt: TOWER_SIZE
Fügen Sie innerhalb der Schleife hinzu:
- local spawnZ = widthIndex * CUBE_SIZE
- makeCube(spawnX, spawnY, spawnZ)
- Eine Wartezeit von 0,25, damit Sie sehen können, wie der Turm gebaut wird.


-- Baut den Turm
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

Um jede Etage in einer zufälligen Farbe zu haben, ändern Sie currentColor auf zufällige RGB-Nummern in der gleichen Schleife, in der Sie eine neue Etage erstellen.


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

Führen Sie das Projekt aus und warten Sie, um zu sehen, dass ein vollständiger Turm ohne Fehler im Ausgabefenster erstellt wurde.

Optionale Herausforderungen

Unten finden Sie verschiedene selbstgesteuerte Herausforderungen, die geschachtelte Schleifen auf unterschiedliche Weise verwenden. Versuchen Sie, selbst zu codieren, bevor Sie die Lösung ansehen.

Teile verblassen lassen

Während der Turm gebaut wird, lassen Sie die Teile von links nach rechts in der Transparenz verblassen.

Die Lösung des Codes ist unten.


local TOWER_SIZE = 6
local CUBE_SIZE = 2

-- Erstellt einzelne Würfel
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 -- Setzt die Transparenz
    cube.CFrame = CFrame.new(spawnX, spawnY, spawnZ)
    cube.Parent = workspace
end

-- Baut den Turm
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 -- Aktualisiert jede Schleife, beginnend bei 0

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

Objekte herabregnen lassen

Anstelle von Teilen versuchen Sie, ein tatsächliches Objekt zu erzeugen. Das hier gezeigte Beispiel verwendete Cupcakes.

Versuchen Sie es selbst zu sehen, ob Sie:

Ein Objekt aus Basisteilen erstellen. Stellen Sie sicher, dass Sie alle Teile zusammenfügen, damit das Objekt nicht auseinanderfällt.
Das Objekt in ServerStorage platzieren
Modifizieren Sie das PartMaker-Skript, das in dem Beispiel für geschachtelte Schleifen gefunden wurde, um Ihr Objekt anstelle von Teilen zu verwenden.

Ein Beispiel ist hier gezeigt.

Eine Lösung des Codes mit Cupcakes ist enthalten.


local numberOfBatches = 30
local cupcakesPerBatch = 6

local cupcakesBaked = 0

-- Erstellt einen einzelnen 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


-- Äußere Schleife
for cupcakeBatch = 1, numberOfBatches do
    print("Obere äußere Schleife: Cupcake-Gruppe " .. 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))

    -- Innere Schleife
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Innere Schleife: Cupcake " .. cupcakeNumber)
        -- Verfolgt, wie viele Muffins gebacken wurden
        cupcakesBaked += 1
        task.wait(0.5)
    end

    print("Untere äußere Schleife: " .. cupcakesBaked .. " Cupcakes bisher gebacken.")
end

Zusammenfassung

Um komplexere Aufgaben zu erfüllen, finden es Programmierer hilfreich, mehrere Schleifen zu kombinieren, und sogar unterschiedliche Schleifentypen. Alle Schleifen können geschachtelt werden, was bedeutet, dass eine Schleife innerhalb einer anderen ist. Geschachtelte Schleifen folgen der gleichen Logik wie jede andere Schleife. Sie beginnen in der ersten äußeren Schleife, führen Aufgaben in inneren Schleifen aus und kehren dann zur ersten Schleife zurück, wenn zutreffend.