../courses.php

Procedural PHP

PHP

90

Functions Build Programs

Why a variable changed inside a function does not change the same name outside it.

A function changes the value of a variable called $total inside itself, using the exact same name as a $total that already exists outside the function, one the rest of the page depends on. After the function runs, the outer $total is completely unaffected by anything that happened inside. Why would using the very same name not connect the two at all?

PHP gives each function its own local scope by default. A variable name used inside a function is a brand-new, separate variable, even when an outer variable happens to share the exact same name. The two $total variables are not connected, unless the function specifically receives the outer one as a parameter and returns a new value, or the function uses the global keyword to reach outside its own scope on purpose.

A function is defined once, with function followed by a name and a list of parameters in parentheses, and can then be called by that name as many times as needed, from anywhere later in the same file.

A parameter is a placeholder name a function uses for whatever value gets passed in when it is called. The same function, called twice with two different values, runs its exact same code against two different sets of parameter values.

return sends a single value back out of a function to wherever it was called from. A function with no return line at all produces null as its result, even if the function's body did other useful work along the way.

A parameter can be given a default value directly in the function's own definition, such as function f( $percent = 10 ). That default is only ever used when a call leaves that argument out entirely.

Two calls to the same function are completely independent of each other. Nothing a function does during one call carries over into the next call, except through a value that call explicitly returns and something outside the function chooses to store.

Two chained calls to one function, using a default parameter

$percent = 10 inside the parameter list means a call like apply_discount( $total ), with only one argument, still works, using 10 automatically. The second call, apply_discount( $total, 25 ), supplies its own value instead, overriding that default just for that one call.

$discount, created inside the function, never exists anywhere outside it. Once the function returns, that name is gone completely, and the next line of the program could reuse $discount for something else entirely with no connection to this one.

apply_discount( $total ) does not hand the function the variable $total itself. It hands the function a copy of whatever value $total held at that exact moment. Changes the function makes to its own local $amount parameter never reach the outer $total at all, only the returned value does.

$total = apply_discount( $total ) deliberately reuses the same name on both sides. This is not the function changing $total. It is the outer code choosing to replace its own $total with whatever value comes back from the call, which only looks like the same variable being updated in place.

Calling apply_discount() twice in a row, with the first call's result feeding into the second, chains a 10 percent discount and then a 25 percent discount on top of the already-discounted number, not 35 percent off the original amount.

A variable inside a function cannot be reached from outside it

$discount, created inside apply_discount(), produces an undefined-variable warning if read anywhere outside the function, even on the very next line after calling it. This strict separation, called scope, is what lets two different functions both use a name like $discount internally without ever colliding.

Function arguments are copies, not the original variables

Passing $total into apply_discount( $amount, ... ) gives the function its own separate copy, named $amount, to work with. Reassigning $amount inside the function, even many times, never changes the value sitting in the outer $total variable at all.

A default parameter value only fills in a gap, it never overrides a supplied value

apply_discount( $total, 25 ) ignores the default of 10 completely, because a value was actually supplied for that position. The default in the function's own definition only ever takes effect when that argument is left out of the call entirely.

Stacking function calls compounds, it does not add

Two discounts of 10 percent and 25 percent, applied one after the other through two separate calls, remove about 32.5 percent of the very original amount in total, not 35 percent, because the second discount is calculated on the already-reduced number left by the first call.

global lets a function reach outside its own scope, on purpose

Writing global $total; as the first line inside a function connects that function's $total directly to the outer one, instead of creating a separate local copy. This is the one deliberate exception to the usual rule, and it is rarely used in well-organized PHP, precisely because it makes a function's behavior depend on something its own parameter list does not show.

Reaching outside the function with global

Passing the value in and returning the new one

When an AI tool writes a function, three things are worth checking. First, does it rely on global to reach a variable, when accepting a parameter and returning a value would do the exact same job more clearly. Second, if a parameter has a default value, does any actual call site ever rely on that default, or does every call supply its own value anyway, making the default dead code. Third, when two calculations are meant to be chained, does the function's logic correctly compound on the previous result, rather than always recalculating from one fixed starting number.

Call apply_discount( $total, 0 ) and confirm the returned value equals the original $total exactly, to check that a 0 percent discount really changes nothing.

Remove the default value from $percent entirely, then call apply_discount( $total ) with only one argument as before, and read the resulting error message closely.

Write a second function, apply_tax( $amount, $percent = 8 ), shaped the same way as apply_discount(), and chain it after a call to apply_discount().

Add a global $log = []; line outside the function, and a line inside apply_discount() that appends to $log using global $log;, to see the global keyword used for a purpose other than changing $total itself.

Predict the final total if apply_discount( $total, 25 ) is called before apply_discount( $total ) instead of after, swapping the two calls' order, then run it to check.

Expecting a value changed inside a function to automatically update the outer variable that was passed in, without using return and reassigning the result.

Defining a default value for a parameter that comes before a required parameter with no default, such as function f( $a = 1, $b ), which PHP either rejects or handles in a confusing, easy-to-misuse way. Required parameters belong before parameters with defaults, not after.

Giving two completely different functions the exact same name in the same file, which produces a fatal cannot-redeclare error the moment the file runs, rather than the second definition quietly replacing the first.

Forgetting return inside a function entirely, then trying to use the function's result directly, such as echo apply_discount( $total );, and getting nothing printed at all, because a function with no return produces null.

Treating the order of arguments in a call as unimportant, as long as the right values are present somewhere. apply_discount( 25, $total ) silently swaps which number is treated as the amount and which is treated as the percent, since PHP matches arguments to parameters by position, not by guessing intent.

You can now explain why a variable changed inside a function does not affect a same-named variable outside it, unless the value is explicitly returned and reassigned. You can also use a default parameter value correctly, and you can trace what happens when two function calls are chained together, one feeding its result into the next.