将（n）个键从对象数组中分离到一个带有键名的数组中

Question

我需要在对象数组中执行过滤以获取所有键。虽然，只要该键中有一个 obj，我就需要获取键名并与 obj 中的键名连接，例如：

const data = [ id: 5, name: "Something", obj: { lower: True, higher: False } ]
result = ["id", "name", "obj.lower", "obj.higher"]

我可以做到上面的代码，但是，如果数据中有更多的objs，我需要在我的逻辑中不断添加一个if条件，我想知道是否有其他方法，所以无论我在对象中有多少对象，它都会始终连接。
上面提到的我使用的代码：

const itemsArray = [
      { id: 1, item: "Item 001", obj: { name: 'Nilton001', message: "Free001", obj2: { test: "test001" } } },
      { id: 2, item: "Item 002", obj: { name: 'Nilton002', message: "Free002", obj2: { test: "test002" } } },
      { id: 3, item: "Item 003", obj: { name: 'Nilton003', message: "Free003", obj2: { test: "test003" } } },
    ];

const csvData = [    
    Object.keys(itemsArray[0]),
    ...itemsArray.map(item => Object.values(item))
].map(e => e.join(",")).join("\n")

// Separating keys
let keys = []
const allKeys = Object.entries(itemsArray[0]);
for (const data of allKeys) {
    if (typeof data[1] === "object") {
        const gettingObjKeys = Object.keys(data[1]);
        const concatingKeys = gettingObjKeys.map((key) => data[0] + "." + key);        
        keys.push(concatingKeys);
    } else {
        keys.push(data[0])
    }
}

//Flating
const flattingKeys = keys.reduce((acc, val: any) => acc.concat(val), []);

我想实现的，假设我有这个对象数组：

const data = 
[
   { id: 10, obj: {name: "Name1", obj2: {name2: "Name2", test: "Test"}}}
   ...
]

Final result = ["id", "obj.name", "obj.obj2.name2", "obj.obj2.test"]

OBS: The first obj contains all the keys I need, no need to loop through other to get KEYS.

我想实现，数组第一个对象的所有键，如果对象内部有对象，我想连接对象名称（obj.obj2key1）

Answer 1

OP 解决方案可以通过接受前缀参数（父键）和结果参数（默认为 [] 并传递到递归）来简化...

let obj = { key0: 'v0', key1: { innerKey0: 'innerV0', innerInner: { deeplyNested: 'v' } }, key2: { anotherInnerKey: 'innerV' } }

function recursiveKeys(prefix, obj, result=[]) {
  let keys = Object.keys(obj);
  keys.forEach(key => {
    if (typeof obj[key] === 'object')
      recursiveKeys(key, obj[key], result);
    else
      result.push(`${prefix}.${key}`)
  });
  return result;
}

console.log(recursiveKeys('', obj))

Answer 2

像这样

const itemsArray = [
      { id: 1, item: "Item 001", obj: { name: 'Nilton001', message: "Free001", obj2: { test: "test001" } } },
      { id: 2, item: "Item 002", obj: { name: 'Nilton002', message: "Free002", obj2: { test: "test002" } } },
      { id: 3, item: "Item 003", obj: { name: 'Nilton003', message: "Free003", obj2: { test: "test003" } } },
    ];
    
const item = itemsArray[0];

const getAllKeys = (obj, prefix=[]) => {
 if(typeof obj !== 'object'){
   return prefix.join('.')
 }
 return Object.entries(obj).flatMap(([k, v]) => getAllKeys(v, [...prefix, k]))
}

console.log(getAllKeys(item))

Answer 3

function getKeys(obj) {
  return Object.keys((typeof obj === 'object' && obj) || {}).reduce((acc, key) => {
    if (obj[key] && typeof obj[key] === 'object') {
      const keys = getKeys(obj[key]);
      keys.forEach((k) => acc.add(`${key}.${k}`));
    } else {
      acc.add(key);
    }
    return acc;
  }, new Set());
}

// accumulate the keys in a set (the items of the array may
// have different shapes). All of the possible keys will be
// stored in a set
const s = itemsArray.reduce(
  (acc, item) => new Set([...acc, ...getKeys(item)]),
  new Set()
);

console.log('Keys => ', Array.from(s));

Answer 4

您可以映射键或嵌套对象的键。

const
    getKeys = object => Object
        .entries(object)
        .flatMap(([k, v]) => v && typeof v === 'object'
            ? getKeys(v).map(s => `${k}.${s}`)
            : k
        ),
    getValues = object => Object
        .entries(object)
        .flatMap(([k, v]) => v && typeof v === 'object'
            ? getValues(v)
            : v
        ),
    data = { id: 1, item: "Item 001", obj: { name: 'Nilton001', message: "Free001", obj2: { test: "test001" } } },
    keys = getKeys(data),
    values = getValues(data);

console.log(keys);
console.log(values);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 5

您可以按如下方式使用递归。由于typeof([1,3,5])是object，我们还要确认value不是数组，!Array.isArray(value):

const obj = { id: 10, obj: {name: "Name1", obj2: {name2: "Name2", test: "Test"}}};

const getKeys = (o,p) => Object.entries(o).flatMap(([key,value]) => 
    typeof(value) === 'object' && !Array.isArray(value) ? 
        getKeys(value, (p?`${p}.`:"") + key) : 
        (p ? `${p}.`: "") + key
);

console.log( getKeys(obj) );

将（n）个键从对象数组中分离到一个带有键名的数组中

Separating (n) keys from array of objects into a single array with keys names

javascript

arrays

object

typescript