第六题：实现一个 chunk 函数 #8

KieSun · 2021-03-14T23:33:03Z

/**
 * @param input
 * @param size
 * @returns {Array}
 */
_.chunk(['a', 'b', 'c', 'd'], 2)
// => [['a', 'b'], ['c', 'd']]

_.chunk(['a', 'b', 'c', 'd'], 3)
// => [['a', 'b', 'c'], ['d']]

_.chunk(['a', 'b', 'c', 'd'], 5)
// => [['a', 'b', 'c', 'd']]

_.chunk(['a', 'b', 'c', 'd'], 0)
// => []

去答题

新建了一个大厂真题每日打卡群，有意愿学习打卡的再进，群已达扫码上线，请加好友拉你进群。

yancongwen · 2021-03-15T00:53:47Z

function chunk(input, size) {
    size = Math.max(toInteger(size), 0)
    if (!Array.isArray(input)) {
        return []
    }
    if (size < 1) {
        return []
    }
    const n = input.length
    const result = []
    let start = 0
    while (start < n) {
        result.push(input.slice(start, start + size))
        start += size
    }
    return result
}

可以参考lodash源码

QuXiaoMing · 2021-03-15T00:59:13Z

const chunk = (arr, len) => arr.reduce((pre, cur, index) => {
  if (index % len === 0) {
    pre.push([cur])
    return pre
  }
  const temp = pre[pre.length - 1]
  temp && temp.push(cur)
  return pre
}, [])

XianHuiDeDiZhongHai · 2021-03-15T01:06:13Z

function chunk(arr, len) {
  if (len === 0) return []
  return arr.reduce((prev, item, index) => {
    const value = Math.floor(index / len),
      remainder = index % len
    remainder === 0 ? prev.push([item]) : prev[value].push(item)
    return prev
  }, [])
}

goldEli · 2021-03-15T01:13:22Z

const _ = {};

_.chunk = function (arr, num) {
  const res = [];
  return step(res, arr, 0, num);
};

function step(res, arr, index, num) {
  const len = arr.length;
  if (index >= len || num <= 0) return res;
  const chunk = [];
  for (let i = index; i < index + num; ++i) {
    arr[i] && chunk.push(arr[i]);
  }
  res.push(chunk);
  // console.log(res);
  return step(res, arr, index + num, num);
}

secret344 · 2021-03-15T01:32:36Z

function chunk(arr = [], size) {
    let result = [];
    if (size === 0) return result;
    let len = arr.length;
    if (size >= len) return arr;
    if (size > Math.ceil(len / 2)) return [arr.slice(0, size), arr.slice(size)];
    for (let i = 0; i < len; i++) {
        let index = i + size - 1;
        if (index >= len) {
            result.push(arr.slice(i));
            break;
        } else {
            result.push(arr.slice(i, index + 1));
        }
        i = index;
    }
    return result;
}

ctime-zliang · 2021-03-15T01:37:04Z

const chunk = (array, size) => {
const res = []
Array.from({ length: Math.ceil(array.length / size) }, (value, index) => {
res.push(array.slice(+value * size, (index + 1) * size))
})
return res
}

XINXINP · 2021-03-15T01:40:51Z

//_.chunk(array, size)
//根据size参数将数组分组，size是每一组的长度。如果数组不能均分，最后一组就会包含剩下的元素。
let _ = {}
_.chunk  = function (arr,size) {
if(arr.length == 0||!size) return[]
if(arr.length<= size) return arr
let result = []
while (arr.length){
    result.push(arr.splice(0,size))
}
return result
}

GeekNoble · 2021-03-15T01:57:14Z

`
function chunk(arr, n) {

  let i = 0, result = []
  if (n == 0 || arr.length == 0) {
    return []
  }

  while(i < arr.length) {
    let chunks = []
    for (let j = 0; j < n && i < arr.length; j++) {
      chunks.push(arr[i])
      i++
    }
    result.push(chunks)
  }

  return result
}

`

teefing · 2021-03-15T02:12:06Z

const chunk = (arr, chunkSize) =>
  arr.reduce((acc, cur, index) => {
    index % chunkSize === 0 ? acc.push([cur]) : acc[acc.length - 1].push(cur);
    return acc;
  }, []);

SunshineZJJ · 2021-03-15T02:24:32Z

