Question

Is it possible to detect duplicate functions in Javascript (which may be written by accident in some cases)? In Google Chrome,

printLah(); //this prints "Haha" for some reason, without even printing an error message in the Javascript console!
function printLah(){
    alert("Hahah!");
}


function printLah(){
    alert("Haha");
}

Here it is on JSfiddle.

Answer 1

The short answer is, no it’s not.

This is how javascript works. A function name is just a variable that is assigned a function. For example:

function foo () {
    alert('foo!');
}

foo = 1;

foo();

The code above will generate an error because a number is not a function! There is no difference between function names and variable names. In fact, an alternative way to define functions looks exactly like how you’d define variables:

var foo = function () {
              alert('foo!');
          }

It’s because of this functions-as-first-class-objects behavior that javascript cannot prevent re-assignment otherwise you cannot re-assign variables (pure functional languages on the other hand have no problems with disallowing variable re-assignments).

---

Work-arounds and best practice:

This is the reason people keep saying that you shouldn’t define too many globals in javascript. That includes functions. Otherwise it may clash by accident with someone else’s code.

There are two powerful features in javascript that can mitigate this problem: objects and closures.

Because javascript supports objects you should use object oriented programming to limit the number of globals in your program. Unlike traditional OOP, javascript works better when using objects as collections or namespaces. This is because javascript doesn’t have file scope and everything is global.

This doesn’t mean you shouldn’t create smaller objects that encapsulate smaller problems like you do with traditional OOP. It just means that you should, if you can, contain all your objects within a single parent object. And I don’t mean inheritance here, I mean in a has-a relationship. Look at popular libraries like jQuery and Raphael for examples of this. They export only one object to the global scope to avoid clashing with other people’s code.

But, again, this doesn’t really protect people from re-assigning your objects (because they’re variables after all). For example, you can easily break jQuery by doing this at the top of your HTML file before other bits of javascript have the chance to run:

jQuery = null;

The way to protect your code from being tampered with is to use a closure. Third party code has no access to any code you run from inside your closure. As long as you avoid globals that is.