Jak Mogę uzyskać dostęp i przetwarzać zagnieżdżone obiekty, tablice lub JSON?

Możesz uzyskać do niego dostęp w ten sposób

data.items[1].name

Lub

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

Obie drogi są równe.

Jeśli próbujesz uzyskać dostęp do item z przykładowej struktury przez id lub name, bez znajomości jego pozycji w tablicy, najprostszym sposobem na to jest użycie podkreślenia .biblioteka js:

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

_.find(data.items, function(item) {
  return item.id === 2;
});
// Object {id: 2, name: "bar"}

Z mojego doświadczenia wynika, że używanie funkcji wyższego rzędu zamiast pętli for lub for..in powoduje, że kod jest łatwiejszy do rozumowania, a przez to łatwiejszy do utrzymania.

Obiekty i tablice mają wiele wbudowanych metod, które mogą pomóc w przetwarzaniu danych.

Uwaga: w wielu przykładach używam funkcji strzałek. Są one podobne do wyrażeń funkcyjnych , ale wiążą wartość this leksykalnie.

Object.keys(), Object.values() (ES 2017) oraz Object.entries() (ES 2017)

Object.keys() zwraca tablicę kluczy obiektu, Object.values() zwraca tablicę wartości obiektu, a Object.entries() zwraca tablicę klucze obiektu i odpowiadające im wartości w formacie [key, value].

const obj = {
  a: 1
 ,b: 2
 ,c: 3
}

console.log(Object.keys(obj)) // ['a', 'b', 'c']
console.log(Object.values(obj)) // [1, 2, 3]
console.log(Object.entries(obj)) // [['a', 1], ['b', 2], ['c', 3]]

Object.entries() z pętlą for-of i przypisaniem destrukcji

const obj = {
  a: 1
 ,b: 2
 ,c: 3
}

for (const [key, value] of Object.entries(obj)) {
  console.log(`key: ${key}, value: ${value}`)
}

Bardzo wygodne jest iterację wyniku Object.entries() za pomocąpętli For-of Iprzypisania destrukcji .

Przypisanie destrukcji pozwala wyodrębnić wartości z tablicy lub obiektu i przypisać je do zmiennych. W tym przypadku const [key, value] oznacza, że zamiast przypisać tablicę [key, value] do element, przypisujemy pierwszy element tej tablicy do key, a drugi do value. Jest to równoważne:

for (const element of Object.entries(obj)) {
  const key = element[0]
       ,value = element[1]
}

Jak widzisz, destrukcja sprawia, że jest to o wiele prostsze.

Array.prototype.every() oraz Array.prototype.some()

The every() metoda zwraca true jeśli określona funkcja zwrotna zwraca true dla każdego elementu tablicy. Metoda some() zwraca true jeśli określona funkcja zwrotna zwraca true dla jakiegoś (co najmniej jednego) elementu.

const arr = [1, 2, 3]

// true, because every element is greater than 0
console.log(arr.every(x => x > 0))
// false, because 3^2 is greater than 5
console.log(arr.every(x => Math.pow(x, 2) < 5))
// true, because 2 is even (the remainder from dividing by 2 is 0)
console.log(arr.some(x => x % 2 === 0))
// false, because none of the elements is equal to 5
console.log(arr.some(x => x === 5))

Array.prototype.find() oraz Array.prototype.filter()

Metody find() zwracają pierwszy element spełniający podaną funkcję wywołania zwrotnego. Metoda filter() zwraca tablicę wszystkie elementy, które spełniają podaną funkcję zwrotną.

const arr = [1, 2, 3]

// 2, because 2^2 !== 2
console.log(arr.find(x => x !== Math.pow(x, 2)))
// 1, because it's the first element
console.log(arr.find(x => true))
// undefined, because none of the elements equals 7
console.log(arr.find(x => x === 7))

// [2, 3], because these elements are greater than 1
console.log(arr.filter(x => x > 1))
// [1, 2, 3], because the function returns true for all elements
console.log(arr.filter(x => true))
// [], because none of the elements equals neither 6 nor 7
console.log(arr.filter(x => x === 6 || x === 7))

Array.prototype.map()

Metoda map() zwraca tablicę z wynikami wywołania dostarczonej funkcji wywołania zwrotnego na elementach tablicy.

const arr = [1, 2, 3]

console.log(arr.map(x => x + 1)) // [2, 3, 4]
console.log(arr.map(x => String.fromCharCode(96 + x))) // ['a', 'b', 'c']
console.log(arr.map(x => x)) // [1, 2, 3] (no-op)
console.log(arr.map(x => Math.pow(x, 2))) // [1, 4, 9]
console.log(arr.map(String)) // ['1', '2', '3']

