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

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

例如:

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

我如何访问项目中的第二个项目的名称?

当前回答

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

如果你已经知道确切的路径，那么你可以像这样在你的脚本中硬编码它:

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

这些也有用——

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

如果您事先不知道确切的名称，或者用户是为您提供名称的人。然后需要动态搜索数据结构。有些人建议可以使用for循环来完成搜索，但是有一种非常简单的方法可以使用Array.reduce遍历路径。

const data = { code: 42, items: [{ id: 1, name: 'foo' }, { id: 2, name: 'bar' }] }
const path = [ 'items', '1', 'name']
let result = path.reduce((a,v) => a[v], data)

路径的意思是:首先获取带有关键项的对象，它恰好是一个数组。然后取第1个元素(0个索引数组)。最后取该数组元素中键名的对象，恰好是字符串bar。

如果路径很长，甚至可以使用String。分开让这一切更容易-

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

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

2018-02-15 10:06:43

其他回答

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

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

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

如果已经知道要访问的属性，但是路径很复杂，例如在这个对象中

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

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

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

然而，这将导致一个异常，因为对象没有该名称的属性。能够使用这种方法的解决方案是将对象的树形面平直。这可以递归完成。

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 obj = previous definition;
var flat = flatten(obj);
var moe = flat["arr[0].name"];//moe

下面是使用这种方法的jsFiddle演示。

2014-08-18 19:20:05

预赛

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

(普通)对象具有窗体

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

数组有这样的形式

[value, value, ...]

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

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

const value = obj.someProperty;

或者括号，如果属性名不是一个有效的JavaScript标识符名称[spec]，或者名称是一个变量的值:

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

因此，数组元素只能使用括号符号访问:

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

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

等待……JSON呢?

JSON是数据的文本表示，就像XML、YAML、CSV等一样。要处理这些数据，首先必须将其转换为JavaScript数据类型，即数组和对象(以及如何处理这些数据)。如何解析JSON在问题中解释了解析JSON在JavaScript?．

进一步阅读材料

如何访问数组和对象是基本的JavaScript知识，因此最好阅读MDN JavaScript指南，特别是部分

使用对象数组雄辩的JavaScript -数据结构

访问嵌套数据结构

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

这里有一个例子:

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

让我们假设我们想要访问第二个项目的名称。

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

正如我们所看到的，数据是一个对象，因此我们可以使用点表示法访问它的属性。items属性的访问方式如下:

data.items

该值是一个数组，要访问它的第二个元素，我们必须使用括号表示:

data.items[1]

这个值是一个对象，我们再次使用点表示法来访问name属性。所以我们最终得到:

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

或者，我们可以对任何属性使用括号表示法，特别是如果名称中包含的字符将使它不能使用点表示法:

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

我试图访问一个属性，但我只得到未定义的回来?

大多数情况下，当你获得undefined时，对象/数组根本没有这个名称的属性。

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

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

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

如果属性名是动态的，而我事先不知道它们怎么办?

如果属性名未知，或者我们想访问一个对象/数组元素的所有属性，可以使用for…in [MDN]循环用于对象，for [MDN]循环用于数组遍历所有属性/元素。

对象

要遍历数据的所有属性，我们可以像这样遍历对象:

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
}

根据对象的来源(以及您想要做什么)，您可能必须在每次迭代中测试该属性是否真的是对象的属性，还是继承的属性。你可以使用Object#hasOwnProperty [MDN]来实现。

作为…的替代方案在hasOwnProperty中，你可以使用Object。key [MDN]获取属性名数组:

Object.keys(data).forEach(function(prop) {
  // `prop` is the property name
  // `data[prop]` is the property value
});

数组

