The document explains PHP closures as anonymous functions that can access variables from their parent scope, allowing for more concise and expressive code. It discusses the advantages of closures, such as reducing code complexity, while also noting potential drawbacks like memory leaks if not managed properly. The document emphasizes the benefits of using closures for code reusability and clarity, and encourages readers to seek consultation for proper implementation.

1. From the Resource Library of Andolasoft.Inc | Web and Mobile App Development
Company
1

2. From the Resource Library of Andolasoft.Inc | Web and Mobile App Development
Company
2
How to Use Closure in PHP
Closure is an anonymous function (a function without name. Ex- function (){})
assigned to a variable.With using closure one can use the variable from immediate
parent scope or even the variable declared inside the global scope.
Closure has a great little feature that you may or may not have heard of. It’s
essentially a way to reduce the verbosity when writing functions that accept other
functions as arguments.
Reducing the size of your code with Closure will allow your PHP scripts to load faster
and take up less disk space. You may also find that coding in Closure results in
programs that are easier to understand and debug by reducing complexity, which
can be challenging when dealing with dynamic languages like PHP.
Using closure functions in PHP can help to make code more succinct, expressive, and
safer.
There are several ways to implement closures in PHP.
The above statement can be executed with the use language construct inside the
function.
Syntax:
function() use ($variable) { /* code to be executed */ }
What is a Closure?
A Closure is a function that can call itself, even when it has finished executing. In
other words, Closure is a function that can access variables outside its own scope.
This is made possible through a process in which the function remembers and “closes
over” its surrounding variables, even after it has finished executing.

3. From the Resource Library of Andolasoft.Inc | Web and Mobile App Development
Company
3
When a function is said to be “closed over” a certain set of variables, what this
means is that those variables are in fact “closed” and are no longer in their original
scope, but instead exist in the new scope of the function that captured them.
A closure is a function that captures its non-global variables (known as “free
variables”) from the execution environment in which it was created. The closure
remembers and can use those variables as if it were still executing in that
environment. This is a very powerful feature that can greatly increase the expressive
power of a programming language.
How to Pass a Variable inside the Closure:
There are two ways to pass a variable inside the closure.
1. Pass by value.
2. Pass by reference.
Pass By Value:
By passing a variable by value we cannot overwrite the value inside the closure
scope.
Example:
<?php
$value = 'this is a car';
functionmyFunc()
{
$value = 'this is a bus';
$func = function() use ($value)
{
echo $value;
};
$func();
}
myFunc();// this will print this is a bus.
?>

4. From the Resource Library of Andolasoft.Inc | Web and Mobile App Development
Company
4
If we overwrite a value inside the closure scope it can’t be resigned because the
variable is passed by its value.
Example:
<?php
$value = 'this is a car';
functionmyFunc()
{
$value = 'this is a bus';
$func = function() use ($value)
{
$value = 'I have a bus';
};
$func();
echo $value; // prints this is a bus!
}
myFunc();
?>
To overcome such situations one can pass the variable by reference.
Pass By Reference:
By passing a variable by reference, the variable can be overwritten inside the closure
scope.

5. From the Resource Library of Andolasoft.Inc | Web and Mobile App Development
Company
5
Example:
<?php
$value = 'this is a car';
functionmyFunc()
{
$value = 'this is a bus';
$func = function() use (&$value)
{
$value = 'I have a bus';
};
$func();
echo $value; // prints I have a bus!
}
myFunc();
?>
Advantages of Closure:
The simple advantages of using closure is that when the outer function executes all
of its variables still remain in memory until the function completed its execution but
in case of closures, the variables declared inside will be released as soon as the
closure completed its execution.
Disadvantages of Closure:
As long as closures are active, this memory cannot be garbage collected. Therefore,
closures can lead to memory leaks if not used well.

6. From the Resource Library of Andolasoft.Inc | Web and Mobile App Development
Company
6
Conclusion
One of the most important aspects of programming is the ability to abstract your
code, making it more general and reusable.
Closures make it possible to write more concise and expressive code, which can help
make your code more reusable.
Closures are a powerful tool that can make your code more expressive and easier to
read, especially when you have nested functions or lots of logic. This can make it
difficult to read and follow the code in certain scenarios.
Closures are a very useful programming tool, but they can also be powerful enough
to be dangerous if not used correctly. If you’re not sure how to use them, then
please book a free consultation with us to get clarification or if you just want to make
sure you’re using them the right way, then make sure you cross check them before
continuing.