Forge Titanium

Javascript can give you an headache sometimes; the way the scope works in this language is something that definitely will.

Let’s see an example:

The code is pretty simple: we are defining a global variable called x, and then re-defining it inside the test function; you would expect the first time we call console.log(x) to see “hello” printed out in the console, but that’s not the case. This is because, since a local version of x is defined inside test(), Javascript will use it inside the whole function, even before it is defined; however, since the actual value is set after the first call, the first call will simply print out undefined.

There is a more subdle problem here: function declaration do not follow this path. Here’s another example:

In this case, we are defining two functions inside test(): one is declared – as before – using var; as we have seen before, when we call bad(), the variable is undefined, and the call will fail. That should be pretty clear. However, the same is not happening for the other function: despite we declare good() after we call it, doing this without the var keyword will not cause the mentioned problem. Which means, you will see This will work in the console, and an error message afterwards.

This issue might come up in particular when you minimize the code, before using it: you might have used the good() format to declare your function after you use them, and everything works, but once the code is minimized, your app will stop working; this happens if the minimization converts your function from the original format to the other one. That said, always pay attention how your variables (and functions) are declared in your code: despite you are free to do as you prefer, it is always better to declare everything in the beginning of the function, in order to avoid problem.