recorrer objetos objeto metodos lista eliminar elemento buscar array agregar javascript object properties

objetos - object to array javascript



Acceder dinĂ¡micamente a la propiedad del objeto utilizando la variable. (11)

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

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


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


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


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


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


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