Vòng lặp for trong R: cú pháp, seq_along, break, next và khi nào không cần lặp

Vòng lặp for cơ bản

Vòng lặp (loop) for trong R chạy một khối lệnh một lần cho mỗi phần tử của một vector hoặc list. Biến lặp lần lượt nhận từng giá trị:

fruits <- c("apple", "banana", "cherry")

for (fruit in fruits) {
  print(fruit)
}

Ba phần tử, ba lượt lặp. Không cần khởi tạo bộ đếm, cũng không cần duy trì điều kiện: for (fruit in fruits) đọc là "với mỗi fruit trong fruits", và nó làm đúng như vậy. Cùng một dạng này lặp qua các phần tử của list, một dãy số (for (i in 1:10)), hoặc tên của bất cứ thứ gì qua names().

In bên trong vòng lặp cần print() hoặc cat()

Ở console, gõ x sẽ in ra giá trị của nó. Bên trong thân vòng lặp thì không: R chỉ tự động in ở cấp cao nhất, còn một biểu thức trơn trong vòng lặp được tính rồi bị bỏ đi:

for (n in 1:3) {
  n                       # evaluated, silently discarded
  cat("n is", n, "\n")    # this is what actually prints
}

Vì vậy khi một vòng lặp "chẳng làm gì cả", đây là điều đầu tiên cần kiểm tra. Dùng print() để xem nhanh một giá trị bất kỳ, hoặc cat() khi bạn tự ghép một dòng đầu ra (nhớ thêm "\n", vì cat() không tự xuống dòng).

Lặp theo chỉ số với seq_along()

Đôi khi bạn cần cả vị trí lẫn giá trị: để ghi vào một vector khác ở cùng chỉ số, hoặc để in một danh sách có đánh số. Lặp qua các chỉ số bằng seq_along():

prices <- c(9.99, 4.50, 12.00)

for (i in seq_along(prices)) {
  cat("Item", i, "costs", prices[i], "\n")
}

Trong code cũ bạn sẽ gặp for (i in 1:length(prices)), và cách viết này ẩn chứa một bug thật sự. Khi vector rỗng, length() bằng 0, mà 1:0 không có nghĩa là "không lặp lần nào": dấu hai chấm đếm lùi:

empty <- numeric(0)

print(1:length(empty))   # 1 0  - two iterations against nothing!
print(seq_along(empty))  # integer(0) - zero iterations, as it should be

Vòng lặp qua 1:length(empty) chạy hai lần, truy cập những phần tử không tồn tại (empty[1] là NA, còn phép gán thì tạo ra các phần tử ma). seq_along() trả về dãy rỗng cho vector rỗng, nên thân vòng lặp đơn giản là không bao giờ chạy. Hãy tập thói quen dùng seq_along(); hàm anh em seq_len(n) làm cùng việc khi bạn có một con số đếm thay vì một vector.

Gom kết quả: cấp phát trước, đừng nối dần

Phản xạ tự nhiên đầu tiên khi gom kết quả trông như sau:

squares <- c()
for (i in 1:10000) {
  squares <- c(squares, i^2)   # copies the ENTIRE vector every pass
}

Cách này chạy được, nhưng mỗi lần c(squares, ...) lại cấp phát một vector hoàn toàn mới và sao chép mọi phần tử cũ vào đó. Đến cuối, bạn đã sao chép khoảng 50 triệu con số chỉ để tạo ra 10.000 con số. Anti-pattern vector lớn dần này là lý do lớn nhất khiến người ta bảo vòng lặp R chậm.

Cách sửa: tạo kết quả với đủ kích thước ngay từ đầu, rồi gán theo chỉ số:

n <- 5
squares <- numeric(n)          # c(0, 0, 0, 0, 0), allocated once

for (i in seq_len(n)) {
  squares[i] <- i^2
}

print(squares)

Với kết quả không phải số, cùng ý tưởng áp dụng với character(n), logical(n), hoặc vector("list", n) cho một list chứa đủ loại thứ. Vòng lặp được cấp phát trước chạy rất nhanh.

next và break

Hai từ khóa điều khiển vòng lặp từ bên trong thân của nó: next bỏ dở lượt hiện tại và nhảy sang phần tử kế tiếp; break thoát hẳn khỏi vòng lặp.

