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  

如何访问items中第二个项目的名称？

序言

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  

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

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，或名称是变量的值：

// 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  

要迭代数据的所有属性，我们可以像这样迭代对象：

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  

作为hasOwnProperty中for…的替代方法，您可以使用获取属性名称数组：

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

阵列

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

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

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或名称从示例结构中访问某个项，而不知道该项在数组中的位置，则最简单的方法是使用库：

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  

---

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

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  

如果正在访问的属性已经已知，但路径很复杂，例如在该对象中

var obj = {
 arr: [
    { id: 1, name: "larry" },    
    { id: 2, name: "curly" },
    { id: 3, name: "moe" }
 ]
};

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

你知道你想得到对象中数组的第一个结果，也许你想使用

var moe = obj["arr[0].name"];

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

但是，这将导致异常，因为没有具有该名称的对象属性。能够使用此功能的解决方案是展平对象的树外观。这可以递归地完成

function flatten(obj){
 var root = {};
 (function tree(obj, index){
   var suffix = toString.call(obj) == "[object Array]" ? "]" : "";
   for(var key in obj){
    if(!obj.hasOwnProperty(key))continue;
    root[index+key+suffix] = obj[key];
    if( toString.call(obj[key]) == "[object Array]" )tree(obj[key],index+key+suffix+"[");
    if( toString.call(obj[key]) == "[object Object]" )tree(obj[key],index+key+suffix+".");   
   }
 })(obj,"");
 return root;
}

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

现在，可以展平复杂对象

var obj = previous definition;
var flat = flatten(obj);
var moe = flat["arr[0].name"];//moe

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

---

下面是使用这种方法的一个示例。

如果您要查找一个或多个符合特定条件的对象，可以使用以下选项

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

还有一个单点和单点默认值，它们的工作原理与FirstOrdefault和FirstOrdefault非常相似。唯一的区别是，如果发现一个以上的匹配，他们将抛出

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

---

对于查询js的进一步解释，您可以从以下内容开始

我更喜欢JQuery。它更干净，更容易阅读

$.each($.parseJSON(data), function (key, value) {
  alert(value.<propertyname>);
});

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

---

这个问题很古老，所以作为当代的更新。随着ES2015的开始，有其他方法可以获得您所需的数据。现在有一个称为对象分解的功能，用于访问嵌套对象

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

常数数据={ 代码：42， 项目：[{ id:1， 姓名：“富” }, { id:2， 名称：“酒吧” }] }; 常数{ 项目：[，]{ 姓名：第二姓名 }] }=数据； console.logsecondName；下划线js方式 这是一个JavaScript库，它提供了大量有用的函数式编程助手，而不扩展任何内置对象

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

解决方案： 风险值数据={ 代码：42， 项目：[{ id:1， 姓名：“富” }, { id:2， 名称：“酒吧” }] }; var item=uu0.findHeredata.items{ 身份证号码：2 }; 如果。不确定{ console.log'NAME=>'，item.NAME； } //使用find- var item=\uu0.finddata.items，functionitem{ 返回项.id==2； }; 如果。不确定{ console.log'NAME=>'，item.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  

、ES 2017和ES 2017 Object.keys返回一个对象键数组，Object.values返回一个对象值数组，Object.entries以[key，value]格式返回一个对象键数组和相应的值

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

常量对象={ a:1 ，b:2 ，c:3 } console.logObject.keysobj/['a'，'b'，'c'] console.logObject.valuesobj/[1,2,3]

---

console.logObject.entriesObject/['a'，1]，'b'，2]，'c'，3]一种解构任意JSON树的pythonic、递归和函数式方法：

handlers = {
    list:  iterate,
    dict:  delve,
    str:   emit_li,
    float: emit_li,
}

def emit_li(stuff, strong=False):
    emission = '<li><strong>%s</strong></li>' if strong else '<li>%s</li>'
    print(emission % stuff)

def iterate(a_list):
    print('<ul>')
    map(unravel, a_list)
    print('</ul>')

def delve(a_dict):
    print('<ul>')
    for key, value in a_dict.items():
        emit_li(key, strong=True)
        unravel(value)
    print('</ul>')

def unravel(structure):
    h = handlers[type(structure)]
    return h(structure)

unravel(data)

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

---

我不认为提问者只关心一个级别的嵌套对象，所以我提供以下演示来演示如何访问深度嵌套json对象的节点。好的，让我们找到id为“5”的节点

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

