Hướng dẫn javascript flatten array of objects by key - javascript làm phẳng mảng đối tượng bằng phím

Thử nó

Cú pháp

Thông số

someObject = {
    foo: 1,
    bar: 2
}

Mức độ sâu chỉ định mức độ sâu của cấu trúc mảng lồng nhau nên được làm phẳng. Mặc định là 1.

Giá trị trả về

Một mảng mới với các phần tử con được nối với nó.

Sự mô tả

Phương pháp

someObject = {
    foo: 1,
    bar: 2
}

someObject = {
    foo: 1,
    bar: 2
}

Phương pháp

someObject = {
    foo: 1,
    bar: 2
}

someObject = {
    foo: 1,
    bar: 2
}

Phương pháp

someObject = {
    foo: 1,
    bar: 2
}

someObject = {
    foo: 1,
    bar: 2
}

someObject = {
    foo: 1,
    bar: 2
}

Lựa chọn thay thế

giảm và liên kết

const arr = [1, 2, [3, 4]];

// To flat single level array
arr.flat[];
// is equivalent to
arr.reduce[[acc, val] => acc.concat[val], []];
// [1, 2, 3, 4]

// or with decomposition syntax
const flattened = [arr] => [].concat[...arr];

Giảm + Concat + Isarray + đệ quy

const arr = [1, 2, [3, 4, [5, 6]]];

// to enable deep level flatten use recursion with reduce and concat
function flatDeep[arr, d = 1] {
  if [!Array.isArray[arr]] {
    return arr;
  }
  return d > 0
    ? arr.reduce[[acc, val] => acc.concat[flatDeep[val, d - 1]], []]
    : arr.slice[];
}

flatDeep[arr, Infinity];
// [1, 2, 3, 4, 5, 6]

Sử dụng một ngăn xếp

// non recursive flatten deep using a stack
// note that depth control is hard/inefficient as we will need to tag EACH value with its own depth
// also possible w/o reversing on shift/unshift, but array OPs on the end tends to be faster
function flatten[input] {
  const stack = [...input];
  const res = [];
  while [stack.length] {
    // pop value from stack
    const next = stack.pop[];
    if [Array.isArray[next]] {
      // push back array items, won't modify the original input
      stack.push[...next];
    } else {
      res.push[next];
    }
  }
  // reverse to restore input order
  return res.reverse[];
}

const arr = [1, 2, [3, 4, [5, 6]]];
flatten[arr];
// [1, 2, 3, 4, 5, 6]

Sử dụng hàm máy phát điện

function* flatten[array, depth] {
  if [depth === undefined] {
    depth = 1;
  }

  for [const item of array] {
    if [Array.isArray[item] && depth > 0] {
      yield* flatten[item, depth - 1];
    } else {
      yield item;
    }
  }
}

const arr = [1, 2, [3, 4, [5, 6]]];
const flattened = [...flatten[arr, Infinity]];
// [1, 2, 3, 4, 5, 6]

Ví dụ

Làm phẳng mảng lồng nhau

const arr1 = [1, 2, [3, 4]];
arr1.flat[];
// [1, 2, 3, 4]

const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat[];
// [1, 2, 3, 4, [5, 6]]

const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat[2];
// [1, 2, 3, 4, 5, 6]

const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat[Infinity];
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Sử dụng flat [] trên các mảng thưa thớt

Phương thức

someObject = {
    foo: 1,
    bar: 2
}

const arr5 = [1, 2, , 4, 5];
console.log[arr5.flat[]]; // [1, 2, 4, 5]

const array = [1, , 3, ["a", , "c"]];
console.log[array.flat[]]; // [ 1, 3, "a", "c" ]

const array2 = [1, , 3, ["a", , ["d", , "e"]]];
console.log[array2.flat[]]; // [ 1, 3, "a", ["d", empty, "e"] ]
console.log[array2.flat[2]]; // [ 1, 3, "a", "d", "e"]

Gọi phẳng [] trên các đối tượng không phải là

Phương thức

someObject = {
    foo: 1,
    bar: 2
}

someObject = {
    foo: 1,
    bar: 2
}

someObject = {
    foo: 1,
    bar: 2
}

someObject = {
    foo: 1,
    bar: 2
}

const arrayLike = {
  length: 3,
  0: [1, 2],
  // Array-like objects aren't flattened
  1: { length: 2, 0: 3, 1: 4 },
  2: 5,
};
console.log[Array.prototype.flat.call[arrayLike]];
// [ 1, 2, { '0': 3, '1': 4, length: 2 }, 5 ]

Xem thêm