第六题：实现一个 chunk 函数

Question

第六题：实现一个 chunk 函数

KieSun opened this issue 3 years ago · comments

/**
 * @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)
// => []

去答题

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

Javon Yan · Answer 1 · Mon Mar 15 2021 08:53:47 GMT+0800 (China Standard Time)

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源码

shellming · Answer 2 · Mon Mar 15 2021 08:59:13 GMT+0800 (China Standard Time)

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
}, [])

H · Answer 3 · Mon Mar 15 2021 09:06:13 GMT+0800 (China Standard Time)

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
  }, [])
}

缪宇 · Answer 4 · Mon Mar 15 2021 09:13:22 GMT+0800 (China Standard Time)

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);
}

secret · Answer 5 · Mon Mar 15 2021 09:32:36 GMT+0800 (China Standard Time)

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;
}

c.zliang · Answer 6 · Mon Mar 15 2021 09:37:04 GMT+0800 (China Standard Time)

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
}

雾灵 · Answer 7 · Mon Mar 15 2021 09:40:51 GMT+0800 (China Standard Time)

//_.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
}

风之翼 · Answer 8 · Mon Mar 15 2021 09:57:14 GMT+0800 (China Standard Time)

`
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 · Answer 9 · Mon Mar 15 2021 10:12:06 GMT+0800 (China Standard Time)

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

SunshineZJJ · Answer 10 · Mon Mar 15 2021 10:24:32 GMT+0800 (China Standard Time)

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
			}

LiuJianliang · Answer 11 · Mon Mar 15 2021 10:27:12 GMT+0800 (China Standard Time)

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 · Answer 12 · Mon Mar 15 2021 10:30:09 GMT+0800 (China Standard Time)

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 · Answer 13 · Mon Mar 15 2021 10:34:31 GMT+0800 (China Standard Time)

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 · Answer 14 · Mon Mar 15 2021 10:46:06 GMT+0800 (China Standard Time)

// 第六题：实现一个 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 · Answer 15 · Mon Mar 15 2021 10:47:52 GMT+0800 (China Standard Time)

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");
  }
}

chenX · Answer 16 · Mon Mar 15 2021 11:16:19 GMT+0800 (China Standard Time)

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 · Answer 17 · Mon Mar 15 2021 11:28:25 GMT+0800 (China Standard Time)

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;
  }

刘健飞 · Answer 18 · Mon Mar 15 2021 11:34:27 GMT+0800 (China Standard Time)

      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 · Answer 19 · Mon Mar 15 2021 11:41:10 GMT+0800 (China Standard Time)

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;
}

注水的猪 · Answer 20 · Mon Mar 15 2021 11:44:35 GMT+0800 (China Standard Time)

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 · Answer 21 · Mon Mar 15 2021 11:49:49 GMT+0800 (China Standard Time)

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;
}

Deleted user · Answer 22 · Mon Mar 15 2021 13:47:05 GMT+0800 (China Standard Time)

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

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

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

这样就完整了

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

lp-lupe · Answer 23 · Mon Mar 15 2021 14:02:49 GMT+0800 (China Standard Time)

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 · Answer 24 · Mon Mar 15 2021 14:09:36 GMT+0800 (China Standard Time)

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));
// => []

青云码上 · Answer 25 · Mon Mar 15 2021 14:22:19 GMT+0800 (China Standard Time)

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));

uuCui · Answer 26 · Mon Mar 15 2021 14:53:05 GMT+0800 (China Standard Time)

第一个参数是数组第二参数分成几份
利用第二个参数跟第一数组的长度做一下向上取整，
循环的时候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 · Answer 27 · Mon Mar 15 2021 14:54:34 GMT+0800 (China Standard Time)

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;
}

星空 · Answer 28 · Mon Mar 15 2021 15:08:56 GMT+0800 (China Standard Time)

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

ErnestWangZuNian · Answer 29 · Mon Mar 15 2021 15:12:25 GMT+0800 (China Standard Time)

刚刚理解错chunk的意思这样就可以了

const chunk = (source: any[], size: number) => {
    let newSource: any[] = [];
    const len = source.length;
    if (size > 0) {
        const overGroup = len % size;
        const groupCount = Math.floor(len / size);
        let result = [];
        for (let i = 0; i < groupCount; i++) {
            result.push(source.slice(i * size, (i + 1) * size))
        }
        if (overGroup > 0) {
            result.push(source.slice(len - overGroup, len))
        }
        newSource = result;

    };
    console.log(newSource, 'wwwww');
    return newSource;
}

chunk(['a', 'b', 'c', 'd'], 0)
chunk(['a', 'b', 'c', 'd'], 1)
chunk(['a', 'b', 'c', 'd'], 2)
chunk(['a', 'b', 'c', 'd'], 3)
chunk(['a', 'b', 'c', 'd'], 4)
chunk(['a', 'b', 'c', 'd'], 5)

Dengju Deng · Answer 30 · Mon Mar 15 2021 15:42:17 GMT+0800 (China Standard Time)

Typescript 版本实现 👋

使用 Array.from 构建新数组，并进行迭代截取。

interface Lodash {
  chunk: <T>(input: Array<T>, size: number) => Array<Array<T>>;
}

const _: Lodash = {
  chunk: (input, size) => {
    if (size === 0) return [];
    return Array.from(Array(Math.ceil(input.length / size)), (v, i) =>
      input.slice(i * size, i * size + size)
    );
  }
};

测试：

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));

输出：

+ [['a', 'b'], ['c', 'd']]
+ [['a', 'b', 'c'], ['d']]
+ [['a', 'b', 'c', 'd']]
+ []

好像使用 Array.prototype.reduce 也能实现：

const _: Lodash = {
  chunk: (input, size) => {
    return input.reduce((arr, item, idx) => {
      return idx % size === 0
        ? [...arr, [item]]
        : [...arr.slice(0, -1), [...arr.slice(-1)[0], item]];
    }, []);
  }
}

蚂蚁呀嘿 · Answer 31 · Mon Mar 15 2021 15:48:15 GMT+0800 (China Standard Time)

function chunk(input, size) {
if (input.length <= size) return input
let newArr = []
while (input.length > 0) {
newArr.push(input.splice(0, size))
}
return newArr
}

Yugang Cao · Answer 32 · Mon Mar 15 2021 15:53:33 GMT+0800 (China Standard Time)

let _ = {}
_.chunk = function (arr, len) {
  let res = []
  if (arr.length === 0 || len === 0) {
    return res
  }
  let item = []
  for (let i = 0; i < arr.length; i++) {
    item.push(arr[i])
    if ((i + 1) % len === 0) {
      res.push(item)
      item = []
    }
  }

  item.length > 0 && res.push(item)
  return res
}

a11995910 · Answer 33 · Mon Mar 15 2021 16:22:34 GMT+0800 (China Standard Time)

function trunk(arr,size){
    if (!Array.isArray(arr)&&typeof size!='number') return
    if(size<1){
        return []
    }else{
        let sizes = arr.length/Math.floor(size);
        if(sizes>1){
            let resaultarr = []
            for(let i=0;i<arr.length;i+=size){
                resaultarr.push(arr.slice(i,Math.floor(size)+i)) 
            }
            // return resaultarr
            console.log(resaultarr)
        }else{
            return [arr]
        }
    }
}

doo · Answer 34 · Mon Mar 15 2021 16:42:50 GMT+0800 (China Standard Time)

function chunk(arr, size) {
  size = Math.max(0, size);

  if (!Array.isArray(arr) || size === 0) return [];
  if (size === 1) return arr;

  let res = [];
  for (let i = 0; i < arr.length; i += size) {
    res.push(arr.slice(i, i + size));
  }

  return res;
}

Akimoto · Answer 35 · Mon Mar 15 2021 16:43:21 GMT+0800 (China Standard Time)

/**
 * Desc: 实现一个 chunk 函数
 * Date: 2021-03-15
 * Author: Akimto
 *
 * @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)
    // => []
 */

