下面是一种迭代方法，它使用给定集合中的索引组合。
从k个索引的初始组合开始，这些索引被原地移位/递增，以便获得长度为k的下一个组合，依此类推：

function * combinations(set, k) {
  const n = set.length;
  if (k > n)
    return;

  // Shift combi indexes to make it the next k-combination. Return true if
  // successful, false otherwise (when there is no next of that length).
  const next = (combi, i) => {
    if (++combi[i] < n)
      return true;
    let limit = n;
    while (i > 0) {
      if (++combi[--i] < --limit) {
        let idx = combi[i];
        while (++i < combi.length)
          combi[i] = ++idx;
        return true;
      }
    }
    return false;
  };

  const combi = Array.from(Array(k), (_, i) => i);
  const i = k-1;

  do yield combi.map(j => set[j]);
  while (next(combi, i));
}

这比人们想象的要高效得多，尤其是与总是从空组合开始而不考虑k的递归算法相比（函数next（）可能会被优化）。
一个更复杂的版本，它允许指定一个k值列表，以及是否允许重复，可以在这里找到（以及它上面的递归实现）。

结果证明我们可以避免使用递归。
我想到了Python中的itertools.combinations。
CPython是开源的，所以我们可以看到C. https://github.com/python/cpython/blob/main/Modules/itertoolsmodule.c中的源代码
您可以看到itertools_combinations_impl和combinations_next的函数定义。
不过，还有一些refCount和垃圾收集器的东西，它们可能与另一种语言无关。
我尝试在TypeScript中编写一个“combinationsobject”版本，并在其后添加了一些测试（TS playground），然后很容易从编译输出中获得JS：

"use strict";
//this class is based on https://github.com/python/cpython/blob/main/Modules/itertoolsmodule.c
class CombinationObject {
    constructor(list, r) {
        let n = list.length;
        this.pool = list;
        this.indices = [];
        for (let i = 0; i < r; i++)
            this.indices[i] = i;
        this.result = null;
        this.r = r;
        this.stopped = r > n;
    }
    next() {
        if (this.stopped)
            return null;
        let { pool, indices, r } = this;
        if (this.result === null) {
            //first pass 
            this.result = [];
            for (let i = 0; i < r; i++) {
                let index = indices[i];
                this.result[i] = pool[index];
            }
        }
        else {
            this.result = this.result.slice();
            let n = pool.length;
            let i; //needs to be used outside the for loop 
            /* Scan indices right-to-left until finding one that is not at its maximum (i + n - r). */
            for (i = r - 1; i >= 0 && indices[i] == i + n - r; i--) { }
            if (i < 0) {
                this.stopped = true;
                return null;
            }
            /* Increment the current index which we know is not at its maximum.
              Then move back to the right setting each index to its lowest possible value (one higher than the index to its left).
            */
            indices[i]++;
            for (let j = i + 1; j < r; j++) {
                indices[j] = indices[j - 1] + 1;
            }
            /* Update the result for the new indices starting with i, the leftmost index that changed */
            for (; i < r; i++) {
                let index = indices[i];
                this.result[i] = pool[index];
            }
        }
        return this.result;
    }
}
let list = ["One", 2, "Three", 4, 5, 'Six'];
let K = 3;
const LIMIT = 1000;
let co = new CombinationObject(list, K);
let count = 0;
while (!co.stopped && count < LIMIT) {
    let result = co.next();
    if (result === null)
        break;
    console.log(result);
    count++;
}
function factorial(n) {
    let t = 1;
    for (let i = 2; i <= n; i++)
        t *= i;
    return t;
}
function nCk(n, k) {
    if (k > n)
        return 0;
    return factorial(n) / factorial(n - k) / factorial(k);
}
console.log(nCk(list.length, K));
console.log(count);