let _={};
			_.chunk=function(arr,length){
				let result=[];
				let num=Math.ceil(arr.length/length);
				let index=0;
				for(let i=0;i<num;i++){
					console.log(index,num,arr,length,arr.slice(index,index+length))
					result.push(arr.slice(index,index+length));	
					index=index+length;
				}
				return result
			}

Ecaknight · 2021-03-15T02:27:12Z

function chunk (arr, size) {
    if (!size) return arr
    const len = Math.ceil(arr.length / size)
    const ret = []
    let first = 0
    let end = size
    for (let i = 0; i < len; i++) {
      const temp = arr.slice(first, end)
      first = size
      end = first + size + 1
      ret.push(temp)
    }
    return ret
  }

mengzhe510 · 2021-03-15T02:30:09Z

const _ = {
chunk: function (input, size) {
let arrs = []
if (!Array.isArray(input) || size < 1 || input.length === 0) {
return arrs
}
for (let i = 0; i < input.length; i = i + size){
arrs.push(input.slice(i, i + size))
}
return arrs
}
}

learnRy · 2021-03-15T02:34:31Z

function chunk(array, size) {
  if(size === 0) {
    return []
  }
  if(size >= array.length) {
    return [array.slice()]
  }
  const arr = []
  const num = array.length / size
  for(let i = 0; i < num; i++) {
    arr.push(array.slice(i*size, (i + 1)*size))
  }
  return arr
}

monadaa · 2021-03-15T02:46:06Z

// 第六题：实现一个 chunk 函数
/**
 * @param input
 * @param size
 * @returns {Array}
 */
// _.chunk(['a', 'b', 'c', 'd'], 2)
// => [['a', 'b'], ['c', 'd']]
// _.chunk(['a', 'b', 'c', 'd'], 3)
// => [['a', 'b', 'c'], ['d']]
// _.chunk(['a', 'b', 'c', 'd'], 5)
// => [['a', 'b', 'c', 'd']]
// _.chunk(['a', 'b', 'c', 'd'], 0)
// => []
function chunk(arr, size){
    // 首先是数组array是否合法的判断:
    let length = arr === null ? 0 : arr.length;
    if(!length) return [];
    //排除
    if(size < 1) return [];
    // 
    const result = [];
    let start = 0;
    while (start < length) {
        result.push(arr.slice(start, start + size));
        start += size;
    }
    return result;
}

l0ng09 · 2021-03-15T02:47:52Z

function chunk(arr, num) {
  if (num === 0) return [];
  if (Array.isArray(arr) && typeof num === "number") {
    let result = [];
    let i = 0;
    while (i < arr.length) {
      result.push(arr.slice(i, i + num));
      i += num;
    }
    return result;
  } else {
    console.log("params type error");
  }
}

Xchen1995 · 2021-03-15T03:16:19Z

function chunk(arr, number) {
  if (number < 0 || arr.length === 0) {
    return arr;
  }
  const total = arr.length / number;
  const newArr = [];
  for (let i = 0; i < total; i++) {
    console.log(arr.slice(i * number, (i + 1) * number))
    newArr.push(arr.slice(i * number, (i + 1) * number));
  }
  return newArr
}

weiChow · 2021-03-15T03:28:25Z

const chunk = (array: any[], size = 1) => {
    size = Math.max(size, 0);

    if (!array.length || size <= 0) {
      return [];
    }

    let _chunkArray: any[][] = [];
    let _chunkIndex = 0;

    while(_chunkIndex < Math.ceil(array.length / size)) {
      _chunkArray[_chunkIndex] = array.slice(_chunkIndex * size, (++_chunkIndex) * size);
    }

    return _chunkArray;
  }

abu-ab · 2021-03-15T03:34:27Z

      function chunk(array, size) {
        if (size == 0) {
          return [];
        }
        let flag = -1;
        let arr = [];
        for (let i = 0; i < array.length; i++) {
          if (i % size == 0) {
            arr[++flag] = [];
          }
          arr[flag].push(array[i]);
        }
        return arr;
      }

      console.log(chunk(["a", "b", "c", "d"], 2));
      console.log(chunk(["a", "b", "c", "d"], 3));
      console.log(chunk(["a", "b", "c", "d"], 5));
      console.log(chunk(["a", "b", "c", "d"], 0));

huahua5525 · 2021-03-15T03:41:10Z

