The following is the simplest code to prove this.


var x = function y () {} // Doesn't work in Safari
var x = function (){} // Works in safari


I had been using named functions to help me while debugging code but stopped doing it once I found that Safari couln’t handle it.

The interesting thing about functions in Javascript is that they can be passed around like variables. What you’re doing with

this.c = new function() { this.x = "woo"; };

is saying ‘assign property c the value of a new variable’. It doesn’t matter that it’s a function.

The other way you could do it is:

function Inner() {
this.x = "woo";
}

function Test(a,b) {
this.a = a;
this.b = b;
this.c = Inner;
}


In this example, you define Inner, and then you set C be that function.

The second way has the advantage that you can use the Inner function elsewhere – for calling independently, or for other properties.

The first way has the advantage of being clearer (IMHO), and can be combined with a feature of Javascript called ‘closures’. If you’re just getting into JavaScript, it’s worth noting that they’re a).useful, b). something worth learning about, c). can leak memory, and d). that you’ll come back to later.

Because Javascript is a language where the statement-ends do not have to be explicitly marked up with semicolons (why! why!?), it is very possible that the statement-end discovery rules considered e.g. the start of the { block as the end of the (then invalid) this.c = new (function Inner() code. Although I, of course, have not been able to try that out in that particular browser.

~Grauw

function Test(a,b) {
this.a = a;
this.b = b;
this.c = new (function Inner(a) {
this.x = ‘woo’;
this.y = a;
})(17.5); /* 17.5 is argument a */
}

The above would create an object foo with foo.a == a, foo.b == b, foo.c.x == 'woo', and foo.c.y == 17.5. However, you don’t have any arguments like the above example, so you don’t need the parentheses.

My guess is that Safari’s either bailing on the extraneous (but valid) parentheses or on the Inner part. Usually in a situation such as you propose the function is declared anonymously:

function Test(a,b) {
this.a = a;
this.b = b;
this.c = new (function () {
this.x = ‘woo’;
})
}

You can name an “anonymous” function like this using the syntax you describe at the beginning, but it’s not common. Up until a week or so ago I’d never seen it used before, but it’s allowed.

If you’re feeling really masochistic, you can look this up in the ECMA-262 specifications which are based upon JavaScript. Go to page 83 and look at the definition of FunctionExpression, noting that the Identifier part (the function name) has an “opt” subscript. Page 170 later defines a NewExpression as a MemberExpression, and a MemberExpression is defined as (among others) a FunctionExpression. Thus, the Inner part of your example is valid.

Arrays, Objects and Functions are all weirdly similar in JS.

So using Adrian’s code (which does sound the best fit), you could actually call your properties using the array obj["a"] style.

Or iterate over your properties:
for p in obj {
writeOut(obj[p]);
}

instead of explicitly calling obj.a and obj.b

Then you can even create properties as you go along, just by assigning them. Array style, or . style.

One thing that really pushed my JS skills was looking through the prototype library.

Good luck, JS is a very intersting language.

function Test(a,b) {
this.a = a;
this.b = b;
this.c = {
x: ‘woo’,
y: ‘wee’
};
}

It’s always the simple answers that I overlook in the most determined fashion…

What I’m trying to do is, as in the file, be able to set up a thingy (object? constructor? class? dunno!) that has a bunch of sub-parts that I can calculate, and then reference later. So I want to be able, later on, to just grab the values of obj.a, obj.b, and obj.c.x.

This is just a simple test file, of course. For the actual purposes I have in mind, I need to have several properties of the object, and sub-properties of those properies. As an example, I’d eventually want to set up obj.c.x, obj.c.y, obj.c.z, and so on. They’re likely to involve simple math when the object is created, and need to be easily retrievable later.

Apologies if that wasn’t clear from the contents of the test file.

this.c = new function() { this.x = "woo"; };

If you’re instantiating an object with an inline named constructor (eh?) then either just declare the object, or drop the brackets: would you write new (Object()) or new Object()?

Whats wrong with: this.c = { x: "woo" }; ? The ‘serializer’ doesn’t seem to pick up the constructor name.

So you want a named constructor, but within the local scope of the Test object constructor? Why not just declare it, then call this.c = new Inner();

Never mind parsing errors, what are you trying to do?!?

(By the way, it’s a “Mac”, not a “MAC”—unless of course one buys a Dell LATITUDE instead of a Dell Latitude.)