I write the code as follows,
function Myfunction(){ Myfunction.myvar = "somevar"; } After I execute the function, I can able to access Myfunction.myvar
How is it working? And If I do so, What is the problem hidden in this?
If any problem, please explain context of that.
Since the function does not execute until you call it, Myfunction.myvar is not evaluated immediately.
Once you call it, the function definition has been installed as Myfunction, so that it can be resolved when you do call it.
Something like the following would not work:
var x = { foo: 1, bar: x.foo } // x does not exist yet. 
How is it working?
When you declare a function in some execution context, a binding is added to the variable environment of that context. When you reference an identifier, the current variable environment is checked to see if a binding exists for that identifier.
If no binding exists, the outer variable environment is checked, and so on, back up to the global scope.
So:
// OUTER SCOPE // Binding exists for 'example' function example() { // INNER SCOPE // No binding for 'example' // References 'example' in outer scope example.x = 1; } What is the problem hidden in this?
There are none (in general... although whether it's the right solution for you depends on what you're trying to do).
You are effectively creating a "static" property of the function. As JavaScript functions are first-class you can set properties on them as you would with any other object.
Note that the behaviour is different if you have a named function expression, rather than a function declaration:
var x = function example () { // Identifier 'example' is only in scope in here }; One problem you might get because of scoping, as a more complicate example shows:
function Other() { console.log("a) Other.Myvalue",Other.Myvalue); Other.Myvalue=typeof Other.Myvalue==='undefined' ? 0 : Other.Myvalue+1; console.log("b) Other.Myvalue",Other.Myvalue); } Other(); Other(); this would lead to
a) Other.Myvalue undefined b) Other.Myvalue 0 a) Other.Myvalue 0 b) Other.Myvalue 1 so you realy bind your variable Myvar to the function object itself which is a singleton and exists just once (and is created by the function definition itself in the current context which may be the global context), not to an instance of that object. But if you just use static values and don't need any logic, it's like the literal form, and I wouldn't expect any problems, other that the literal form is more convenient:
var Other = { Myvalue: "somevalue" }; 
var x = Myfunction(); value of x will be undefined and x.Myvar will cause an error... he simply creates a static variable inside function when it will be called. So, if you want to get value of Myvar you should use Myfunction.Myvar.In javascript every function is an object. So you can add any custom fields to it.
function A() {} A.somevar = 'this is custom field'; A.prototype.somevar2 = 'this is field in A proto'; So when you will create new object with A contructor it will take properties from prototype.
var b = new A(); alert(b.somevar2); 