function chunk (arr, size){
  if (!Array.isArray(arr) || !size) return []
  if (size >= arr.length) return arr
  let result = []
  let i = 0
  while (i < arr.length) {
    result.push(arr.slice(i, i + size));
    i += size;
  }
  return result;
}

HydratedPig · 2021-03-15T03:44:35Z

function chunk(arr, length) {
  if (length <= 0) return [];
  const res = arr.reduce((prev, a) => {
    const l = prev.length;
    if (l === 0 || prev[l - 1].length === length) {
      prev.push([a]);
    } else {
      prev[l - 1].push(a);
    }
    return prev;
  }, []);
  return res;
}

AbigaiL533 · 2021-03-15T03:49:49Z

function _chunk(input, size = 1) {
  if (!Array.isArray(input)) return;
  if (input.length === 0 || size < 1) return [];
  const newLength = Math.ceil(input.length / size);
  const result = new Array(newLength);
  for (let i = 0; i < newLength; i++) {
    result[i] = input.slice(size * i, size * (i + 1));
  }
  return result;
}

ghost · 2021-03-15T05:47:05Z

预先解释一下，chunk 函数输入两个值，第一个：待分块的数组，第二个：每块的长度。该函数将数组按照长度分块，如果剩余的元素数量不足一块，则按照一块处理。

我是百度了之后才了解这个函数的……题目中给的例子需要加一个：

_.chunk([1,2,3,4,5],2)
=>[[1,2],[3,4],[5]]

这样就完整了

看评论区都是直接上来就给答案，我确实很佩服……

lp-lupe · 2021-03-15T06:02:49Z

chunk(input,size){
      let array = []
        if (size<=0||!input){
          console.log(array)
          return array
        }else if(input.length<=size){
          array = [input]
          console.log(array)
          return array
        }else{
          for (const i of input){
           array.push(input.splice(0,size))
          }
      }
      if(input.length!=0){
        array.push(input)
      }
        console.log(array)
        return array
    }

vandvassily · 2021-03-15T06:09:36Z

let _ = {
    chunk: function (arr, size) {
        if (size === 0) {
            return [];
        }
        const nums = Math.ceil(arr.length / size);
        const res = [];
        for (let i = 0; i <= nums - 1; i++) {
            res.push(arr.slice(i * size, (i + 1) * size));
        }
        return res;
    }
};

/**
 * @param input
 * @param size
 * @returns {Array}
 */
console.log(_.chunk(['a', 'b', 'c', 'd'], 2));
// => [['a', 'b'], ['c', 'd']]

console.log(_.chunk(['a', 'b', 'c', 'd'], 3));
// => [['a', 'b', 'c'], ['d']]

console.log(_.chunk(['a', 'b', 'c', 'd'], 5));
// => [['a', 'b', 'c', 'd']]

console.log(_.chunk(['a', 'b', 'c', 'd'], 0));
// => []

1742284240 · 2021-03-15T06:22:19Z

function chunk(input, size) {
  if (size == 0) {
    return [];
  }
  let newArr = [];
  let n = Math.ceil(input.length / size);
  for (let i = 0; i < n; i++) {
    newArr.push(input.slice(size * i, size * (i+1)));
  }
  return newArr;
}

测试结果

console.log(chunk(["a", "b", "c", "d"], 0));
console.log(chunk(["a", "b", "c", "d"], 1));
console.log(chunk(["a", "b", "c", "d"], 2));
console.log(chunk(["a", "b", "c", "d"], 3));
console.log(chunk(["a", "b", "c", "d"], 4));
console.log(chunk(["a", "b", "c", "d"], 5));

startfromscratch · 2021-03-15T06:53:05Z

第一个参数是数组第二参数分成几份
利用第二个参数跟第一数组的长度做一下向上取整，
循环的时候push到[]中顺便删除掉推进去的数组但保持其原有的下标。

function chunk(arr, num){
if(num < 1 || arr.length < 1){ return []}
let nums = Math.ceil(arr.length / num)
let datas = []
for(let i = 0; i<nums; i++){
datas.push(arr.slice(num * i, num * (i + 1)))
}
return datas
}

adam-zhou · 2021-03-15T06:54:34Z

let myChunk = function(input, size) {
     if (!Array.isArray(input)) return;
     let result = [];
     if (size === 0) return [];
     if (size < input.length)  {
        result.push(input.slice(0, size),  input.slice(size))
     } else {
        result.push(input.slice(0, size))
     }
     return result;
}

