Breve estudio de todas las posibilidades que ofrece php en relación a las funciones.

1. Programación
PHP Funciones en
detalle
Dev010101
06/07/2019

2. Las funciones son bloques de código que por lo general agrupan instrucciones
que realizan operaciones sobre datos, pudiendo o no devolver información
fuera del ámbito de la misma. Las funciones solucionan problemas que resultan
repetitivos, permitiendo la reutilización de código:
//Función que suma dos enteros y devuelve un resultado
$a = 20;
$b = 40;
function suma($a,$b){
return $a + $b;
}
echo suma($a,$b);
Ámbito de variables en funciones
Las variables que se definen fuera de una función son por defecto globales.
Todas ellas son almacenadas en el arreglo asociativo GLOBALS, podemos
acceder al valor de cada una de ellas por medio del índice
$GLOBALS[“nombre_variable”].
Sin embargo las variables definidas dentro de una función son locales al
ámbito de la misma. Por ejemplo:
$str = “ámbito global”;
function local(){
$str = “ámbito local”;
}
local();
echo $str;
El resultado es: ámbito global.
Las variables definidas dentro de una función son destruidas al terminar su
ejecución, no pudiendo acceder a sus valores en el ámbito global, sin embargo
dentro de las funciones, si se pueden modificar los valores de variables
definidas en el ámbito global por medio del arreglo $GLOBALS. Por ejemplo:
$str = “ámbito global”;
function local(){
$str = “ámbito local”;
$GLOBALS[“str”] = $str;
}
local();

3. echo $str;
El resultado es: ámbito local.
Paso de argumentos
Las funciones que reciben argumentos tratan estas variables por valor, es
decir las operaciones que se hagan sobre ellas no son reconocidas en el ámbito
global (en los arreglos es igual). Por ejemplo:
$a = 20;
function cambiar($a){
$a = 100;
}
cambiar($a);
//La variable $a sigue valiendo 20
echo $a;
La forma para que las modificaciones al argumento recibido sean reconocidas
al término de la ejecución de la función es pasar los variables por referencia,
anteponiendo al identificador un carácter &. Esto también es válido para los
arreglos.
$a = 20;
function cambiar(&$a){
$a = 100;
}
cambiar($a);
//La variable $a ahora vale 100
echo $a;
Parámetros predeterminados
La lista de parámetros que recibe como argumento una función puede tener
valores predeterminados que pueden ser utilizados en la función. Por ejemplo:
$a = 80;
function sumar($nro,$cien = 100){
return $nro + $cien;
}
//La salida es 180
echo sumar($a);
Los parámetros predeterminados deben posicionarse siempre al final de la lista
de parámetros. También se puede definir como predeterminados todos los
parámetros de la función: por ejemplo:

