Use var, it reduces the scope of the variable otherwise the variable looks up to the nearest closure searching for a var statement. If it cannot find a var then it is global (if you are in a strict mode, using strict, global variables throw an error). This can lead to problems like the following.

Copyfunction f (){
    for (i=0; i<5; i++);
}
var i = 2;
f ();
alert (i); //i == 5. i should be 2

If you write var i in the for loop the alert shows 2.

JavaScript Scoping and Hoisting

Use let in for loops. The difference is that var is function scoped and let is block scoped. When you use var you will be able to access i anywhere in the function it's declared in, even outside of the for loop. Generally you only want to use i inside the for loop so it's better to use let. const shouldn't work because i++ implies you are reassigning the value of i.

What are the errors you are getting? From looking at this code it would not be an 'error' but how javascript works in general. I assume you are expecting the mouseout event to refer to the index of the listItems? However, what instead happens, the index always refers to the last item in the array when the mouseout event occurs? If this is what you are experiencing it is because of the asynchrounous nature of javascript. var i = 0 in your for loop will hoist i into the global scope. So i will constantly update until it reaches the end of the array. This is solved with using let i = 0. that is because let will not hoist into the global scope, but instead remains in the scope of the for loop. Letting your event listeners refer to the correct index. In the days before let this had to be solved using closures. If this does not make any sense - I suggest watching the closures lecture on treehouse. That example is pointed out in there and was a huge 'aha' moment for me.

There is absolutely no difference in meaning or performance, in JavaScript or ActionScript.

var is a directive for the parser, and not a command executed at run-time. If a particular identifier has been declared var once or more anywhere in a function body(*), then all use of that identifier in the block will be referring to the local variable. It makes no difference whether value is declared to be var inside the loop, outside the loop, or both.

Consequently you should write whichever you find most readable. I disagree with Crockford that putting all the vars at the top of a function is always the best thing. For the case where a variable is used temporarily in a section of code, it's better to declare var in that section, so the section stands alone and can be copy-pasted. Otherwise, copy-paste a few lines of code to a new function during refactoring, without separately picking out and moving the associated var, and you've got yourself an accidental global.

In particular:

for (var i; i<100; i++)
    do something;

for (var i; i<100; i++)
    do something else;

Crockford will recommend you remove the second var (or remove both vars and do var i; above), and jslint will whinge at you for this. But IMO it's more maintainable to keep both vars, keeping all the related code together, instead of having an extra, easily-forgotten bit of code at the top of the function.

Personally I tend to declare as var the first assignment of a variable in an independent section of code, whether or not there's another separate usage of the same variable name in some other part of the same function. For me, having to declare var at all is an undesirable JS wart (it would have been better to have variables default to local); I don't see it as my duty to duplicate the limitations of [an old revision of] ANSI C in JavaScript as well.

(*: other than in nested function bodies)

let is introduced in Ecma Script 6 - the new javascript version - which is still in development at the time of this writing. Therefore, using var will get you across more browsers for the time being.

On the other hand, I urge people to use let instead of var from now on. I would go ahead and list the reasons but you have already have a link in your post with a great explanation in it. Long story short, let helps you avoid the variable hoisting in javascript and keep your variables' scope at just where it needs to be.

update

I've forgotten about this post until I recently got an upvote. I'd like to update this statement. I personally use const as much as I can these days. If you get into linting your code, which I highly recommend, and use something like airbnb lint rules, it will also tell you to use const. It will make your variables a constant so you will not be able to mutate them once you set their value thus it is not applicable in all cases. const and let also have advantages in terms of scope over var and it is well worth a read. My hierarchy of usage goes as such const > let > var

Using var to define a variable in a loop creates a variable within the scope of the loop only, while not using var changes or defines the variable globally, and can overwrite variables in other parts of the program if they share variable names. It's a best practice to use var, and then you'll never have to worry. This concept is touched on elsewhere in Treehouse. I think this is the video about it: https://teamtreehouse.com/library/javascript-basics-2/creating-reusable-code-with-functions/variable-scope

Without a var declaration somewhere in a function, references to i will be to the i property of the global object. This risks all sorts of unpredictable behavior if code in the body of the for loop invokes code (say, inside a called method) that also modifies the global i.

Note that declaring var i in the for loop initialization

for (var i = ...)

is equivalent to declaring var i; before the for loop:

var i;
for (i = ...)

In particular, the declaration of i will be hoisted to the top of the enclosing scope.

EDIT: If you enable strict mode, then you must declare your loop variables (all variables, actually). Referencing a variable that has not been declared with a var statement will result in a ReferenceError being thrown (rather than resulting in a global variable coming into existence).

See the MDN for the "initialization" of a for-loop:

An expression (including assignment expressions) or variable declaration evaluated once before the loop begins. Typically used to initialize a counter variable. This expression may optionally declare new variables with var or let keywords. Variables declared with var are not local to the loop, i.e. they are in the same scope the for loop is in. Variables declared with let are local to the statement. The result of this expression is discarded.