lucas270 · 2021-03-15T07:08:56Z

}
console.log(chunk(a,3));

Leexuetao · 2021-03-15T14:26:51Z

const _ = {
chunk: function(arr, target) {
if (target === 0) {return []}
let result = []
let i = 0, len = arr.length
while(i<len) {
result.push(arr.slice(i, i+target))
i += target
}
return result
}
}

chen870370470 · 2021-03-15T14:44:21Z

// chunk函数根据size参数将第一个array数组参数分组，剩下的如果不足则size个数也会被分成一组
// size如果为0则返回空数组
let _ = {}
_.chunk  = function (arr,size=0) {
if(!(arr instanceof Array)) return console.log('请传入一个数组!')
if(arr.length === 0) return[]
if(arr.length<= size) return arr
let result = []
while (arr.length){
    result.push(arr.splice(0,size))
}
return result
}

panalanjun · 2021-03-15T14:45:52Z

var _ = {
	chunk: (arr, size) =>{
		if (size === 0) {
			return [];
		}
		var filter = arr.filter((item, index) =>{
				return index < size
			});
		return size >= arr.length 
		?	[filter] 
		: 	[filter, arr.slice(size, arr.length)]
	}
}

console.log(_.chunk(['a', 'b', 'c', 'd'], 2));
console.log(_.chunk(['a', 'b', 'c', 'd'], 3));
console.log(_.chunk(['a', 'b', 'c', 'd'], 5));
console.log(_.chunk(['a', 'b', 'c', 'd'], 0));

owlsignl · 2021-03-15T14:58:03Z

function chunk(arr,num){
            if(!Array.isArray(arr)){
                throw new Error("请传入数组");
            }
            const len = arr.length;
            if(num <= 0){
                return []
            }
            const r1 = arr.slice(0,num)
            const r2 = arr.slice(num,len);
            return r2.length > 0 ? [r1,r2] : [r1]
        }

ahaghosthao · 2021-03-15T15:32:55Z

function chunk(nums, count) {
    if (Array.isArray(nums) && nums.length > 0) {
        if (count === 0) return [];

        let result = [], start = 0;
        while (nums.length > start) {
            result.push(nums.slice(start, (start += count)));
        }
        return result;
    } else {
        return false;
    }
}

xt1995726 · 2021-03-15T15:36:35Z

function chunk(arr, size) {
  if (arr.length === 0 || size === 0) {
    return [];
  }
  let resArr = [];
  arr.forEach((item, index) => index % size === 0 ? resArr.push([item]) : resArr[resArr.length - 1].push(item));
  return resArr;
}

cduyzh · 2021-03-16T02:59:36Z

splice能改变原数组利用这个特性去实现的

// 单独实现方法 一行代码
function chunk(array, num) {
  return num > 0
    ? Array.from(new Array(Math.ceil(array.length / num))).map(() =>
        array.splice(0, num)
      )
    : [];
}

chunk([1, 2, 3, 4, 5], 2);

// 符合题的示例解法
class LodashFn {
  constructor() {}
  chunk(array, num) {
    return num > 0
      ? Array.from(new Array(Math.ceil(array.length / num))).map(() =>
          array.splice(0, num)
        )
      : [];
  }
}

const _ = new LodashFn();

_.chunk(["a", "b", "c", "d"], 2);
// => [['a', 'b'], ['c', 'd']]

_.chunk(["a", "b", "c", "d"], 3);
// => [['a', 'b', 'c'], ['d']]

_.chunk(["a", "b", "c", "d"], 5);
// => [['a', 'b', 'c', 'd']]

_.chunk(["a", "b", "c", "d"], 0);
// => []

liyanangrace · 2021-03-16T03:26:08Z

chunk 函数接受两个参数：

第一个：待分块的数组；
第二个：每块的长度。
该函数将数组按照长度分块，如果剩余的元素数量不足一块，则按照一块处理。

