How do I make a nonexistent (non-member, non-global) method invocable without using eval?

Question

Let's start from the code:

function say(name) {
    var ghost=function () {
        function ghost() {
            alert('!');
        };

        return body;
    };

    eval("var body=''+"+name+';');
    eval(name+('=('+ghost).replace('body', body)+')();');
    eval(name+'();');
}

function Baal() {
    if ('undefined'===typeof ghost) {
        say('Baal');
        return;
    }

    ghost();
}

say('Baal'); // or just Baal();

Looks like that saying the devil's name invoke his presence (well, maybe he needs somebody for spiritual possession) ..

As you can see the ghost doesn't exist along with Baal, but we can invoke it since there're evals in say(name).

say(name) reassigns Baal to its code body as a closure and makes it captured a ghost method, that's how things work. But I'm trying to avoid eval ..

So .. let me reword the question:

How do I make a nonexistent(and not a member or global) method invocable without using eval?

Answer 1

Let me rephrase your question, just to make sure I’ve got it. Given a function, you want to put a new variable in its scope, without that scope being the global scope or a scope shared between the caller and the subject, without using eval (or the equivalent new Function and other hacks depending on the environment).

You can’t.

In the case you just mentioned, you could define one function, base(), that uses arguments.callee.caller.

Don’t do that.

Answer 2

The short answer: You don't.

That scope is not available. If you were to attach the scope then it would be available inside of the scope used. You could then access the method handles. I assume this is not what you were looking for, but here is what that would look like. demo

function say(name){
 var methods = {};   
 methods.Baal = function(){
  alert("!");  
 };

 return methods[name];//this could invoke as well: methods[name]()
}

var handle = say('Baal');
handle();

What your evals break down to is something along these lines (although with dynamic content from string building - this is the end result)

function say(name) {
 var Baal = (function () {
    function ghost() {
        alert('!');
    };

    return function(){ 
     if ('undefined'===typeof ghost) {
      say('Baal');
      return;
     }
     ghost();
   }
 })();
 Baal();
}

say('Baal'); // or just Baal();

Note that the meat of what happens here is from the function Baal, namely that it calls a hardcoded ghost() which in turn calls a hardcoded alert. Why go through all of this trouble to access a hardcoded function?

A better way would be to inject this function as a callback which expects some parameters to be injected.

jsFiddle Demo

function say(callback){
 var params = "!";
 if( typeof callback == "function" ){
  callback(params);   
 }
}

say(function(params){
 alert(params);  
});

Answer 3

So if I understand, it seems like you want to create an alias of eval: Something like

#Note this code is not intended as a solution, but demonstrates
#an attempt that is guaranteed to fail.
#
function myAlias(ctx) {
eval.call(ctx, 'var ghost = 42');
}

myAlias(this);
alert(ghost);

Javascript allows many funky sleight-of-hand tricks especially with closures, but this is maybe the one impossible thing that javascript cannot do. I've tried at length to do this exact same thing, and I can tell you that you'll run into nothing but complaints from the browser, saying that eval cannot be re-contexted or aliased in any way.

Answer 4

It's very difficult for me to read through your code and figure out what you are trying to accomplish with it, but it appears that you are trying to introduce a variable into the current scope so that you can call it. You cannot do this in javascript with the method that you demonstrated. Scoping only ever "flows down". By that I mean that a variable or function defined within a function will only be available to that function and any other functions defined therein. Your function named ghost will only ever be available within the function where it is defined, regardless of when that function is evaluated.

What you can do, however, is write a function that returns a function. You can then call that function and assign the result to a variable in the scope where you want to expose functionality. Doing that would look something like this.

function defineSpecialAlert() {
    return function(name) {
        alert(name + "!");
    };
}

var newlyDefinedMethod = defineSpecialAlert();

newlyDefinedMethod("Baal");