CURSO DE PHP Y MYSQL GRATIS

Introducción - Funciones

Las funciones son grupos de instrucciones independientes que tienen un
propósito determinado.
Así, tenemos funciones que calculan la raíz cuadrada de un número, nos
dan un número aleatorio o permiten contar los caracteres de una palabra.

La sintaxis básica de una función es la siguiente:
nombre_función (parámetrol, parámetro2 , parámetro3...parámetro_n)
Las funciones pueden ser llamadas con varios parámetros o con ninguno,
dependiendo de su definición.

Cuando PHP encuentra en el código la llamada a una función, primero,
evalúa cada argumento y los utiliza como parámetro de entrada. Después,
ejecuta la función y devuelve el valor solicitado o realiza alguna acción
sin enviar ningún valor de salida.

El siguiente ejemplo contiene un conjunto de llamadas a funciones con
0,1 ó 2 parámetros de entrada:

<?php
echo sqrt(9); // Raíz cuadrada de 9 es 3
echo rand(10,20); // Número aleatorio entre 10 y 20
echo pi(); //Número pi
?>

Valores de las funciones
Cada función en PHP se considera como una expresión. Se pueden utilizar
las funciones para lo mismo que se utilizan las expresiones, como almacenar
su resultado en una variable o formar parte de una expresión
más compleja.

<?php
$numero_aleatorio = rand (1,100); // Se almacena en una
variable
$numero_aleatorio = rand (1,100) + rand (1,100) * sqrt(9); //
Expresión compleja
?>

No todas las funciones devuelven un valor numérico. También pueden
devolver caracteres, array o true/false si la función ha tenido éxito o no.
Este tipo de funciones se utiliza para conectar a bases de datos, escribir a
ficheros de texto, manipular imágenes, etcétera.


Función de ejemplo. Obtención de la fecha
actual

Existen un conjunto de funciones que permiten averiguar la fecha actual
del sistema. Una de estas funciones es d a t e ( ) , que permite recuperar el
año, día, mes, etcétera, del momento en el que se hace la consulta. Para
averiguar el día de hoy podemos utilizar la construcción:
<?
d a t e ("d") ;
?>
El parámetro que pasamos entre paréntesis indica a la función el formato
de fecha que queremos obtener. En este caso, la d indica que queremos
obtener el día en formato numérico. La siguiente tabla relaciona los caracteres
dentro de la función d a t e () con su aplicación práctica:

Se pueden utilizar varios caracteres dentro de la función, indicando el formato
de fecha que nos interesa.
<?php
$meses = array ("Enero", "Febrero", "Marzo", "Abril", "Mayo",
"Junio", "Julio", "Agosto", "Septiembre",
"Octubre", "Noviembre", "Diciembre");
echo "Fecha actual: " . date("d-m-Y") . "<br>";
echo "Día del año: " . date("z") . "<br>";
echo "Estamos en el mes: " . $meses[date("n") ] . "<br>";
?>

Documentación sobre funciones
Desde sus inicios, PHP se diseñó para que fuera sencillo de utilizar y de
extender por la comunidad de desarrolladores.
La potencia reside en la gran cantidad de funciones escritas de todo
tipo.

Este libro cubre las funciones más utilizadas en el desarrollo de un proyecto
profesional, pero sería imposible cubrir todas las funciones existentes
con detalle. Por esta razón es imprescindible tener como referencia la

guía on-line de PHP en www.php.net, donde podemos encontrar clasificadas
por temática todas las funciones existentes hasta ahora.
Además, contamos con un buscador de apoyo que nos permite buscar la
definición de una función y ejemplos de uso escritas por usuarios de PHP.
Para los usuarios que no conocen la forma de trabajar con el lenguaje C, se
hace necesario explicar cómo aparecen las funciones descritas en el manual
de www.php.net. El formato es el siguiente:

tipo_devuelto nombre_función (tipol argl, tipo2 arg2...) ,-
El t i p o - d e v u e l t o es el tipo de valor que la función dará como salida.
Puede ser un integer, double, array, etcétera. El nombre de la f u n c i ó n es
la forma correcta de ejecutar el código. Los p a r á m e t r o s de e n t r a d a (argumentos)
deben pertenecer al tipo que define la función. Un ejemplo de
definición es:

string substr (string string, int start[, int length] ) ;
Puede ver que la función s u b s t r () devolverá como resultado una cadena
de caracteres y que tiene 2 argumentos de entrada como mínimo. El
parámetro que se encuentra entre dos corchetes es opcional y puede decidir
usarlo o no.

