ลูปซ้อนกัน

การซ้อนลูปทำให้คุณสามารถทำงานซ้ำในกลุ่มได้ เช่น การอบคัพเค้กสามกลุ่มกลุ่มละหกชิ้น หรือการมอบอาวุธให้กับผู้เล่นในสองทีม

วิธีการทำงานของลูปซ้อนกัน

เมื่อมีการซ้อนลูป สคริปต์จะดำเนินการจากบรรทัดหนึ่งไปยังอีกบรรทัดหนึ่งจนกว่าจะถึงลูปถัดไป ลูปภายในจะทำงานจนกว่าจะตรงตามเงื่อนไขก่อนที่จะกลับไปที่ลูปภายนอก

ลอจิกของลูปซ้อนกัน

ภาพประกอบต่อไปนี้แสดงขั้นตอนที่ลูปใช้

ลูปภายนอก: โค้ดทำงานจากบรรทัดหนึ่งไปยังอีกบรรทัดหนึ่งจนกว่าจะถึงลูปภายใน ลูปภายนอก: โค้ดทำงานจากบรรทัดหนึ่งไปยังอีกบรรทัดหนึ่งจนกว่าจะถึงลูปภายใน ลูปภายนอก: โค้ดทำงานจากบรรทัดหนึ่งไปยังอีกบรรทัดหนึ่งจนกว่าจะถึงลูปภายใน

ตัวอย่างลูปซ้อนกัน

ลูปซ้อนกันอาจดูเหมือนนามธรรม แต่ตัวอย่างภาพสามารถช่วยได้ สำหรับการออกกำลังกายนี้ ให้คัดลอกและวางสคริปต์ตัวอย่างและรันใน Studio สคริปต์นี้จะสร้างหอคอยจากชิ้นส่วน โดยลูปภายนอกจะควบคุมจำนวนชิ้นส่วนที่จะสร้าง ในขณะที่ลูปภายในจะสร้างกลุ่มจริง ๆ

1. สร้างสคริปต์ใหม่ใน 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("Top outer loop: part batch " .. partBatch)
     currentColor = Color3.fromRGB(math.random(0, 255), math.random(0, 255), math.random(0, 255))
   
     -- ลูปภายใน
     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. ดูในขณะที่สคริปต์สร้างกลุ่มชิ้นส่วนสีต่าง ๆ หลังจากผ่านหนึ่งกลุ่ม มันจะหยุดชั่วขณะเป็นเวลา 2 วินาที คำสั่งพิมพ์ในลูปภายนอกจะทำงานเพียงครั้งเดียวต่อหนึ่งลูปภายในที่เสร็จสิ้น

หอคอยลูป for

แต่ละลูปมีชุดโค้ดของตัวเอง ดังนั้นอาจรับผิดชอบต่อการทำงานที่แตกต่างกัน หนึ่งในสิ่งที่ลูปซ้อนกันสามารถทำได้คือการเปลี่ยนตำแหน่งที่วัตถุจะสร้างเพื่อสร้างหอคอยเหมือนในวิดีโอนี้ มีลูปสามตัว หนึ่งลูปสำหรับควบคุมที่ตำแหน่งความกว้าง ความยาว และความสูงของหอคอยที่ทรงลูกบาศก์จะสร้างขึ้น

เขียนสคริปต์สร้างลูกบาศก์

เพื่อฝึกลูปซ้อนกัน คุณจะสร้างสคริปต์ที่สร้างหอคอยของลูกบาศก์ สำหรับสคริปต์หอคอยลูกบาศก์ ให้เขียนฟังก์ชันที่สร้างลูกบาศก์เดียวก่อน หอคอยจะถูกสร้างโดยการเรียกฟังก์ชันนี้ซ้ำ

ตั้งค่าสคริปต์

สำหรับสคริปต์หอคอยลูกบาศก์ ให้เริ่มต้นเขียนฟังก์ชันที่สร้างลูกบาศก์เดียวก่อน หอคอยจะถูกสร้างโดยการเรียกฟังก์ชันนี้ซ้ำ

1. ลบ สคริปต์ PartMaker หรือปิดการใช้งาน (ในคุณสมบัติของสคริปต์ ให้ทำเครื่องหมายที่ Disabled) หากคุณไม่ทำเช่นนั้น จะมีสคริปต์สองชุดในการสร้างชิ้นส่วนในตำแหน่งเดียวกัน

2. สร้างสคริปต์ใหม่ชื่อ TowerBuilder เพิ่มตัวแปรสำหรับขนาดหอคอยและขนาดลูกบาศก์ที่ด้านบน

   local TOWER_SIZE = 4
   local CUBE_SIZE = 2

   สังเกตว่าตัวแปรด้านบนทั้งหมดใช้ตัวอักษรใหญ่ นี่เรียกว่า ค่าคงที่ หรือ ตัวแปรที่ไม่เปลี่ยนแปลง เพื่อแยกแยะจากตัวแปรที่จะแก้ไขภายในสคริปต์ ให้พิมพ์ด้วยตัวอักษรใหญ่และขีดเส้นใต้

