objetos - object to array javascript

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

Question

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!"

Answer 1

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

Answer 2

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

Answer 3

Debe usar JSON.parse , eche un vistazo a https://www.w3schools.com/js/js_json_parse.asp

const obj = JSON.parse(''{ "name":"John", "age":30, "city":"New York"}'')
console.log(obj.name)
console.log(obj.age)

Answer 4

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

Answer 5

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

Answer 6

Hay dos formas de acceder a las propiedades de un objeto:

• Notación de puntos: something.bar
• Notación del corchete: something[''bar'']

El valor entre paréntesis puede ser cualquier expresión. Por lo tanto, si el nombre de la propiedad se almacena en una variable, tiene que usar la notación de corchete:

var foo = ''bar'';
something[foo];
// both x = something[foo] and something[foo] = x work as expected

Answer 7

Puedes hacerlo así usando Lodash get.

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

Answer 8

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

Answer 9

Se vuelve interesante cuando tienes que pasar parámetros a esta función también.

Codigo jsfiddle

var obj = {method:function(p1,p2,p3){console.log("method:",arguments)}}
var str = "method(''p1'', ''p2'', ''p3'');"
var match = str.match(/^/s*(/S+)/((.*)/);/s*$/);
var func = match[1]
var parameters = match[2].split('','');
for(var i = 0; i < parameters.length; ++i) {
// clean up param begninning
parameters[i] = parameters[i].replace(/^/s*[''"]?/,'''');
// clean up param end
parameters[i] = parameters[i].replace(/[''"]?/s*$/,'''');
}
obj[func](parameters); // sends parameters as array
obj[func].apply(this, parameters); // sends parameters as individual values

Answer 10

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

Answer 11

const something = { bar: "Foobar!" };
const foo = ''bar'';
something[/`${foo}/`];