JavaScript does not yet have a native representation of namespaces, but TypeScript does.

For example, you could use the following TS code ([playground][1])

```ts
namespace Stack {
    export const hello = () => console.log('hi')
}

Stack.hello()
```

If you can't update your code to TS, you can at least use the pattern employed by TS when generating the JS output for namespaces, which looks like this:

```js
var Stack;
(function (Stack) {
    Stack.hello = () => console.log('hi');
})(Stack || (Stack = {}));
Stack.hello();
```

### Further Reading:


* [TS - Namespaces][2]
* [TS - Namespaces and Modules][3]

[1]: https://www.typescriptlang.org/play?#code/HYQwtgpgzgDiDGEAEBlALgg1kg3gKCUKQgA8YB7AJzSXnOChoAsIAbV8pAXiQAoBKbgD5a9KOVYQAdBwDmvAORMAlgv54AvnjzosUlu3IC8QA
[2]: https://www.typescriptlang.org/docs/handbook/namespaces.html
[3]: https://www.typescriptlang.org/docs/handbook/namespaces-and-modules.html


How do I create a namespace in JavaScript so that my objects and functions aren't overwritten by other same-named objects and functions? I've used the following:

    if (Foo == null || typeof(Foo) != "object") { var Foo = new Object();}

Is there a more elegant or succinct way of doing this?



How do I declare a namespace in JavaScript?

This will happen anytime that you are attempting to use a namespace that also exists anywhere within the hierarchy of the currently scoped namespace.  Let me explain me with the following example:

Say you have the following code:



	Namespace Company.Application
		Module Module1
			Sub Main()
				'Code Goes Here
			End Sub
		End Module
	End Namespace

	Namespace Company.Application
		Public Class ApplicationClass
		End Class
	End Namespace

	Namespace Company.Business
		Public Class BusinessClass
		End Class
	End Namespace

	Namespace Business
		Public Class RootLevelBusiness
		End Class
	End Namespace

Now let's see what's exposed when we go to use the *`Business`* Namespace in our Module (we should expect to see the *`RootLevelBusiness`* class

![Business](http://i.imgur.com/UfIGQ2M.png)

**But We Don't!!!**

That's because the code has worked it's way up the hierarchy of the current namespace and found a business class before getting to the root.  To help prove that, look what happens when we include *`Company`*:

![Company](http://i.imgur.com/wEMgnb5.png)

You'll see that *`Company`* is greyed out because it doesn't need it.  It would be running the same code with or without qualifying that it comes from Company, because we're already in the *`Company`*`.Application` namespace.

Solution - Use `Global`
=======

If you'd like to qualify classes inline, you need a way of telling the compiler to not look inside of your current namespace when resolving classes.  For this, use [**`Namespace Global`**](http://blogs.msdn.com/b/vbteam/archive/2011/09/27/announcement-namespace-global.aspx) which provides: 

>a new way to “escape” your classes out of the project’s Root Namespace

![global](http://i.imgur.com/bXZVj7j.png)

Global tells the compiler to start from scratch, in which case we immediately find the Business namespace.

The reason you can add the class through the [**`Imports`**](http://msdn.microsoft.com/en-us/library/7f38zh8x.aspx) statement without using Global is because `Imports` is global by default.  Because you have to declare `Imports` before defining any `Namespaces`, the imports statement has no way to presume what the namespace will be in any subsequent block of code in the rest of the file because you can (although probably shouldn't) declare as many namespaces as you want within a single file.  For this reason, Imports will always start from the root of any namespace and work it's way down.

I'm having an odd issue with a reference to an assembly

I have a VS2008 project which references an assembly with the RootNamespace `Business.CHHS`.  When I import the namespace, the contained classes are properly exposed

![Working](http://i.imgur.com/uqhhXWh.png)

However, if I instead use the fully qualified name, it can no longer find the referenced namespace or its types.

![NotWorking](http://i.imgur.com/mg4LV2N.png)

I've definitely put in the reference and built the solution (everything compiles in the first example).  When I'm typing the namespace into the imports statement, I get full intellisense support for CHHS, when i'm specifying the variable type, CHHS does not show up under the Business namespace.

**Q**: *What's going on here?*