风险值数据={ 代码：42， 项目：[{ id:1， 名称：“aaa”， 项目：[{ id:3， 名称：“ccc” }, { id:4， 名称：“ddd” }] }, { id:2， 名称：“bbb”， 项目：[{ id:5， 姓名：'eee' }, { id:6， 名称：“fff” }] }] }; var jsonloop=新的JSONLoopdata，'id'，'items'； jsonloop.findNodeByIddata，5，函数错误，节点{ 如果出错{ document.writeer； }否则{ document.writeJSON.stringifynode，null，2； } };

---

老问题，但没有人提到洛达斯，只是强调一下

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

如果您已经在项目中使用lodash，我认为在一个复杂的示例中使用lodash是一种优雅的方式：

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

选择1

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

同：

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

选择2

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

第一个选项和第二个选项之间的区别在于，在Opt 1中，如果路径中缺少未定义的属性之一，则不会出现错误，它会返回第三个参数

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

对于数组过滤器，lodash有u0.find，但我宁愿使用常规过滤器。但我仍然认为，当处理非常复杂的数据时，上面的方法u.get非常有用。我以前遇到过非常复杂的API，而且非常方便

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

我希望它能对正在寻找操作标题所暗示的真正复杂数据的选项的人有用。

您可以使用lodash\u get函数：

var object = { 'a': [{ 'b': { 'c': 3 } }] };