遍历数据的所有元素。数组中，我们使用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`.
}

One也可以用for…在数组上迭代，但有原因为什么这应该避免:为什么'for(var item in list)'数组被认为是JavaScript中的坏做法?

随着浏览器对ECMAScript 5的支持越来越多，数组方法forEach [MDN]也成为了一个有趣的替代方案:

data.items.forEach(function(value, index, array) {
    // The callback is executed for each element in the array.
    // `value` is the element itself (equivalent to `array[index]`)
    // `index` will be the index of the element in the array
    // `array` is a reference to the array itself (i.e. `data.items` in this case)
});

在支持ES2015 (ES6)的环境中，你也可以使用for…[MDN]循环，它不仅适用于数组，而且适用于任何可迭代对象:

for (const item of data.items) {
   // `item` is the array element, **not** the index
}

在每次迭代中，对于…Of直接提供了可迭代对象的下一个元素，没有“索引”可以访问或使用。

如果我不知道数据结构的“深度”会怎样?

除了未知的键，数据结构的“深度”(即有多少个嵌套对象)也可能是未知的。如何访问深度嵌套的属性通常取决于确切的数据结构。

但是如果数据结构包含重复的模式，例如二叉树的表示，解决方案通常包括递归地访问数据结构的每一层。

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

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);

访问具有未知键和深度的嵌套数据结构的一种更通用的方法是测试值的类型并据此进行操作。

下面是一个示例，它将嵌套数据结构中的所有原语值添加到一个数组中(假设它不包含任何函数)。如果遇到一个对象(或数组)，我们简单地对该值再次调用toArray(递归调用)。

function toArray(obj) {
    const result = [];
    for (const prop in obj) {
        const value = obj[prop];
        if (typeof value === 'object') {
            result.push(toArray(value)); // <- recursive call
        }
        else {
            result.push(value);
        }
    }
    return result;
}

Const data = { 42岁的代码: 项目:[{ id: 1、名称:“foo” }, { id: 2 名称:“酒吧” }) }; 函数toArray(obj) { Const result = []; For (const prop in obj) { Const值= obj[道具]; If (typeof value === 'object') { result.push (toArray(值)); }其他{ result.push(价值); ｝｝返回结果; ｝ console.log (toArray(数据));

助手

由于复杂对象或数组的结构并不明显，我们可以在每一步检查值，以决定如何进一步移动。console.log [MDN]和console.log。dir [MDN]帮助我们做到这一点。例如(Chrome控制台的输出):

> console.log(data.items)
 [ Object, Object ]

这里我们看到数据。Items是一个包含两个元素的数组，两个元素都是对象。在Chrome控制台中，对象甚至可以立即展开和检查。

> console.log(data.items[1])
  Object
     id: 2
     name: "bar"
     __proto__: Object

这告诉我们数据。[1]是一个对象，展开它后，我们看到它有三个属性，id, name和__proto__。后者是用于对象的原型链的内部属性。但是，原型链和继承不在这个答案的范围之内。

2012-08-12 13:02:12

下划线js的方式

这是一个JavaScript库，它提供了一大堆有用的函数式编程助手，而不扩展任何内置对象。

解决方案:

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

var item = _.findWhere(data.items, {
  id: 2
});
if (!_.isUndefined(item)) {
  console.log('NAME =>', item.name);
}

//using find - 

var item = _.find(data.items, function(item) {
  return item.id === 2;
});

if (!_.isUndefined(item)) {
  console.log('NAME =>', item.name);
}

2016-08-13 10:39:25

如果您试图在JSON字符串中查找路径，可以将数据转储到https://jsonpathfinder.com并单击GUI元素。它将生成元素路径的JS语法。

除此之外，对于您可能想要迭代的任何数组，用循环替换相关的数组偏移下标，如[0]。

这里有一个简单版本的工具，你可以在这里或在https://ggorlen.github.io/json-dive/上运行。单击要将路径复制到剪贴板的节点。

/* code minified to make the tool easier to run without having to scroll */ let bracketsOnly=!1,lastHighlighted={style:{}};const keyToStr=t=>!bracketsOnly&&/^[a-zA-Z_$][a-zA-Z$_\d]*$/.test(t)?`.${toHTML(t)}`:`["${toHTML(t)}"]`,pathToData=t=>`data-path="data${t.join("")}"`,htmlSpecialChars={"&":"&","<":"<",">":">",'"':""","'":"'","\t":"\\t","\r":"\\r","\n":"\\n"," ":" "},toHTML=t=>(""+t).replace(/[&<>"'\t\r\n ]/g,t=>htmlSpecialChars[t]),makeArray=(t,e)=>`\n [<ul ${pathToData(e)}>\n ${t.map((t,a)=>{e.push(`[${a}]`);const n=`<li ${pathToData(e)}>\n ${pathify(t,e).trim()},\n </li>`;return e.pop(),n}).join("")}\n </ul>]\n`,makeObj=(t,e)=>`\n {<ul ${pathToData(e)}>\n ${Object.entries(t).map(([t,a])=>{e.push(keyToStr(t));const n=`<li ${pathToData(e)}>\n "${toHTML(t)}": ${pathify(a,e).trim()},\n </li>`;return e.pop(),n}).join("")}\n </ul>}\n`,pathify=(t,e=[])=>Array.isArray(t)?makeArray(t,e):"object"==typeof t&&t!=null?makeObj(t,e):toHTML("string"==typeof t?`"${t}"`:t),defaultJSON='{\n "corge": "test JSON... \\n asdf\\t asdf",\n "foo-bar": [\n {"id": 42},\n [42, {"foo": {"baz": {"ba r<>!\\t": true, "4quux": "garply"}}}]\n ]\n}',$=document.querySelector.bind(document),$$=document.querySelectorAll.bind(document),resultEl=$("#result"),pathEl=$("#path"),tryToJSON=t=>{try{resultEl.innerHTML=pathify(JSON.parse(t)),$("#error").innerText=""}catch(t){resultEl.innerHTML="",$("#error").innerText=t}},copyToClipboard=t=>{const e=document.createElement("textarea");e.textContent=t,document.body.appendChild(e),e.select(),document.execCommand("copy"),document.body.removeChild(e)},flashAlert=(t,e=2e3)=>{const a=document.createElement("div");a.textContent=t,a.classList.add("alert"),document.body.appendChild(a),setTimeout(()=>a.remove(),e)},handleClick=t=>{t.stopPropagation(),copyToClipboard(t.target.dataset.path),flashAlert("copied!"),$("#path-out").textContent=t.target.dataset.path},handleMouseOut=t=>{lastHighlighted.style.background="transparent",pathEl.style.display="none"},handleMouseOver=t=>{pathEl.textContent=t.target.dataset.path,pathEl.style.left=`${t.pageX+30}px`,pathEl.style.top=`${t.pageY}px`,pathEl.style.display="block",lastHighlighted.style.background="transparent",(lastHighlighted=t.target.closest("li")).style.background="#0ff"},handleNewJSON=t=>{tryToJSON(t.target.value),[...$$("#result *")].forEach(t=>{t.addEventListener("click",handleClick),t.addEventListener("mouseout",handleMouseOut),t.addEventListener("mouseover",handleMouseOver)})};$("textarea").addEventListener("change",handleNewJSON),$("textarea").addEventListener("keyup",handleNewJSON),$("textarea").value=defaultJSON,$("#brackets").addEventListener("change",t=>{bracketsOnly=!bracketsOnly,handleNewJSON({target:{value:$("textarea").value}})}),handleNewJSON({target:{value:defaultJSON}}); /**/ *{box-sizing:border-box;font-family:monospace;margin:0;padding:0}html{height:100%}#path-out{background-color:#0f0;padding:.3em}body{margin:0;height:100%;position:relative;background:#f8f8f8}textarea{width:100%;height:110px;resize:vertical}#opts{background:#e8e8e8;padding:.3em}#opts label{padding:.3em}#path{background:#000;transition:all 50ms;color:#fff;padding:.2em;position:absolute;display:none}#error{margin:.5em;color:red}#result ul{list-style:none}#result li{cursor:pointer;border-left:1em solid transparent}#result li:hover{border-color:#ff0}.alert{background:#f0f;padding:.2em;position:fixed;bottom:10px;right:10px}  <div class="wrapper"><textarea></textarea><div id="opts"><label>brackets only: <input id="brackets"type="checkbox"></label></div><div id="path-out">click a node to copy path to clipboard</div><div id="path"></div><div id="result"></div><div id="error"></div></div>

Unminified(也可以在GitHub上找到):

这并不是为了代替学习如何钓鱼，但一旦你知道了，可以节省时间。

2021-07-20 19:22:48

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

data.items[1].name

data["items"][1]["name"]

两边相等。

2013-05-14 03:29:19

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

推荐文章

最新文章

标签