Array.prototype.reduce()

Metoda reduce() redukuje tablicę do pojedynczej wartości przez wywołanie dostarczonej funkcji wywołania zwrotnego z dwoma żywioły.

const arr = [1, 2, 3]

// Sum of array elements.
console.log(arr.reduce((a, b) => a + b)) // 6
// The largest number in the array.
console.log(arr.reduce((a, b) => a > b ? a : b)) // 3

Metoda reduce() pobiera opcjonalny drugi parametr, który jest wartością początkową. Jest to przydatne, gdy tablica, na której wywołujesz reduce() może mieć zero lub jeden element. Na przykład, jeśli chcemy utworzyć funkcję sum(), która pobiera tablicę jako argument i Zwraca sumę wszystkich elementów, możemy napisać ją w następujący sposób:

const sum = arr => arr.reduce((a, b) => a + b, 0)

console.log(sum([]))     // 0
console.log(sum([4]))    // 4
console.log(sum([2, 5])) // 7

Czasami pożądane jest uzyskanie dostępu do zagnieżdżonego obiektu za pomocą łańcucha znaków. Proste podejście jest pierwszym poziomem, na przykład

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

Ale często tak nie jest w przypadku złożonego json. W miarę jak json staje się bardziej złożony, podejścia do znajdowania wartości wewnątrz json również stają się złożone. Rekurencyjne podejście do nawigacji po json jest najlepsze, a sposób wykorzystania tej rekurencji zależy od rodzaju wyszukiwanych danych. Jeśli w grę wchodzą wyrażenia warunkowe, a json search może być dobrym narzędziem do użycia.

Jeżeli dostępna właściwość jest już znana, ale ścieżka jest złożona, na przykład w tym obiekcie

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

I wiesz, że chcesz uzyskać pierwszy wynik tablicy w obiekcie, być może chciałbyś użyć

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

Spowoduje to jednak wyjątek, ponieważ nie ma właściwości obiektu o tej nazwie. Rozwiązaniem, aby móc tego użyć, byłoby spłaszczenie aspektu drzewa obiektu. Można to zrobić rekurencyjnie.

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

Teraz obiekt złożony może zostać spłaszczony

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

Oto jsFiddle Demo tego podejścia.

To pytanie jest dość stare, więc jako współczesna aktualizacja. Wraz z pojawieniem się ES2015 istnieją alternatywy, aby uzyskać dostęp do wymaganych danych. Istnieje teraz funkcja o nazwie destrukcja obiektów do uzyskiwania dostępu do zagnieżdżonych obiektów.

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

const {
  items: [, {
    name: secondName
  }]
} = data;

console.log(secondName);

Powyższy przykład tworzy zmienną o nazwie secondName z klucza name z tablicy o nazwie items, która mówi o pominięciu pierwszego obiektu w tablicy.

Zwłaszcza, że to chyba przesada dla tego przykładu, as simple array acccess jest łatwiejszy do odczytania, ale przydaje się przy rozbijaniu obiektów w ogóle.

To bardzo krótkie wprowadzenie do konkretnego przypadku użycia, destrukcja może być nietypową składnią, do której można się przyzwyczaić na początku. Polecam przeczytanie dokumentacji przypisania destrukcji Mozilli , aby dowiedzieć się więcej.

Możesz użyć lodash _get funkcji:

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

_.get(object, 'a[0].b.c');
// => 3

Aby uzyskać dostęp do zagnieżdżonego atrybutu, musisz podać jego nazwę, a następnie przeszukać obiekt.

Jeśli znasz już dokładną ścieżkę, możesz ją na twardo zakodować w swoim skrypcie w następujący sposób:

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

Te również działają -

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

Gdy nie znasz dokładnej nazwy przed ręką, lub użytkownik jest Tym, który podaje nazwę dla Ciebie. Następnie wymagane jest dynamiczne przeszukiwanie struktury danych. Niektórzy sugerowali tutaj, że wyszukiwanie można wykonać za pomocą pętli for, ale jest bardzo prosty sposób na przejście ścieżki za pomocą 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)

Ścieżka jest sposobem na powiedzenie: najpierw weź obiekt za pomocą klucza items, który jest tablicą. Następnie weź element 1 - st (0 tablic indeksowych). Na koniec weź obiekt z kluczem name w tym elemencie tablicy, który jest łańcuchem bar.