Funciones de usuario
Para realizar programas complejos en PHP 5, no es necesario escribir funciones.
Se pueden escribir programas utilizando todo lo aprendido hasta
ahora.

A medida que el proyecto se haga más complejo, el código se hará más
extenso y menos legible. En este punto debería comenzar a pensar en crear
funciones que realicen determinadas tareas.
Definición de funciones
El formato es el siguiente:
function nombre_función($argumentol, $argumento2, ..)
{
instrucciónl;
instrucción2;
instrucción3;
}

Como puede ver, se comienza con la palabra reservada f u n c t i o n seguida
del nombre de la f u n c i ó n y el número de p a r á m e t r o s n e c e s a r
i o . El bloque de código que pertenece a nuestra función debe introducirse
entre dos símbolos de llave ( { } ). Un ejemplo clásico consiste en calcular
el factorial de varios números. El factorial del número x se obtiene multiplicando
el número x por el factorial de (x-1), teniendo en cuenta que el
factorial de 1 es 1. Por ejemplo, el factorial de 3 sería 3 por el factorial de 2,
es decir 3 * 2 * 1. El código sin utilizar funciones es:
<?php
$resultado = 1;
$factorial = 3;// Queremos calcular el factorial de 3
for ($x = $factorial; $x > 0; $x--) {
^resultado = $resultado * $x;
}
echo "El factorial de $factorial es $resultado<br>" ,•
$resultado = 1;
$factorial = 4 ; // Queremos calcular el factorial de 4
for ($x = $factorial; $x > 0; $x--) {
$resultado = $resultado * $x;
}
echo "El factorial de $factorial es $resultado<br>";
$resultado = 1;
$factorial = 5 ; // Queremos calcular el factorial de 5
for ($x = $factorial; $x > 0; $x--) {
$resultado = $resultado * $x;
}
echo "El factorial de $factorial es $resultado<br>";
?>
Si se fija en el código anterior, podrá comprobar que sigue un patrón muy
evidente. El cálculo del factorial se realiza en un bucle que va disminuyendo
el valor de una variable y multiplicando todos los valores entre sí.
Aprovechando este patrón puede crear una función que realice el factorial
del número x ahorrando líneas de código:
<?php
function factorial($numero)
{
$resultado = 1;
for ($x = $numero; $x > 0; $x--) {
$resultado = $resultado * $x;
}
return $resultado;
}
echo "El factorial de 3 es ".factorial(3)."<br>";
echo "El factorial de 4 es ". factorial(4)."<br>" ;
echo "El factorial de 5 es ".factorial(5). "<br>";
?>
Si comparamos los dos ejemplos, podemos llegar a la conclusión de que el
segundo es mucho más legible y más sencillo de realizar. Como puede ver,
la función f a c t o r i a l () hace uso de la palabra reservada r e t u r n , que
es la encargada de devolver el valor que estamos solicitando cuando se
invoca la función.

Parámetros insuficientes
Si llama a una función con menos parámetros de los que debe utilizar por
definición aparecerá el siguiente error por defecto:
Warning: Missing argument 1 for factorial()

Este tipo de error no es crítico y puede controlarse con excepciones, como
veremos en capítulos sucesivos. Además de las excepciones podemos utilizar
el operador de supresión de error @ delante de la función de esta forma:
@ f a c t o r i a l ( ) .

No se recomienda eliminar los mensajes de error en este caso, ya que hace
complicado la corrección de los posibles fallos.

Parámetros en exceso
Si al contrario que en el apartado anterior le pasa a una función más parámetros
que los definidos, éstos serán omitidos y la ejecución continuará
normalmente sin ningún mensaje de error. Esta propiedad de PHP 5 permite
utilizar variables con un número de parámetros variable.

Ámbito de las variables
Las variables definidas en un archivo de PHP permanecen declaradas en
todo el fichero, menos en las funciones. Las funciones crean un entorno
de ejecución donde sólo pueden ver las variables que están dentro de las
mismas. Aunque no parece muy lógico, esto nos permite tener variables con el mismo nombre en diferentes funciones, haciendo el código reutilizable.
Si nos fijamos en el ejemplo:

<?php
$pi = 3.14;
function valor_pi() {
if ( ü s s e t ($pi) ) {
$pi = pi () ;
}
return $pi;
}
echo v a l o r _ p i ( );
?>

