咨询：是否存在可接收语句作为参数的等效函数？代码复用需求

Hey there! Great question—this is exactly where callback functions (or higher-order functions) shine, since they let you pass reusable chunks of code as arguments to a generic loop wrapper. No more copy-pasting that nested loop structure 5 times!

核心思路 #

Instead of duplicating the entire loop block, you’ll wrap the repeated loop logic into a single function that accepts another function (your custom code) as a parameter. That custom function gets executed exactly where your //new lines here comment was.

示例实现（以JavaScript为例） #

First, create a reusable wrapper function for your loop structure:

function runNestedLoops(initialDay, initialSize, customCode) {
  let loop_day = 0; // Adjust initial value to match your actual use case
  while (loop_day < (initialDay + 1)) {
    let loop_size = 0; // Same here—tweak if your starting value differs
    let size = initialSize; // Isolate the size variable to avoid unintended side effects
    while (loop_size < (size + 1)) {
      customCode(size); // Pass current size to your custom code if needed
      size += 1;
    }
    loop_day += 1;
  }
}

Then, reuse it 5 times with different custom logic:

// 1. First use case: Log the current size
runNestedLoops(5, 2, (currentSize) => {
  console.log(`Current size is: ${currentSize}`);
});

// 2. Second use case: Accumulate a total value
let total = 0;
runNestedLoops(3, 1, (currentSize) => {
  total += currentSize;
});
console.log(`Total accumulated: ${total}`);

// 3. Third use case: Update an array
const sizeHistory = [];
runNestedLoops(4, 0, (currentSize) => {
  sizeHistory.push(currentSize);
});
console.log(`Size history: ${sizeHistory}`);

其他语言的类似实现 #

If you’re using a statically typed language like Java, you can use functional interfaces like Consumer:

import java.util.function.Consumer;

public class LoopWrapper {
    public static void runNestedLoops(int initialDay, int initialSize, Consumer<Integer> customCode) {
        int loopDay = 0;
        while (loopDay < (initialDay + 1)) {
            int loopSize = 0;
            int size = initialSize;
            while (loopSize < (size + 1)) {
                customCode.accept(size);
                size++;
            }
            loopDay++;
        }
    }

    // Usage example
    public static void main(String[] args) {
        // Log size
        runNestedLoops(5, 2, size -> System.out.println("Current size: " + size));
        
        // Accumulate total
        int[] total = {0}; // Use array to bypass final variable restriction
        runNestedLoops(3, 1, size -> total[0] += size);
        System.out.println("Total: " + total[0]);
    }
}

为什么这方案可行 #

• 遵循DRY原则：你的循环结构只写一次——如果以后需要调整循环条件（比如把day+1改成day），只需要修改一处即可。
• 逻辑分离清晰：自定义业务逻辑和循环框架解耦，代码更易读、易维护。
• 匹配你的搜索需求：你找的“可接收语句作为参数的函数”本质就是接收回调的高阶函数，这是几乎所有现代编程语言都支持的标准模式。

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