Lập trình games với Love2D - Chương 7 - Bảng và vòng lặp for

2023-10-22 07:47:18 Love2D Học Lập Trình Lua 167 lượt xem 0 bình luận

### Các bảng - Tables

Các bảng về cơ bản là các danh sách mà chúng ta có thể lưu trữ các giá trị.

Bạn tạo bảng có dấu ngoặc nhọn ```{}```:

```lua
function love.load()
    fruits = {}

end
```

Chúng ta vừa tạo một bảng có tên là ```fruits```. Bây giờ chúng ta có thể lưu trữ các giá trị bên trong bảng. Có nhiều cách để làm điều này.

Một cách là đặt các giá trị bên trong dấu ngoặc nhọn.

```lua
function love.load()
    -- Mỗi giá trị được phân tách bằng dấu phẩy, giống như với tham số và đối số
    fruits = {"apple", "banana"}
end
```

Chúng ta cũng có thể sử dụng hàm ```table.insert```. Đối số đầu tiên là bảng, đối số thứ hai là giá trị chúng ta muốn lưu trữ bên trong bảng đó.

```lua
function love.load()
    --Mỗi giá trị được phân tách bằng dấu phẩy, giống như với tham số và đối số
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")
end
```

Vì vậy, bây giờ sau ```love.load```, bảng của chúng ta sẽ chứa "apple", "banana" và "pear". Để chứng minh điều đó, hãy đưa các giá trị lên màn hình. Để làm được điều này chúng ta sẽ sử dụng ```love.graphics.print(text, x, y)```.

Ví dụ:

```lua
function love.load()
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")
end

function love.update(dt)

end

function love.draw()
    --Đối số: (text, x-position, y-position)
    love.graphics.print("Test", 100, 100)
end
```

Khi chạy trò chơi, bạn sẽ thấy dòng chữ "Test" được viết.

Chúng ta có thể truy cập các giá trị của bảng bằng cách viết tên bảng, theo sau là dấu ngoặc ([]) (không phải dấu ngoặc nhọn mà là dấu ngoặc vuông!). Bên trong các dấu ngoặc này, chúng ta viết vị trí của giá trị mà chúng ta muốn.

![](/images/2023/7/10/24-1698144732-table.png)

Như đã nói, bảng là danh sách các giá trị. Đầu tiên chúng ta thêm "apple" và "banana", vì vậy chúng nằm ở vị trí thứ nhất và thứ hai trong danh sách. Tiếp theo, chúng ta thêm "pear", vì vậy nó ở vị trí thứ ba trong danh sách. Ở vị trí 4 không có giá trị nào, vì chúng ta chỉ thêm 3 giá trị.

Vì vậy nếu muốn in "apple" thì chúng ta phải lấy giá trị đầu tiên của danh sách.

```lua
function love.draw()
    love.graphics.print(fruits[1], 100, 100)
end
```

Mã đầy đủ:

```lua
function love.load()
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")
end

function love.update(dt)

end

function love.draw()
    love.graphics.print(fruits[1], 100, 100)
end
```

Và bây giờ chạy, nó sẽ vẽ "apple". Nếu bạn thay thế ```[1]``` bằng ```[2]```, bạn sẽ nhận được "banana", và với ```[3]``` bạn nhận được "pear".

Bây giờ chúng ta muốn vẽ cả 3 loại quả. Chúng ta có thể sử dụng ```love.graphics.print``` 3 lần, mỗi lần có một mục nhập bảng khác nhau...

```lua
function love.draw()
    love.graphics.print(fruits[1], 100, 100)
    love.graphics.print(fruits[2], 100, 200)
    love.graphics.print(fruits[3], 100, 300)
end
```

...nhưng hãy tưởng tượng nếu chúng ta có 100 giá trị trong bảng của mình. May mắn thay, có một giải pháp cho vấn đề này: vòng lặp for!

### Vòng lặp for

Vòng lặp for là một cách lặp lại một đoạn mã trong một số lần nhất định.

Bạn tạo một vòng lặp for như thế này:

```lua
function love.load()
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")

for i=1,10 do
        print("hello", i)
    end
end
```

Nếu bạn chạy trò chơi, bạn sẽ thấy nó in ra hello 1, hello 2, hello 3, cho đến tận 10 ở trong bảng đầu ra ```console``` của bạn.