/**
 * 
 * @param array 数组
 * @param size 分块大小
 * @returns 返回新结果数组
 */
const chunk = (array: any[], size: number) => {
    if (!Array.isArray(array)) {
        return [];
    }
    if (array.length == 0) {
        return [];
    }
    let resultArray = [];
    let resultIndex = 0;
    let currentIndex = 0;
    while (currentIndex < array.length) {
        resultArray[resultIndex] = array.slice(currentIndex, currentIndex + size);
        resultIndex++;
        currentIndex += size;
    }
    return resultArray;
}

const res = chunk(['a', 'b', 'c', 'd'], 2);
console.log(res);

Output:

katenewbie · Answer 36 · Mon Mar 15 2021 16:47:36 GMT+0800 (China Standard Time)

const chunk = (arr, group = 1, arr2 = []) => {
  const arr1 = [...arr]
  if (group <= 0) {
    return []
  }
  const end = Math.round(group)
  while (arr1.length) {
    arr2.push(arr1.splice(0, end))
  }
  return arr2
}

console.log(chunk([1, 2, 3, 4, 5, 6, 7, 8, 9], 10))
//[1,2,3,4,5,6,7,8,9]

Leon · Answer 37 · Mon Mar 15 2021 16:53:23 GMT+0800 (China Standard Time)

