Set Javascript variable in a class from outside

You can't reasonably do this, not least because A is fundamentally broken (see below).

Whether you can do it at all depends entirely on where the A code is: If it's at global scope, you can do what you want but shouldn't. If it isn't at global scope, you can only do it from code within the scope where me is declared (or a scope within it).

If it's at global scope, you'd do it like this (but don't :-) ):

// The "A" Code
var me;
var A = function(_me){
  me = _me;
}
A.prototype.getMe = function(){
  me();
}

// Your code using it
new A(); // Create `A.prototype.getMe`, because unless
         // `A` is called at least once, it doesn't exist
var myMe = function() {
  console.log("myMe called");
};
me = myMe; // Set the global `me`
A.prototype.getMe(); "myMe called"

The only way to do this is, I guess to use an if .

if(!me){
  me = this.myMe
}

So I did A.prototype.getMe.call({myMe: myMe}, args) but would it define the variable in global space ?

Yes, it would. That's what me = this.myMe does.

From that observation, it sounds like you can modify A's code. If so, fix it so that it doesn't define a prototype function in terms of a global variable. Perhaps isolate the code from the function into a function that doesn't expect to be called on an instance and pass in me as a parameter.

I am working on an existing library to make a small change. So I can only change inside getMe function definition. And I cant change var me definition.

In that case, you can add a new optional parameter at the end, and use that if provided and me if not provide:

A.prototype.getMe = function(myMe){
    var meToCall = myMe || me;
    meToCall();
};

Live Example:

// The "A" Code
var me;
var A = function(_me){
  me = _me;
}
A.prototype.getMe = function(myMe){
  var meToCall = myMe || me;
  meToCall();
}

// Your code using it
A.prototype.getMe(function() {
  console.log("My me!");
});

And, separately, A is fundamentally broken if it's really as shown (barring an extremely specific use-case). Having constructor code set a global (global at least to A's code) that's then used by a prototype function is a huge design and maintenance red flag.

Consider the cross-talk horror:

// The "A" Code
var me;
var A = function(_me){
  me = _me;
}
A.prototype.getMe = function(){
  me();
}

// Using it
var a1 = new A(function() {
  console.log("me1");
});
a1.getMe(); // "me1" -- so far so good
var a2 = new A(function() {
  console.log("me2");
});
a2.getMe(); // "me2" -- yup, still fine
a1.getMe(); // "me2" -- what the...?!?!?!!