Se puede observar que definimos, al comienzo del código, la variable $pi
como un valor aproximado del número pi (3,14). La función v a l o r _ p i ()
comprueba si la variable $pi está definida, y si no lo está recupera ese
valor con una función de PHP 5. Para entender el alcance de las variables
vamos a ir paso a paso viendo qué es lo que ocurre:

• Se define $pi a nivel global en el programa.
• Se define la función v a l o r _ p i () que por ahora no se utiliza.
• Se lanza la ejecución de la función.
• La función evalúa si existe la variable $pi y da como resultado false.
Esto es así porque la variable está definida fuera de la función y no
dentro de ella, por lo tanto se considera que la variable $pi dentro de
la función es distinta (entorno local) a la variable $pi definida fuera
de la función (entorno global).
• El resultado por pantalla es 3.1415926535898.

Esta forma de programar se considera la correcta en la comunidad de desarrolladores
de PHP. Aún así, existen mecanismos que permiten que una
variable definida fuera de una función pueda ser utilizada dentro de la
misma, simplemente anteponiendo la palabra reservada g l o b a l a la variable
definida dentro de la función.

Utilizando el ejemplo anterior tenemos:
<?php
$pi = 3.14;
function valor_pi() {
global $pi;
if ( Ü s s e t ($pi) ) {
$pi = pi () ;
}

return $pi;
}
echo valor_pi() ;
?>
Si vemos paso a paso el ejemplo:
• Se define $pi a nivel global en el programa.
• Se define la función v a l o r _ p i () que por ahora no se utiliza.
• Se lanza la ejecución de la función.
• Dentro de la función, la variable $pi se define como global, es decir,
se utiliza la variable creada al principio del código.
• La función evalúa si existe la variable $pi y da como resultado true.
• El resultado por pantalla es 3.14.
Variables estáticas
Por defecto, las funciones que creamos en PHP 5 no retienen en memoria
el valor de las variables que se utilizan. Cada llamada a una función implica
la nueva creación de las variables locales con su valor inicial. La declaración
static añadida a una variable causa que la función retenga en
memoria el valor de esa variable en cada llamada. Como puede ver en el
ejemplo, las 100 llamadas a la función c o n t a d o r () dan siempre el mismo
resultado, porque la variable $contador se crea con cada llamada.
<?php
function contador() {
$contador = 0;
$contador = $contador +1;
return $contador;
}
for ($x = 1; $X <= 100; $x++) {
echo contador() ." , ";
}
?>
Sin embargo, podemos hacer que la función recuerde los valores, añadiendo
la palabra s t a t i c a la definición de la variable:
<?php
function contador() {
static $contador = 0;
$contador = $contador + 1;
return $contador;
}
for ($x = 1; $x <= 100; $x++) {
Funciones 105
echo contador() ." , ";
}
?>

ínclude() y require()
A medida que su proyecto se hace más complejo, comenzará a crear funciones
muy útiles para conectar a bases de datos, crear imágenes al vuelo,
conectar por FTP, etcétera y, seguramente, quiera emplear estas funciones
en otros proyectos distintos para ahorrar tiempo. El camino para hacer
esto es muy sencillo. Sólo tiene que guardar las funciones necesarias
en un fichero con extensión php, htm, c s s , inc, etcétera y utilizar las
directivas i n c l u d e () o r e q u i r e f ) desde la Web que vaya a utilizarlas.

En PHP 5 no existen apenas diferencia entre ambas funciones, salvo que
la función i n c l u d e () es más tolerante a fallos que r e q u i r e () y permite
continuar la ejecución del programa aunque se haya encontrado un fallo.
La conclusión es que debe utilizarse r e q u i r e () para aplicaciones que
necesiten obligatoriamente algún archivo crítico y no pueda continuarse
la ejecución sin él.

Si en el desarrollo de nuestro proyecto nos encontramos con que vamos a
utilizar varios archivos que hacen llamadas unos a otros podría pasar que
hagamos varias inclusiones del mismo archivo en distintos puntos, provocando
algún fallo difícil de detectar. Las funciones r e q u i r e _ o n c e ()
e i n c l u d e _ o n c e () solucionan éste problema, ya que si se intenta incluir
un fichero varias veces con dichas funciones, PHP 5 simplemente ignorará
las llamadas.

