Javascript 如何访问和处理嵌套对象、数组或JSON？

我有一个包含对象和数组的嵌套数据结构。如何提取信息，即访问特定或多个值（或键）

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

例如：

var data = {
    code: 42,
    items: [{
        id: 1,
        name: 'foo'
    }, {
        id: 2,
        name: 'bar'
    }]
};

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

如何访问

项目

中第二个项目的

名称

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

JavaScript只有一种数据类型可以包含多个值：Object。数组是对象的一种特殊形式

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

（普通）对象具有以下形式：

{key: value, key: value, ...}

[value, value, ...]

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

数组具有以下形式：

{key: value, key: value, ...}

[value, value, ...]

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

数组和对象都公开了

key->value

结构。数组中的键必须是数字，而任何字符串都可以用作对象中的键。键值对也称为“属性”

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

可以使用点表示法访问属性

const value = obj.someProperty;

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

或者，如果属性名称不是有效的JavaScript，或者名称是变量的值，则使用括号表示法：

// the space is not a valid character in identifier names
const value = obj["some Property"];

// property name as variable
const name = "some Property";
const value = obj[name];

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

因此，只能使用括号表示法访问数组元素：

const value = arr[5]; // arr.5 would be a syntax error

// property name / index as variable
const x = 5;
const value = arr[x];

data.items[1]

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

等待那么JSON呢？ JSON是数据的文本表示，就像XML、YAML、CSV等。要处理此类数据，首先必须将其转换为JavaScript数据类型，即数组和对象（刚才已经解释了如何处理这些数据）。问题中解释了如何解析JSON

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

进一步阅读材料 如何访问数组和对象是JavaScript的基础知识，因此建议阅读，尤其是章节

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

---

---

访问嵌套数据结构 嵌套数据结构是指引用其他数组或对象的数组或对象，即其值是数组或对象。这种结构可以通过连续应用点或括号符号来访问

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

以下是一个例子：

const data = {
    code: 42,
    items: [{
        id: 1,
        name: 'foo'
    }, {
        id: 2,
        name: 'bar'
    }]
};

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

假设我们想要访问第二项的

名称

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

以下是我们如何一步一步地做到这一点：

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

正如我们所看到的，

数据

是一个对象，因此我们可以使用点表示法访问它的属性。

items

属性的访问方式如下：

data.items

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

该值是一个数组，要访问其第二个元素，必须使用括号表示法：

const value = arr[5]; // arr.5 would be a syntax error

// property name / index as variable
const x = 5;
const value = arr[x];

data.items[1]

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

该值是一个对象，我们再次使用点表示法访问

name

属性。因此，我们最终得到：

const item_name = data.items[1].name;

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

或者，我们可以对任何属性使用括号表示法，特别是如果名称中包含的字符会使其对点表示法的使用无效：

const item_name = data['items'][1]['name'];

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

---

我试图访问一个属性，但只返回了

未定义的
？
大多数情况下，当您获取未定义的
时，对象/数组根本没有具有该名称的属性

const foo = {bar: {baz: 42}};
console.log(foo.baz); // undefined

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

使用或检查对象/数组的结构。您试图访问的属性实际上可能是在嵌套对象/数组上定义的

console.log(foo.bar.baz); // 42

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  


如果属性名是动态的，而我事先不知道它们怎么办？
如果属性名称未知，或者我们希望访问一个对象/数组元素的所有属性，我们可以使用对象循环和数组循环来迭代所有属性/元素

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

对象

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

要迭代
数据的所有属性
，我们可以迭代对象，如下所示：

for (const prop in data) {
    // `prop` contains the name of each property, i.e. `'code'` or `'items'`
    // consequently, `data[prop]` refers to the value of each property, i.e.
    // either `42` or the array
}

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

根据对象来自何处（以及您想要做什么），您可能必须在每次迭代中测试该属性是否真的是对象的属性，还是继承的属性。你可以用它来做这件事

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

作为使用
hasOwnProperty
在
中为…选择
，您可以使用获取属性名称数组：

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

阵列

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

为了迭代
数据.items
数组的所有元素，我们使用
for
循环：

for(let i = 0, l = data.items.length; i < l; i++) {
    // `i` will take on the values `0`, `1`, `2`,..., i.e. in each iteration
    // we can access the next element in the array with `data.items[i]`, example:
    // 
    // var obj = data.items[i];
    // 
    // Since each element is an object (in our example),
    // we can now access the objects properties with `obj.id` and `obj.name`. 
    // We could also use `data.items[i].id`.
}

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

在支持ES2015（ES6）的环境中，您还可以使用环路，它不仅适用于阵列，而且适用于任何：

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

在每次迭代中，
for…of
直接为我们提供iterable的下一个元素，没有可访问或使用的“索引”

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  


如果我不知道数据结构的“深度”，该怎么办？
除了未知键之外，数据结构的“深度”（即有多少嵌套对象）也可能未知。如何访问深度嵌套的属性通常取决于确切的数据结构

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

但是，如果数据结构包含重复模式，例如二叉树的表示，则解决方案通常包括访问数据结构的每个级别

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

下面是获取二叉树的第一个叶节点的示例：

function getLeaf(node) {
    if (node.leftChild) {
        return getLeaf(node.leftChild); // <- recursive call
    }
    else if (node.rightChild) {
        return getLeaf(node.rightChild); // <- recursive call
    }
    else { // node must be a leaf node
        return node;
    }
}

const first_leaf = getLeaf(root);

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

您可以通过这种方式访问它

data.items[1].name

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

或

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

这两种方法都是相同的。
如果您试图通过
id
或
name
从示例结构访问
项，而不知道它在数组中的位置，最简单的方法是使用库：

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

根据我的经验，使用高阶函数而不是
for
或
for..in
循环会导致代码更易于推理，因此更易于维护

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

只要我的2美分。
如果您愿意包括一个库，那么使用JSONPath将是最灵活的解决方案之一：
var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

（节点和浏览器）

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

对于您的用例，json路径为：

$..items[1].name

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

因此：

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

有时，使用字符串访问嵌套对象是可取的。例如，简单方法是第一级

var obj = { hello: "world" };
var key = "hello";
alert(obj[key]);//world

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

但复杂的json通常不是这样。随着json变得越来越复杂，在json中查找值的方法也变得复杂。导航json的递归方法是最好的，如何利用递归将取决于搜索的数据类型。如果涉及到条件语句，那么a是一个很好的工具

var object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

如果要访问的属性已经已知，但路径