Jeśli masz bardzo długą ścieżkę, możesz nawet użyć String.split, aby to wszystko ułatwić -

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

Jest to po prostu zwykły JavaScript, bez użycia jakichkolwiek biblioteki innych firm, takie jak jQuery lub lodash.

var ourStorage = {


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

Lub

//parent.subParent.subsubParent["almost there"]["final property"]

Zasadniczo, używaj kropki pomiędzy każdym potomkiem, który rozwija się pod nim i gdy masz nazwy obiektów wykonane z dwóch łańcuchów, musisz użyć notacji ["obj Name"]. W przeciwnym razie wystarczy kropka;

Aby dodać do tego, dostęp do zagnieżdżonych tablic stanie się tak:

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"

Źródło: https://learn.freecodecamp.org/javascript-algorithms-and-data-structures/basic-javascript/accessing-nested-arrays/

Kolejny bardziej przydatny dokument przedstawiający powyższą sytuację: https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/Basics#Bracket_notation

Dostęp do nieruchomości przez dot walking: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors#Dot_notation

To proste wyjaśnienie:

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

/*
1. `data` is object contain `item` object*/
console.log(data);

/*
2. `item` object contain array of two objects as elements*/
console.log(data.items);

/*
3. you need 2nd element of array - the `1` from `[0, 1]`*/
console.log(data.items[1]);

/*
4. and you need value of `name` property of 2nd object-element of array)*/
console.log(data.items[1].name);

Na wszelki wypadek, ktoś odwiedza to pytanie w 2017 lub później i szuka łatwego do zapamiętania sposobu, oto rozbudowany post na blogu o dostępie do zagnieżdżonych obiektów w JavaScript bez bycia oszukanym przez

nie można odczytać właściwości 'foo' undefined error

1. Wzór dostępu do zagnieżdżonego obiektu Olivera Steele ' a

Najprostszym i najczystszym sposobem jest użycie zagnieżdżonego wzorca dostępu Olivera Steele ' a

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

Z tą notacją, nigdy nie wpadniesz na

nie można odczytać właściwości 'name' niezdefiniowanej .

Zasadniczo sprawdzasz, czy użytkownik istnieje, jeśli nie, tworzysz pusty obiekt w locie. W ten sposób klucz następnego poziomu będzie zawsze dostępny z istniejącego obiektu lub pustego obiektu , ale nigdy z undefined.

2. Dostęp Do Zagnieżdżonych Obiektów Za Pomocą Array Reduce

Aby mieć dostęp do zagnieżdżonych tablic, możesz napisać własną array reduce util.

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.

Istnieje również doskonała obsługa typu minimalna biblioteka typy , która robi to wszystko za Ciebie.

Użycie JSONPath byłoby jednym z najbardziej elastycznych rozwiązań, jeśli chcesz dołączyć bibliotekę: https://github.com/s3u/JSONPath (węzeł i przeglądarka)

W Twoim przypadku ścieżka json będzie:

$..items[1].name

Więc:

var secondName = jsonPath.eval(data, "$..items[1].name");

Dostęp do dynamicznie wielopoziomowego obiektu.

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

Praca: https://jsfiddle.net/andreitodorut/3mws3kjL/

Wolę JQuery. Jest czystszy i czytelny.

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

Jeśli szukasz jednego lub więcej obiektów spełniających określone kryteria, masz kilka opcji za pomocą query-js

//will return all elements with an id larger than 1
data.items.where(function(e){return e.id > 1;});
//will return the first element with an id larger than 1
data.items.first(function(e){return e.id > 1;});
//will return the first element with an id larger than 1 
//or the second argument if non are found
data.items.first(function(e){return e.id > 1;},{id:-1,name:""});

Istnieje również single i singleOrDefault działają podobnie jak odpowiednio first i firstOrDefault. Jedyną różnicą jest to, że będą rzucać, jeśli więcej niż jeden mecz zostanie znaleziony.

Dla dalszego wyjaśnienia zapytania-js możesz zacząć od tego post

The Underscore js Way

, która jest biblioteką JavaScript, która dostarcza całą masę użytecznych helperów functional programming bez rozszerzania żadnych wbudowanych obiektów.

Rozwiązanie:

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

Stare pytanie, ale jak nikt nie wspomniał lodash (tylko podkreślam).

Opt 1

_.get(response, ['output', 'fund', 'data', '0', 'children', '0', 'group', 'myValue'], '')

To samo co:

Opt 2

response.output.fund.data[0].children[0].group.myValue

Różnica między pierwszą i drugą opcją jest taka, że w opcie Opt 1 jeśli w ścieżce brakuje jednej z właściwości (niezdefiniowanej), nie otrzymasz błędu, zwróci ci trzecią parametr.

Dla filtra tablicy lodash ma _.find() ale wolałbym użyć zwykłego filter(). Ale nadal uważam, że powyższa metoda _.get() jest bardzo przydatna przy pracy z naprawdę złożonymi danymi. W przeszłości miałem do czynienia z naprawdę złożonymi interfejsami API i było to przydatne!

Mam nadzieję, że będzie to przydatne dla tych, którzy szukają możliwości manipulowania naprawdę złożonymi danymi, co sugeruje tytuł.

Nie wydaje mi się, aby questerer dotyczył tylko jednego zagnieżdżonego obiektu, dlatego przedstawiam poniższe demo, aby zademonstrować, jak uzyskać dostęp do węzła głęboko zagnieżdżonego obiektu json. Znajdźmy węzeł o id '5'.

var data = {
  code: 42,
  items: [{
    id: 1,
    name: 'aaa',
    items: [{
        id: 3,
        name: 'ccc'
      }, {
        id: 4,
        name: 'ddd'
      }]
    }, {
    id: 2,
    name: 'bbb',
    items: [{
        id: 5,
        name: 'eee'
      }, {
        id: 6,
        name: 'fff'
      }]
    }]
};

var jsonloop = new JSONLoop(data, 'id', 'items');

jsonloop.findNodeById(data, 5, function(err, node) {
  if (err) {
    document.write(err);
  } else {
    document.write(JSON.stringify(node, null, 2));
  }
});

<script src="https://rawgit.com/dabeng/JSON-Loop/master/JSONLoop.js"></script>

Możesz użyć składni jsonObject.key, Aby uzyskać dostęp do wartości. Jeśli chcesz uzyskać dostęp do wartości z tablicy, możesz użyć składni jsonObjectArray[index].key.

Oto przykłady kodu, aby uzyskać dostęp do różnych wartości, aby dać ci pomysł.

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

        // if you want 'bar'
        console.log(data.items[1].name);

        // if you want array of item names
        console.log(data.items.map(x => x.name));

        // get the id of the item where name = 'bar'
        console.log(data.items.filter(x => (x.name == "bar") ? x.id : null)[0].id);

W 2020 roku możesz użyć @babel / plugin-proposal-optional-chaining bardzo łatwo jest uzyskać dostęp do zagnieżdżonych wartości w obiekcie.

 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

Https://babeljs.io/docs/en/babel-plugin-proposal-optional-chaining

Https://github.com/tc39/proposal-optional-chaining

Podejście dynamiczne

W poniższej funkcji deep(data,key) możesz użyć dowolnego key string-w Twoim przypadku items[1].name (możesz użyć notacji tablicy [i] na dowolnym poziomie) - jeśli klucz jest nieprawidłowy, to undefined jest return.

let deep = (o,k) => k.split('.').reduce((a,c,i) => {
    let m=c.match(/(.*?)\[(\d*)\]/);
    if(m && a!=null && a[m[1]]!=null) return a[m[1]][+m[2]];
    return a==null ? a: a[c];
},o);

// TEST

let key = 'items[1].name' // arbitrary deep-key

let data = {
    code: 42,
    items: [{ id: 11, name: 'foo'}, { id: 22, name: 'bar'},]
};

console.log( key,'=', deep(data,key) );

Funkcja grep JQuery pozwala filtrować przez tablicę:

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

$.grep(data.items, function(item) {
    if (item.id === 2) {
        console.log(item.id); //console id of item
        console.log(item.name); //console name of item
        console.log(item); //console item object
        return item; //returns item object
    }

});
// Object {id: 2, name: "bar"}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

// const path = 'info.value[0].item'
// const obj = { info: { value: [ { item: 'it works!' } ], randominfo: 3 }  }
// getValue(path, obj)

export const getValue = ( path , obj) => {
  const newPath = path.replace(/\]/g, "")
  const arrayPath = newPath.split(/[\[\.]+/) || newPath;

  const final = arrayPath.reduce( (obj, k) => obj ?  obj[k] : obj, obj)
  return final;
}

A pythonic, recursive i functional approach to unravel arbitrary JSON trees:

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)

