PHP 5.5.15 is released

Funciones definidas por el usuario

Una función puede ser definida usando una sintaxis como la siguiente:

Ejemplo #1 Pseudo código para demostrar el uso de funciones

<?php
function foo($arg_1$arg_2/* ..., */ $arg_n)
{
    echo 
"Función de ejemplo.\n";
    return 
$valordevuelto;
}
?>

Cualquier código PHP válido puede aparecer dentro de una función, incluso otras funciones y definiciones de clases.

Los nombres de las funciones siguen las mismas reglas que otras etiquetas de PHP. Un nombre de función válido comienza con una letra o guión bajo, seguido de cualquier número de letras, números, o guiones bajos. Como expresión regular se expresaría así: [a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*.

Las funciones no necesitan ser definidas antes de que se referencien, excepto cuando una función está condicionalmente definida como se muestra en los dos ejemplos de abajo.

Cuando una función está definida de una forma condicional como en los dos ejemplos mostrados, sus definiciones deben ser procesadas antes de ser llamadas.

Ejemplo #2 Funciones condicionales

<?php

$haceralgo 
true;

/* No podemos llamar a foo() desde aquí
   ya que no existe aún,
   pero podemos llamar a bar() */

bar();

if (
$haceralgo) {
  function 
foo()
  {
    echo 
"No existo hasta que la ejecución del programa llegue hasta mí.\n";
  }
}

/* Ahora podemos llamar de forma segura a foo()
   ya que $haceralgo se evaluó como verdadero */

if ($haceralgofoo();

function 
bar()
{
  echo 
"Existo desde el momento inmediato que comenzó el programa.\n";
}

?>

Ejemplo #3 Funciones dentro de funciones

<?php
function foo()
{
  function 
bar()
  {
    echo 
"No existo hasta que se llame a foo().\n";
  }
}

/* No podemos llamar aún a bar()
   ya que no existe. */

foo();

/* Ahora podemos llamar a bar(),
   el procesamiento de foo()
   la ha hecho accesible. */

bar();

?>

Todas las funciones y las clases de PHP tienen ámbito global - pueden ser llamadas fuera de una función incluso si fueron definidas dentro, y viceversa.

PHP no soporta la sobrecarga de funciones, ni es posible 'desdefinir' ni redefinir funciones previamente declaradas.

Nota: Los nombres de las fuciones son insensibles a mayúsculas-minúsculas, por lo que es una buena idea llamar a las funciones tal y como aparecen en sus declaraciones.

El número variable de argumentos y los argumentos predeterminados están soportados por las funciones. Vea también las referencias de funciones para func_num_args(), func_get_arg(), y func_get_args() para más información.

En PHP es posible llamar a funciones recursivas. Sin embargo, evite las llamadas a funciones/métodos recursivos con más de 100-200 niveles de recursividad ya que pueden agotar la pila y causar la terminación del script actual.

Ejemplo #4 Funciones recursivas

<?php
function recursividad($a)
{
    if (
$a 20) {
        echo 
"$a\n";
        
recursividad($a 1);
    }
}
?>

add a note add a note

User Contributed Notes 5 notes

up
7
aydinantmen [at] hotmail [dot] com
3 months ago
I want to use multidimentional arrays in a callback function what accepts second parameter.

Solution:

<?php

$arr1
= array("a" => "b", "c", "d's", "e" => array("f's", "g" => array("h's", "i" => "j's")));
$arr2 = mdarr_parameter($arr1);
$arr3 = mdarr_parameter($arr2, true);

function
mdarr_parameter($needle, $job=false) {
    if (
is_array($needle)) {
        foreach(
$needle as $name => $value) {
           
$needle[$name] = mdarr_parameter($value, $job);
        }
    } else {
       
// Now you do anything you want...
       
if ($job === true) {
           
$needle = stripslashes($needle);
        } else {
           
$needle = addslashes($needle);
        }
    }
    return
$needle;
}

print_r($arr2);
print_r($arr3);

/**
Outputs:

Array
(
    [a] => b
    [0] => c
    [1] => d\'s
    [e] => Array
        (
            [0] => f\'s
            [g] => Array
                (
                    [0] => h\'s
                    [i] => j\'s
                )

        )

)
Array
(
    [a] => b
    [0] => c
    [1] => d's
    [e] => Array
        (
            [0] => f's
            [g] => Array
                (
                    [0] => h's
                    [i] => j's
                )

        )

)
**/

?>
up
5
webmaster at heathdale dot vic dot edu dot au
3 months ago
<?php

// first run (function doesn't exist)
$myfunc_exists;
if (!
$myfunc_exists) {
    function
myfunc() {
        echo (
'myfunc ran definition #1<br>');
    }
   
$myfunc_exists = true;
}

myfunc();   // echoes 'myfunc ran definition #1<br>'

// second run (function already exists, so won't be redefined and won't cause error)
// e.g. if the file containing the function got #included twice (it does happen)
$myfunc_exists;
if (!
$myfunc_exists) {
    function
myfunc() {
        echo (
'myfunc ran definition #2<br>');
    }
   
$myfunc_exists = true;
}

myfunc();  // still echoes 'myfunc ran definition #1<br>' (not #2)

?>
up
-8
Alexandre
2 months ago
In  PHP version less than 5 a function named "retorna_so_numeros" was OK.

Now in current PHP version I had to rename this function to "retorna_numeros" or the script won't work.
up
-36
Ben Tiessen
6 months ago
Functions can also be executed from variables:

function myFunc(){
  echo "Hello World";
}

$myFunc = myFunc();

$myFunc();

// Will output Hello World
up
-37
lubaev
6 months ago
<?php

function overload()
{
 
$overloadFn = array();
 
 
// key = count arguments, value = callback function.
 
$overloadFn[0] = function() {
    return print
nl2br("Zero argument. \n");
  };
 
$overloadFn[1] = function($a) {
    return print
nl2br("One argument. Result: $a \n");
  };
 
$overloadFn[2] = function($a,$b) {
    return print
nl2br("Two argument. Result: $a, $b \n");
  };
 
$overloadFn[4] = function($a,$b,$c,$d) {
    return print
nl2br("Four argument. Result: $a, $b, $c, $d \n");
  };
 
 
$countArgs = func_num_args();
 
$valueArgs = func_get_args();
 
  if( isset(
$overloadFn[ $countArgs ]) )
  {
    return
call_user_func_array( $overloadFn[ $countArgs ], $valueArgs );
  }
 
trigger_error("Wrong number of arguments!", E_USER_WARNING);
 
}

// OVERLOAD
overload(); // Zero argument.
overload(1); // One argument. Result: 1
overload(1,2); // Two argument. Result: 1, 2
overload(1,2,3); // Warning: Wrong number of arguments!
overload(1,2,3,4); // Four argument. Result: 1, 2, 3, 4
overload(1,2,3,4,5); // Warning: Wrong number of arguments!

?>
To Top