var myObj = {
test: 1,
innerObj: {
test: [1,2,3],
innerInnerObj: {
test: 3
}
}
};

String.prototype.findValuesIn = function(obj){
var arr = [], x, that = this.toString(),
f = function (o){
for (x in o) {
if (typeof o[x] === “object” && o.hasOwnProperty(x)){
if (o[x].length) {
arr.push(o[x]);
} else {
f(o[x]);
}
} else if (x === that){
arr.push(o[x]);
}
}
};

f(obj);
return arr;
};

“test”.findValuesIn(myObj); //[1, [1, 2, 3], 3]

The feature we can achieve with this is quite good, but unfortunately there are some things that I thought need to be considered:

(1) Extending a built-in object – In this code you have extended a built-in JavaScript object without checking whether the object support its own findIn method. I am sure that at the moment String object does not support a findIn method. But personally I feel that it would be a lot better if we can avoid extending the built-in object, if that is possible.

(2) Works on String – I don’t know whether this is a personal feeling towards the approach using String. As a developer I feel this approach would be far better if this works directly on a JavaScript object instead of a string.

Taffy DB ( http://taffydb.com/ ) is one such framework through which one can manipulate JS literal objects (simple as well as complex one) quickly.

Note to self: refresh page before posting.

if(typeof multi == ‘object’)
{
return multi[val];
}
else if(typeof multi == ‘array’)
{
return multi[val];
}

why not just:

return multi[val];

or unless there is some javascript object/array functionality that prevents it.