生成一个函数，该函数接受数组中的组数，并将数组分成所需的组-javascript

我需要创建一个属性数组

say:

var数组=['dog'、'cat'、'lion'、'tiger'、'bear'、'human'、'snake']

并制作一个函数，将其划分为所需的多个组

例如，输入将是
函数arraygroup（array，3）

输出将是一个名为
group1
和
dog、cat、lion
的字符串

第2组
老虎、熊

第3组
人、蛇

如果我做了

函数数组组合器（数组，2）

它会回来的

  group 1   dog, cat, lion, tiger
  group 2   bear, human, snake

到目前为止，我有一个for循环可以在这个函数中工作，但我已经知道它不会以我想要的方式工作：

  var team1 = [];
   var team2 = [];
   var team3 = [];



    for(var i = 0; i < array.length; i++)
    {
       if([i] <= Math.floor((array.length)/3))
        team1.push(array[i]);
    if ([i] > Math.floor(((array.length)/3)) && [i] <= (array.length - 3))
      team2.push(array[i]);
    if([i] > (array.length - 3))
    team3.push(array[i]);

   }
   print(team1);
   print(team2); 
   print(team3);

var team1=[]；
var team2=[]；
var team3=[]；
对于（var i=0；i

另外，我不想在函数中使用
slice
或
splice
。
var main_数组=['cat'，'dog'，'apple'，'orange']；
var main_array = ['cat', 'dog', 'apple', 'orange'];

function grouper(arr_arg, group_num){
  var arr_length  = arr_arg.length;
  var new_group   = [];
  var groups      = [];
  var group0      = ['cat', 'dog'];
  var group1      = ['apple', 'orange'];
  var group_length;
  var i;
  var j;

  groups[0]       = group0;
  groups[1]       = group1;  
  group_length = groups[group_num].length;

  for(i = 0; i < arr_length; i += 1){
    for(j = 0; j < group_length; j += 1){
      if(arr_arg[i] === groups[group_num][j]){
        new_group.push(arr_arg[i]);
      }
    }
  }  
  return new_group;
}

console.log('Group 0 is: ' + grouper(main_array, 0));
console.log('Group 1 is: ' + grouper(main_array, 1));

函数组（arr\u arg，group\u num）{
var arr_length=arr_arg.length；
var new_group=[]；
var组=[]；
var group0=['cat'，'dog']；
var group1=['苹果'，'橙色']；
var组长度；
var i；
var j；
组[0]=组0；
组[1]=组1；
组长度=组[组数量].长度；
对于（i=0；i

给你

注意：您可以这样访问/保存组

var group = arrayGrouper(array,2);
var group1 = group['group1'];
var group2 = group['group2'];

这将返回您的组数组。（您可以在此处进行测试）

函数数组组合器（数组，n）
{
var maxlen=array.length/n；
var result=新数组（）；
对于（var i=0；i，此函数返回一个新数组，其中包含每个组的子数组：

function arrayGrouper(stack, slices) {
    var remainder = stack.length % slices,
        size = Math.ceil(stack.length / slices),
        result = [],
        i = 0,
        slice;
    while (result.length < slices) {
        result.push(slice = []);
        while (slice.length < size) {
            slice.push(stack[i++]);
        }
        if (result.length === remainder) size--;
    }
    return result;
}

如果需要字符串而不是数组，请使用
连接
：

这是一个现场演示：。
这样就可以了：

function arrayGrouper(array, n) {
    var length, group = 0;
    var perGroup = Math.floor(array.length / n);
    var remain = array.length - (perGroup * n);
    var results = new Array(n);
    for (var i = 0; i < array.length; i++) {
        (results[group] || (results[group] = [])).push(array[i]);
        length = results[group].length;
        if (length >= perGroup) {
            group++;
            if (remain && length < perGroup + 1) {
                remain--;
                group--;
            }
        }
    }

    // print results
    for (var i = 0; i < results.length; i++) {
        var str = 'group ' + (i + 1) + ' ' + results[i].join(', ');
        console.log(str);
    }
}

函数数组组合器（数组，n）{
变量长度，组=0；
var perGroup=数学地板（array.length/n）；
var remain=array.length-（每组*n）；
var结果=新数组（n）；
对于（var i=0；i=每组）{
组++；
如果（保持和长度<每组+1）{
保持--；
组--；
}
}
}
//打印结果
对于（var i=0；i

除了向
main_数组添加一个元素外，还必须定义组是什么，否则函数如何知道如何查找匹配项？您的代码依赖于数组中按顺序排列的组以及由长度定义的组。@Zllani Mine按任意顺序搜索匹配项。这两种方法都有效，仅取决于需要。它是akes sense！！那么我该如何编辑它，使最大的组只比其他组多1个元素？假设有4个组，每个组有2个元素，最小的组有1个元素？对于
ArrayGroup（数组，5）来说，这不符合预期
@levi我已经知道它的输出了，你能告诉我它应该输出什么吗？
[第一组：“狗，猫”，第二组：“狮子，老虎”，第三组：“熊”，第四组：“人”，第五组：“蛇”]
。根据OP的示例输出，他似乎希望组尽可能均匀，但我可能错了。下面是一个演示：。请注意，对组使用数组是无用的，因为您不使用索引。
ArrayGroup（数组，2）
返回一些空字符串我已经更新了答案并添加了演示：。现在它肯定可以工作了：D我认为结果比您标记为已接受的答案更接近您的要求；）有关详细信息，请参阅注释。
function arrayGrouper(array, n)
{
    var maxlen=array.length/n;
    var result=new Array();
    for(var i=0;i<n;i++) result[i]='';
    for(var i=0;i<array.length;i++)
        result[Math.floor(i/maxlen)]+=array[i].toString()+', ';
    for(var i=0;i<n;i++) result[i]=result[i].substring(0, result[i].length - 2);
    return result;
}

function arrayGrouper(stack, slices) {
    var remainder = stack.length % slices,
        size = Math.ceil(stack.length / slices),
        result = [],
        i = 0,
        slice;
    while (result.length < slices) {
        result.push(slice = []);
        while (slice.length < size) {
            slice.push(stack[i++]);
        }
        if (result.length === remainder) size--;
    }
    return result;
}

var groups = arrayGrouper(array, 2);
var team1 = groups[0]; // ["dog", "cat", "lion", "tiger"]
var team2 = groups[1]; // ["bear", "human", "snake"]

var groups = arrayGrouper(array, 2);
var team1 = groups[0].join(' '); // "dog cat lion tiger"
var team2 = groups[1].join(' '); // "bear human snake"

function arrayGrouper(array, n) {
    var length, group = 0;
    var perGroup = Math.floor(array.length / n);
    var remain = array.length - (perGroup * n);
    var results = new Array(n);
    for (var i = 0; i < array.length; i++) {
        (results[group] || (results[group] = [])).push(array[i]);
        length = results[group].length;
        if (length >= perGroup) {
            group++;
            if (remain && length < perGroup + 1) {
                remain--;
                group--;
            }
        }
    }

    // print results
    for (var i = 0; i < results.length; i++) {
        var str = 'group ' + (i + 1) + ' ' + results[i].join(', ');
        console.log(str);
    }
}