El formato es el siguiente:
require "base_datos.php";
include "contador_vistas.php";
require_once "test, php",-
include_once "visitas.php";

Recursividad
El paradigma de la programación nos lleva a los desarrolladores a inventar
fórmulas que minimicen el esfuerzo en nuestros programas pecando, algunas veces, de complejidad. Las funciones recursivas son aquellas capaces
de llamarse a sí mismas. Como único requisito es que haya una forma
de salir en la llamada recursiva. Si volvemos al ejemplo del número
factorial nos encontramos en que se puede escribir de la siguiente forma:

<?php
function factorial($numero)
{
if ($numero == 1) {
return $numero;
} else {
return $numero * factorial($numero-l);
}
}
echo "El factorial de 7 es ". factorial(7) ." <br>";
?>

Lo primero que llama la atención es que carece de un bucle f or para ir
disminuyendo los números implicados en el factorial. Lo que hace la función
es multiplicar el número que se pasa por el factorial del número-1. Si
el número que se pasa es igual a 1, la función deja de hacer llamadas recursivas
y comienza a devolver los valores hasta llegar al resultado final.

Funciones con número de argumentos
variables
Es habitual que el número de parámetros que se le pase a una función
dependa de la situación en la cual es llamada. Hay tres formas de hacer
esto en PHP:
• Definiendo la función con argumentos por defecto. Este método permite
hacer llamadas con menos parámetros sin que aparezca un error.
• Usando un array para pasar las variables.
• Usando las funciones de argumento variable f unc_num_args () ,
f u n c _ g e t _ a r g () y f u n c _ g e t _ a r g s () , ya utilizadas en PHP 4.

Argumentos por defecto
Para definir parámetros de este tipo, se sustituyen las variables por expresiones
de asignación. El formato es el siguiente:

function nombre_función($argumentol=valorl, $argumento2=valor2, ..)
De esta forma, al llamar a la función, podemos hacerlo con varios parámetros.
Si alguno de los parámetros es obviado, la variable tendrá como valor,
el valor por defecto de la definición.

