unique reference id

[Matija Papec]

I would like to be able to convert any reference (function, object, or
array) into unique string id and retrieve original reference afterwards
using same id.

The following code does this but only for functions, and for some
unknown reason does not work properly for other kind of references.
var func = function(){};
var ref_id = $GS(func);
// get original reference
var func_2 = $GO(ref_id);
function $GS (ref) { return jsref(ref, "gstr"); }
function $GO (s) { return jsref(s, "gobj"); }
function jsref (ref, what) {

// guess
if (!what) {
what = (typeof(ref) == "string") ? "gobj" : "gstr";
}

var c = jsref;

if (!c.str_ref) c.str_ref = {};
if (!c.ref_str) c.ref_str = {};
if (!c.n) c.n = 0;

if (what == "gstr") {
if (!c.ref_str[ref]) {
c.n++;
c.ref_str[ref] = c.n;
c.str_ref[c.n] = ref;
}
return "jsref:"+ c.ref_str[ref];
}
else if (what == "gobj") {
ref = ref.replace(/\D+/g, '');
return c.str_ref[ref];
}
return null;
}

[Matija Papec]

Erwin Moller wrote:

// OK, so here you make c pointing to some reference.
var c = jsref;

if (!c.str_ref) c.str_ref = {};
if (!c.ref_str) c.ref_str = {};
if (!c.n) c.n = 0;

if (what == "gstr") {
if (!c.ref_str[ref]) {
// Here you ADD a property to c, so that is a property for each object.
c.n++;

c.ref_str[ref] = c.n;
c.str_ref[c.n] = ref;
}
return "jsref:"+ c.ref_str[ref];
}
else if (what == "gobj") {
ref = ref.replace(/\D+/g, '');
return c.str_ref[ref];
}
return null;
}
</script>
Conclusion: You are NOT doing what I suggested.
You are adding the n property to your object: poluting your objects with
that, and possibly overwriting existing ones (I cannot tell).

c is actually referring to jsref function (or "this"), so
c.str_ref,
c.ref_str and
c.n
are class properties.

First two are lookup objects (or hashes) and c.n is counter for unique
reference id's.

Solution: Review my earlier posted code and use that approach. Use 1
counter for all and don't touch the objects the references point to.

Disclaimer:
Possibly I am missing something since I never use $ in Javascript in the
way you do. I only use $ in regular expressions in JavaScript.
I looked it up in my Definitive Guide 4th edition, but it is not listed
in there in the way you use it.
So maybe I miss something important. ;-)

There is nothing special with '$', I was just carried away after playing
with jQuery :)

I have no time right now to investigate the $ futher, but hope my
comments help nonetheless

tnx for hints.

[Richard Cornford]

On Oct 17, 10:53 am, Matija Papec wrote:

Thomas 'PointedEars' Lahn wrote:

<snip>

