Question

How namespace helps in preventing pollution of global namespace?

Answer 1

A namespace is simply the space in which names exist (seems obvious enough now).

Let's say you have two pieces of code, one to handle linked lists, the other to handle trees. Now both of these pieces of code would benefit from a getNext() function, to assist in traversal of the data structure.

However, if they both define that function with the same name, you may have a clash. What will your compiler do when you enter the following code?

xyzzy = getNext (xyzzy);

In other words, which getNext() do you actually want to use? There are numerous ways to solve this, such as with object-oriented code, where you would use:

xyzzy = xyzzy.getNext();

and that would auto-magically select the correct one by virtue of the fact you've specified the type via the variable xyzzy itself.

But, even with mostly-OO code, there may be situations where you have a conflict, and that's where namespaces enter the picture. They allow you to place the names into their own area so as to distinguish them.

C++, as one example, places all its standard library stuff into the std namespace. If, for some reason, you need an fopen() or rand() function that works differently from the one in the library, you can place it in your own namespace to keep them separate.

Now that describes namespace clashes. Technically, namespace pollution is simply leaving your symbols in a namespace where they shouldn't really be. This doesn't necessarily lead to clashes but it makes it more likely.

The reason why making a method static (in C-like languages) has to do with the names being made available to the world outside the given translation unit (when linking, for example). With the code:

int get42 (void) { return 42; }

int main (void) { return get42(); }

both of those functions are made available to the linker.

Unless you have a need to call get42() from somewhere else, making it static:

static int get42 (void) { return 42; }

int main (void) { return get42(); }

will prevent it from polluting the namespace maintained by the linker – in C, applying the static qualifier to a file-level object or function gives it internal linkage.

It's similar to the C++ namespaces in that you can have a static int get42() in four hundred different source files and they won't interfere with each other.

Answer 2

Answer:

Function overloading isn't supported in Javascript. Accordingly, depending on the order in which two functions are loaded when they have the same name invoked, one function will take precedence over the other. Thus, namespaces are absent from JavaScript. To prevent name collisions, we can instead utilize objects to build namespaces.

Explanation:

• "Variables will be eligible for garbage collection when they become scope-less. If they are globally scoped, they won't be available for collection until the global namespace is no longer relevant."
• Languages like C++ or Delphi make it simple to resolve naming problems across libraries: If the same name appears in many libraries, the name should be qualified by the library name:

1. myVariable is defined by libA.
2. myVariable is defined by libB.

#SPJ2