The use of undefined variables in if-statements

I sense you are asking because you are aware that javascript seems to allow undefined variables in some situations (ie no runtime errors) and not in others.

The reasoning is as follows: javascript always throws an error on checking undefined variables, but never throws an error on checking undefined properties, as long as you only use one level of indirection.

Example:

// throws runtime error
if(foo) {
    // ...
}

// does not throw runtime error
if(window.foo) {
    // ...
}

// does not throw runtime error
var obj = {};
if(obj.foo) {
    // ...
}

// throws runtime error
if(obj.foo.bar) { // going two levels deep, but foo is undefined
    // ...
}

Hope that clears it up a bit.

That would be because you're now defining it with:

var foo = foo || null

Why don't you define it in the first place? That seems pretty straightforward to me (unless I'm missing something).

Using a variable before it's created (or set to something) is bad programming practice, and should be avoided. My advice is to not use that trick to ensure it is set to something but to track down the logic error and fix it.

It seems strange question to me. Lets say I wanted to call a function:-

thing();

If thing hasn't be defined anywhere surely I would expect it to fail.

Why would you expect to use a variable called foo without defining it anywhere in your code?

I find this a bit of a strange question. To answer it I think it's best to ask the question the other way round...

What would be the expected result of

if (foo) {
    // ...
}

where foo is not defined as a variable?

I think the only possible answer is that the if would always evaluate to false and you'd never execute that block.

Asking a more direct question to you, why would you expect code to work which refers to variables that don't exist and have not had values assigned? What is foo in the context you define above?

Bottom line is that without the declaration the subsequent statement does not have any meaning. foo is not a term which can be evaluated on its own so you have to give the interpreter a context for the reference to foo so it can evaluate it.

There are languages which automatically create variables for you when they are first assigned (python and VB share that dangerous trait) but even those will not be able to evaluate a variable prior to assignment, so the interpreters throw errors.

If you had a compiler it would have told you about this too...

This is not a strange question coz I'm on the same boat :p

I reach here after googling "javascript use variable undefined". I got confuse coz I've seen somewhere that people can simply use undefined variable in a loop.

Maybe I saw it on different language

I've found it. The first codes successfully executed while the second codes runtime error.

First Codes:

test();
function test() { x = 4; }
console.log(x); //this produce 4

Second Codes:

test();
function test() { x[0] = 1; }
console.log(x[0]);