const _ = {};
_.chunk = (input, size) => {
    if(Object.prototype.toString.call(input) !== '[object Array]') {
        return new TypeError('请输入数组!')
    }
    if(!size) {
        return []
    }
    if(size > input) {
        return [input]
    }

    const targetArr = []
    const recurseFunc = (arr) => {
        if(arr.length > size) {
          targetArr.push(arr.splice(0, size))
         return recurseFunc(arr)
        } 
        return targetArr.push(arr)
    }
    recurseFunc(input)
    
    return targetArr
}

MR.Kevin · Answer 38 · Mon Mar 15 2021 17:24:38 GMT+0800 (China Standard Time)

const chunk = (input = [], size = 0) => {
  if (size === 0) {
    return []
  }
  let start = 0
  let len = input.length
  let result = []
  while (start < len) {
    result.push(input.slice(start, start + size))
    start += 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))

yangdong9527 · Answer 39 · Mon Mar 15 2021 17:26:39 GMT+0800 (China Standard Time)

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

console.log(chunk([1,2,3,4,5], 2))

PS C:\Users\Y_D\Desktop\daka> node .\06题.js
[ [ 1, 2 ], [ 3, 4 ], [ 5 ] ]

Eddy.Wang · Answer 40 · Mon Mar 15 2021 18:04:39 GMT+0800 (China Standard Time)

function chunk(arr, num){ const r = []; while(arr.length && num){ r.push(arr.splice(0, num)) } return r }

smiledgy · Answer 41 · Mon Mar 15 2021 18:15:51 GMT+0800 (China Standard Time)

function chunk(arr, size) {
let newArr = []
if (!Array.isArray(arr)) return newArr
if (size < 1) return newArr
while (arr.length) {
newArr.push(arr.splice(0, size))
}
return newArr
}

console.log(chunk(['a', 'b', 'c', 'd','e'], 2))

vision · Answer 42 · Mon Mar 15 2021 18:19:23 GMT+0800 (China Standard Time)

function chunk(input, size) {
  if (!Array.isArray(input)) {
        return []
  }
  if(!size) return [];

  const n = input.length;
  const result = [];
  let start = 0;
  while (start <= n-1) {
    result.push(input.slice(start,start+size));
    start += size;
  }
  return result;
}

