Next up is something you may not use often, but

is a good thing to know, and those are closures.

Closures are anonymous functions, which are functions with no name,

that are capable of accessing variables outside of the function scope.

We'll talk more about the use of closures as call backs when we

get to the internal functions video.

For now, let's look at how this works.

Okay, to provide an example of a closure, let's start by opening and

closing a set of PHP tags.

Then inside of those, we're gonna do it a little bit differently.

Before we had used the function keyword, right?

And then added a name for our function.

In this case, we're going to use $greet as a variable, and

then set it equal to function, and then open and close parentheses.

And then open and close our curly braces, and

then follow that as a statement, enclosing it with a semi-colon.

So what this is going to do is whatever we do inside this function, it's going to set

its output to greet, $greet will contain whatever function produces.

So let's do this.

We'll add inside the function echo Hello there and then close that statement.

This way, when we call $greet then we'll get hello there.

Now let's say we have something outside of the function scope.

Well anonymous functions are not able to access things outside of

the function scope unless we utilize the use keyword.

So what we'll do here is if we have a variable named $name and that's equal

to friend and we wanna use it in our greet function, or our greet anonymous function,

then we simply say function use, and then in parentheses, $name.

This way, inside of our statement, inside of the function we can say,

echo Hello there, $name.

Notice how I've surrounded it in double quotes now so

that we can actually output the value of the string.

So to build out our example in WorkSpaces,

we are going to define our anonymous function or

our closure with $greet as the name and then we'll set that equal to a function.

And then open and close our parenthesis.

Open and close our curly braces, but

the big case here is to make sure you end this in a semicolon.

So a anonymous function is really more like

a single line function that's being assigned to a variable.

So we'll make sure we end it in a semicolon and

then inside we'll actually do an echo statement.

So we'll say echo and then our echo will be hello there, okay?

Close it with a semicolon and

then in order to call this, we'll simply type in $greet and

then open and closed parenthesis, just like we did in a variable function.

Let's head over to our preview and take a look.

Okay, so you'll see here we have hello and in there exclamation point.

So, that's exactly what we're looking for.

Okay, so let's head back over to WorkSpaces and

build out this example just a little bit more.

Let's say we wanna greet a name.

All right, so we'll say function and

then we want something outside of the function scope.

So we'll have something like name, and then we'll set that equal to Mike.

All right.

So inside of our function we want to access greet.

Well we can't just pass it through as an argument and we don't want to use global.

So we can use the keyword, use.

So we'll say use, and then what we want to use is $name.

So now we can go through and say hello and then $name.

But we want to make sure we change this to double quotes because we

are evaluating name and single quotes don't do evaluation.

So let's go ahead and hit Save and see if this does what we expect.

Refresh.

And then it says, hello Mike.

So in an anonymous function, instead of passing through an argument anonymously,

we'll just use something outside of the function scope.

So name would be outside the function scope defined on line three.

We utilize the use keyword and then pass through $name that way