metodos - recorrer array de objetos javascript




Acceder dinámicamente a la propiedad del objeto utilizando la variable. (8)

Estoy tratando de acceder a una propiedad de un objeto usando un nombre dinámico. es posible?

const something = { bar: "Foobar!" };
const foo = 'bar';
something.foo; // The idea is to access something.bar, getting "Foobar!"

ACTUALIZADO

He tomado en consideración los comentarios a continuación y estoy de acuerdo. Eval debe evitarse.

El acceso a las propiedades de la raíz en el objeto se logra fácilmente con obj[variable] , pero la anidación complica la cosa. No escribir código ya escrito que sugiero utilizar lodash.get .

Ejemplo

// Accessing root property
var rootProp = 'rootPropert';
_.get(object, rootProp, defaultValue);

// Accessing nested property
var listOfNestedProperties = [var1, var2];
_.get(object, listOfNestedProperties);

Lodash get se puede utilizar de diferentes maneras, aquí hay un enlace a la documentación lodash.get


A continuación se muestra un ejemplo de ES6 de cómo puede acceder a la propiedad de un objeto utilizando un nombre de propiedad que se ha generado dinámicamente mediante la concatenación de dos cadenas.

var suffix = " name";

var person = {
    ["first" + suffix]: "Nicholas",
    ["last" + suffix]: "Zakas"
};

console.log(person["first name"]);      // "Nicholas"
console.log(person["last name"]);       // "Zakas"

Esto se llama nombres de propiedad computados


En javascript podemos acceder con:

  • notación de puntos - foo.bar
  • corchetes - foo[someVar] o foo["string"]

Pero solo el segundo caso permite acceder dinámicamente a las propiedades:

var foo = { pName1 : 1, pName2 : [1, {foo : bar }, 3] , ...}

var name = "pName"
var num  = 1;

foo[name + num]; // 1

// -- 

var a = 2;
var b = 1;
var c = "foo";

foo[name + a][b][c]; // bar

Esta es mi solución:

function resolve(path, obj) {
    return path.split('.').reduce(function(prev, curr) {
        return prev ? prev[curr] : null
    }, obj || self)
}

Ejemplos de uso:

resolve("document.body.style.width")
// or
resolve("style.width", document.body)
// or even use array indexes
// (someObject has been defined in the question)
resolve("part.0.size", someObject) 
// returns null when intermediate properties are not defined:
resolve('properties.that.do.not.exist', {hello:'world'})

Puedes hacerlo así usando Lodash get.

_.get(object, 'a[0].b.c');

Puedes lograr esto de diferentes maneras.

let foo = {
    bar: 'Hello World'
};

foo.bar;
foo['bar'];

La notación de corchetes es especialmente poderosa, ya que le permite acceder a una propiedad basada en una variable:

let foo = {
    bar: 'Hello World'
};

let prop = 'bar';

foo[prop];

Esto se puede extender a lo largo de cada propiedad de un objeto. Esto puede parecer redundante debido a las nuevas construcciones de JavaScript como for ... of ..., pero ayuda a ilustrar un caso de uso:

let foo = {
    bar: 'Hello World',
    baz: 'How are you doing?',
    last: 'Quite alright'
};

for (let prop in foo.getOwnPropertyNames()) {
    console.log(foo[prop]);
}

La notación de punto y corchete también funciona como se espera para los objetos anidados:

let foo = {
    bar: {
        baz: 'Hello World'
    }
};

foo.bar.baz;
foo['bar']['baz'];
foo.bar['baz'];
foo['bar'].baz;

Desestructuración de objetos

También podríamos considerar la destrucción de objetos como un medio para acceder a una propiedad en un objeto, pero de la siguiente manera:

let foo = {
    bar: 'Hello World',
    baz: 'How are you doing?',
    last: 'Quite alright'
};

let prop = 'last';
let { bar, baz, [prop]: customName } = foo;

// bar = 'Hello World'
// baz = 'How are you doing?'
// customName = 'Quite alright'

Siempre que necesite acceder a la propiedad dinámicamente, debe utilizar corchetes para acceder a la propiedad, no "." operador
Sintaxis: objeto [propiedad]

const something = { bar: "Foobar!" };
const foo = 'bar';
// something.foo; -- not correct way at it is expecting foo as proprty in  something={ foo: "value"};
// correct way is  something[foo]
alert( something[foo])


const something = { bar: "Foobar!" };
const foo = 'bar';

something[\`${foo}\`];




properties