"with" scope and properties with square bracket notation

Question

Is it possible to access object properties that can only be accessed with the square bracket notation when inside a "with" statement.

Example:

var o = { "bad-property": 1, "another:bad:property": 2, "goodProperty": 3 };

with(o) {
    console.log(goodProperty); // works awesome
    console.log(???) // how to access "bad:property"?
}

`with` has it's uses, just like `goto` or `eval`. I think that the generic [considered harmful](http://en.wikipedia.org/wiki/Considered_harmful) statement is more harmful than the thing in question. — Anurag, Jun 06 '10 at 22:06
@M28 I agree with Anurag, one of the beauties of JavaScript is it's versatility. Please see this post http://stackoverflow.com/questions/61552/are-there-legitimate-uses-for-javascripts-with-statement . Though it does have its dangers. — Laramie, Jun 06 '10 at 22:17
from 'Javascript: The Good Parts by Douglas Crockford' - Appendix B: Bad Parts 'with Statement': "...its results can sometimes be unpredictable, so it should be avoided.", "...It was well intentioned, but the language would be better if it didn't have it." - there is more, read the book. — house9, Jun 07 '10 at 00:13
@Anurag: Unfortunately you can't do this, in the only implementation that is possible is in Rhino, where you can have direct access to the latest object in the scope chain, using the Rhino-specific `__parent__` property e.g. `with(o) { print(function () {}.__parent__['bad-property']); }` ... — Christian C. Salvadó, Jun 07 '10 at 07:03
@CMS thanks for the info. It's good to know that Rhino has a way of reaching the current object in scope. — Anurag, Jun 08 '10 at 18:26

score 2 · Accepted Answer · answered Sep 10 '10 at 19:36

Wow this is old, but the answers here are wrong, there is in fact way to do exactly as you ask.

with({'!@#$%': 'omg', d: 'hai'}) {
  console.log(d); //hai - naturally
  console.log(valueOf()['!@#$%']); //omg - OMG
}

Did you see it? valueOf() is the magic word. It returns the primitive value of its parent object, or if the object has no primitive value, the object itself. Every object and object-like primitive inherits this method, as it is a built in property on Object.prototype. So...there you go.

it is a little late, but thank you for `valueOf`. This solves the problem outright. — Anurag, Feb 21 '11 at 08:29

score 1 · Answer 2 · answered Jun 06 '10 at 22:09

1

Generally the with keyword is used to resolve long namespaces, not a single object reference. I guess I'd need to know what the intent of using the keyword here is. I don't believe the syntax parser will let you get away with o.bad:property, which is basically what's being coded using with.

If the o object in the example was just a shortcut to a longer namespace, my recommendation would be to stop one object short in the resolution using with, then put box your property into a string like this...

var nmSpace = new Object();
nmSpace.o = { "bad:property": 1, "goodProperty": 2 };

with (nmSpace) {
    alert(o['goodProperty']); // works awesome
    alert(o['bad:property']);  // now accesses "bad:property"!
}

Hope that helps.

answered Jun 06 '10 at 22:09

Laramie

5,457
2
39
46

It's being used in a template using [JR's tiny library](http://ejohn.org/blog/javascript-micro-templating/). The data is coming from an external source, and I am passing the relevant root object to the template engine which populates it. I can't arbitrarily break object chains without also breaking apart the templates. – Anurag Jun 06 '10 at 22:15
got it. if you can't influence the template to string qualify the property names, my guess is that you're on the money with having to normalize property names through regex to avoid syntax violations. – Laramie Jun 06 '10 at 22:43
The only way to access those values would be through quoted identifiers -- o['bad-property'] and o['bad:property'] still work. This works inside the `with` (though at this point you shouldn't need to use it). And the props are still available through `for(var s in o){}. If your templating engine is expecting a variable name exactly matching the property name of your object, I don't think you can do it without, as you already mentioned, normalizing everything. – Andrew Jun 07 '10 at 00:13
thanks @Laramie - that's what I am doing as of now as there seems to be no other alternative. @Andrew - I would lose all benefits of using the templates if `o` is directly referenced, unless I wrap everything inside another object (for consistency) just to be able to access them as `outerObject['x:prop']` as @Laramie suggested, but I'll let that go for now. – Anurag Jun 07 '10 at 02:56

score 0 · Answer 3 · answered Jun 06 '10 at 21:56

0

As I understand it with(o) essentially jumps to the scope of o, so properties are accessible by their name: “bad” and “goodProperty” respectively.

with(o) {
  bad="new value";
  goodProperty=22;
}

answered Jun 06 '10 at 21:56

user268396

11,576
2
31
26

1

The question was, how to access properties that are inaccessible by their name (by virtue of how they were named). – Lauri Lehtinen Jun 06 '10 at 22:00
I added a confusing property name. `"bad:property"` is the name of the property (it could've just as well been `"bad-property"`), but I don't know if it's accessible inside the with scope. One solution is to normalize the property name and change `"bad:property"` to `"badProperty"`, but I was hoping to avoid that as it may be impossible for some cases. – Anurag Jun 06 '10 at 22:01

"with" scope and properties with square bracket notation

3 Answers3