Is it good to write javascript functions inside functions and not use 'new' on the main function?

I now know this works:

function outerfunction(arg1, arg2, arg3) {
    var others;
    //Some code

    innerFunction();

    function innerFunction() {
        //do some stuff
        //I have access to the args and vars of the outerFunction also I can limit the scope of vars in the innerFunction..!
    }
    //Also
    $.ajax({
            success : secondInnerFunction;
        });

    开发者_高级运维function secondInnerFunction() {
        // Has all the same benefits!
    }
}

outerFunction();

So, I am not doing a 'new' on the outerFunction, but I am using it as an object! How correct is this, semantically?

There doesn't appear to be anything wrong with what you're doing. new is used to construct a new object from a function that is intended as a constructor function. Without new, no object is created; the function just executes and returns the result.

I assume you're confused about the closure, and how the functions and other variables belonging to the function scope are kept alive after the function exits. If that's the case, I suggest you take a look at the jibbering JavaScript FAQ.

You are not using the outer function as an object. You are using it to provide a closure. The border line is, admittedly, thin, but in this case, you are far away from objects, since you do not pass around any kind of handle to some more generic code invoking methods, all you do is limiting the scope of some variables to the code that needs to be able to see them.

JFTR, there is really no need to give the outer function a name. Just invoke it:

(function() { // just for variable scoping
  var others;
  ...
})()

I do this sort of thing all the time. Yes - javascript blurs the boundary between objects and functions somewhat. Or perhaps, more correctly, a javascript function is just an object that is callable. You would only really use the 'new' prefix if you wanted to have multiple instances of the function. My only suggestion here is that its usually considered good practice to call a function after you've declared it (you are calling the innerFunction before it has been declared) - although that could be considered nit-picking.

This is a valid example.

Functions in JavaScript are first order objects. They can be passed as an argument, returned from a function or even set to a variable. Therefore they are called 'lambda'.

So when you are directly using this function (without new keyword) you are directly dealing with the function as an object. When u are using new keyword, you are dealing with an object instance of the function.