在不使用 .flat();的情况下展平数组

Question

如何在不使用 flat(( 的情况下展平数组。

到目前为止，我有这个

function flatten(array) {
let flattened = [];
for (let i = 0; i < array.length; i++) {
const current = array[i];
for (let j = 0; i < current.length; j++) {
flattened.push(current[j])
}
}
return flattened
}
console.log(flatten([['foo', 'bar'], ['baz', 'qux']]));
// -> ["foo", "bar", "baz", "qux"]
flatten([[1], [2], 3, 4, [5]]);
// -> [1, 2, 3, 4, 5]
flatten([false, [true, [false]], [true]]);
// -> [false, true, [false], true]
flatten([]);
// -> []

它崩溃了我的记忆

Answer 1

我希望这有帮助

var twoDimension = [[1], [2], 3, 4, [5]];
var plano = twoDimension.reduce((acc, el) => acc.concat(el), []);
console.log(plano);

Answer 2

您可以使用Array.reduce和spread syntax：

function flatten(array) {
return array.reduce(
(accumulator, item) => {
// if `item` is an `array`,
// use the `spread syntax` to 
// append items of the array into 
// the `accumulator` array
if (Array.isArray(item)) {
return [...accumulator, ...item];
}
// otherwise, return items in the 
// accumulator plus the new item
return [...accumulator, item];
}
, []); // initial value of `accumulator`
}
console.log(flatten([['foo', 'bar'], ['baz', 'qux']]));
// -> ["foo", "bar", "baz", "qux"]
console.log(flatten([[1], [2], 3, 4, [5]]));
// -> [1, 2, 3, 4, 5]
console.log(flatten([false, [true, [false]], [true]]));
// -> [false, true, [false], true]
console.log(flatten([]));
// -> []

引用：

• Array.reduce - MDN
• 扩展语法 - MDN

Answer 3

要仅按单个级别扁平化，可以利用Array#concat()。它接受任意数量的参数，因此数组可以分散到函数调用中：

[].concat(...arr)

这避免了任何显式循环。JavaScript 处理一切：

function flatten(arr) {
return [].concat(...arr);
}
console.log(flatten([['foo', 'bar'], ['baz', 'qux']]));
// -> ["foo", "bar", "baz", "qux"]
console.log(flatten([[1], [2], 3, 4, [5]]));
// -> [1, 2, 3, 4, 5]
console.log(flatten([false, [true, [false]], [true]]));
// -> [false, true, [false], true]
console.log(flatten([]));
// -> []

Answer 4

如果您的数组具有基元数据类型并希望完全平化它，则可以使用以下方法：

arr.toString().split(',');

Answer 5

你可以使用 JavaScript 的reducer作为 flat(( 的替代品。

const arr = [1, 2, [3, 4]];
arr.reduce((acc, val) => acc.concat(val), []);
// [1, 2, 3, 4]

或者您可以使用分解语法

const flattened = arr => [].concat(...arr);

有关更多详细信息，请访问 Mozilla MDN

Answer 6

//Using Recursion
const arr = [1, 2, 3, 4, [5, 6, [6, 7], 7, 8]]

let arr2 = [];
function flat(arr) {
arr.forEach(element => {
if (typeof (element) == 'object') {
flat(element);
} else {
arr2.push(element);
}
});
}

flat(arr);

console.log(arr2);

Answer 7

这里有一个错误：

for (let j = 0; i < current.length; j++) {
//              ^ wrong variable, should be j

并且您需要检查该值是否不是数组，然后只需推送当前值并继续循环即可。

function flatten(array) {
let flattened = [];
for (let i = 0; i < array.length; i++) {
const current = array[i];
if (!Array.isArray(current)) {
flattened.push(current);
continue;
}
for (let j = 0; j < current.length; j++) {
flattened.push(current[j])
}
}
return flattened
}
console.log(flatten([['foo', 'bar'], ['baz', 'qux']]));
// -> ["foo", "bar", "baz", "qux"]
console.log(flatten([[1], [2], 3, 4, [5]]));
// -> [1, 2, 3, 4, 5]
console.log(flatten([false, [true, [false]], [true]]));
// -> [false, true, [false], true]
console.log(flatten([]));
// -> []

Answer 8

你有一个错字，在最里面的循环中，你将 i 设置为 0 而不是 j。您唯一需要做的就是检查外部数组中的每个元素是否是标量(不是数组(，如果是，则将其推送到返回的数组。

function flatten(arr) {
let flat = []
for (let i=0; i < arr.length; i++) {
const cur = arr[i]
if(!Array.isArray(cur)){
flat.push(cur)
}else{
for (let j=0; j < cur.length; j++) {
flat.push(cur[j])
}
}
}
return flat
}
console.log(flatten([['foo','bar'],['baz','qux']]))
console.log(flatten([[1],[2],3,4,[5]]))
console.log(flatten([false,[true,[false]],[true]]))
console.log(flatten([]))

Answer 9

好吧，您可以使用带有reduce的点差运算符。

function flatten(array) {
return array.reduce((a,v) => [...a, ...(Array.isArray(v) ? v : [v])], []);
}
console.log(flatten([['foo', 'bar'], 'baz', 'qux']))

Answer 10

以下内容可以用作 Array.prototype.flat(( 的一般实现

function flattenArray(arr, depth = 1) {
if (!Array.isArray(arr)) {
return [arr];
}
return depth > 0
? arr.reduce(
(acc, curr) =>
acc.concat(
Array.isArray(curr) ? flattenArray(curr, depth - 1) : curr
),
[]
)
: arr.slice();
}
const a = [1, 2, 3, 4];
const b = "a";
const c = [1, [2, 3], 4];
const d = [1, [2, [3, 4], 5], 6];
const e = [1, [2, [3, [4, [5], [6]], 7], 8], 9];
console.log(flattenArray(a, Infinity));
console.log(flattenArray(b, Infinity));
console.log(flattenArray(c, Infinity));
console.log(flattenArray(d, Infinity));
console.log(flattenArray(e, Infinity));

Answer 11

还有另一种有趣的方法可以做到这一点。

1. 字符串化数组
2. 删除所有数组开始符号 ([( 和数组结束符号 (](
在开头添加数组
3. 开始符号，在末尾添加数组结束符号。
4. 现在解析结果字符串

常量 arr2 = [0， 1， 2， [5， [10， [3， 4]

]]]

const arr2 = [0, 1, 2, [5, [10, [3, 4]]]]
console.log( JSON.parse('['+ JSON.stringify(arr2).replace(/[/g, ' ').replace(/]/g, ' ') + ']'))

Answer 12

假设给定的扁平数字列表而不使用平面函数是：

let array = [2,3,[5,2,[6,[3, [4, 5, [5, 1, 3]]]],1,1],9];
//let array= [2,3,[5,2,[6,[3, [4, 5, [5, {"key":"value"}, 3]]]],1,1],9]; 
//achieve above commented nested array condition using second approach. 

@Mahipal已经给出的最佳答案将是第一种方法，即

array.toString().split(',')

带数字数组转换

array.toString().split(',').map(n => +n)

另一种方法是使用函数递归而不使用toString()

function flatter(arr) {
if (!Array.isArray(arr) && (!isNaN(arr) || typeof arr === "object")) {
return arr;
}
return arr.reduce((a, b) => {
a.push(...[].concat(flatter(b)));
return a; 
}, [])
}
flatter(array);

输出为：

[ 2, 3, 5, 2, 6, 3, 4, 5, 5, 1, 3, 1, 1, 9 ]

希望这会帮助很多人。

Answer 13

var multiDimensionArray = [["a"],["b","c"],["d"]]; //array of arrays
var flatArray = Array.prototype.concat.apply([], multiDimensionArray); //flatten array of arrays
console.log(flatArray); 

Answer 14

这对我有用：

function myFlattern(arr) {
let check;
do{
check=false;
for(let i=0;i<arr.length;i++)
{
if(Array.isArray(arr[i]))
{
check=true;
let x=arr[i];
arr.splice(i,1,...x);        
}
}
}while(check)
return arr;
}

Answer 15

let array = [1,[3,5],[6,8],[3,[0,9],7],4];
let flattened = [];
for (let i = 0; i < array.length; i++) {
const current = array[i];
if (!Array.isArray(current)) {
flattened.push(current);
}
for (let j = 0; j < current.length; j++) {
if (!Array.isArray(current[j])){
flattened.push(current[j]);
}else if (Array.isArray(current[j])){
let newle = current[j]
flattened.push(newle[0]);
flattened.push(newle[1]);
}
}
}
console.log(flattened);

Answer 16

//For infinite nested array
const ar =[1,2,[3,[4,5,[6,7,[8,9]]]]]
function flatten(ar) {
return ar.reduce((ac, cur) =>{
if(Array.isArray(cur)){
return [...ac, ...flatten(cur)]
}
return [...ac, cur];
},[])
}
console.log(flatten(ar)) 

Answer 17

一个可能的替代方案是不使用flat((：

var arr = [['object1', 'object2'],['object1'],['object1','object2','object3']];
var flattened = [].concat.apply([],arr);

Answer 18

你可以用它来忘记嵌套的深度：

let multiArr = [1, [1, 2, [3, 4]], [2, 4, [45, 98]]];
while (multiArr.find((elem) => Array.isArray(elem))) {
multiArr = [].concat.apply([], multiArr);
}
console.log(multiArr);