ByeLe · Answer 43 · Mon Mar 15 2021 18:53:24 GMT+0800 (China Standard Time)

function chunk(arr, len) {
    const res = [];
    let temp = [];
    if (len === 0) {
        return [];
    }
    for (let i = 0; i < arr.length; i++) {
        temp.push(arr[i]);
        if (temp.length === len) {
            res.push(temp);
            temp = [];
        }
    }
    if (temp.length != 0) {
        res.push(temp);
    }
    return res;
};
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));

[ [ 'a', 'b' ], [ 'c', 'd' ] ]
[ [ 'a', 'b', 'c' ], [ 'd' ] ]
[ [ 'a', 'b', 'c', 'd' ] ]
[]

Mr.Huang · Answer 44 · Mon Mar 15 2021 19:28:00 GMT+0800 (China Standard Time)

尽量一行代码来实现

function chunk(arr, size){
  return Array.from({length: (size = Number.parseInt(size)) ? Math.ceil(arr.length/size) : 0})
    .map((a,i) => arr.slice(i*size, (i+1)*size))
}
let _ = {
  chunk
}
console.log(JSON.stringify(_.chunk(['a', 'b', 'c', 'd'], 2)))
console.log(JSON.stringify(_.chunk(['a', 'b', 'c', 'd'], 3)))
console.log(JSON.stringify(_.chunk(['a', 'b', 'c', 'd'], 5)))
console.log(JSON.stringify(_.chunk(['a', 'b', 'c', 'd'], 0)))

wyss · Answer 45 · Mon Mar 15 2021 19:54:05 GMT+0800 (China Standard Time)

const chunk = (arr, size = 1, cache = []) => {
  const temp = [...arr]
  if (size <= 0) {
    return cache
  }
  while(temp.length) {
    cache.push(temp.splice(0, size))
  }
  return cache
}

boyrest · Answer 46 · Mon Mar 15 2021 20:22:42 GMT+0800 (China Standard Time)

Li · Answer 47 · Mon Mar 15 2021 20:56:48 GMT+0800 (China Standard Time)

function Loadsh() {}

Loadsh.prototype.chunk = function chunk() {
  let input = arguments[0],
      size = arguments[1],
      length = input.length,
      to = []

  if (size == 0) return to;

  while (length >= size) {
    to.push(input.splice(0, size))
    length = input.length
  }

  if (length && length < size) {
    to.push(input)

    return to
  }

  return to
}

const _ = new Loadsh()

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))
//[ [ 'a', 'b' ], [ 'c', 'd' ] ]
//[ [ 'a', 'b', 'c' ], [ 'd' ] ]
//[ [ 'a', 'b', 'c', 'd' ] ]
//[]

muzishuiji · Answer 48 · Mon Mar 15 2021 20:57:51 GMT+0800 (China Standard Time)

const _ = {
  chunk(input, index) {
    if (!index) {
      return [];
    }
    const temp = [];
    for (let i = 0, len = input.length; i < len; i += index) {
      temp.push(input.slice(i, i + index));
    }
    return temp;
  },
};


_.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)
// => []

sunsmeil · Answer 49 · Mon Mar 15 2021 21:27:02 GMT+0800 (China Standard Time)

const _ = {
  /**
   * 
   * @param {待分割数组} array 
   * @param {分割块大小} size 
   */
  chunk: (array, size) => {
    if(!Array.isArray(array)){
      return null
    }
    if(size <= 0 || array.length <= size) {
      return array
    }

    let result = []
    let rem = array.length % size
    let i = 0
    while(i != array.length - rem) {
      result.push(array.slice(i, i+size))
      i += size
    }
    if(rem != 0) {
      result.push(array.slice(-rem))
    }

    return result
  }
}
console.log(_.chunk(['a', 'b', 'c', 'd'], 5))

pandaomeng · Answer 50 · Mon Mar 15 2021 21:44:06 GMT+0800 (China Standard Time)