我的思路使用splice 删除每次返回的的项目数组添加进结果数组，（splice 会改变原数组），while进行判断只要arr具有长度，就不断将要删除的元素数组push到结果中。

      let _ = {};
      _.chunk = function (arr, size) {
        if (!Array.isArray(arr)) {
          return [];
        }
        if (size === 0) {
          return [];
        }
        let result = [];
        while (arr.length) {
          result.push(arr.splice(0, size));
        }
        return result;
      };
      console.log(_.chunk(["a", "b", "c", "d"], 2));
      console.log(_.chunk(["a", "b", "c", "d"], 3));
      console.log(_.chunk(["a", "b", "c", "d"], 5));
      console.log(_.chunk(["a", "b", "c", "d"], 0));
      console.log(_.chunk(["a", "b", "c", "d", "e"], 2));

另外上面最后一个console 加一个测试用例

TMBeliever · 2021-03-16T05:08:06Z

function _chunk(arr, size) {
  if (!Array.isArray(arr)) return
  if (!size) return []
  if (arr.length <= size) return arr
  let result = []
  let chunkArr = []
  for (let i = 0; i < arr.length; i++) {
    if (i !== 0 && !(i % size))  {
      result.push(chunkArr)
      chunkArr  = []
    }
    chunkArr.push(arr[i])
    if  (i === arr.length - 1) {
      result.push(chunkArr)
      return result
    }
  }
  return result
}

pengpeng9413 · 2021-03-16T06:05:04Z

function fn(){
  
  // 感觉像纯考数学题，考察处理边界问题
  this.chunk=function(array,number){
    let newArray=[];
    if(number===0){
      return newArray;
    }
    array.forEach((item,index)=>{
      if(!array[index*number]) return
      newArray.push(array.slice(index*number,(index+1)*number))
    })
    console.log(newArray)
    return newArray
  }
  
}


const demoFn=new fn()
demoFn.chunk(['a', 'b', 'c', 'd'], 4)

pengpeng9413 · 2021-03-16T06:06:29Z

chunk 函数接受两个参数：

第一个：待分块的数组；

第二个：每块的长度。
该函数将数组按照长度分块，如果剩余的元素数量不足一块，则按照一块处理。

我的思路使用splice 删除每次返回的的项目数组添加进结果数组，（splice 会改变原数组），while进行判断只要arr具有长度，就不断将要删除的元素数组push到结果中。
  let _ = {};
  _.chunk = function (arr, size) {
    if (!Array.isArray(arr)) {
      return [];
    }
    if (size === 0) {
      return [];
    }
    let result = [];
    while (arr.length) {
      result.push(arr.splice(0, size));
    }
    return result;
  };
  console.log(_.chunk(["a", "b", "c", "d"], 2));
  console.log(_.chunk(["a", "b", "c", "d"], 3));
  console.log(_.chunk(["a", "b", "c", "d"], 5));
  console.log(_.chunk(["a", "b", "c", "d"], 0));
  console.log(_.chunk(["a", "b", "c", "d", "e"], 2));
另外上面最后一个console 加一个测试用例

那你个改变原数组了

zhangyingcai · 2021-03-16T08:20:03Z

 const chunk = (input, size)=>{
     if(!input || !Array.isArray(input) || size<=0)
     return [];
    //  if(size > input.length) return input;
    const result = [];
    let childArr = [];
    input.forEach((item,index)=>{
        if((index + 1)%size === 1){
            childArr = []
        }
        childArr.push(item)
        if((index + 1)%size === 0 || index===input.length-1){
            result.push(childArr)
        }
    })
    
    return result
 }

 const chunk1 = (input, size)=>{
    if(!input || !Array.isArray(input) || size<=0)
    return [];
    const result = [];
    let start = 0;
    while(start<input.length){
        result.push(input.slice(start, start+size));
        start += size
    }
    console.log(result)
    return result;
 }

huangzhuangjia · 2021-03-16T08:22:46Z

function chunk(arr, count) {
  if (!Array.isArray(arr)) {
    console.error(`${arr} must be array`);
    return;
  }
  if (typeof count !== 'number') {
    console.error(`${count} must be number`);
    return;
  }
  if (count === 0) {
    return [];
  }
  const len = arr.length;
  const result = [];
  for(let i = 0; i < Math.ceil(len / count); i++) {
    result.push(arr.splice(0, count))
  }
  return result;
}

zhangyingcai · 2021-03-16T08:25:39Z

不修改原数组 splice
const chunk2 = (input, size)=>{
    if(!input || !Array.isArray(input) || size<=0)
    return [];
    const result = [];
    let start = 0;
    const orginArr = [...input];
    while(orginArr.length){
        result.push(orginArr.splice(0, size));
    }
    console.log(result)
    return result;
 }

