第 36 题：使用迭代的方式实现 flatten 函数

[Moriarty02]

var arr=[1,2,3,[4,5],[6,[7,[8]]]]
/**
 * 使用递归的方式处理
 * wrap内保存结果ret 
 * 返回一个递归函数
 *
 * @returns
 */
function wrap(){
    var ret=[];
    return function flat(a){
        for(var item of a){
            if(item.constructor===Array){
                ret.concat(flat(item))
            }else{
                ret.push(item)
            }
        }
        return ret
    }
}
console.log(wrap()(arr));

将一个多维数组拍平为一个一维数组

[suguoyao]

const spreadableSymbol = Symbol.isConcatSpreadable
const isFlattenable = (value) => {
  return Array.isArray(value) || (typeof value == 'object' && value !== null
    && Object.prototype.toString.call(value) === '[object Arguments]') ||
    !!(spreadableSymbol && value && value[spreadableSymbol])
}

/**
 * flatten的基本实现，具体可以参考lodash库的flatten源码
 * @param array 需要展开的数组
 * @param depth 展开深度
 * @param predicate 迭代时需要调用的函数
 * @param isStrict 限制通过`predicate`函数检查的值
 * @param result 初始结果值
 * @returns {Array} 返回展开后的数组
 */
function flatten(array, depth, predicate, isStrict, result) {
  predicate || (predicate = isFlattenable)
  result || (result = [])

  if (array == null) {
    return result
  }

  for (const value of array) {
    if (depth > 0 && predicate(value)) {
      if (depth > 1) {
        flatten(value, depth - 1, predicate, isStrict, result)
      } else {
        result.push(...value)
      }
    } else if (!isStrict) {
      result[result.length] = value
    }
  }
  return result
}

flatten([1, 2, 3, [4, 5, [6]]], 2)
// [1, 2, 3, 4, 5, 6]

[zzzzzhowie]

迭代的实现:

let arr = [1, 2, [3, 4, 5, [6, 7], 8], 9, 10, [11, [12, 13]]]

const flatten = function (arr) {
    while (arr.some(item => Array.isArray(item))) {
        arr = [].concat(...arr)
    }
    return arr
}

console.log(flatten(arr))

递归的实现(ES6简写):

const flatten = array => array.reduce((acc, cur) => (Array.isArray(cur) ? [...acc, ...flatten(cur)] : [...acc, cur]), [])

[Rashomon511]

let arr = [1, 2, [3, 4, 5, [6, 7], 8], 9, 10, [11, [12, 13]]]

迭代实现

    function flatten(arr) {
      let arrs =[...arr]
      let newArr = [];
      while (arrs.length){
        let item = arrs.shift()
        if(Array.isArray(item)){
          arrs.unshift(...item)
        }else {
          newArr.push(item)
        }
      }
      return newArr
    }

递归实现

    function flatten(arr) {
    let arrs = [];
      arr.map(item => {
        if(Array.isArray(item)){
          arrs.push(... flatten(item))
        } else {
          arrs.push(item)
        }
      })
      return arrs
    }

字符串转换

arr.join(',').split(',').map(item => Number(item)))

[underlineMY]

使用Generator实现数组flatten:

function* flat(arr){
	for(let item of arr){
		if(Array.isArray(item)){
			yield* flat(item);//Generator委托
		}else {
			yield item
		}
	}
}
function flatten(arr) {
	let result = [];
	for(let val of(flat(arr))){
		result.push(val);
	}
	return result;
}
let arr1 = [1,[2,3,[4,5],6],[7]];
console.log(flatten(arr1));//[1, 2, 3, 4, 5, 6, 7]

[Ray-56]

const arr = [1,2,3,[4,5],6,[7,[8, 9, 10]]]

// 递归
function flatten(arr, res = []) {
    for (let i = 0; i < arr.length; i++) {
        if (typeof arr[i] === 'object') {
            flatten(arr[i], res);
        } else {
            res.push(arr[i]);
        }
    }
    return res;
}

// 队列
function flatten1(arr) {
    const newArr = [...arr];
    const res = [];
    while (newArr.length) {
        const item = newArr.shift(); // 出队
        if (Array.isArray(item)) {
            newArr.unshift(...item); // 入队
        } else {
            res.push(item);
        }
    }
    return res;
}

[fingerpan]

/**
*

• @param {Array} arr 需要扁平化的数组
• @param {Number} [depth=1] 扁平化深度
• @return {Array} 扁平化后的新数组
  */
  function flatten(arr, depth = 1) {
  return arr.reduce((newArr, nextArr) => newArr.concat(depth > 1 && Array.isArray(nextArr) ? flatten(nextArr, depth - 1) : nextArr), [])
  }

[ringcrl]

ES10

arr.flat(Infinity);

[wind-stone]

function flatten(arr) {
  const result = [...arr];
  for (let i = 0; i < result.length; i++) {
    const item = result[i]
    if (Array.isArray(item)) {
      Array.prototype.splice.apply(result, [i, 1, ...item])
      i--
    }
  }
  return result
}

[gaomin]

var arr=[1,2,3,[4,5],[6,[7,[8]]]]
function flatten(arr, result){
    if(!result){
        var result = [];
    }
    
    if(Object.prototype.toString.call(arr) == "[object Array]"){
        for (let i=0; i<arr.length; i++){
            if(Object.prototype.toString.call(arr[i]) == "[object Array]"){
                flatten(arr[i], result);
            }else{
                result.push(arr[i]);
            }
        } 
    }
    return result;
}

flatten(arr);

[dorseysen]

const flatten = (arr, deep) => {

    deep = deep ? deep : Infinity;
    while(deep && arr.some(item => Array.isArray(item))) {
        arr = [].concat(...arr);
        deep --;
    }
    return arr;
}
Array.prototype.flatten = function (deep) {
    
    return flatten(this, deep);
}
[1,[123,["213",["dorsey","123"]]]].flatten();

[wind1996]

const flatten = x => x.reduce((pre, cur) => Array.isArray(cur) ? pre.concat(flatten(cur)) : pre.concat(cur), []);

[xiaobaichiliangpi]

let arr = [1, 2, [3, 4, 5, [6, 7], 8], 9, 10, [11, [12, 13]]]
arr.toString().split(',')
or
arr.join(',').split(',')

[scq000]

function flatten(a) {
return Array.isArray(a) ? [].concat(...a.map(flatten)) : a;
}

[z253573760]

[formattedzzz]

为什么我老是喜欢投机取巧,哈哈

var arr = [1,[2,3,[4,5]],8]
function flat (arr) {
  return JSON.parse('[' + JSON.stringify(arr).replace(/\[|\]/g, '') + ']')
}
flat(arr)