const chunk = (inputArr: any[], chunkSize: number) => {
    if (chunkSize === 0) {
        console.log('result: ', [])
        return []
    }
    let result = []
    let index = 0
    const inputArrLength = inputArr.length
    while(index < inputArrLength) {
        const item = inputArr.slice(index, index + chunkSize)
        result.push(item)
        index += chunkSize
    }
    console.log('result: ', result)
    return result
}

const _ = {
    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)
// => []

打印结果：

Leexuetao · Answer 51 · Mon Mar 15 2021 22:26:51 GMT+0800 (China Standard Time)

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
}
}

ChenJK · Answer 52 · Mon Mar 15 2021 22:44:21 GMT+0800 (China Standard Time)

// 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 · Answer 53 · Mon Mar 15 2021 22:45:52 GMT+0800 (China Standard Time)

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 · Answer 54 · Mon Mar 15 2021 22:58:03 GMT+0800 (China Standard Time)

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 · Answer 55 · Mon Mar 15 2021 23:32:55 GMT+0800 (China Standard Time)

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;
    }
}

慕童 · Answer 56 · Mon Mar 15 2021 23:36:35 GMT+0800 (China Standard Time)

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;
}

水美眉 · Answer 57 · Tue Mar 16 2021 10:59:36 GMT+0800 (China Standard Time)

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);
// => []

Li Ya Nan · Answer 58 · Tue Mar 16 2021 11:26:08 GMT+0800 (China Standard Time)

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 加一个测试用例

Liang · Answer 59 · Tue Mar 16 2021 13:08:06 GMT+0800 (China Standard Time)

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
}

xxp9413 · Answer 60 · Tue Mar 16 2021 14:05:04 GMT+0800 (China Standard Time)

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)

xxp9413 · Answer 61 · Tue Mar 16 2021 14:06:29 GMT+0800 (China Standard Time)

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 加一个测试用例

那你个改变原数组了

zyc · Answer 62 · Tue Mar 16 2021 16:20:03 GMT+0800 (China Standard Time)

 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;
 }

Junga · Answer 63 · Tue Mar 16 2021 16:22:46 GMT+0800 (China Standard Time)

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;
}

zyc · Answer 64 · Tue Mar 16 2021 16:25:39 GMT+0800 (China Standard Time)

不修改原数组 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;
 }

wengsj · Answer 65 · Tue Mar 16 2021 23:05:15 GMT+0800 (China Standard Time)

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] ], [])

smy · Answer 66 · Tue Mar 16 2021 23:44:39 GMT+0800 (China Standard Time)

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 · Answer 67 · Fri Mar 19 2021 10:50:08 GMT+0800 (China Standard Time)

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;
};

灿灿 · Answer 68 · Sun Mar 21 2021 14:11:29 GMT+0800 (China Standard Time)


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);

Jialing · Answer 69 · Mon Mar 22 2021 22:45:24 GMT+0800 (China Standard Time)

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;
}

执念 · Answer 70 · Wed Mar 24 2021 11:20:50 GMT+0800 (China Standard Time)

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 · Answer 71 · Thu Mar 25 2021 00:32:45 GMT+0800 (China Standard Time)

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];
};

wumo · Answer 72 · Thu Apr 08 2021 16:42:00 GMT+0800 (China Standard Time)

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

宇 · Answer 73 · Tue Apr 20 2021 14:11:27 GMT+0800 (China Standard Time)

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 · Answer 74 · Fri Apr 23 2021 11:51:26 GMT+0800 (China Standard Time)

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
}

Luckyhui · Answer 75 · Mon Apr 26 2021 15:32:04 GMT+0800 (China Standard Time)

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 · Answer 76 · Fri May 07 2021 16:23:53 GMT+0800 (China Standard Time)

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 · Answer 77 · Mon Jul 19 2021 23:44:59 GMT+0800 (China Standard Time)

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);
    });
}