<?php
function capitales($Pais,$Capital = "Madrid",$habitantes = "muchos") {
return ("La c a p i t a l de $Pais es $Capital y tiene $habitantes
habitantes.<br>") ;
}
echo capitales("España");
echo capitales("Portugal","Lisboa");
echo capitales("Francia","Paris","muchísimos");
?>

La salida por pantalla es la siguiente:
La capital de España es Madrid y tiene muchos habitantes.
La capital de Portugal es Lisboa y tiene muchos habitantes.
La capital de Francia es Paris y tiene muchísimos habitantes.
La función c a p i t a l e s () tiene un parámetro fijo y dos parámetros por
defecto. El parámetro $Pais es obligatorio, pero los demás pueden quedarse
en blanco, recibiendo el valor por defecto. La limitación de este
método es que los argumentos tienen un orden y no podemos saltarnos
ninguno, es decir, no podemos dar los valores $ C a p i t a l y $ h a b i t a n -
t e s , porque en medio hay otro parámetro.

Argumentos mediante un array
Si no encontró alguna utilidad a la anterior forma de pasar valores variables,
quizás necesite utilizar un array para pasarlos. El ejemplo siguiente
usa esta estrategia y algunos trucos más, como el operador ternario y los
array asociativos.

<?php
function capitales($datos) {
$Pais = isset ($datos['Pais' ] ) ? $datos ['Pais'] : "España";
$Capital = isset ($datos['Capital'] ) ? $datos ['Capital'] : "Madrid";
$habitantes = isset ($datos['habitantes'] ) ? $datos
['habitantes'] : "muchos";
return ("La capital de $Pais es $Capital y tiene $habitantes
habitantes.<br>");
}
// Introducimos en el array los datos uno por uno para que sea
más fácil de entender
$datos ['Pais'] = "España";
echo capitales($datos);
$datos ['Pais'] = "Portugal";
$datos ['Capital'] = "Lisboa";
echo capitales($datos);
$datos ['Pais'] = "Francia";
$datos ['Capital'] = "Paris",
$datos ['habitantes'] = "muchísimos";
echo capitales($datos);
?>
Como puede ver, la función tiene un único argumento, que contiene todos
los datos que nuestro programa necesita. Esta vez, los valores por
defecto los introducimos mediante el operador ternario, que chequea si
existe el dato referido al P a i s , C a p i t a l o h a b i t a n t e s y, si no existe, se
añaden los datos "España", "Madrid" y "muchos ". El ejemplo utiliza
la función con 0, 2 y 3 parámetros. La ventaja de este método es que podrá
utilizar los argumentos que quiera y en el orden que necesite, sin encasillarse
en una forma especial de pasar los datos.

Múltiples argumentos con func_num_args()
Desde la versión 4, PHP ofrece algunas funciones que pueden ser utilizadas
para recuperar los argumentos.

Son muy similares al lenguaje C:

• func_num_args(): Devuelve el número de argumentos que recibe la
función desde la que es llamada.
• func_get_arg(): Devuelve uno a uno los argumentos pasados de la siguiente
forma: func_get_arg(0), func_get_arg(l), func_get_arg(5).
• func_get_args(): Devuelve un array con todos los argumentos pasados
a la función, con los índices del array empezando desde 0.
Cualquiera de estas funciones dará un error si son llamadas fuera del entorno
de una función, y f u n c _ g e t _ a r g () , producirá un fallo si es llamada
con un número más alto que los argumentos que se reciben.

Las funciones anteriores dan una ventaja a largo plazo, ya que si, durante
el período de vida de una función necesita añadir algún argumento más,
puede capturar sin necesidad de cambiar el código de las llamadas o el de
definición de la función.

En el ejemplo siguiente puede comprobar cómo se utiliza este método:

<?php
function capitales() {
$numero_argumentos = func_num_args();
$Pais = $numero_argumentos > 0 ? func_get_arg(0) : "España";
$Capital = $numero_argumentos > 1 ? func_get_arg(1) : "Madrid";
$habitantes = $numero_argumentos > 2 ? func_get_arg (2) :
"muchos " ;
return ("Número de argumentos es: $numero_arguraentos. La capital
de $Pais es $Capital y tiene $habitantes habitantes.<br>");
}
echo capitales();
echo capitales("Portugal", "Lisboa");
echo capitales("Francia", "Paris", "muchísimos");
?>

Esta forma de utilizar los argumentos sigue teniendo una limitación. Los
argumentos deben ser pasados en un lugar determinado, sino la función
no hará bien su trabajo.

Utilizar los parámetros como array, es el método más flexible y el más utilizado
en los programas PHP.

Aún así, es muy útil cuando no sepa cuántos datos necesita manejar una
función. Podemos utilizarlo para funciones que sumen todos los parametros que introduzca o concatenen todas las palabras, como el ejemplo siguiente:
<?php
function concatenar() {
$resultado = "" ;
$numero_argumentos = func_num_args();
$array_parametros = func_get_args();
for ($x = 0; $x <= $numero_argumentos; $x++){
$resultado = $resultado . $array_parametros[$x] ;
}
return $resultado."<br>" ;
}
echo concatenar("Hola ","Mundo");
echo concatenar("Esto ","es ","una ","prueba ","de","la
potencia"," de este"," método");
?>

Llamadas por valor
Por defecto, las llamadas a funciones se hacen por valor. Esto quiere decir
que las variables que se utilizan como parámetros se copian al entorno de
la función.

Todos los cambios de valor que sufra la variable en este entorno no afectarán
al programa fuera de la función.

<?php
function elevado($nuraero,$ índice) {
$resultado = $numero;
for ($x = $indice; $x > 0; $x--) {
$resultado = $resultado * $nuraero;
}
$numero = $resultado;
return $numero;
}
$numero = 2;
$indice = 5;
echo $numero." elevado a ".$indice." es igual a
".elevado($numero,$ indice) ."<br>";
echo $numero." elevado a ".$indice." es igual a
".elevado ($numero,$ indice) ."<br>";
?>

El resultado por pantalla es:
2 elevado a 5 es igual a 64
2 elevado a 5 es igual a 64

El ejemplo anterior calcula el resultado de $numero elevado a $ Í n d i c e .
La función e l e v a d o () crea un bucle para multiplicar $numero por las veces que indica el $ í n d i c e y lo va almacenando en la variable temporal $resultado.

Cuando el bucle termina, este resultado se vuelve a pasar a la variable $ numero, que es devuelta como salida de la función. Cuando volvemos a ejecutar la función con los mismos parámetros, vemos que la variable $numero no ha cambiado en la ejecución anterior, porque, en realidad, lo que se pasa es una copia del valor y todas las modificaciones se hacen sobre la copia y no sobre la variable original.

Llamadas por referencia
PHP 5 ofrece actualmente dos caminos diferentes para cambiar sus argumentos:
en la definición de la función y en la llamada a la misma.
Las variables pasadas por referencia pueden ser modificadas durante el
proceso de una llamada, porque lo que se pasa no es una copia, sino la
variable en sí misma.
Para pasar variables por referencia hay que utilizar el operador (&) delante
de la variable.
Lo mejor es verlo en un ejemplo:
<?php
function elevado(&$numero,&$indice) {
$resultado = $numero;
for ($x = $índíce; $x > 0; $x--) {
$resultado = $resultado * $numero;
}
$numero = $resultado;
return $numero;
}
$numero = 2 ;
$ índice = 5;
echo $numero." elevado a ".$indice." es igual a
" .elevado($numero,$ indice) ."<br>";
echo $numero." elevado a ".$indice." es igual a
".elevado($numero,$ indice) ."<br>";
?>

El resultado por pantalla es ahora:
2 elevado a 5 es igual a 64
64 elevado a 5 es igual a 68719476736

El funcionamiento es exactamente igual, pero el resultado es distinto. El
operador (&) hace que la variable $numero pueda ser modificada dentro
de la función y guarde este número fuera de ella.

También puede forzar a una función a tomar argumentos por referencia,
aunque esta capacidad de PHP puede desaparecer en futuras versiones
del lenguaje. Las llamadas pueden hacerse de la siguiente forma:

$numero = 2;
$indice = 5;
echo $numero." elevado a ".$indice." es igual a
".elevado(&$numero,&$indice)."<br>";
echo $numero." elevado a ".$indice." es igual a
".elevado(&$numero,&$indice)."<br>";

El resultado es exactamente igual que al poner la referencia en la definición
de la función.

Referencia a variables
Las referencias pueden usarse también fuera de las funciones, en el ámbito
de las variables. El ejemplo siguiente muestra cómo trabaja el operador
(&) con las variables:
<?php
$nombre = "Luis Miguel";
$apellídos = "Cabezas Granado";
//$nombre auxiliar es simplemente una copia de $nombre
$nombre_auxiliar = $nombre,-
//$nombre_referencia es una referencia a la variable
$nombre_referencia = &$nombre;
echo $nombre." " . $apellidos."<br>" ;
$nombre_auxiliar = "Alberto";
echo $nombre. " " . $apellidos."<br>" ;
$nombre_referencia = "Felipe";
echo $nombre." " . $apellidos."<br>" ;
?>

$nombre__auxiliar es una copia de la variable $nombre y por mucho
que la cambiemos, $nombre permanecerá con el mismo valor. En cambio,
la variable $nombre_ref e r e n c i a es un alias de $nombre, por lo tanto
todos los cambios que se hagan en cualquiera de las dos variables les afectará
por igual.

Funciones variables
Uno de los trucos que se pueden hacer con PHP es utilizar variables para
almacenar el nombre de funciones. Si una variable almacena el nombre de
una función, simplemente tendrá que añadir unos paréntesis al final de la
variable para hacer la llamada correctamente.

<?php
function saludo_maniana() {
return ("Buenos Días");
}
function saludo_tarde() {
return ("Buenas Tardes");
}
function saludo_noche() {
return ("Buenas Noches");
}
$horario = "tarde";
$funcion_variable = "saludo_".$horario;
echo $funcion_variable () ;
?>

En el ejemplo anterior tenemos tres funciones que nos "saludan" dependiendo
del horario en el que ejecutemos el programa. Este valor se recoge
en la variable $horarío. Sabemos que todas las funciones comienzan con
la palabra "saludo_". Si a la variable $f u n c i o n _ v a r í a b l e le concatenamos
el valor de $ h o r a r i o , tenemos como resultado el nombre de la función que nos dará el saludo. Para que esto funcione, añadimos dos símbolos
de paréntesis al final de la expresión.

Resumen
Si el capítulo anterior daba rienda suelta a su imaginación para comenzar
con el desarrollo de pequeños scripts, después de leer este capítulo estará
en situación de realizar un gran proyecto. Ahora que conoce el secreto para
almacenar en distintos archivos funciones y partes de un programa escrito
en PHP, podrá crear aplicaciones más extensas y complejas.
Ahora bien, debe tener en cuenta que hay que tener cuidado con el alcance
de las variables y los pasos por valor y referencia, aspecto muy relevante
en el capítulo referido a los objetos.