Gdzie data jest listą Pythona (przetwarzaną z ciągu tekstowego JSON):

data = [
    {'data': {'customKey1': 'customValue1',
           'customKey2': {'customSubKey1': {'customSubSubKey1': 'keyvalue'}}},
  'geometry': {'location': {'lat': 37.3860517, 'lng': -122.0838511},
               'viewport': {'northeast': {'lat': 37.4508789,
                                          'lng': -122.0446721},
                            'southwest': {'lat': 37.3567599,
                                          'lng': -122.1178619}}},
  'name': 'Mountain View',
  'scope': 'GOOGLE',
  'types': ['locality', 'political']}
]

Oto odpowiedź za pomocą object-scan.

Podczas uzyskiwania dostępu do pojedynczego wpisu, ta odpowiedź nie przynosi zbyt wielu korzyści w porównaniu z JavaScript vanilla. Jednak interakcja z wieloma polami w tym samym czasie ta odpowiedź może być bardziej wydajna.

Oto jak można oddziaływać z pojedynczym polem

// const objectScan = require('object-scan');

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

const get = (haystack, needle) => objectScan([needle], {
  abort: true,
  rtn: 'value'
})(haystack);

const set = (haystack, needle, value) => objectScan([needle], {
  abort: true,
  rtn: 'bool',
  filterFn: ({ parent, property }) => {
    parent[property] = value;
    return true;
  }
})(haystack);