>`{x: 1}' and `{x: 1}' (and `[x]' and `[x]') result in references
to *different* objects ({x: 1} != {x: 1}).

Yes, of course they refer to different objects and I'm expecting
such behavior.
In the mean time I found what was the problem when looking for
object id in lookup table.

var h1 = {foo: 33};
var h2 = {foo: 33};
// false as expected
alert(h1==h2);

var lookup = {};
lookup[h1] = true;
// true, but I'm expecting false or undefined
alert(lookup[h2]);

It seems that references cannot be used as *object keys*

One of consequences of attaching arbitrary terminology to aspects of
javascript is that it tends to introduce unsound expectations. There
are no "object keys", they are property names. And being names it
should not be too surprising if they are constrained to being
sequences of zero or more (Unicode) characters.

so lookup fails
when searching for reference.

<snip>
Bracket notation property accessors type-convert the value of the
expression that appears between the brackets into a string. When the
value of the expression is an object that type-conversion is (almost
always) the result of calling the - toString - method of the object,
which is usually the one inherited from the - Object.prototyp e - (at
least for Object objects (as opposed to functions, regular
expressions, arrays, etc.)). For your two objects the results of
calling their - toString - methods are identical so they both end up
referring to the same property name.

Richard.

[Erwin Moller]

Matija Papec schreef:

Erwin Moller wrote:

>// OK, so here you make c pointing to some reference.
var c = jsref;

if (!c.str_ref) c.str_ref = {};
if (!c.ref_str) c.ref_str = {};
if (!c.n) c.n = 0;

if (what == "gstr") {
if (!c.ref_str[ref]) {
// Here you ADD a property to c, so that is a property for each object.
c.n++;

c.ref_str[ref] = c.n;
c.str_ref[c.n] = ref;
}
return "jsref:"+ c.ref_str[ref];
}
else if (what == "gobj") {
ref = ref.replace(/\D+/g, '');
return c.str_ref[ref];
}
return null;
}
</script>
Conclusion: You are NOT doing what I suggested.
You are adding the n property to your object: poluting your objects with
that, and possibly overwriting existing ones (I cannot tell).

c is actually referring to jsref function (or "this"), so
c.str_ref,
c.ref_str and
c.n
are class properties.

Oops sorry.
As you can tell I don't program JavaScript at all in the way you do it.

Erwin Moller <-- Old fashioned guy who likes all his functions named. ;-)

However, I am totally sure my posted approach will work, since I used a
similar approach once (including the Ajax calls) without any problems.

So if you just ditch all the fancy stuff I don't get, you'll have
yourself a working reference-passing-getting thingy, ready for use to
pass around the id to ajax and back. :P

Good luck.

Regards,
Erwin Moller

[Thomas 'PointedEars' Lahn]

Matija Papec wrote:

var h1 = {foo: 33};
var h2 = {foo: 33};
// false as expected
alert(h1==h2);

var lookup = {};
lookup[h1] = true;
// true, but I'm expecting false or undefined
alert(lookup[h2]);

A possibility to make that work is to serialize the object when converted
into a string for property lookup, using the aforementioned iteration
algorithm in its toString() method or explicitly calling a serializer method
on property access:

function serialize(o)
{
var a = [{];

for (var p in o)
{
a.push(...)
}

return a.join(",") + "}";
}

However, of course that does not allow to differentiate between different
objects, just between objects with different enumerable properties. A
solution for the former, though, is to store object references as elements
of an array, or (more efficient on retrieval) to store references to objects
as elements of an array that is referred to by a property of another object
which name is a serialization of the object to be stored (a hash table
algorithm):

var registry = {
items: {},
add: function(o) {
var it = this.items;
var s = serialize(o);
if (!it.hasOwnProp erty(s))
{
it[s] = [o];
}
else
{
var a = it[s];
if (a.indexOf(o) < 0) a.push(o);
}
}
};

Note that Array.prototype .indexOf() is a proprietary method available in
JavaScript since version 1.6; you need a fallback for other implementations .
There are also caveats for other language features used here.

<http://PointedEars.de/scripts/es-matrix/>
PointedEars
--
var bugRiddenCrashP ronePieceOfJunk = (
navigator.userA gent.indexOf('M SIE 5') != -1
&& navigator.userA gent.indexOf('M ac') != -1
) // Plone, register_functi on.js:16

[Thomas 'PointedEars' Lahn]

Thomas 'PointedEars' Lahn wrote:

* function serialize(o)
* {
* * var a = [{];

var a = ["{"];

* * for (var p in o)
* * {
* * * a.push(...)

Trailing semicolon not required, but good style and missing here.

* * }

* * return a.join(",") + "}";
* }

[...]
* var registry = {
* * items: {},
* * add: function(o) {
* * * var it = this.items;
* * * var s = serialize(o);
* * * if (!it.hasOwnProp erty(s))
* * * {
* * * * it[s] = [o];
* * * }
* * * else
* * * {
* * * * var a = it[s];
* * * * if (a.indexOf(o) < 0) a.push(o);
* * * }
* * }
* };

Reviewing this, it only works with objects that never change, though.
Anyhow, maybe the hash table algorithm helps someone somewhere else.
PointedEars

[Matija Papec]

Thomas 'PointedEars' Lahn wrote:

function serialize(o)
{
var a = [{];

for (var p in o)
{
a.push(...)
}

return a.join(",") + "}";
}

However, of course that does not allow to differentiate between different
objects, just between objects with different enumerable properties. A
solution for the former, though, is to store object references as elements
of an array, or (more efficient on retrieval) to store references to objects
as elements of an array that is referred to by a property of another object
which name is a serialization of the object to be stored (a hash table
algorithm):

I think I'll stick with plain array for lookups as there are not many
references to be stored and it will not suffer from serialization
overhead (in case if there is any). Tnx for the tips!

[Matija Papec]

Erwin Moller wrote:

>c is actually referring to jsref function (or "this"), so
c.str_ref,
c.ref_str and
c.n
are class properties.

Oops sorry.
As you can tell I don't program JavaScript at all in the way you do it.

Erwin Moller <-- Old fashioned guy who likes all his functions named. ;-)

However, I am totally sure my posted approach will work, since I used a
similar approach once (including the Ajax calls) without any problems.

So if you just ditch all the fancy stuff I don't get, you'll have
yourself a working reference-passing-getting thingy, ready for use to
pass around the id to ajax and back. :P

I'm working on new version which will use some of your approach. :)

[Matija Papec]

Richard Cornford wrote:

>when searching for reference.

<snip>
Bracket notation property accessors type-convert the value of the
expression that appears between the brackets into a string. When the
value of the expression is an object that type-conversion is (almost
always) the result of calling the - toString - method of the object,
which is usually the one inherited from the - Object.prototyp e - (at
least for Object objects (as opposed to functions, regular
expressions, arrays, etc.)). For your two objects the results of
calling their - toString - methods are identical so they both end up
referring to the same property name.

Tnx for clarification.
To be honest, I've expected something similar to perl behavior when
dealing with references

perl -e 'print {}'
HASH(0x817f880)

:)