I have a several variables which are assigned to the same function. The property 'name' is "" as this function is anonymous;
There also isn't a function call involved, and as such no callee.
Is there a way in JS to obtain the variable's name, through a self-implemented reflection algorithm?
e.g.
var x = function(){}
var myUnknownNamedVar1 = myUnknownNamedVar2 = x;
Background:
for space efficiency, thousands of variable names are assigned to the same 'static' function as a lazy-loaded stumps, which get resolved to individual functions upon the first call invocation. (The variable name also contains a namespace).
Alternatives:
My alternative would be the use of objects such as {_name: myUnknownNamedVar1 , _fn: x}
Solutions to this issue would be interesting. A particular issue is discerning variables with different names ,in the script, which point to the same object.
1. You could try parsing the script's text.
JSFiddle Example
var x = function(){}
var myUnknownNamedVar1 = myUnknownNamedVar2 = x;
var txt = (document.currentScript && document.currentScript.textContent) ||
(document.scripts && document.scripts[1]
&& document.scripts[1].textContent);
var arr = txt.match(/var\s*(.*)\s*=\s*x\b/);
arr[1] = arr[1].replace(/\s+$/,"");
var vars = arr[1].split(/\s*=\s*/);
// vars: ["myUnknownNamedVar1", "myUnknownNamedVar2"]
2. You can try comparing values
JSFiddle Example
var x = function(){}
var myUnknownNamedVar1 = myUnknownNamedVar2 = x;
var vars = [];
for (var prop in window){
if (window[prop] == x)
vars.push(prop);
}
// vars: ["x", "myUnknownNamedVar1", "myUnknownNamedVar2"]
Note: Both methods will need refining (eg recursion, better/more match patterns). The second one only looks at global variables, whereas some variables in closures may not be exposed to the global namespace. Also, there are objects of objects.
No. There is not.
A simple explanation (that reinforces the point in the post) for this is simply: a variable (or property) is not a value/object. Rather, it is a "name" for a value/object. The same object can be named multiple times.
Imagine this example, and consider how it maps to "names" given to people :-)
var fred = function Fred () {}
fred.name // "Fred"
// An unknown number of nicknames can exist...
var francisco = fred
var frankyTheFiveFingers = fred
someOtherRegion.theGoodPerson = fred
// But sometimes nicknames are known; note that this is
// a locatable (e.g. "known") iterable set.
// (While properties can be iterated, variables cannot.
// However, iterating *every* object is not feasible, hence
// it must be a locatable set.)
fred.nicknames = ["Freddy", "FD"]
mary.nicknamesFor(fred) // who knows :-)
Happy coding.
It is possible to use object reflection, as such:
const getVarName = obj => Object.keys(obj)[0];
const varToGetTheNameOf = "Value!";
getVarName({ varToGetTheNameOf }) // => "varToGetTheNameOf"
You can use decorators to detect the name of variable that must be :
(a)- Class
(b)- Attribute of class or of instance
(c)- Method of class or of instance
The decorator provides 3 informations about the decorated :
- target
- key
- Descriptor
Thus:
- the name of (a) is
target.name
the name of (b) or (c) is key
directly
function logName(target, key) {
console.log(!key ? target.name : key);
}
example (Try Fiddle) :
@logName
class Person {
@logName
firstname="Someone";
@logName
fullName() {
return this.firstname+' '+this.lastname;
}
}
Try Fiddle