Namespaces are a common idea in many programming languages and

PHP has had them since PHP 5.3.

To some developers, they still feel a little new.

So let's take a look at how they work.

The basic idea of using namespaces is to ensure that two difference classes,

functions, or constants with the same name do not cause conflicts.

For example, if you try to define two classes called client,

then the second definition will cause a fatal error,

complaining that you can not redefine that class.

If instead, you put that class into a namespace,

you can refer to both of them differently.

Let's take a look at how that works with some code.

Before we get started, pay no attention to line four,

as I'll explain about display errors later on.

So on line seven, we're including a third-party piece of

code that has been placed in the source folder which handles HTTP interactions.

On line eight, we're including another third-party piece of

code which will help us interact with the Twitter API.

Sadly, the developer of both the HTTP code and the Twitter code has not

used namespaces and instead declared the classes into global namespace.

Now we have these two client classes which looks a little funny and

will throw an error when we try and run the preview.

So you can see here, they've had trouble redeclaring the class client

because there's already a class called client.

If we have a look at the code we can see how to fix this.

We go into the source folder and inside the HTTP folder and look at the Client.

You can see here that there's no namespace declaration.

Now our namespace declaration is simply the word namespace and then the name.

We save that and we do the same thing to Twitter and save that too.

Now when we run this, PHP gives us a different error.

The complaint here is the class client does not exist.

Which is completely true.

Now the class client is not being defined in the global space.

It has to be referenced with the namespace.

Let's get back to our workspace and try that out.

So if we remember the names of our namespaces, which were HTTP,

we type that in and we use a backslash to de-reference it.

Do the same for Twitter, and now we've referenced our two different client

classes correctly with their namespaces so PHP knows where to find that code.

We run this again.

We can see that two objects, HTTPClient and TwitterClient, have been created.

We can further improve this code by using auto-loading, and

that's what we'll do in the next lesson.