What is the function of the var keyword and when to use it (or omit it)?

There's a difference.

var x = 1 declares variable x in current scope (aka execution context). If declaration appears in a function - local variable is declared; if it's in global scope - global variable is declared.

x = 1, on the other hand, is merely a property assignment. It first tries to resolve x against scope chain. If it finds it anywhere in that scope chain, it performs assignment; if it doesn't find x, only then it creates x property on a global object (which is a top level object in a scope chain).

Now, notice that it doesn't declare global variable, it creates a global property.

The difference between two is subtle and might be confusing unless you understand that variable declarations also create properties (only on a Variable Object) and that every property in Javascript (well, ECMAScript) have certain flags that describe their properties - ReadOnly, DontEnum and DontDelete.

Since variable declaration creates property with DontDelete flag, the difference between var x = 1 and x = 1 (when executed in global scope) is that former one - variable declaration - creates DontDelete'able property, and latter one doesn't. As a consequence, property created via this implicit assignment can then be deleted from the global object, and former one - the one created via variable declaration - can not be.

But this is jut theory of course, and in practice there are even more differences between two, due to various bugs in implementations (such as that from IE).

Hope it all makes sense : )

[Update 2010/12/16]

In ES5 (ECMAScript 5; recently standardized, 5th edition of the language) there's a so-called "strict mode" — an opt-in language mode, which slightly changes the behavior of undeclared assignments. In strict mode, assignment to an undeclared identifier is a ReferenceError. The rationale for this was to catch accidental assignments, preventing creation of undesired global properties. Some of the newer browsers have already started rolling support for strict mode. See, for example, my compat table.

Saying it's the difference between "local and global" isn't entirely accurate.

It might be better to think of it as the difference between "local and nearest". The nearest can surely be global, but that won't always be the case.

/* global scope */
var local = true;
var global = true;

function outer() {
    /* local scope */
    var local = true;
    var global = false;

    /* nearest scope = outer */
    local = !global;

    function inner() {
        /* nearest scope = outer */
        local = false;
        global = false;

        /* nearest scope = undefined */
        /* defaults to defining a global */
        public = global;
    }
}

When Javascript is executed in a browser, all your code is surrounded by a with statement, like so:

with (window) {
    //Your code
}

More info on with - MDN

Since var declares a variable in the current scope , there is no difference between declaring var inside window and not declaring it at all.

The difference comes when you're not directly inside the window, e.g. inside a function or inside a block.

Using var lets you hide external variables that have the same name. In this way you can simulate a "private" variable, but that's another topic.

A rule of thumb is to always use var, because otherwise you run the risk of introducing subtle bugs.

EDIT: After the critiques I received, I would like to emphasize the following:

• var declares a variable in the current scope
• The global scope is window
• Not using var implicitly declares var in the global scope (window)
• Declaring a variable in the global scope (window) using var is the same as omitting it.
• Declaring a variable in scopes different from window using var is not the same thing as declaring a variable without var
• Always declare var explicitly because it's good practice

You should always use the var keyword to declare variables. Why? Good coding practice should be enough of a reason in itself, but declaring a variable without the var keyword means it is declared in the global scope (a variable like this is called an "implied" global). Douglas Crockford recommends never using implied globals, and according to the Apple JavaScript Coding Guidelines:

Any variable created without the var keyword is created at the global scope and is not garbage collected when the function returns (because it doesn’t go out of scope), presenting the opportunity for a memory leak.

So, in short, always declare variables using the var keyword.

Here's quite a good example of how you can get caught out from not declaring local variables with var:

<script>
one();

function one()
{
    for (i = 0;i < 10;i++)
    {
        two(i);
        alert(i);
    }
}

function two()
{
    i = 1;
}
</script>

(i is reset at every iteration of the loop, as it's not declared locally in the for loop but globally)

another difference e.g

var a = a || [] ; // works 

while

a = a || [] ; // a is undefined error.

I would say it's better to use "var" in most situations.

Local variables are always faster than the variables in global scope.

If you do not use "var" to declare a variable, the variable will be in global scope.

For more information, you can search "scope chain javascript" in Google.

Without var - global variable. Strongly recommended to ALWAYS use var statement, because init global variable in local context - is evil. But, if you need this dirty trick, you should write comment at start of page:

/* global: varname1, varname2... */

Using var is always a good idea to prevent variables from cluttering the global scope and variables from conflicting with each other, causing unwanted overwriting.

Inside a code you if you use a variable without using var, then what happens is the automatically var var_name is placed in the global scope eg:

someFunction() {
    var a = some_value; /*a has local scope and it cannot be accessed when this
    function is not active*/
    b = a; /*here it places "var b" at top of script i.e. gives b global scope or
    uses already defined global variable b */
}

this is example code I have written to understand this concept. I hop this is helpful.

var foo = 5; 
    bar = 2;     
    fooba = 3;
    // Execute an anonymous function
    function test()
    {    bar=100;
       var foo = 4; 
       var fooba=900;
        document.write(foo);//4
        document.write(bar);//100
        document.write(fooba);//900
    }
    test();
    document.write('<br/>');
    document.write('<br/>');
    document.write(foo);//5
    document.write(bar);//100
    document.write(fooba);//3

Without using "var" variables can only define when set a value. In example:

my_var;

cannot work in global scope or any other scope. It should be with value like:

my_var = "value";

On the other hand you can define a vaiable like;

var my_var;

Its value is undefined ( Its value is not null and it is not equal to null interestingly.).

Differences between declaring a variable with 'var' and without 'var' keyword:

I would like to add two words to answer the question 'Initializing' and 'assignment'

If you declare a variable with 'var' keyword it simply initialize the variable.

Example: var x=10; (initialize the variable)

If you declare a variable without 'var' keyword it will assign the value to variable name. If the variable is not intialized earlier it does the initialization of variable.

Example: x=10; (it will assign '10' to 'x')

CONSIDER THE BELOW EXAMPLES:

example 1:

var x=10; //initialize and assigns 10 to y (global scope)

function fun(){

var x=20; //initialize and assigns 10 to x (local scope)

console.log(x); //prints 20

}

console.log(x); //prints 10

example 2:

y=10; //initialize and assigns 10 to y (global scope)

function fun(){

y=20; //assign 20 to y (global scope)

console.log(y); //prints 20

}

console.log(y); //prints 20

example 3: z=10; //initialize and assigns 10 to z (global scope)

function fun(){

var z=20; //intialize and assigns 20 to z (local scope)

console.log(z); //prints 20

}

console.log(z); //prints 10

basically 'var' keyword is used to define a variable with in local scope if you use 'var' keyword the value will be available to that particular scope only.