_.get(object, 'a[0].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  

风险值数据={ 代码：42， 项目：[{ id:1， 姓名：“富” }, { id:2， 名称：“酒吧” }] }; $.grepdata.items，functionitem{ 如果item.id==2{ console.logitem.id；//项的控制台id console.logitem.name；//项的控制台名称 console.logitem；//控制台项对象 退货项目//返回项对象 } }; //对象{id:2，名称：bar} 使用lodash将是一个很好的解决方案

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  

var obj = {
  name: "john doe",
  subobj: {
    subsubobj: {
      names: "I am sub sub obj"
    }
  }
};

var level = "subobj.subsubobj.names";
level = level.split(".");

var currentObjState = obj;

for (var i = 0; i < level.length; i++) {
  currentObjState = currentObjState[level[i]];
}

console.log(currentObjState);

---

工作fiddle:

要访问嵌套属性，需要指定其名称，然后搜索对象

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

如果您已经知道确切的路径，则可以在脚本中对其进行硬编码，如下所示：

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  

data.items[1].name
data['items'][1].name
data.items[1]['name']

当您手头上不知道确切的名称时，或者是用户为您提供了名称。然后需要在数据结构中进行动态搜索。这里有人建议可以使用for循环进行搜索，但是有一种非常简单的方法可以使用for遍历路径

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

路径是这样说的：首先获取包含关键项的对象，它恰好是一个数组。然后取第1个元素0索引数组。最后，获取该数组元素中键名为的对象，该元素恰好是字符串栏

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

如果路径很长，甚至可以使用String.split来简化所有操作-

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

'items.1.name'.split('.').reduce((a,v) => a[v], data)

---

这只是简单的JavaScript，没有使用任何第三方库，如jQuery或lodash。

以防万一，如果有人在2017年或以后访问这个问题，并寻找一种易于记忆的方法，这里有一篇详细的博客文章，不会被迷惑

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

无法读取未定义错误的属性“foo”

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

1.Oliver Steele的嵌套对象访问模式 最简单、最干净的方法是使用Oliver Steele的嵌套对象访问模式

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

const name = ((user || {}).personalInfo || {}).name;

有了这个符号，你永远不会遇到

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

无法读取未定义的属性“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  

2.使用Array Reduce访问嵌套对象 为了能够访问嵌套数组，您可以编写自己的数组reduce util

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

const getNestedObject = (nestedObj, pathArr) => {
    return pathArr.reduce((obj, key) =>
        (obj && obj[key] !== 'undefined') ? obj[key] : undefined, nestedObj);
}

// pass in your object structure as array elements
const name = getNestedObject(user, ['personalInfo', 'name']);

// to access nested array, just pass in array index as an element the path array.
const city = getNestedObject(user, ['personalInfo', 'addresses', 0, 'city']);
// this will return the city from the first address item.

还有一个出色的类型处理最小库，可以为您完成所有这些

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

var ourStorage = {


"desk":    {
    "drawer": "stapler"
  },
"cabinet": {
    "top drawer": { 
      "folder1": "a file",
      "folder2": "secrets"
    },
    "bottom drawer": "soda"
  }
};
ourStorage.cabinet["top drawer"].folder2; // Outputs -> "secrets"

或

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

基本上，在展开的每个子体之间使用一个点，当对象名称由两个字符串组成时，必须使用[obj 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 object = { 'a': { 'b': { 'c': 3 } } };                                                                                               
_.get(object, 'a.b.c');                                                                                             
// => 3  

var ourPets = [
  {
    animalType: "cat",
    names: [
      "Meowzer",
      "Fluffy",
      "Kit-Cat"
    ]
  },
  {
    animalType: "dog",
    names: [
      "Spot",
      "Bowser",
      "Frankie"
    ]
  }
];
ourPets[0].names[1]; // Outputs "Fluffy"
ourPets[1].names[0]; // Outputs "Spot"

资料来源：

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

描述上述情况的另一份更有用的文件：

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

通过点走访问属性：

我的stringdata来自PHP文件，但我仍然在var中指出。当我直接将json放入obj时，它不会显示这就是为什么我将json文件作为

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

var obj=JSON.parsestringdata； 在这之后，我得到消息obj并显示在警报框中，然后我得到数据，它是json数组并存储在一个变量ArrObj中，然后我读取该数组的第一个对象，其键值如下ArrObj[0].id

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

动态方法 在下面的deepdata，key函数中，您可以使用任意键字符串-在您的例子中是items[1]。name您可以在任何级别使用数组符号[i]-如果键无效，则返回undefined

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

设deep=o，k=>k.split'.'。reducea，c，i=>{ 设m=c.match/*？\[\d*\]/； ifm&&a！=null&&a[m[1]]！=null返回a[m[1][+m[2]]； 返回a==null？a:a[c]； }，o； //试验 let key='items[1]。name'//任意深度键 让数据={ 代码：42， 项目：[{id:11，名称：'foo'}，{id:22，名称：'bar'}，] };

---

console.log键“=”，deepdata，键 在2020年，您可以使用@babel/plugin建议可选链接，访问对象中的嵌套值非常容易

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

 const obj = {
 foo: {
   bar: {
     baz: class {
   },
  },
 },
};

const baz = new obj?.foo?.bar?.baz(); // baz instance

const safe = new obj?.qux?.baz(); // undefined
const safe2 = new obj?.foo.bar.qux?.(); // undefined

您可以使用语法jsonObject.key来访问该值。如果要从数组中访问值，则可以使用语法jsonObjectArray[index].key

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

下面是访问各种值的代码示例，让您了解这些值

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

风险值数据={ 代码：42， 项目：[{ id:1， 姓名：“富” }, { id:2， 名称：“酒吧” }] }; //如果你想要“酒吧” console.logdata.items[1]。名称； //如果需要项名称数组 console.logdata.items.mapx=>x.name； //获取名称为'bar'的项的id

---

console.logdata.items.filterx=>x.name==bar？x、 id:null[0]。id 这是一个简单的解释：

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

风险值数据={ 代码：42， 项目：[{ id:1， 姓名：“富” }, { id:2， 名称：“酒吧” }] }; /* 1. `数据“是对象”包含“项”对象*/ 控制台日志数据； /* 2. `item`object包含两个对象作为元素的数组*/ console.logdata.items； /* 3.您需要数组的第二个元素，`[0，1]中的`1``*/ console.logdata.items[1]； /* 4.您需要数组的第二个对象元素的'name'属性的值*/ console.logdata.items[1]。名称 这里有一个答案

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 objectScan=需要“对象扫描”； 常量数据={code:42，项：[{id:1，名称：'foo'}，{id:2，名称：'bar'}]}； const get=haystack，针=>objectScan[Pionel]{ 中止：对， rtn:'价值' }干草堆； 常量集=干草堆，针，值=>objectScan[针]{ 中止：对， rtn:‘bool’， filterFn:{parent，property}=>{ 父[属性]=值； 返回true； } }干草堆； console.loggetdata，'items[1].name'； //=>巴 console.logsetdata，'items[1].name，'foo2'； //=>正确 控制台日志数据； //=>{code:42，项：[{id:1，名称：'foo'}，{id:2，名称：'foo2'}]} .作为控制台包装{最大高度：100%！重要；顶部：0} 下面介绍了获取对象属性的4种不同方法： 风险值数据={ 代码：42， 项目：[{ id:1， 姓名：“富” }, { id:2， 名称：“酒吧” }] }; //方法1 让method1=data.items[1].name； console.logmethod1； //方法2 设method2=data.items[1][name]； console.logmethod2； //方法3 方法3=数据[项目][1][名称]； console.logmethod3； //方法4分解结构 设{items:[，{name:second_name}]}=data；

---

---

console.logu第二个名称@Marcel：它必须被读取，因为我有一个数据嵌套的数据结构或JSON，我如何访问一个特定的值？。我知道其中的区别，但很多人不知道，而且可能正在搜索JSON而不是object。实际上，许多问题的形式是如何在这个JSON中访问X。我在回答中提到JSON的唯一地方是解释它是什么。如果你有一个如何更好地交流的建议，我洗耳恭听。这个答案的可能重复帮助我很好地解决了访问嵌套对象的问题。香草：允许编写例如：someObject.accessfirstPart[2].someOtherPart.MyId此处链接的一些内容实际上是询问如何在jQuery中执行此操作，公平地说，这可以简化这里的一两件事情。不确定是让这篇文章更像是一篇博文，还是单独回答这些问题——这里介绍的关于什么是对象什么是数组的基本知识通常是真正被问到的@菲利克斯·克林有一件事。。。对于嵌套对象，例如let object={a:1，b:2，c:{a:3，b:4}；，这将返回一个数组，其中包含每个嵌套对象的数组，在本例中[1,2,3,4]]在递归调用中使用concat而不是push不是更好吗？要求结果是可变的这一页让我了解了数组和OBJWTH之间的区别。您想使用obj[arr[0].name]而不是obj.arr[0].name吗？除了序列化，你几乎不需要/不想处理这个问题。@Bergi-我经常看到这个问题，因为这个问题被规范地使用，所以我发布了这个版本的答案。如果可以避免，那么使用obj.arr[0].name要快得多，但有时人们希望传递字符串访问器，这就是这样做的一个例子。Urgh。尽管如此，几乎没有理由只使用单个字符串路径来展平整个对象，您可以简单地解析它并进行动态查找。我很想知道如何改进这一点。想留下评论吗？是的，但你不能做数据[项目].1.nameFirst更直观、可读性更强、更简短；我更喜欢仅当属性名为变量时才使用括号属性语法。@neaumusic为什么要这样做？这个问题是关于JavaScript的，不是关于Python的。不确定Python是否存在类似的问题。使用eval不是一个好的解决方案。相反，可以使用第一类函数。如何使用变量访问嵌套的json对象。数据={a:{b:'ss'}}；var key=a.b数据[key]不工作这与什么不同？这个问题主要是关于现有的访问属性。关于您所指的内容以及您的大多数解决方案，已经存在一个问题：或。但无论如何：不幸的是，您无法使用此技巧访问嵌套数组。为什么不呢？数组是对象，所以它也应该工作。你能提供一个没有的例子吗？@FelixKling当我们尝试使用Oliver Steele模式访问数组时，我们将无法动态创建长度为“n”的数组并访问第n个索引，而不会出现“未定义”错误。例如.user |{}.address | | new Array3[1].name您没有一致地应用您的模式。当然…[1]。如果元素1不存在，bar将导致错误。但如果foo不存在，foo.bar也是如此。您还必须保护访问1，就像保护任何其他属性访问一样。数组只是一个对象。数组元素只是一个属性。如果应用正确，它将是user |{}.address |{}[1]|{}.name。这很好。我并没有这样想。谢谢@FelixKling，我会去更新博客帖子的。@DineshPandiyan你应该讨论一下

---

既然你是typy的作者，我是在读了你的博文后来到这里的。虽然这个链接可能会回答这个问题，但最好在这里包含答案的基本部分，并提供链接供参考。如果链接页面发生更改，仅链接的答案可能无效。-我编辑了这篇文章。尽管人们很快就给它留下了坏名声。下次我将避免给出答案。@Riddick不要重复，只需确保不要只发布链接。该示例令人困惑，因为stringjson不是字符串。这是我最喜欢的答案。您还可以为循环添加一个示例，例如Object.KeyData[items].forEachfunctionkey{console.logdata[items][key].id；console.logdata[items][key].name；}；我很确定这就是node.js，他想知道如何用javascript实现它。如果他真的想使用node.js，他当然会把它放在他的标签中。但这会对我有所帮助，因为我正试图在node.js中寻找解决方法。Nodejs是javascript。但如果我正确理解您的评论：我认为您可以在浏览器javascript中使用任何npm包，例如babel？node.js是服务器端，javascript是客户端。不，你不能在浏览器javascript中使用npm包，只有我，我已经试过了。我主要是为了好玩才试的。但是，即使是node.js，您基本上说的是一种漫长而复杂的方式@这个答案实际上可以解决问题。你绝对可以——我喜欢的软件包可以做很多事情。因此，基于您的用例，拥有它可能会很好。我知道设置它可能需要一些工作up@JonathanJ.Pecany我对示例进行了编辑，使其可运行，并展示了如何在浏览器中使用它。我只想快速对此进行评论，因为这个问题的作者没有选择最佳答案。这实际上是最好的答案。所以其他任何人都在寻找答案，这是最好的答案。这个答案不会添加任何其他答案中没有的东西，比如被接受的答案