It's not easy to achieve the syntax you desire in JavaScript. The only way to inject a variable into a Lexical Environment is through using eval or the Function constructor, which comes with its own set of drawbacks. Some solutions propose using global variables as a workaround, but each solution has its limitations.

If you don't want to go down that route, your best bet is to explore alternative syntax options. One suggestion is passing a parameter from doSomething to the callback, as Aadit M Shah recommends. It may not be ideal, but it's better than resorting to a messy hack.

Alternative answer (written after gaining better understanding)

Perhaps what you're looking for is a closure concept? Take a look at these examples:

var myVariable = "value";
function doSomething() {
    console.log(myVariable);
};
doSomething(); // prints "value"

Or maybe this approach:

function createClosure(myVariable) {
    return function() {
        console.log(myVariable);
    };
}
var closure = createClosure("value");
closure(); // prints "value"

Another option could be:

var closure = function(myVariable) {
    return function() {
        console.log(myVariable);
    };
}("value");
closure(); // prints "value"

Give this a shot:

function manipulateVariables(parameters, operation) {
    for (var parameter in parameters) { // assign the variables in parameters
        window[parameter] = parameters[parameter];
    }
    operation.call(); // invoke operation
    for (var parameter in parameters) { // remove the variables to restrict access outside of operation
        delete window[parameter];
    }
}

Define global variables that can be utilized within operation

Check out the JSFiddle: http://jsfiddle.net/shawn31313/MbAMQ/

Caution: this code is downright repulsive

function executeWithScope(func, scope, parameters) {
    var previousProperties = {};

    for(var property in scope) {
        if(scope.hasOwnProperty(property)) {
            var oldProperty = Object.getOwnPropertyDescriptor(self, property);
            previousProperties[property] = oldProperty;

            (function(property) {
                Object.defineProperty(self, property, {
                    get: function() {
                        if(arguments.callee.caller === func) {
                            return scope[property];
                        }

                        if(!oldProperty) {
                            return;
                        }

                        if(oldProperty.get) {
                            return oldProperty.get.apply(this, arguments);
                        }

                        return oldProperty.value;
                    },
                    set: function(value) {
                        if(arguments.callee.caller === func) {
                            scope[property] = value;
                        }

                        if(!oldProperty) {
                            return;
                        }

                        if(oldProperty.set) {
                            return oldProperty.get.apply(this, arguments);
                        } else if(!oldProperty.writable) {
                            var dummyObject = {};
                            Object.defineProperty(dummyObject, property, {value: null, writable: false});
                            dummyObject[property] = value; // Not the best approach, but...
                            return;
                        }

                        oldProperty.value = value;
                    }
                });
            })(property);
        }
    }

    func.apply(this, parameters);

    for(var property in scope) {
        if(scope.hasOwnProperty(property)) {
            if(previousProperties[property]) {
                Object.defineProperty(self, property, previousProperties[property]);
            } else {
                delete self[property];
            }
        }
    }
}

This code is extremely unpleasant, so please avoid using it. However, surprisingly, it does work.

There are different ways to approach passing information or defining globals, but I personally believe that passing as an object may be the best option.

Currently, I am in the process of developing a Module maker/runner that allows for executing sloppy/dangerous code without interfering with the host environment. This setup enables the re-definition of variables, which can then be passed as an object.

While this solution does involve the use of eval (Function() technically), it is structured to run in "use strict" mode and aims to avoid any overly complex or risky behavior. It has been designed not to leave behind any unwanted artifacts or cause harm to global variables.

Although still a work in progress, the functionality seems stable enough to perform the required operations. However, I recommend refraining from using it for highly secure applications until all security aspects have been thoroughly vetted.

The system has been tested in ch28, FF22, and IE10:

function Module(strCode, blnPreventExtensions, objWhitelist, objExtend) {
   // Function definition details...
}

/////////////////////////////////////////////////////////////

function doSomething(context, fn){
    console.log(myVariable);
    return myVariable;
}


// Example 1:
 alert(    Module(doSomething, true, {console:1}, {myVariable: "value123"} )    );// Immediate execution

// Example 2:
var fn=Module(doSomething, false, {console:1}, {myVariable: "value123"} );// As a function
alert(fn);
alert(fn());

In conclusion, while I suggest sticking to simpler solutions whenever possible, I present this Module maker/runner with good intentions to offer a comprehensive and inspiring alternative.

One way to create a context is by using call() function. See the example below:

var func = function(){
    console.log(this.value);
};

func.call({value: 'example'})

This code will output "example"

Avoiding the use of eval() when calling a function is possible by utilizing it in the doSomething() method:

function abc() {
   console.log(myVariable);
}

// Displays "value"
callWith({ myVariable: "value" }, abc);

function callWith(context, func) {
  for(var i in context) eval('var ' + i + ' = context[i];');

  eval('(' + func.toString() + ')')();
}

To learn more about this technique, check out this informative post.

Check out goog.partial, move up a bit to read about what it does:

Take a look at this demonstration of its usage:

var b = goog.partial(alert, 'Hello world!');
b();//displays an alert saying "Hello world!"

In the given example, it passes the function alert with the parameter "Hello world!", but you can pass your own function with multiple parameters as well.

This feature enables you to create a variable that references a function which always receives a specific parameter. To utilize unnamed parameters in a function, you can use arguments:

function test(){
  console.log(arguments);//["hello","world"]
}

test("hello", "world");