Will I Have Any Problems If I Declare The Same Variable Multiple Times?

So lets say I have some code: //Javascript var elements = []; function addNumbah1(){ var i = 1; elements.push(i); } function addNumbah2(){ var i = 2; elements.push(

Solution 1:

Short answer: NO, JS hoists all variable declarations to the top of the scope, regardless of how many times you've declared them:

var i = 0
for (var i=0;i<10;i++)
{
    var j = i%2;//declared 10 times, on each iteration
}

Will be translated to

var i, j; //i is undefined at this point in the code.
for (i = 0;i<10;i++)
{
    j = i%2;//declared 10 times, on each iteration
}

In your first example, you're declaring i as a variable in a function's scope, which is what you must do to avoid cluttering the global scope. The memory these variables use is allocated when the function is called, and deallocated when the function returns (roughly, closures form an exception, but that would take us to far). Consider this:

var i = 10;
function someF()
{
    var i = 1;
    alert(i);
}
someF();//alerts 1 <-- value of i, local to someF
alert(i);//10, global i is unchanged

But if you were to omit the var:

function someF()
{
    i = 1;
    alert(i);
}

You'll see that 1 is alerted twice. If JS can't find a variable declaration in the current scope, it will look in the higher scopes until a var is found. If no variable is found, JS will create one for you in the highest scope (global). Check my answer here on how implied globals work for a more detailed example, or read the MDN pages, especially the section on Name conflicts

Lastly, I'd like to add that globals, especially implied globals, are evil. Also know that the ECMA6 standard is clearly moving away from global variables and introduces support for true block-scopes. As you can see here
Oh, and if you want to check if a function uses implied globals: 'use strict'; is a great thing:

(function()
{
    'use strict';
    var localVar = 123;//ok
    impliedGlobal = 123;//TypeError!
}());

As you can see, implied globals are not allowed. See MDN on strict mode for the full explanation

Solution 2:

The second form, with global i might actually be a bit slower because it's defined in a higher scope, and variables defined in a higher scope take longer to resolve.

Aside from any performance considerations just stick with common guidelines unless performance is really an issue. In this case: scope your variables as narrowly as possible.

I would strongly advise you to use the first form.

Solution 3:

The first way you did it is fine. Each instance of i would have no knowledge of the other i in the other functions.

You should read this tutorial on global versus local variables

Also, could I suggest an optimization. Why can't you just do the following to cover any number (instead of separate functions for each number)?

var elements = [];
function addNumbah(number){
    elements.push(number);
}

Solution 4:

It is okay to declare variables with same name in different functions.

Solution 5:

Variables declared inside a function only exist in the scope of that function, so having the same variable name across different functions will not break anything.

In fact, it is good form to keep variables in as small of a scope as possible! Global variables can be difficult to manage and can create really bad bugs, especially if one function isn't done using the variable when another function tries to access it.

Specifically for simple variables, declaring

var i = 0;

every time is perfectly fine.