Functions are another type of variable in JavaScript (with some nuances of course). Creating a function within another function changes the scope of the function in the same way it would change the scope of a variable. This is especially important for use with closures to reduce total global namespace pollution.

The functions defined within another function won't be accessible outside the function unless they have been attached to an object that is accessible outside the function:

function foo(doBar)
{
  function bar()
  {
    console.log( 'bar' );
  }

  function baz()
  {
    console.log( 'baz' );
  }

  window.baz = baz;
  if ( doBar ) bar();
}

In this example, the baz function will be available for use after the foo function has been run, as it's overridden window.baz. The bar function will not be available to any context other than scopes contained within the foo function.

as a different example:

function Fizz(qux)
{
  this.buzz = function(){
    console.log( qux );
  };
}

The Fizz function is designed as a constructor so that, when run, it assigns a buzz function to the newly created object. That is, you'd use it like this:

const obj = new Fizz();
obj.buzz();

or more concisely (if you don't need to keep the object after calling buzz):

new Fizz().buzz();

Why do you think that nesting functions is bad form? Modern Javascript is often written in a class-like block structure, to make for ease of exporting.

As other commenters have observed, nested functions are "private" in the sense that you won't be able to access them directly. This is a feature, not a bug. It's really the cornerstone of object-oriented programming: by nesting related functions into the same shared block structure, you can vastly reduce the complexity of your code base.

This is the way I write JS code by default:

var basketModule = (function () {

  // privates

  var basket = [];

  function doSomethingPrivate() {
        //...
  }

  function doSomethingElsePrivate() {
        //...
  }

  // Return an object exposed to the public
      return {

          // Add items to our basket
          addItem: function( values ) {
              basket.push(values);
          },

          // Get the count of items in the basket
          getItemCount: function () {
              return basket.length;
          },

          // Public alias to a private function
          doSomething: doSomethingPrivate,

          // Get the total value of items in the basket
          getTotal: function () {

              var q = this.getItemCount(),
                  p = 0;

              while (q--) {
                  p += basket[q].price;
              }

              return p;
          }
     };
 })();

This is similar to what in other languages is called a class.

I'm generally in favor of nested functions, especially in JavaScript.

• In JavaScript, the only way to limit a function's visibility is by nesting it inside another function.
• The helper function is a private implementation detail. Putting it at the same scope is akin to making a class' private functions public.
• If it turns out to be of more general use, it's easy to move out, because you can be confident the helper is currently only used by that one function. In other words, it makes your code more cohesive.
• You can often eliminate parameters, which makes the function signature and implementation less verbose. This is not the same thing as making variables global. It's more like using a class member in a private method.
• You can give the helper functions better, simpler names, without worrying about conflicts.
• The helper function is easier to find. Yes, there are tools that can help you. It's still easier to just move your eyes up the screen a bit.
• Code naturally forms a sort of tree of abstraction: a few general functions at the root, branching out into several implementation details. If you use an editor with function folding/collapsing, nesting creates a hierarchy of closely-related functions at the same level of abstraction. That makes it very easy to study the code at the level you need and hide the details.

I think a lot of opposition comes from the fact that most programmers were either brought up in a C/C++/Java tradition, or were taught by someone else who was. Nested functions don't look natural because we weren't exposed to them much when we were learning to program. That doesn't mean they aren't useful.