for (n in 1:10) {
  if (n %% 2 != 0) next   # skip odd numbers
  if (n > 8) break        # stop once past 8
  print(n)
}

Đoạn này in ra 2 4 6 8: các số lẻ bị next bỏ qua, và khi đến 10, break kết thúc vòng lặp trước khi in. Dùng next để loại sớm các trường hợp (giúp thân chính không bị thụt lề thêm), và break khi vòng lặp đã tìm thấy thứ nó cần và không còn lý do để chạy tiếp.

Vòng lặp lồng nhau

Thân vòng lặp có thể chứa một vòng lặp khác. Vòng lặp trong chạy trọn vẹn cho mỗi lượt của vòng lặp ngoài; ví dụ kinh điển là bảng cửu chương:

for (i in 1:3) {
  for (j in 1:3) {
    cat(sprintf("%2d ", i * j))
  }
  cat("\n")
}

Với mỗi hàng i, vòng lặp trong đi qua mọi cột j, và ký tự xuống dòng của hàng được in sau khi vòng lặp trong kết thúc. Lồng hai cấp thì ổn; từ ba cấp trở lên, thân vòng lặp thường đang muốn được tách thành một hàm, hoặc cả phép tính đang muốn trở thành outer() hay một phép toán ma trận.

Lồng nhau cũng dùng để lặp qua một list các vector: vòng ngoài lặp qua list, vòng trong (hoặc tốt hơn, một lệnh gọi vector hóa) xử lý từng phần tử:

results <- list(alice = c(80, 91), bob = c(72, 65, 88))

for (name in names(results)) {
  cat(name, "average:", mean(results[[name]]), "\n")
}

Để ý rằng rốt cuộc không cần vòng lặp trong: mean() xử lý cả vector bên trong chỉ bằng một lệnh gọi. Nhận xét này áp dụng rộng hơn nhiều, và nó đưa ta đến phần thẳng thắn nhất.

Khi nào không nên dùng vòng lặp

R là ngôn ngữ vector hóa: các phép toán cơ bản của nó vốn đã làm việc trên cả vector cùng lúc. Một vòng lặp biến đổi từng phần tử một thường chỉ là cách viết dài hơn cho một dòng code:

prices <- c(100, 250, 40)

# The loop version
taxed <- numeric(length(prices))
for (i in seq_along(prices)) {
  taxed[i] <- prices[i] * 1.2
}
print(taxed)

# The vectorized version - same result
print(prices * 1.2)

Hãy ưu tiên dạng vector hóa mỗi khi có: ngắn hơn, khó sai hơn và nhanh hơn. Để áp dụng một hàm lên mọi phần tử của list, họ apply (sapply, lapply, vapply) đóng vai trò tương tự.

Nhưng đừng máy móc biến điều này thành "vòng lặp là xấu". Vòng lặp là công cụ đúng khi các lượt lặp phụ thuộc vào lượt trước (trạng thái tích lũy, mô phỏng), khi bạn tạo hiệu ứng phụ như ghi tệp, hoặc đơn giản khi vòng lặp là phiên bản mà bạn và người đọc hiểu ngay khi nhìn vào. Một vòng lặp rõ ràng tốt hơn một dòng code khéo léo mà không ai đọc nổi.

Những điều cần nhớ

• for (x in v) { ... } chạy thân vòng lặp một lần cho mỗi phần tử, không cần quản lý bộ đếm.
• Bên trong vòng lặp, in rõ ràng bằng print() hoặc cat(); biểu thức trơn sẽ bị bỏ đi.
• Lặp theo vị trí bằng seq_along(v), đừng bao giờ dùng 1:length(v): cách sau chạy hai lần trên vector rỗng.
• Cấp phát trước kết quả bằng numeric(n) / vector("list", n) rồi gán theo chỉ số; nối dần bằng c() sẽ sao chép mọi thứ ở mỗi lượt.
• next bỏ qua một lượt, break thoát vòng lặp; ưu tiên phép toán vector hóa khi có, nhưng đừng ngại một vòng lặp dễ đọc.

Tiếp theo: những vòng lặp chạy cho đến khi có điều gì đó xảy ra thay vì một lần cho mỗi phần tử, tức while và repeat.