4. //Suma los números hasta el 100
function sumar($i = 0,$cien = 100){
$suma = 0;
for(;$i <= $cien;$i++){
$suma += $i;
}
return $suma;
}
echo sumar();
También se aceptan arreglos con valores predeterminados.
function sumar($suma =0,$nros=[10,20,30,40,50]){
for($i = 0;$i < count($nros);$i++){
$suma += $nros[$i];
}
return $suma;
}
echo sumar();
Devolución de arreglos anónimos
Para devolver más de un valor desde una función, por lo general se utilizan
arreglos anónimos, en donde en cada índice de almacenan los valores que
deseamos devolver. Por ejemplo:
$a = 40;
$b = 20;
function operaciones($a,$b){
$suma = $a + $b;
$resta = $a - $b;
$multi = $a * $b;
$div = $a / $b;
return [$suma, $resta, $multi, $div];
}
echo "<br>La suma entre $a y $b es = ".operaciones($a,$b)[0];
echo "<br>La resta entre $a y $b es = ".operaciones($a,$b)[1];
echo "<br>La multiplicación entre $a y $b es = ".operaciones($a,$b)[2];
echo "<br>La división entre $a y $b es = ".operaciones($a,$b)[3];
Argumentos variables
Las funciones pueden recibir en su lista de parámetros, una longitud variable
de argumentos, creándose un arreglo de parámetros para ser usado dentro de
la función. Por ejemplo:
//Recibe argumentos variables
function sumar(...$nros){
$suma = 0;

5. $i = 0;
for(;$i < count($nros);$i++){
$suma += $nros[$i];
}
return $suma;
}
$resultado = sumar(10, 20,30,40,50,60,70,80,90);
echo "<br>La suma de los numeros es = $resultado";
También es posible pasar arreglos como argumentos de longitud variable
$nros1=[10,20,30];
$nros2=[40,50,60];
$nros3=[70,80,90];
//Recibe 3 arreglos y suma sus indices correlativamente
function suma_multiple(...$arreglos){
$suma=[0,0,0];
$cont=0;
for($i =0;$i < count($arreglos);$i++){
$suma[$i] = $arreglos[$cont++][$i] + $arreglos[$cont++][$i] +
$arreglos[$cont++][$i];
$cont = 0;
}
return $suma;
}
//Pasa los 3 arreglos ya declarados
$suma_arreglos = suma_multiple($nros1,$nros2,$nros3);
for($i=0;$i < count($suma_arreglos);$i++){
echo "<br> La suma $nros1[$i] + $nros2[$i] + $nros3[$i] =
".$suma_arreglos[$i];
}
El compilador también permite enviar argumentos variables a la función y no
tan solo recibirlos como ya se vio anteriormente. Por ejemplo:
//Enviar argumentos de longitud variable para sacar promedio
function promedio($a,$b,$c){
return ($a + $b + $c)/func_num_args();
}
echo "<br> El promedio es: ".promedio(...[10,20,30]);

6. Además los argumentos de longitud variable pueden ser pasados por
referencia. He aquí un ejemplo: (Corregido por Nikic)
$arr = [10];
function asignar(&...$arr){
//De esta manera no se sobrescribe el valor en posición 0
$arr[0][0] = 100;
}
asignar($arr);
echo "<br> ".$arr[0];
Determinación de tipos
La determinación de tipos en php, permite forzar a que los parámetros de una
función sean de un tipo determinado. Por ejemplo:
//Función con determinación de tipos en su lista de parámetros
function promedio2(int $a,int $b,int $c){
//Sacar promedio
return array_sum(func_get_args())/func_num_args();
}
echo "<br> El promedio es : ".promedio2(...["oi",20,30]);
Daría un error fatal de tipo: Uncaught TypeError: Argument 1 passed to
promedio2() must be of the type int, string given,…
Los argumentos pasados a funciones con determinación de tipos aceptan
conversiones implícitas permitidas por el compilador. Por ejemplo si
modificáramos la siguiente línea el código igual funcionaria:
echo "<br> El promedio es : ".promedio2(...["10","20",30]);
También es posible pasar argumentos por referencia a una lista de parámetros
que utilice la determinación de tipos.
/Determinación de tipos pasados por referencias
$str = "programacion";
function reemplazo_caracter(string &$str, string $valor, string
$nuevo_valor){
for($i = 0; $i < strlen($str);$i++){
if($str[$i] == $valor){
$str[$i] = $nuevo_valor;
}
}

7. }
reemplazo_caracter($str,"o","a");
echo "<br> Cadena tiene los siguientes caracteres : $str";
Preservación de valores en funciones
Para preservar los valores de las variables que son declaradas dentro de una
función, cuando termine la ejecución de esta se hace necesario el uso de
variables estáticas. Así cada vez que se llame a la función que retorne una
variable estática esta mantendrá su valor entre llamadas. Ejemplo de función
normal:
//Preservación de valores en funciones
function ambito_estatico($a){
$sum = 0;
$sum += $a;
return $sum;
}
echo "<br>".ambito_estatico(10);
echo "<br>".ambito_estatico(10);
echo "<br>".ambito_estatico(10);
El resultado siempre será: 10.
Sin embargo si cambiamos la siguiente línea, el resultado ira aumentando a
medida que invoquemos a la función con su argumento correspondiente:
static $sum = 0;
Determinación de tipos de retorno
Los valores de retorno de una función también pueden ser determinados por
un tipo específico, así se anulan las conversiones automáticas que realiza el
compilador, forzando la salida a un tipo específico que le indiquemos:
//Determinacion de tipos de retorno
function multi($a,$b): float{
return $a * $b;
}
//Lo normal sería que retornará un tipo int
var_dump(multi("78","89"));

