cleartime / --lodash Goto Github PK

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

function _chunk(arr, num){
	let len = arr.length;
	if(len<num){
		num = len
	}
	let beishu = Math.ceil(len/num);
	let newArr = [];
	let temp = 0;
	for(let j=0 ; j<beishu ;){
		let start = temp;
		j++;
		let end = j*num;
		temp = end;
		newArr.push(arr.slice(start,end))
	}
	return newArr
}
// log(_chunk(['a', 'b', 'c', 'd'], 1))

function chunk(array, size) {
	// 转换为数字，防止负数
  size = Math.max(size, 0) 	
  	// 获取数组的长度					  
  const length = array == null ? 0 : array.length		
  // 如果数组为空或者切割的长度不够1就返回空数组
  if (!length || size < 1) {
    return []
  }
  let index = 0
  let resIndex = 0
  // 判断切割之后有几个数组，new Array(2)相当于[].length=2
  const result = new Array(Math.ceil(length / size))
  // 很巧妙的循环判断，边界就是我数组的长度，你从头开始切，切到你需要的尺寸，直到大于数组的长度，就表示不能再切了
  // 再一个很巧妙的设计，之前设置了需要切的空数组,每次循环就把当前的数据加入到当前的index里面，循环满了也不用再继续加入了
  while (index < length) {
    result[resIndex++] = array.slice(index, (index += size))
  }
  return result
}

var array = [1];
var other = _.concat(array, 2, [3], [[4]]);
 
// console.log(other);
// => [1, 2, 3, [4]]
 
// console.log(array);
// => [1]

function concat() {
  // 判断参数长度
  var length = arguments.length;
  if (!length) {
    return [];
  }
  var args = Array(length - 1), // 参数
      array = arguments[0],     // 第一个参数
      index = length;           // 索引
  // 判断长度为0就停止
  while (index--) {
  // 复制参数导args中
    args[index - 1] = arguments[index];
  }
  // 获取到了所有的参数然后都push到新数组中
  return arrayPush(Array.isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
}

_.compact([0, 1, false, 2, '', 3]);
// => [1, 2, 3]

function __compact(array) {
  let resIndex = 0
  const result = []
  // 过滤参数为null的情况下返回空数组
  if (array == null) {
    return result
  }
  // 迭代器遍历数组
  for (const value of array) {
  	// 如果有数据则放到空数组中
    if (value) {
    	// 索引值对应增加
      result[resIndex++] = value
    }
  }
  return result
}
// log(__compact([0, 1, false, 2, '', 3]))