console.log(get(data, 'items[1].name'));
// => bar

console.log(set(data, 'items[1].name', 'foo2'));
// => true
console.log(data);
// => { code: 42, items: [ { id: 1, name: 'foo' }, { id: 2, name: 'foo2' } ] }

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

<script src="https://bundle.run/[email protected]"></script>

Disclaimer : jestem autorem object-scan

A oto jak można współdziałać z wiele pól jednocześnie

// const objectScan = require('object-scan');

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

const get = (haystack, ...needles) => objectScan(needles, {
  joined: true,
  rtn: 'entry'
})(haystack);

const set = (haystack, actions) => objectScan(Object.keys(actions), {
  rtn: 'count',
  filterFn: ({ matchedBy, parent, property }) => {
    matchedBy.forEach((m) => {
      parent[property] = actions[m];
    })
    return true;
  }
})(haystack);

console.log(get(data, 'items[0].name', 'items[1].name'));
// => [ [ 'items[1].name', 'bar' ], [ 'items[0].name', 'foo' ] ]

console.log(set(data, {
  'items[0].name': 'foo1',
  'items[1].name': 'foo2'
}));
// => 2
console.log(data);
// => { code: 42, items: [ { id: 1, name: 'foo1' }, { id: 2, name: 'foo2' } ] }

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

<script src="https://bundle.run/[email protected]"></script>

Disclaimer : jestem autorem object-scan

I oto jak można znaleźć encję w głęboko zagnieżdżonym obiekcie szukającą po id (jak pytano w komentarzu)

// const objectScan = require('object-scan');

const myData = { code: 42, items: [{ id: 1, name: 'aaa', items: [{ id: 3, name: 'ccc' }, { id: 4, name: 'ddd' }] }, { id: 2, name: 'bbb', items: [{ id: 5, name: 'eee' }, { id: 6, name: 'fff' }] }] };

const findItemById = (haystack, id) => objectScan(['**(^items$).id'], {
  abort: true,
  useArraySelector: false,
  rtn: 'parent',
  filterFn: ({ value }) => value === id
})(haystack);

console.log(findItemById(myData, 5));
// => { id: 5, name: 'eee' }

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

<script src="https://bundle.run/[email protected]"></script>

Disclaimer : jestem autorem object-scan

Mój stringdata pochodzi z pliku PHP, ale i tak wskazuję tutaj w var. Kiedy bezpośrednio wezmę mój json do obj, nic nie pokaże, dlaczego umieściłem mój plik json jako

var obj=JSON.parse(stringdata); tak więc po tym dostaję message obj i pokazuję w polu alertu potem dostaję data która jest tablicą json i przechowuję w jednej zmiennej {[7] } wtedy odczytuję pierwszy obiekt tej tablicy z wartością klucza jak ta ArrObj[0].id

     var stringdata={
        "success": true,
        "message": "working",
        "data": [{
                  "id": 1,
                  "name": "foo"
         }]
      };

                var obj=JSON.parse(stringdata);
                var key = "message";
                alert(obj[key]);
                var keyobj = "data";
                var ArrObj =obj[keyobj];

                alert(ArrObj[0].id);

Korzystanie z lodash byłoby dobrym rozwiązaniem

Ex:

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