8. Funciones variable
Otra característica de php son las funciones variable, que permiten utilizar
variables como funciones tan solo asignándoles los nombres de las funciones
entre comillas. De esta manera se podría crear un arreglo de funciones
como se mostrará en el siguiente ejemplo básico del uso de esta característica:
//Se declaran funciones normales de operaciones aritméticas
function multiplica($a,$b){
return $a * $b;
}
function sum($a,$b){
return $a + $b;
}
function resta($a,$b){
return $a - $b;
}
function division($a,$b){
return $a / $b;
}
//Se asignan esas funciones a variables
$func_multi = 'multiplica';
$func_sum = 'sum';
$func_resta = 'resta';
$func_division = 'division';
//Se define arreglo asociativo con las variables anteriores
$opers = array(
"multiplicacion" => $func_multi,
"suma" => $func_sum,
"resta" => $func_resta,
"division" => $func_division
);
//Se llama a cada función desde la variable que la representa
//en el arreglo
function calculos($opers,$a,$b){
foreach($opers as $clave => $valor){
echo "<br> La $clave entre $a y $b es = ".$valor($a,$b);
}
}
calculos($opers,70,14);

9. Funciones anidadas
En php se pueden anidar funciones una dentro de otra, pudiendo agrupar
funciones que se relacionen lógicamente una con la otra, y al mismo tiempo
funciones que no se necesiten llamar desde afuera, por ejemplo, función que
agrupa operaciones básicas sobre números.
NOTA: Las funciones internas no reconocen las variables declaradas en la lista
de parámetros de la función que las encapsula.
//Funciones anidadas
function calculo($a,$b,string $opc){
if(is_string($a) || is_string($b)){
return "<br>Error !!! necesito numeros";
}else{
if($opc == "s"){
function adicion($a,$b){
return "<br>La suma de $a + $b = ".($a + $b);
}
$resultado = adicion($a,$b);
}else if($opc == "r"){
function restar($a,$b){
return "<br>La resta de $a + $b = ".($a-$b);
}
$resultado = restar($a,$b);
}else if($opc == "m"){
function multiplicar($a,$b){
return "<br>La multiplicacion de $a + $b = ".($a*$b);
}
$resultado = multiplicar($a,$b);
}else if($opc == "d"){
function div($a,$b){
return "<br>La division de $a + $b = ".($a/$b);
}
$resultado = div($a,$b);
}else{
$resultado = "<br> Error!! opcion no valida";
}
}
return $resultado;
}
echo calculo(70,20,"d");
echo calculo(203,20,"m");

10. echo calculo(500,30,"s");
echo calculo(50,30,"r");
También se ven funciones condicionales, las cuales su definición puede o no
darse, para este código se hizo necesario aplicarlas, debido a que no puede
redefinir el nombre de una función más de una vez, ocurriendo esto al llamar a
la función contenedora más de una vez.
Funciones anónimas
Las funciones anónimas no tienen nombre para ser invocadas, en el ejemplo
que se verá se asigna el valor que devuelve una función a una variable,
pasando a ser esa variable la función a la cual llamar.
//Asignación de función anónima
$arr_str = function(string $cadena){
//No acepta ni números ni cadenas de números
//Si acepta mezcla de números y letras
if(is_numeric($cadena)){
return "Error!! se necesita cadena";
}else{
$arr = [];
}
for($i =0; $i < strlen($cadena);$i++){
$arr[$i] = $cadena[$i];
}
return $arr;
};
echo "<br>";
var_dump($arr_str("programacion2019"));