R语言中如何针对变量名与函数正确编写遍历1:100的循环

Hey there! Let's get your command working across all values from 1 to 100. Since you didn't share your exact working single-value command, I'll use a generic example (some_function(x) where x is your input) to walk through the most common, reliable approaches—you can swap this out with your actual code.

1. Basic for Loop (Most Intuitive) #

If you prefer a straightforward, easy-to-debug approach, a for loop is perfect. It’s great for keeping track of progress or handling side effects (like saving files):

# First, initialize a storage object (list works for any output type; use a vector if your result is scalar)
results <- vector("list", length = 100)

# Loop through each value from 1 to 100
for (i in 1:100) {
  # Replace this line with your actual working command, using `i` instead of your single value
  results[[i]] <- some_function(i)
  
  # Optional: Print progress every 10 iterations to stay updated
  if (i %% 10 == 0) {
    cat("Completed iteration", i, "\n")
  }
}

# If your output is a single number/string, convert the list to a vector:
results_vector <- unlist(results)
# Or initialize a vector from the start for scalar outputs:
results_vector <- numeric(100)
for (i in 1:100) {
  results_vector[i] <- some_function(i)
}

2. Functional Programming with lapply (R-Friendly) #

R favors functional approaches, and lapply is a clean way to avoid explicit loops. It returns a list of results by default:

# Use lapply to apply your function to each value in 1:100
results_list <- lapply(1:100, function(x) {
  # Your command here—`x` represents the current value from 1 to 100
  some_function(x)
})

# For a vector output, use `sapply` (simplifies the list to a vector if possible)
results_vector <- sapply(1:100, function(x) some_function(x))

# Or `vapply` (safer, since you specify the expected output type upfront)
results_vector <- vapply(1:100, function(x) some_function(x), numeric(1))

3. Tidyverse Approach with purrr::map #

If you use the tidyverse ecosystem, purrr::map functions are a more readable alternative to lapply:

library(purrr)

# `map` returns a list; use type-specific variants for vectors
results_list <- map(1:100, ~ some_function(.x))  # `.x` is the current input value
results_double_vector <- map_dbl(1:100, ~ some_function(.x))  # For numeric outputs
results_int_vector <- map_int(1:100, ~ some_function(.x))      # For integer outputs

Quick Tips #

• Avoid overwriting variables inside loops: Always store results in a pre-allocated object (like the list/vector we initialized) instead of creating new variables each time—it’s way faster.
• Debugging: If your loop fails, test your single-value command with a few values (e.g., 5, 10) first to make sure it works before scaling to 100.
• Side effects: If your command writes files or modifies external data, make sure each iteration uses a unique identifier (like i in the loop) to avoid overwriting files.

内容的提问来源于stack exchange，提问作者romaug