A sometimes useful concept inside of PHP is that of variable functions.

This is a way for you to use a variable's value to call a function of the same name.

This way if a variable name has parenthesis appended to it, PHP will look

for a function with the same name as whatever the variable evaluates to,

and then will attempt to execute it.

We will use this mostly as a callback in our code,

allowing us to call different functions from another function or

from an action based off of the result of the main function.

Let's go to Workspaces and look at this a bit closer.

>> Okay. So, let's open up some php tags here and

we have existing functions already for hello and greet.

Well now, let's say function is equal to hello.

So, this is just simple, variable named func, F-U-N-C, or function.

And then, we set it equal to hello.

Now, this variable can be named anything, just like a normal string variable.

You could name it, you know, Bob, Chris, Tom, but it makes sense that

we're going to use a function name, so we'll just say, func equals hello.

Now, in order to call it we simply use $func, but then open and

close parentheses, and put a semi colon after it.

This is the exact same as if we called hello with open and

close parentheses, because in variable functions inside of

php whatever the value of the variable name is.

Which the value is hello of func, it will call that function, or

look for a function with that same name.

So, let's say we change func to greet, and then called F-U-N-C, or

func with the open and close parentheses.

It would be the same as if we had called greet.

We can also pass through arguments such as dollar sign func and then Mike and

then evening.

This would be the exact same as if we called greet then Mike

then comma then evening.

Okay. So, where we left off we actually have

a function here called add up.

Let's say, we'll call it add up and then we'll have another one and

we'll call it subtract.

So, first thing we're gonna do is just simplify these just to make them nice and

clean for now.

We'll actually return just $a plus $b.

Okay.

Save that, and then we want to add up those two values, which is totally fine.

And then, we'll add another function in here.

And, we'll call it, answer.

Okay? And then,

that answer won't have any arguments, but we will create it none the less.

And we'll say, return, and then we will return the integer 42.

Okay.

So now, we have our return value of 42 from the answer function and

then we add up two values.

And then here, we have us calling add_up.

We're actually gonna remove this for right now.

Okay. So,

to talk about variable functions, we have two functions here.

The idea behind a variable function is that we're actually able to

call a function by using a string variable.

So, let's try this by creating a new variable, a string variable.

And, we'll call it func, F-U-N-C.

We'll set that equal to a string called answer.

All right.

So, nothing more than just a string variable.

But, in php, if we wanna call maybe a function called answer,

we can do that by simply saying func, which is our variable and

then adding a open and close parenthesis around it, and then doing a semi colon.

So, I'm gonna save this and then go over to our preview, and see what we get.

Okay. We got nothing back.

The reason why, is we didn't actually echo anything.

So, let's actually do echo of func.

Head back over after saving it and refresh.

Perfect, 42. We can actually store this to another

variable if you want.

So, we'll just call it num is equal to funk and then say, echo num.

Save it, go back over, and Refresh.

And, we get the same thing, 42.

We just went about it a different way.

All right.

So, that's a base of any kind of variable function.

But, let's say we wanna change this easily without modifying it at all.

We'll just say, change our string variable value to add up.

Now, this unto itself won't do us much good.

We refresh it and we get 0.

Well, that's because adding 0 and 0 we get 0.

So, we can actually pass through arguments right here on line 13.

So, we can say 5 and then 10.

Save that, head back over, and refresh.

And, we'll get 15.

So, what you can see here with variable functions is that it

as allows us to take input from somewhere and

call any kind of function that preexists, based off of a string variable value.

This could be very helpful for callbacks, which we'll get into in later lessons.

But for now, you can see that just simply taking a variable value, such as add up or

answer, and putting parents behind that function, or

behind that variable definition, you can actually call a variable function.