Are there any benefits in using function expression in JavaScript?

Question

I recently joined a large software developing project which uses mainly JavaScript and a particular question has been on my mind since day one. I know this issue has been here on SO before, but I have never seen the core question being properly answered. So here I ask it again:

Are there any benefits in JavaScript in using function expressions rather than function declarations?

In other words, is this:

var myFunction = function () {
  // Nice code.
}

in any way better than this:

function myFunction () {
  // Nice code.
}

As I see it, function expressions only introduce negative aspects on several levels to the code base. Here I list a few.

1. Function expression as the one above, suddenly forces you to be careful with forward references, as the anonymous function object that the myFunction variable refers to, does not exist until the variable expression actually executes. This is never a problem if you use function declarations.

2. Apart from generating twice as many objects as in the case with function declarations, this usage introduces a very bad programming habit, which is that developers tend to declare their functions only when they feel they need them. The result is code that mixes object declarations, function expressions and logic in something that obscures the core logic of a piece of code.

3. As a side effect of 2), code becomes much harder to read. If you would use proper function declarations and only var declarations for objects that actually will be variable in the code, it becomes far easier to scan the indentation line of code segment and quickly find the objects and the functions. When everything is declared as "var", you are suddenly forced to read much more carefully to find this piece of information.

4. As yet another nasty side effect of 2), as users get into the bad habit of only declaring their functions when they feel they need them, function expressions start showing up inside event handlers and loops, effectively creating a new copy of the function object either each time an event handler is called or for each turn in the loop. Needless to say, this is bad! Here is an example to show what I mean:

   var myList = ['A', 'B', 'C'];

   myList.forEach(function (element) {

   // This is the problem I see.
   var myInnerFunction = function () {
       // Code that does something with element.
   };
   

   };

So to sum up, at least in my view, the only situation in which it is fair to use something like:

var myFunction = function () {
  // Nice code.
}

is when your logic intends to change the myFunction reference to point at different functions during execution. In that situation myFunction (the variable) is something that is variable in the code, hence you are properly informing a different programmer of your intents, rather than confusing him/her.

With this background in mind, I ask my question again. Have I missed something central about function expressions (in the context described above) in which they provide any benefit over function declarations?