3. เพิ่มฟังก์ชันท้องถิ่นชื่อ 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

4. ตั้งค่าสีของลูกบาศก์ให้เป็นตัวแปรซึ่งจะอัปเดตในลูปซ้อนกัน

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

5. สุดท้าย บิด ลูกบาศก์ใหม่ไปยังพื้นที่ทำงานเพื่อให้มันปรากฏขึ้น

   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 เมื่อวัตถุถูกสร้างโดยสคริปต์ แนะนำให้บิดวัตถุในตอนท้าย จะทำให้การทำงานกับตัวอย่างเร็วขึ้นก่อนที่จะมีวัตถุจริงในโลก 3 มิติ

สร้างในทิศทางที่แตกต่างกัน

เพื่อสร้างหอคอย ให้สร้างลูกบาศก์ที่จุดเฉพาะโดยการตั้งค่าคุณสมบัติ X, Y, Z ของลูกบาศก์ใหม่แต่ละตัว X และ Z คือข้างๆ Y คือขึ้นและลง

1. ใน 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

2. ภายในฟังก์ชัน ตั้งค่าคุณสมบัติ CFrame ของลูกบาศก์เป็น CFrame ใหม่โดยใช้พารามิเตอร์ 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

   ใน Roblox CFrame เป็นชนิดข้อมูลที่ใช้เก็บตำแหน่งและทิศทางใน 3 มิติ ใช้ในการวางวัตถุในโลก

สร้างด้วยลูปซ้อนกัน

สคริปต์จะมีลูปทั้งหมดสามลูป หนึ่งลูปสำหรับความยาว ความกว้าง และความสูงของหอคอย เพื่อสร้างชั้นทั้งหมดก่อนที่จะเคลื่อนที่ขึ้น ให้เริ่มต้นด้วยการตั้งค่า Y ในลูปแรกซึ่งจะเป็นลูภายนอก

1. ใต้ฟังก์ชัน 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 ซึ่งเป็นเหตุผลว่าทำไมต้องลบ 1 จาก heightIndex

2. เมื่อเสร็จสิ้นลูปแรกสำหรับความสูง ให้เริ่มที่ลูปที่สอง ภายในลูป 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

   เมื่อทำงานกับลูปซ้อนกัน สิ่งสำคัญคือต้องมั่นใจว่าโค้ดถูกจัดรูปแบบอย่างดี ซึ่งจะช่วยทำให้โค้ดของคุณอ่านได้ง่ายและเป็นระเบียบ

3. ภายในลูป ที่สอง ให้เพิ่มลูป 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

4. เพื่อให้แต่ละชั้นมีสีสุ่ม เปลี่ยน 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

5. รันโปรเจกต์และรอดูว่าหอคอยเต็มตัวถูกสร้างขึ้นโดยไม่มีข้อผิดพลาดในหน้าต่าง Output

ท้าทายเพิ่มเติม

ด้านล่างนี้คือความท้าทายต่าง ๆ ที่สามารถทำได้โดยใช้ลูปซ้อนกันในรูปแบบที่ต่างกัน ลองเขียนโค้ดด้วยตัวเองก่อนที่จะดูที่คำตอบ

ทำให้ชิ้นส่วนจางหายไป

ในขณะที่หอคอยถูกสร้าง ให้ทำให้ชิ้นส่วนจางหายไปในความโปร่งใสจากซ้ายไปขวา

คำตอบโค้ดอยู่ด้านล่าง

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("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))

    -- ลูปภายใน
    for cupcakeNumber = 1, cupcakesPerBatch do
        makeCupcake()
        print("Inner loop: cupcake " .. cupcakeNumber)
        -- ติดตามการทำคัพเค้ก
        cupcakesBaked += 1
        task.wait(0.5)
    end

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

สรุป

เพื่อทำงานที่ซับซ้อนมากขึ้น โปรแกรมเมอร์จะพบว่าการรวมลูปหลายตัว และแม้แต่ประเภทของลูปที่แตกต่างกันสามารถเป็นประโยชน์ ลูปทั้งหมดสามารถซ้อนกันได้ นั่นหมายถึงว่าลูปหนึ่งอยู่ภายในลูปอีกตัวหนึ่ง ลูปซ้อนกันทำตามหลักการเดียวกับลูปอื่น ๆ เริ่มจากลูปภายนอกสุด ทำงานผ่านลูปภายใน แล้วกลับไปที่ลูปแรกหากจำเป็น