wengsj11 · 2021-03-16T15:05:15Z

const chunk = (arr, chunkSize) => arr.reduce((pre, cur, index) => index % chunkSize === 0 ?
[...pre, [cur]] : [...pre.slice(0, pre.length - 1), [...pre[pre.length - 1], cur] ], [])

mingyuesun · 2021-03-16T15:44:39Z

const chunk = (array, size) => {
    if (!array || !Array.isArray(array) || size < 1) return []
    return array.reduce((prev, curr, index) => {
        if (index % size === 0) {
	    prev.push([curr])
		return prev
	}
       const temporary = prev[prev.length - 1]
       temporary && temporary.push(curr)
       return prev
    }, [])
}

tony0511 · 2021-03-19T02:50:08Z

const chunk = (list, ln) => {
  if (ln <= 0) return [];
  const result = [];
  list.forEach((item, index) => {
    const mol = index % ln, idx = Math.floor(index / ln);
    if (mol === 0) result[idx] = [];
    result[idx].push(item);
  });
  return result;
};

z253573760 · 2021-03-21T06:11:29Z


function main() {
  const chunks = (input, size) => {
    size = Math.max(parseInt(size), 0);
    if (!Array.isArray(input)) {
      return [];
    }
    if (size < 1) {
      return [];
    }
    if (size > input.length) {
      return [...input];
    }
    return [input.slice(0, size), input.slice(size, input.length)];
  };
  return {
    chunks,
  };
}
const _ = main();
const res = _.chunks(["a", "b", "c", "d"], 3);
console.log(res);

Vxee · 2021-03-22T14:45:24Z

function chunk(arr, len) {
  if(len === 0) return [];

  let [start, end, res] = [0, len, []];
  while(start < arr.length) {
    res.push(arr.slice(start, end));
    [start, end] = [end, end+len];
  }
  return res;
}

snqqw · 2021-03-24T03:20:50Z

function chunk(arr, step) {
if (!Array.isArray(arr) || !step) return []
let newArr = []
let data = [...arr]
while (data.length > 0) {
newArr.push(data.splice(0, step))
}
return newArr
}

NanYun-rs · 2021-03-24T16:32:45Z

const _chunk = (chunker, size) => {
  let result = [];
  if (size === 0) return [];
  while (chunker.length > size) {
    const s = chunker.splice(0, size);
    result = [...result, s];
  }
  if (chunker.length < size) return [...result, chunker];
};

wumo1016 · 2021-04-08T08:42:00Z

const _ = {
  chunk(list, size) {
    if(size < 1) return []
    const arr = [...list]
    const target = []
    while (arr.length){
      target.push(arr.splice(0, size))
    }
  }
}

wy2008826 · 2021-04-20T06:11:27Z

chunk=(arr,length)=>{
    let i =0
    let arr1= []
    while(i<arr.length){
        arr1.push(arr.slice(i,i+length));
        i=i+=length
    }
    return arr1
}

zhangqianCoding · 2021-04-23T03:51:26Z

function chunk(array=[], size=1) {
  size = Math.max(toInteger(size),0)
  if(!Array.isArray(array)){
    return []
  }
  if(size < 1){
    return []
  }
  let begin = 0
  let len = array.length
  let arr = []
  while(begin < len){
    arr.push(array.slice(begin, begin+size))
    begin += size
  }
  return arr
}

wenhuiyang-luck · 2021-04-26T07:32:04Z

const chunk = (arr, n) => {
  let len = arr.length;
  if (len === 0 || n === 0) return [];
  let res = [];
  let g = Math.floor(len / n);
  while(g) {
    res.push(arr.splice(0, n));
    g--;
  }
  return res;
}

dogloving · 2021-05-07T08:23:53Z

const _ = {}
_.chunk = (arr, size) =>
    arr.reduce((prev,cur,idx)=> {
        idx%size == 0 ? prev.push([cur]) : prev[prev.length-1].push(cur)
        return prev
}, [])
console.log(_.chunk([1,2,3,4,5],2)) // [ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]
console.log(_.chunk([1,2,3,4,5],4)) // [ [ 1, 2, 3, 4 ], [ 5 ] ]

nesxiaogu · 2021-07-19T15:44:59Z

