object's name (anti-eval)

[Oleg Alistratov]

Is in javascript a method to get object's identifier as string?
E.g., may I write function GetName thus, that

var v;
var s = GetName(v);

has led to

s == "v"

Please, help.

[Lee]

Oleg Alistratov said:

Is in javascript a method to get object's identifier as string?
E.g., may I write function GetName thus, that

var v;
var s = GetName(v);

has led to

s == "v"

No. It would make no sense, since the same object can have many
different names. Also, if you think you need an object's name,
you are probably making a design mistake of some sort.

[Douglas Crockford]

> Is in javascript a method to get object's identifier as string?

E.g., may I write function GetName thus, that

var v;
var s = GetName(v);

has led to

s == "v"

You are correct in wanting to avoid eval. Generally, an object's name is
irrelevant because you are working with object references, not object
names. If you need object names in order to avoid learning to use object
references, then you should obtain a better book. See
http://www.crockford.com/javascript/javascript.html

Names can be useful in some applications. In those cases, keep the
objects in a little database.

var database = {};
function MyObject(name) {
this.name = name;
database[name] = this;
}

So,

object.name

returns an object's name.

database[name]

returns the object.

[Oleg Alistratov]

Lee wrote:

No. It would make no sense, since the same object can have many
different names. Also, if you think you need an object's name,
you are probably making a design mistake of some sort.

Thank you!

I'll try to describe the problem as a whole. I hope, somebody may offer
the best decision.

The class Button holds properties which describes a graphic button.
Its method Button.Draw write the corresponding content:

function Button_Draw()
{
document.write(
"<div id=\"" + this.ID + "\"" +
" onclick=\"Button_Click();\">"
);
...

Several buttons are grouping in the button bar:
Bar's constructor:

function Bar(buttons)
{
this.Items = new Array(arguments.length);
for (i = 0; i < arguments.length; i++)
this.Items[i] = arguments[i];
}

In event handler Button_Click I need to get properties of Button object,
which was creating this DIV element.

If we have name of the Bar object, we may build the Button_Click calling
in that way:

"onclick=\"Button_Click('" + BarName + "', " + ButtonIndex + ");\""

This is allow using in Button_Click the following code:

function ButtonClick(BarName, ButtonIdx)
{
var t = eval(BarName).Items[ButtonIdx].Caption;
....
}

For this case I need to get object's name as string variable (BarName).

I understand that this code looks ugly, but I do not see a way to make
it better.

Please, help!

[Duncan Booth]

Oleg Alistratov wrote:

The class Button holds properties which describes a graphic button.
Its method Button.Draw write the corresponding content:

function Button_Draw()
{
document.write(
"<div id=\"" + this.ID + "\"" +
" onclick=\"Button_Click();\">"
);
... Change the onclick to: onclick=\"Button_Click(this);\"


Several buttons are grouping in the button bar:
Bar's constructor:

function Bar(buttons)
{
this.Items = new Array(arguments.length);
for (i = 0; i < arguments.length; i++)
this.Items[i] = arguments[i];
Also set up an object mapping button ids to buttons:

this.ButtonsById = new function(buttons) {
for (i = 0; i < buttons.length; i++)
this[buttons[i].ID] = buttons[i];
}(buttons)
}

Now all you have to do in Button_Click is use the ID to match the event to
the button:

function Button_Click(theDiv) {

var button = thebar.ButtonsById[theDiv.ID];
...

}

BTW, you would be much better to manipulate the HTML DOM directly instead
of using document.write. That would let you associate a function directly
with the event instead of having to use a text string. A function can
access variables in an outer scope when it was defined, so you can bypass
all of the id lookups and do something like:

function AssociateButtonWithDiv(div, button) {
function clicked() {
button.clicked(div);
}

if (isMozilla) {
div.addEventListener("click", clicked, false);
} else if (isIE) {
div.attachEvent("onclick", clicked);
}
}

All code samples above are untested.

[Matt Kruse]

Oleg Alistratov wrote:

The class Button holds properties which describes a graphic button.
Its method Button.Draw write the corresponding content:
... [and written-out content needs to refer back to its writer] ...

What I do in some of my libs at the url below is to have a global array that
stores references to objects of a certain type. Each time an object is
created, it gets a unique index as one of its properties, and adds a
reference to itself into the global array.

So, any time it needs to create a stand-alone reference to itself, it can do
something like
document.write("GlboalObjectArray[" + this.index + "].doSomething()");

There may be better ways to do it, but this works well for me.

--
Matt Kruse
http://www.JavascriptToolbox.com

[Randy Webb]

Oleg Alistratov wrote:

function ButtonClick(BarName, ButtonIdx)
{
var t = eval(BarName).Items[ButtonIdx].Caption;

var t=window[BarName].......

All Global variables are properties of the window object

--
Randy
comp.lang.javascript FAQ - http://jibbering.com/faq

[Oleg Alistratov]

Duncan Booth wrote:

Now all you have to do in Button_Click is use the ID to match the event to
the button:

function Button_Click(theDiv) {

var button = thebar.ButtonsById[theDiv.ID]; ......................====== ...

}
I could found independently to such decision. The further experiments
have appeared, because it was necessary to use multiple bars in the same
document:

var button = SomethingBig.BarById[theBar.ID].ButtonsById[theDiv.ID];

I assumed to use

eval(BarName)

instead

SomethingBig.BarById[theBar.ID]

This situation has led to a problem described in the my first message.
BTW, you would be much better to manipulate the HTML DOM directly instead
of using document.write.

Thanks, it's a good idea. This approach is new to me, I'll try to
understand more in detail. Thank you!

[lawrence]

Douglas Crockford <no****@covad.net> wrote in message news:<1e7a7

Names can be useful in some applications. In those cases, keep the
objects in a little database.

var database = {};
function MyObject(name) {
this.name = name;
database[name] = this;
}

So,

object.name

returns an object's name.

database[name]

returns the object.

Pardon the newbie question, but what does the word "this" mean here?
It seems to have a different meaning in Java and PHP.

[lawrence]

Duncan Booth <du**********@invalid.invalid> wrote in message

BTW, you would be much better to manipulate the HTML DOM directly instead
of using document.write. That would let you associate a function directly
with the event instead of having to use a text string. A function can
access variables in an outer scope when it was defined, so you can bypass
all of the id lookups and do something like:

function AssociateButtonWithDiv(div, button) {
function clicked() {
button.clicked(div);
}

if (isMozilla) {
div.addEventListener("click", clicked, false);
} else if (isIE) {
div.attachEvent("onclick", clicked);
}
}

All code samples above are untested.

Forgive the ignorant question, but what is isMozilla? Is that a
constant that exists in Mozilla, to let you know that you're dealing
with Mozilla? Where did you find it? Can you point me to some
documentation regarding it?

[Randy Webb]

lawrence wrote:

Duncan Booth <du**********@invalid.invalid> wrote in message

BTW, you would be much better to manipulate the HTML DOM directly instead
of using document.write. That would let you associate a function directly
with the event instead of having to use a text string. A function can
access variables in an outer scope when it was defined, so you can bypass
all of the id lookups and do something like:

function AssociateButtonWithDiv(div, button) {
function clicked() {
button.clicked(div);
}

if (isMozilla) {
div.addEventListener("click", clicked, false);
} else if (isIE) {
div.attachEvent("onclick", clicked);
}
}

All code samples above are untested.

Forgive the ignorant question, but what is isMozilla? Is that a
constant that exists in Mozilla, to let you know that you're dealing
with Mozilla? Where did you find it? Can you point me to some
documentation regarding it?

It falls in the same place the isIE variable falls. Its an utterly
flawed attempt to detect the browser when the browser doesn't matter.
The only way that isMozilla/isIE would be accurate in that scenario is
if its defined like this:

if(div.addEventListener) isMozilla = true;

All of it is more predictable when written something like this:

if (div.addEventListener) {
div.addEventListener("click", clicked, false);
} else if (div.attachEvent) {
div.attachEvent("onclick", clicked);
}

Even then, div might not be a good variable name.
--
Randy
comp.lang.javascript FAQ - http://jibbering.com/faq

[Duncan Booth]

Randy Webb wrote:

It falls in the same place the isIE variable falls. Its an utterly
flawed attempt to detect the browser when the browser doesn't matter.
Actually it falls into the category of 'I was trying to paraphrase the
sense of the code relating it to the OP's question, not give them a line
for line working solution'.
The only way that isMozilla/isIE would be accurate in that scenario is
if its defined like this:

if(div.addEventListener) isMozilla = true;

All of it is more predictable when written something like this:

if (div.addEventListener) {
div.addEventListener("click", clicked, false);
} else if (div.attachEvent) {
div.attachEvent("onclick", clicked);
}
Or possibly just check for one then assume the other. It depends whether it
is important to tell the user that the functionality they expect isn't
there, or if you just want to silently fail to provide the functionality.

Even then, div might not be a good variable name.

Nor would I expect things like 'click' to be hardwired in the final code.
Obviously proper code would have a general function for attaching events to
methods.

FWIW, the template I based the paraphrased version on is from Kupu. It also
has the broken method of testing for browser support, but it isn't so
significant in this case because Kupu explicitly only handles IE and
Mozilla (on any other browser it degrades to a textarea).

function addEventHandler(element, event, method, context) {
/* method to add an event handler for both IE and Mozilla */
var wrappedmethod = new ContextFixer(method, context);
try {
if (_SARISSA_IS_MOZ) {
element.addEventListener(event, wrappedmethod.execute, false);
} else if (_SARISSA_IS_IE) {
element.attachEvent("on" + event, wrappedmethod.execute);
} else {
throw "Unsupported browser!";
};
} catch(e) {
alert('exception ' + e.message + ' while registering an event
handler for element ' + element + ', event ' + event + ', method ' +
method);
};
};

function removeEventHandler(element, event, method) {
/* method to remove an event handler for both IE and Mozilla */
if (_SARISSA_IS_MOZ) {
window.removeEventListener('focus', method, false);
} else if (_SARISSA_IS_IE) {
element.detachEvent("on" + event, method);
} else {
throw "Unsupported browser!";
};
};

function ContextFixer(func, context) {
/* Make sure 'this' inside a method points to its class */
this.func = func;
this.context = context;
this.args = arguments;
var self = this;

this.execute = function() {
/* execute the method */
var args = new Array();
// the first arguments will be the extra ones of the class
for (var i=0; i < self.args.length - 2; i++) {
args.push(self.args[i + 2]);
};
// the last are the ones passed on to the execute method
for (var i=0; i < arguments.length; i++) {
args.push(arguments[i]);
};
self.func.apply(self.context, args);
};
};
An example of use matching the question could be:

Button.prototype.addClickHandler = function() {
var theDiv = document.getElementById(this.ID);
addEventHandler(theDiv, 'click', this.onClick, this);
}

Button.prototype.onClick = function() {
... whatever ...
}