Để tạo vòng lặp for, đầu tiên bạn viết for. Tiếp theo bạn viết một biến và gán cho nó một giá trị số. Đây là nơi vòng lặp for bắt đầu. Biến có thể được đặt tên bất kỳ, nhưng nó thường được sử dụng i. Biến này chỉ có thể được sử dụng bên trong vòng lặp for (giống như với các hàm và tham số). Tiếp theo bạn viết số mà nó cần đếm. Vì vậy, ví dụ ```for i=6,18 do``` sẽ bắt đầu từ 6 và tiếp tục lặp lại cho đến 18.

Ngoài ra còn có một số thứ ba, tùy chọn. Đây là mức độ biến tăng. ```for i=6,18,4 do``` sẽ đi: 6, 10, 14, 18. Với điều này, bạn cũng có thể làm cho các vòng lặp for quay ngược lại với -1.

Bảng của chúng ta bắt đầu từ 1 và có 3 giá trị, vì vậy tôi sẽ viết:

```lua
function love.load()
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")

for i=1,3 do
        print(fruits[i])
    end
end
```

Khi chạy game bạn sẽ thấy nó in ra cả 3 loại quả trong  ```console``` của bạn. Trong vòng lặp đầu tiên nó in fruits[1], sau đó ở vòng lặp thứ hai fruits[2] và cuối cùng là ở vòng lặp thứ ba fruits[3].

### Chỉnh sửa bảng

Nhưng nếu chúng ta thêm hoặc bớt một giá trị khỏi bảng thì sao? Chúng ta sẽ phải đổi số ```3``` thành một số khác. Để làm được điều đó, chúng ta sử dụng ```#fruits```. Với dấu ```#```, chúng ta có thể lấy được độ dài của bảng. Độ dài của một bảng đề cập đến số lượng đồ vật trong bảng đó. Độ dài đó sẽ là ```3``` với trường hợp trên, vì chúng ta có 3 mục: ```apple```, ```banana``` và ```pear``` trong bảng ```fruits```.

```lua
function love.load()
    fruits = {"apple", "banana"}

print(#fruits)
    --Output: 2

table.insert(fruits, "pear")

print(#fruits)
    --Output: 3

for i=1,#fruits do
        print(fruits[i])
    end
end
```

Và giờ chúng ta vẽ cả 3 loại quả.

```lua
function love.draw()
    for i=1,#fruits do
        love.graphics.print(fruits[i], 100, 100)
    end
end
```

Mã đầy đủ:

```lua
function love.load()
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")
end

function love.update(dt)

end

function love.draw()
    for i=1,#fruits do
        love.graphics.print(fruits[i], 100, 100)
    end
end
```

Nếu bạn chạy trò chơi, bạn sẽ thấy trò chơi hiện cả 3 loại trái cây, ngoại trừ việc chúng đều được hiện (vẽ) ở cùng một vị trí. Chúng ta có thể khắc phục điều này bằng cách in mỗi loại ở một độ cao khác nhau.

```lua
function love.draw()
    for i=1,#fruits do
        love.graphics.print(fruits[i], 100, 100 + 50 * i)
    end
end
```

Và bây giờ "apple" sẽ được hiện ra ở vị trí y ```100 + 50 * 1```, tức là y = 150. Sau đó "banana" được hiện ra ở dưới y = 200 và "pear" ở dưới y = 250.

![](/images/2023/7/10/24-1698144732-fruits.png)

Nếu chúng ta thêm một loại trái cây khác, chúng ta sẽ không phải thay đổi gì cả. Nó sẽ tự động được hiện ra. Hãy thêm "pineapple".

```lua
function love.load()
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")
    table.insert(fruits, "pineapple")
end
```

Chúng ta cũng có thể xóa các giá trị khỏi bảng của mình. Để làm được điều đó, tôi sử dụng ```table.remove```. Đối số đầu tiên là bảng mà chúng ta muốn xóa nội dung nào đó, đối số thứ hai là vị trí chúng ta muốn xóa. Vậy nếu muốn loại bỏ chuối chúng ta làm như sau:

```lua
function love.load()
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")
    table.insert(fruits, "pineapple")
    table.remove(fruits, 2)
end
```

Khi chạy trò chơi, bạn sẽ thấy quả chuối không còn được hiện ra nữa mà quả lê và quả dứa đã di chuyển lên trên.

![](/images/2023/7/10/24-1698144732-shift.png)

Khi bạn xóa một giá trị khỏi bảng bằng ```table.remove```, tất cả các mục sau trong bảng sẽ di chuyển lên trên. Vì vậy, những gì ở vị trí 3 bây giờ ở vị trí 2 trong bảng. Và những gì ở vị trí 4 bây giờ ở vị trí 3.

Bạn cũng có thể thêm hoặc thay đổi trực tiếp các giá trị bên trong bảng. Ví dụ: chúng ta có thể đổi "apple" thành "tomato":

```lua
function love.load()
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")
    table.insert(fruits, "pineapple")
    table.remove(fruits, 2)
    --Giá trị của vị trí 1 trong bảng trở thành “tomato”
    fruits[1] = "tomato"
end
```

### Ipair

Quay lại vòng lặp for. Thực sự có một cách khác và một cách dễ dàng hơn để lặp qua bảng. Chúng ta có thể sử dụng ```ipairs``` để lặp.

```lua
function love.load()
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")
    table.insert(fruits, "pineapple")
    table.remove(fruits, 2)
    fruits[1] = "tomato"

for i,v in ipairs(fruits) do
        print(i, v)
    end
		
    --Output:
    --1, "tomato"
    --2, "pear"
    --3, "pineapple"
end
```

Vòng lặp for này xuyên qua tất cả các giá trị trong bảng. Các biến ```i``` cho ta biết vị trí của bảng, ```v``` là giá trị của vị trí đó trong bảng. Về cơ bản nó là một cách viết tắt của ```fruits[i]```. Ví dụ: trong lần lặp đầu tiên, giá trị của các biến ```i``` sẽ là 1 và ```v``` sẽ là "apple". Trong lần lặp thứ hai, ```i``` và ```v``` sẽ là 2 và "pear" tương ứng.

Nhưng làm thế nào nó hoạt động? Tại sao chức năng ```ipairs``` này cho phép điều này? Cái đó tôi sẽ giải thích sau. Hiện tại, tất cả những gì bạn cần biết về ```ipairs``` cơ bản là cách viết tắt của những điều sau:

```lua
for i=1, #fruits do
    v = fruits[i]
end
```

Và bây giờ, hãy sử dụng ipairs để vẽ bảng của chúng ta.

```lua
function love.draw()
    -- i và v là các biến nên chúng ta có thể đặt tên gì tùy thích
    for i,fruit in ipairs(fruits) do
        love.graphics.print(fruit, 100, 100 + 50 * i)
    end
end
```

Mã đầy đủ:

```lua
function love.load()
    fruits = {"apple", "banana"}
    table.insert(fruits, "pear")
    table.insert(fruits, "pineapple")
    table.remove(fruits, 2)
    fruits[1] = "tomato"
end

function love.update(dt)

end

function love.draw()
    for i,fruit in ipairs(fruits) do
        love.graphics.print(fruit, 100, 100 + 50 * i)
    end
end
```

### Bản tóm tắt

Bảng là danh sách mà chúng ta có thể lưu trữ các giá trị. Chúng ta thêm các giá trị này bằng ```table.insert```, hoặc thay đổi bằng ```table_name[1] = "some_value"```. Chúng ta có thể lấy chiều dài của bảng với ```#table_name```. Với vòng lặp for, chúng ta có thể lặp lại một đoạn mã nhiều lần. Chúng ta cũng có thể sử dụng vòng lặp for để lặp qua các bảng.

------

[Trước](/learn/detail?learnId=6) | [Mục lục](/learn/search?keyword=Lập%20trình%20games%20với%20Love2D) | [Kế tiếp](/learn/detail?learnId=8)

- Tổng hợp và hướng dẫn về System Admin,
Server, Cloud, Docker, Monitor.
- Hướng dẫn lập trình Backend, Website.
- Hướng dẫn lập trình App Android & IOS.
- Hướng dẫn lập trình Games.
- Học từ vựng và luyện kỷ năng ngoại ngữ.