function chunk(array = [], size = 0) {
    return size === 0 ? [] : new Array(Math.ceil(array.length / size)).fill(0).map((item, index) => {
       return array.slice(index * size, (index + 1) * size);
    });
}

KieSun added the 阿里 label Mar 14, 2021

katenewbie mentioned this issue Mar 15, 2021

```js #9

Closed

KieSun added 常考题手写题 labels Mar 20, 2021

KieSun closed this as completed Sep 16, 2021

第六题：实现一个 chunk 函数 #8

第六题：实现一个 chunk 函数 #8

Comments

KieSun commented Mar 14, 2021 • edited Loading

yancongwen commented Mar 15, 2021

QuXiaoMing commented Mar 15, 2021

XianHuiDeDiZhongHai commented Mar 15, 2021

goldEli commented Mar 15, 2021

secret344 commented Mar 15, 2021 • edited Loading

ctime-zliang commented Mar 15, 2021

XINXINP commented Mar 15, 2021

GeekNoble commented Mar 15, 2021

teefing commented Mar 15, 2021

SunshineZJJ commented Mar 15, 2021

Ecaknight commented Mar 15, 2021

mengzhe510 commented Mar 15, 2021 • edited Loading

learnRy commented Mar 15, 2021

monadaa commented Mar 15, 2021

l0ng09 commented Mar 15, 2021

Xchen1995 commented Mar 15, 2021

weiChow commented Mar 15, 2021

abu-ab commented Mar 15, 2021

huahua5525 commented Mar 15, 2021

HydratedPig commented Mar 15, 2021

AbigaiL533 commented Mar 15, 2021

ghost commented Mar 15, 2021

lp-lupe commented Mar 15, 2021 • edited Loading

vandvassily commented Mar 15, 2021

1742284240 commented Mar 15, 2021 • edited Loading

startfromscratch commented Mar 15, 2021

adam-zhou commented Mar 15, 2021

lucas270 commented Mar 15, 2021 • edited Loading

Leexuetao commented Mar 15, 2021

chen870370470 commented Mar 15, 2021

panalanjun commented Mar 15, 2021

owlsignl commented Mar 15, 2021

ahaghosthao commented Mar 15, 2021

xt1995726 commented Mar 15, 2021

cduyzh commented Mar 16, 2021 • edited Loading

liyanangrace commented Mar 16, 2021 • edited Loading

TMBeliever commented Mar 16, 2021

pengpeng9413 commented Mar 16, 2021

pengpeng9413 commented Mar 16, 2021

zhangyingcai commented Mar 16, 2021

huangzhuangjia commented Mar 16, 2021 • edited Loading

zhangyingcai commented Mar 16, 2021 • edited Loading

wengsj11 commented Mar 16, 2021

mingyuesun commented Mar 16, 2021

tony0511 commented Mar 19, 2021 • edited Loading

z253573760 commented Mar 21, 2021

Vxee commented Mar 22, 2021

snqqw commented Mar 24, 2021 • edited Loading

NanYun-rs commented Mar 24, 2021

wumo1016 commented Apr 8, 2021 • edited Loading

wy2008826 commented Apr 20, 2021

zhangqianCoding commented Apr 23, 2021 • edited Loading

wenhuiyang-luck commented Apr 26, 2021 • edited Loading

dogloving commented May 7, 2021

nesxiaogu commented Jul 19, 2021

KieSun commented Mar 14, 2021 •

edited

Loading

secret344 commented Mar 15, 2021 •

edited

Loading

mengzhe510 commented Mar 15, 2021 •

edited

Loading

lp-lupe commented Mar 15, 2021 •

edited

Loading

1742284240 commented Mar 15, 2021 •

edited

Loading

lucas270 commented Mar 15, 2021 •

edited

Loading

cduyzh commented Mar 16, 2021 •

edited

Loading

liyanangrace commented Mar 16, 2021 •

edited

Loading

huangzhuangjia commented Mar 16, 2021 •

edited

Loading

zhangyingcai commented Mar 16, 2021 •

edited

Loading

tony0511 commented Mar 19, 2021 •

edited

Loading

snqqw commented Mar 24, 2021 •

edited

Loading

wumo1016 commented Apr 8, 2021 •

edited

Loading

zhangqianCoding commented Apr 23, 2021 •

edited

Loading

wenhuiyang-luck commented Apr 26, 2021 •

edited

Loading