Odtnhj

This is my solution:

function resolve(path, obj) self)

Usage examples:

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

In javascript we can access with:

• dot notation - foo.bar


• square brackets - foo[someVar] or foo["string"]
  

But only second case allows to access properties dynamically:

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

Following is an ES6 example of how you can access the property of an object using a property name that has been dynamically generated by concatenating two strings.

var suffix = " name";

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

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

This is called computed property names

You can achieve this in quite a few different ways.

let foo = 
 bar: 'Hello World'
;

foo.bar;
foo['bar'];

The bracket notation is specially powerful as it let's you access a property based on a variable:

let foo = 
 bar: 'Hello World'
;

let prop = 'bar';

foo[prop];

This can be extended to looping over every property of an object. This can be seem redundant due to newer JavaScript constructs such as for ... of ..., but helps illustrate a use case:

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

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

Both dot and bracket notation also work as expected for nested objects:

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

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

Object destructuring

We could also consider object destructuring as a means to access a property in an object, but as follows:

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'

UPDATED

I have take comments below into consideration and agreed. Eval is to be avoided.

Accessing root properties in object is easily achieved with obj[variable], but getting nested complicates thing. Not to write already written code I suggest to use lodash.get.

Example

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

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

Lodash get can be used on different ways, here is link to the documentation lodash.get

Whenever you need to access property dynamically you have to use square bracket for accessing property not "." operator

Syntax: object[propery}

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

You can do it like this using Lodash get

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

It gets interesting when you have to pass parameters to this function as well.

Code 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