Aprender PHP: tutorial de PHP para pri­n­ci­pia­n­tes

PHP es uno de los lenguajes de pro­gra­ma­ción más uti­li­za­dos para la pro­gra­ma­ción del lado del servidor. Con el tiempo, PHP se ha co­n­ve­r­ti­do en una pieza fu­n­da­me­n­tal de muchas páginas web modernas y de numerosas te­c­no­lo­gías de Internet. Sin embargo, aprender PHP puede suponer un desafío para quienes empiezan desde cero. En este tutorial de PHP te mostramos los fu­n­da­me­n­tos de este popular lenguaje de pro­gra­ma­ción, así como sus ope­ra­do­res, bucles y funciones más im­po­r­ta­n­tes.

Tutorial de PHP: qué necesitas para empezar

Este tutorial de PHP está dirigido pri­n­ci­pa­l­me­n­te a personas que comienzan desde cero. Sin embargo, para algunos ejemplos es útil contar con co­no­ci­mie­n­tos básicos de de­sa­rro­llo web moderno y de HTML. Para poder seguir los ejemplos en tu propio ordenador, necesitas preparar lo siguiente:

• Servidor web con in­té­r­pre­te de PHP
• Instalar PHP
• Navegador web
• Editor de texto

XAMPP

Como servidor para empezar te re­co­me­n­da­mos el entorno de pruebas local XAMPP, que Apache Friends ofrece de forma gratuita para los sistemas ope­ra­ti­vos Windows, Linux y macOS. XAMPP es un servidor pensado úni­ca­me­n­te para pruebas. El paquete de software permite a los de­sa­rro­lla­do­res web co­n­fi­gu­rar en muy poco tiempo un entorno completo de prueba para scripts, páginas HTML y hojas de estilo. Sin embargo, no está diseñado para funcionar de forma segura como servidor web en Internet. En­co­n­tra­rás una guía de in­s­ta­la­ción detallada en nuestro tutorial de XAMPP.

Servidor integrado de PHP

Desde la versión 5.4, PHP incorpora un servidor de de­sa­rro­llo integrado que resulta es­pe­cia­l­me­n­te adecuado para pruebas sencillas y para aprender PHP. Este llamado servidor integrado no requiere software de servidor adicional como Apache o NGINX. El único requisito es tener una versión de PHP instalada en tu sistema. Después, puedes iniciar el servidor di­re­c­ta­me­n­te desde la línea de comandos en el di­re­c­to­rio del proyecto:

php -S localhost:8000

PHP pone a di­s­po­si­ción los archivos de la carpeta actual en el navegador web en la dirección http://localhost:8000. El servidor integrado es adecuado para los primeros ex­pe­ri­me­n­tos con PHP, pequeños scripts de prueba o para re­pro­du­cir rá­pi­da­me­n­te ejemplos de código.

Docker y Docker Compose

Una al­te­r­na­ti­va algo más avanzada es el uso de Docker. Docker permite en­ca­p­su­lar entornos de de­sa­rro­llo en co­n­te­ne­do­res. De este modo, el servidor web, PHP y las bases de datos pueden co­n­fi­gu­rar­se exac­ta­me­n­te igual que después fu­n­cio­na­rán en el entorno de pro­du­c­ción.

Para proyectos PHP se utiliza a menudo Docker Compose, que permite iniciar varios servicios co­n­ju­n­ta­me­n­te. Toda la co­n­fi­gu­ra­ción se recoge en un archivo (“docker-compose.yml”) y se puede iniciar con un único comando.

Fu­n­da­me­n­tos de PHP: la sintaxis del lenguaje de scripts

Si ya has co­n­fi­gu­ra­do tu servidor web local (por ejemplo, con ayuda de XAMPP), deberías comprobar si PHP se ha instalado co­rre­c­ta­me­n­te y está listo para ejecutar scripts. Un script es un programa que no se compila pre­via­me­n­te a código binario. En su lugar, lo ejecuta un in­té­r­pre­te. Abre tu editor de texto preferido y copia el siguiente script de PHP:

<?php
phpinfo();
?>

Los scripts de PHP siguen siempre el mismo esquema. La etiqueta de apertura de PHP <?php indica que comienza un entorno de script. A co­n­ti­nua­ción aparece el propio código PHP en forma de in­s­tru­c­cio­nes. En el ejemplo, se trata de la llamada a la función phpinfo().

La mayoría de las funciones de PHP necesitan uno o varios pa­rá­me­tros, que se colocan entre pa­ré­n­te­sis; en phpinfo() son op­cio­na­les. Cada in­s­tru­c­ción termina con un punto y coma (;). Para cerrar el entorno de script se utiliza la etiqueta de cierre de PHP: ?>. En los archivos que contienen úni­ca­me­n­te PHP, esta etiqueta es opcional.

Guarda el archivo de texto con el nombre “test” en formato .php (script de PHP) e inicia tu servidor web. Si utilizas el entorno de pruebas XAMPP, coloca “test.php” en el di­re­c­to­rio de XAMPP dentro de “htdocs” (C:\xampp\htdocs).

Close

El archivo de ejemplo puede abrirse ahora en el navegador web mediante la siguiente URL: http://localhost/test.php. Si utilizas otro servidor web o una co­n­fi­gu­ra­ción pe­r­so­na­li­za­da de XAMPP, elige la URL co­rre­s­po­n­die­n­te a la ruta de acceso del archivo.

Al in­tro­du­cir la URL http://localhost/test.php le indicas a tu navegador web que solicite el archivo “test.php” al servidor web. El Apache HTTP Server o el software de servidor web que prefieras recupera el archivo del di­re­c­to­rio co­rre­s­po­n­die­n­te.

La extensión .php indica que el archivo contiene código PHP. Entonces entra en juego el in­té­r­pre­te de PHP integrado en el servidor web. Este analiza el documento y encuentra la etiqueta de apertura de PHP <?php. El in­té­r­pre­te ejecuta el código PHP y genera una salida HTML, que el servidor web entrega fi­na­l­me­n­te al navegador.

“Hello World!”: así muestras texto con echo

Si PHP se ha instalado sin errores, ha llegado el momento de escribir tu primer script propio. Para ello, la in­s­tru­c­ción PHP echo resulta es­pe­cia­l­me­n­te adecuada. A di­fe­re­n­cia de phpinfo(), echo no es una función. Se trata más bien de una co­n­s­tru­c­ción del lenguaje que permite mostrar como texto una cadena (string) que aparece a co­n­ti­nua­ción.

Crea un nuevo archivo PHP para tu primer script y escribe en él el siguiente código:

<?php
echo 'Hello World!';

La etiqueta de apertura <?php inicia un entorno de script. A co­n­ti­nua­ción aparece la co­n­s­tru­c­ción del lenguaje echo y la cadena “Hello World!” entre comillas simples. Fíjate en el punto y coma al final de la in­s­tru­c­ción. En lugar de “Hello World!” puedes usar cualquier texto. Como se trata de un archivo que contiene solo PHP, hemos omitido la etiqueta de cierre.

Guarda el script como “hello.php” en la carpeta “htdocs” de tu servidor web y abre el archivo en el navegador web mediante la URL http://localhost/hello.php. Si el código se ha tra­n­s­fe­ri­do co­rre­c­ta­me­n­te, la ventana del navegador debería mostrar ahora la cadena de ca­ra­c­te­res que hayas utilizado:

Close

Todo texto que muestres con echo puede eti­que­tar­se, si lo necesitas, con etiquetas HTML. El navegador las in­te­r­pre­ta­rá después según la es­pe­ci­fi­ca­ción HTML. Pruébalo tú mismo, por ejemplo con el siguiente script:

<?php
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';

Al abrirlo en el navegador web, el resultado de la ejecución del script se mostrará de la siguiente manera:

Close

La cadena de ca­ra­c­te­res “Hello World!” entre etiquetas <h1> es in­te­r­pre­ta­da por el navegador como un en­ca­be­za­do de primer nivel. A co­n­ti­nua­ción se produce un salto de línea au­to­má­ti­co y el párrafo de texto <p>.

Según lo que necesites, puedes usar echo tanto con comillas simples (') como con comillas dobles ("). Si solo quieres mostrar texto, no hay di­fe­re­n­cia entre el tipo de comillas que elijas. Sin embargo, esto cambia en cuanto entran en juego las variables de PHP.

Variables

El co­n­s­tru­c­to del lenguaje echo ofrece más que la simple salida de texto. Al fin y al cabo, esto también se puede hacer pe­r­fe­c­ta­me­n­te sin PHP, solo con HTML. El verdadero valor añadido de echo radica en que la in­s­tru­c­ción permite generar textos de forma dinámica con la ayuda de variables.

Las variables pueden pre­se­n­tar­se, por ejemplo, de la siguiente forma: $example.

Cada variable consta de un signo de dólar ($) seguido del nombre de la variable. Las variables se utilizan en scripts PHP para integrar datos externos en páginas web. Estos valores pueden ser de distintos tipos: desde números simples y cadenas de ca­ra­c­te­res hasta textos completos o es­tru­c­tu­ras de do­cu­me­n­tos HTML.

PHP distingue ocho tipos de variables:

La gestión ce­n­tra­li­za­da de co­n­te­ni­dos suele rea­li­zar­se con sistemas de bases de datos. Sin embargo, los valores de las variables también pueden definirse di­re­c­ta­me­n­te en el script. Este tipo de asi­g­na­ción sigue el siguiente esquema:

$example = "value";

Tras el signo de dólar aparece el nombre de la variable (en este caso example). Este se vincula mediante el signo igual (=) con un valor entre comillas dobles. Los valores de las variables de tipo integer y float se escriben sin comillas (por ejemplo, $example = 24; o $example = 2.7;).

PHP te da la libertad de nombrar las variables como quieras. Sin embargo, se aplican las si­guie­n­tes re­s­tri­c­cio­nes:

• Cada variable comienza con un signo de dólar.
• Un nombre de variable puede contener letras, dígitos y guiones bajos (por ejemplo, $example_1).
• Un nombre de variable válido siempre empieza por una letra o un guion bajo ($example1 o $_example), nunca por un dígito (in­co­rre­c­to: $1example).
• PHP es case-sensitive. El lenguaje de script distingue entre ma­yú­s­cu­las y mi­nú­s­cu­las ($example ≠ $Example).
• El nombre de la variable no puede contener espacios en blanco ni saltos de línea (in­co­rre­c­to: $example 1).
• Las palabras re­se­r­va­das por PHP no se pueden usar como nombres de variables (por ejemplo, $this).

Veámoslo con un ejemplo:

<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";

Tras la etiqueta de apertura de PHP sigue la de­fi­ni­ción de la variable: a $author se le asigna el valor “John Doe”. Al ejecutar el script, la variable $author se sustituye en cada aparición dentro del entorno del script por el valor co­rre­s­po­n­die­n­te. La siguiente imagen muestra cómo se ve esto en el navegador:

Close

Si ahora resulta que se ha cometido un error y la página web no es de John Doe, sino de su compañero alemán Max Mu­s­te­r­ma­nn, solo hace falta ajustar la variable llamada $author para co­rre­gi­r­lo. Esto es es­pe­cia­l­me­n­te útil cuando una variable aparece varias veces dentro de un script. En ese caso, la co­rre­c­ción solo hay que hacerla en un único lugar: donde se define el valor de la variable.

Las ventajas de este concepto de diseño son evidentes: si se revisan elementos de la página web (por ejemplo, en el pie de página), no es necesario aplicar los cambios ma­nua­l­me­n­te en cada subpágina del proyecto web. En su lugar, basta con ac­tua­li­zar el valor co­rre­s­po­n­die­n­te en la base de datos. De este modo, la mo­di­fi­ca­ción se aplica au­to­má­ti­ca­me­n­te a todas las páginas web que utilizan esos datos como variables.

Si defines una variable varias veces dentro de un script, la nueva de­fi­ni­ción so­bre­s­cri­be la anterior. Un echo posterior siempre muestra el valor actual de la variable.

<?php
$author = "John Doe";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>";
$author = "Max Mustermann";
echo "<p>Supported by $author.</p>";

En el ejemplo de código, primero se asigna a la variable $author el valor “John Doe” y después se sustituye por el valor “Max Mu­s­te­r­ma­nn”.

Close

Pasemos ahora al tema de las comillas. A di­fe­re­n­cia de las cadenas (strings), las variables in­di­vi­dua­les no necesitan ponerse entre comillas:

<?php
$author = "John Doe";
echo $author;

Esto cambia cuando la variable se utiliza dentro de una cadena. En ese caso se emplean comillas dobles (“). Estas le indican al in­té­r­pre­te de PHP que debe buscar variables dentro del string para su­s­ti­tui­r­las, si procede, por los valores que tengan asociados. Las cadenas que van entre comillas simples (’) se in­te­r­pre­tan y se muestran como texto literal, incluso cuando contienen variables.

<?php
$author = "John Doe";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by $author.</p>';

En este caso, la variable no se in­te­r­pre­ta, sino que si­m­ple­me­n­te se muestra como texto.

Close

Tipado estricto con declare(strict_types=1)

De forma pre­de­te­r­mi­na­da, PHP intenta convertir au­to­má­ti­ca­me­n­te distintos tipos de datos entre sí. A este co­m­po­r­ta­mie­n­to se le suele llamar “type juggling” y puede provocar que valores in­co­rre­c­tos sigan pro­ce­sá­n­do­se sin que te des cuenta.

Con la directiva declare(strict_types=1); puedes des­ac­ti­var ex­pre­sa­me­n­te este co­m­po­r­ta­mie­n­to. PHP co­m­pro­ba­rá entonces de forma estricta, en las llamadas a funciones, si los ar­gu­me­n­tos pasados y los valores de retorno coinciden con los tipos de datos de­cla­ra­dos. La directiva debe estar al principio de un archivo PHP y solo afecta a ese archivo:

<?php

declare(strict_types=1);

function add(int $a, int $b): int
{
    return $a + $b;
}

echo add(2, 3);
echo add("2", 3);

En el ejemplo, una función de PHP llamada add() acepta ex­clu­si­va­me­n­te valores enteros (integer). Mientras que la llamada con 2 y 3 funciona sin problema, la segunda llamada provoca un error, ya que la cadena "2" no se convierte au­to­má­ti­ca­me­n­te en un número entero. Gracias al tipado estricto, este tipo de problemas se detecta de forma temprana, lo que mejora co­n­si­de­ra­ble­me­n­te el ma­n­te­ni­mie­n­to y la fia­bi­li­dad del código PHP.

Mensajes de error y escape de ca­ra­c­te­res

Si se producen errores de sintaxis, el código PHP deja de ser válido y la página cargada en el navegador puede aparecer en blanco o el in­té­r­pre­te de PHP mostrar un mensaje de error. Esto ocurre, por ejemplo, cuando se utiliza la in­s­tru­c­ción echo con una cadena (string) sin comillas:

<?php
echo Hello World!;

Los mensajes de error suelen incluir in­fo­r­ma­ción sobre dónde se ha producido el fallo y ayudan a localizar el problema rá­pi­da­me­n­te. En cualquier caso, también puedes consultar los mensajes en el registro (log) de XAMPP en C:\xampp\logs\php_error_log.

Close

En este ejemplo, el mensaje indica que pro­ba­ble­me­n­te hay un error en la línea 2 del código, justo donde hemos omitido las comillas a propósito para fines de de­mo­s­tra­ción.

También se producen errores de sintaxis cuando intentas mostrar como texto ca­ra­c­te­res que en PHP tienen un si­g­ni­fi­ca­do especial. Un ejemplo sería la comilla simple (’). Solo puedes mostrar este tipo de ca­ra­c­te­res como texto si indicas al in­té­r­pre­te que ese carácter debe in­te­r­pre­tar­se li­te­ra­l­me­n­te. En el caso de las comillas simples, tienes dos opciones: puedes encerrar la cadena entre comillas dobles o utilizar una barra invertida (backslash) para escapar el carácter:

<?php
echo '\'Hello World!\' ';

Close

También es posible combinar comillas simples y dobles:

<?php
echo " 'Hello World!' ";

En cambio, esta forma de escritura provoca un error:

<?php
echo ' 'Hello World!' ';

En los ejemplos se han añadido espacios entre las comillas úni­ca­me­n­te para facilitar la lectura.

Ope­ra­do­res de co­n­ca­te­na­ción

Si quieres mostrar varias variables a la vez dentro de un script de PHP, puedes hacerlo de la forma que has aprendido hasta ahora:

<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo "<h1>Hello World!</h1>
<p>This dynamic web page was created by $author1 and $author2.</p>";

Solo tienes que escribir ambas variables junto con el resto del texto dentro de una cadena entre comillas dobles. PHP reconoce au­to­má­ti­ca­me­n­te las variables por el signo de dólar ($) y sustituye los valores co­rre­s­po­n­die­n­tes.

Close

Entre los de­sa­rro­lla­do­res, este enfoque no se considera muy limpio. Se sigue la re­co­me­n­da­ción de que las variables no formen parte di­re­c­ta­me­n­te del string. Una razón es que muchos lenguajes de pro­gra­ma­ción exigen esta se­pa­ra­ción. Además, PHP también re­co­mie­n­da separar strings y variables cuando se trabaja con llamadas a funciones o con variables más complejas. Por eso conviene aplicar esta se­pa­ra­ción también en la salida de texto, incluso cuando en este caso no sea es­tri­c­ta­me­n­te necesario. Cuando tra­ba­ja­mos con variables, solemos manejar varios elementos que deben unirse para generar una salida. En PHP se utiliza para ello el operador de co­n­ca­te­na­ción (.). El código del ejemplo anterior, escrito de una forma más limpia, tendría el siguiente aspecto:

<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo '<h1>Hello World!</h1>
<p>This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.</p>';

En este caso tra­ba­ja­mos con tres strings y dos variables que se co­n­ca­te­nan para formar una única cadena de ca­ra­c­te­res.

Ten en cuenta que un operador de co­n­ca­te­na­ción une strings o variables sin añadir espacios au­to­má­ti­ca­me­n­te. Si quieres un espacio, debes es­cri­bi­r­lo dentro del string entre comillas, como se muestra en el ejemplo.

Close

Los pro­gra­ma­do­res utilizan el operador de co­n­ca­te­na­ción no solo para enlazar strings y variables en la salida de texto, sino también para ampliar el valor de una variable. Esto se muestra en el siguiente ejemplo:

<?php
$example = 'Hello ';
$example .= 'World';
echo $example;

Para ampliar el valor de una variable, la defines de nuevo uti­li­za­n­do el operador de co­n­ca­te­na­ción antes del signo igual. Se trata de la forma abreviada habitual de escribir $example = $example . 'World';.

PHP añade el nuevo valor al que ya estaba definido pre­via­me­n­te. Si quieres un espacio entre ambos valores, escríbelo, como en el ejemplo, al final del primer string.

Close

Incluir PHP en HTML

El in­té­r­pre­te de PHP solo analiza, en principio, el código que se encuentra entre una etiqueta de apertura y una etiqueta de cierre de PHP (esta última es opcional en archivos que contienen úni­ca­me­n­te PHP):

<?php [This area is parsed by the PHP interpreter] ?>

Todas las demás partes del documento son ignoradas por el in­té­r­pre­te y se envían al servidor web tal como están. De este modo, el código PHP puede in­te­grar­se li­bre­me­n­te en do­cu­me­n­tos HTML, por ejemplo para crear pla­n­ti­llas en un sistema de gestión de co­n­te­ni­dos. Es im­po­r­ta­n­te que los do­cu­me­n­tos HTML que contienen código PHP se guarden como archivos PHP. De lo contrario, el documento no será procesado por el in­té­r­pre­te de PHP, sino que se enviará di­re­c­ta­me­n­te al navegador web. En ese caso, el código PHP apa­re­ce­ría como texto en la página. Puedes imaginar al in­té­r­pre­te de PHP como el compañero perezoso del servidor web que solo trabaja cuando se le solicita ex­plí­ci­ta­me­n­te, por ejemplo mediante una etiqueta de apertura de PHP.

Si quieres combinar HTML y PHP, escribe tu página HTML como de costumbre siguiendo la es­tru­c­tu­ra clásica del documento y guárdala con la extensión .php:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
</body>
</html>

Ahora amplía tu documento HTML con un script PHP. Asegúrate de que todo el código del programa esté dentro de las etiquetas PHP.

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>My first PHP page</title>
</head>
<body>
<h1>Hello World</h1>
<p>What is the current time and date?</p>
<p>Your current time and date is:
<?php
echo date("d.m.Y H:i:s");
?>.</p>
</body>
</html>

En el ejemplo hemos combinado la co­n­s­tru­c­ción del lenguaje echo con la función de PHP date() para mostrar en el servidor la fecha actual, incluida la hora, como texto. El parámetro de la función indica el formato deseado en forma de string:

"d.m.Y H:i:s" (día.mes.año hora:minuto:segundo)

Cuando un navegador solicita un archivo de este tipo, el in­té­r­pre­te de PHP ejecuta primero el script y escribe la fecha y la hora actuales en el documento HTML. A co­n­ti­nua­ción, el servidor web entrega el documento, que se muestra en el navegador como una página web.

Close

Co­me­n­ta­rios en PHP

Al igual que ocurre con el código HTML, el código PHP también puede co­me­n­tar­se. Los co­me­n­ta­rios en el código fuente son ignorados por el in­té­r­pre­te de PHP siempre que estén marcados con la sintaxis co­rre­s­po­n­die­n­te. Para ello, PHP ofrece tres al­te­r­na­ti­vas.

Si quieres marcar una línea completa como co­me­n­ta­rio y excluirla de la ejecución del script, puedes utilizar la al­moha­di­lla (#) o dos barras in­cli­na­das co­n­se­cu­ti­vas (//). En el siguiente ejemplo de código se muestran ambas po­si­bi­li­da­des:

<?php
## This is a single line comment
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
// This is also a single-line comment!

Los editores de texto o los entornos de de­sa­rro­llo (IDE) con resaltado de sintaxis muestran los co­me­n­ta­rios con un color diferente. Los fra­g­me­n­tos de texto marcados como co­me­n­ta­rio dentro del script no llegan al navegador web (a di­fe­re­n­cia de los co­me­n­ta­rios HTML), ya que el in­té­r­pre­te de PHP los ignora durante la ejecución del código.

También puedes insertar co­me­n­ta­rios que se extienden a lo largo de varias líneas. Para ello, marca el inicio de un bloque de co­me­n­ta­rios con una barra inclinada seguida de un asterisco (/*) y el final con un asterisco seguido de una barra inclinada (*/).

<?php
/*
This is a multiple-lines comment block
that spans over multiple
lines
*/
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';

Estos co­me­n­ta­rios tampoco se procesan y, por tanto, no aparecen en la página web.

Close

Los pro­gra­ma­do­res utilizan co­me­n­ta­rios para es­tru­c­tu­rar el código de sus scripts, dejar in­di­ca­cio­nes para futuras mo­di­fi­ca­cio­nes o añadir in­fo­r­ma­ción interna como la autoría o la fecha de creación. Los co­me­n­ta­rios son op­cio­na­les y conviene uti­li­zar­los con mo­de­ra­ción para mantener una buena le­gi­bi­li­dad del código.

Calcular con variables

En este tutorial de PHP ya has trabajado con variables. Hasta ahora, pri­n­ci­pa­l­me­n­te se les han asignado valores de tipo string (es decir, cadenas de ca­ra­c­te­res). Ahora vamos a utilizar variables que re­pre­se­n­tan números enteros (integer) o números de coma flotante (floats).

Si las variables almacenan valores numéricos, PHP permite realizar cálculos con ellas. Empezamos con una suma sencilla de dos números enteros:

<?php 
$number1 = 237; 
$number2 = 148; 
$result = $number1 + $number2; 
echo "Result: " . $result;

Primero asignamos a las variables $number1 y $number2 los números enteros 237 y 148 y, a co­n­ti­nua­ción, definimos la variable $result. Esta almacena la suma de las dos variables. Para ello, uti­li­za­mos el operador ari­t­mé­ti­co + (suma). Fi­na­l­me­n­te, mostramos el resultado mediante la co­n­s­tru­c­ción del lenguaje echo. Ten en cuenta que, al asignar valores numéricos a variables, no necesitas comillas.

Close

El siguiente ejemplo muestra una selección de ope­ra­cio­nes ma­te­má­ti­cas que se pueden realizar del lado del servidor con PHP. Los ope­ra­do­res uti­li­za­dos co­rre­s­po­n­den en su mayor parte a los símbolos ma­te­má­ti­cos ha­bi­tua­les.

<?php
$number1 = 10;
$number2 = 5;
$addition = $number1 + $number2; // Addition
$subtraction = $number1 - $number2; // Subtraction
$multiplication = $number1 * $number2; // Multiplication
$division = $number1 / $number2; // Division
$exponentiation = $number1 ** $number2; // Exponentiation

echo "Result of addition: " . $addition ."<br />";
echo "Result of subtraction: " . $subtraction . "<br />";
echo "Result of multiplication: " . $multiplication . "<br />";
echo "Result of division: " . $division . "<br />";
echo "5th power of 10 (10^5): " . $exponentiation . "<br />";
echo "Square root of 81: " . sqrt(81) . "<br />";

La salida tiene el siguiente aspecto:

Close

Para cálculos más complejos, puedes combinar distintas ope­ra­cio­nes ari­t­mé­ti­cas dentro de un script:

<?php
$number1 = 10;
$number2 = 5;
$result = 2 * $number1 + 5 * $number2 - 3 * sqrt(81);
echo "Result: " . $result;

El in­té­r­pre­te de PHP evalúa las variables y calcula:

2 * 10 + 5 * 5 - 3 * √81 = 20 + 25 - 27 = 18

La función sqrt() calcula la raíz cuadrada del valor indicado entre pa­ré­n­te­sis. PHP sigue el orden de las ope­ra­cio­nes ma­te­má­ti­cas: primero mu­l­ti­pli­ca­cio­nes y di­vi­sio­nes, luego sumas y restas. La in­s­tru­c­ción echo muestra el resultado como cadena para el navegador web.

Los términos entre pa­ré­n­te­sis también se evalúan primero. En el siguiente ejemplo tra­ba­ja­mos con números de coma flotante:

<?php
$number1 = 2.5;
$number2 = 3.7;
$result = 2 * ($number1 + 5) * ($number2 - 3) * sqrt(81);
echo "Result: " . $result;

Close

Como la mayoría de los lenguajes de pro­gra­ma­ción, PHP también admite ope­ra­do­res para in­cre­me­n­tar o reducir valores numéricos en 1. Se di­s­ti­n­guen cuatro ope­ra­do­res: prei­n­cre­me­n­to, pre­de­cre­me­n­to, po­s­ti­n­cre­me­n­to y po­s­t­de­cre­me­n­to.

Mostramos las ope­ra­cio­nes ari­t­mé­ti­cas con ope­ra­do­res de in­cre­me­n­to y de­cre­me­n­to usando como ejemplo el prei­n­cre­me­n­to. El siguiente script aumenta en 1 el valor de la variable $number, guarda el nuevo valor en la variable $result y, a co­n­ti­nua­ción, muestra su valor como cadena:

<?php
$number = 0;
$result = ++$number;
echo "Result: " . $result;

Si aumentas el valor 0 en 1, obtienes el resultado 1.

Close

Para calcular el pre­de­cre­me­n­to de la variable $number, usamos el mismo script, pero su­s­ti­tui­mos el operador (++) por (--):

<?php
$number = 0;
$result = --$number;
echo "Result: " . $result;

De­cre­me­n­ta­mos así el valor 0 de la variable $number y obtenemos el resultado -1. La di­fe­re­n­cia entre prei­n­cre­me­n­to y po­s­ti­n­cre­me­n­to puede verse en el siguiente ejemplo:

<?php
$x = 0;
echo '<p>Result: ' . ++$x;
echo '<br>x has the value ' . $x;
echo '<p>Result: ' . $x++;
echo '<br>x has the value ' . $x, '</p>';

En ambos casos obtenemos el mismo resultado. En el prei­n­cre­me­n­to, el valor de x se aumenta antes de la salida en la línea 3 y, en el po­s­ti­n­cre­me­n­to, después de la salida en la línea 5.

Close

Tipos escalares y Union Types

PHP permite asignar a variables, pa­rá­me­tros de funciones y valores de retorno los llamados tipos escalares. Entre ellos se en­cue­n­tran int, float, string y bool. Mediante la in­di­ca­ción explícita del tipo se define qué tipo de valores espera y devuelve una función. Esto mejora la le­gi­bi­li­dad del código y ayuda a detectar errores típicos en una fase temprana.

<?php
declare(strict_types=1);

function hi(string $name): string {
return "Hello " . $name;
}

En este ejemplo, la función hi() que has creado espera una cadena (string) como parámetro y también devuelve una cadena. Si se le pasa un tipo de dato distinto, PHP genera un error. Sin embargo, en algunas si­tua­cio­nes una función debe aceptar más de un tipo de dato. Para ello, PHP ofrece los llamados Union Types. Estos permiten definir varios tipos posibles, separados por el carácter de barra vertical (|):

<?php
declare(strict_types=1);

function formatId(int|string $id): string {
return "ID: " . $id;
}

La función formatId() acepta tanto números enteros como cadenas de ca­ra­c­te­res como parámetro. No se permiten otros tipos de datos. De este modo, los Union Types permiten definir firmas de función más flexibles sin renunciar al control sobre los tipos de datos.

Las su­pe­r­glo­ba­les $_GET y $_POST

Ahora ya conoces las bases de PHP: sabes trabajar con variables, co­n­ca­te­nar­las y realizar cálculos. A co­n­ti­nua­ción veremos por qué las variables son un concepto fu­n­da­me­n­tal al programar scripts.

Una función im­po­r­ta­n­te de los lenguajes de scripting es la po­si­bi­li­dad de procesar entradas de usuario y tra­n­s­fe­rir los valores a otro script. Para la tra­n­s­mi­sión de datos, PHP utiliza las su­pe­r­glo­ba­les $_GET y $_POST, variables de sistema pre­de­fi­ni­das que están di­s­po­ni­bles en todos los ámbitos de ejecución. Como arrays aso­cia­ti­vos, $_GET y $_POST almacenan un conjunto de variables en forma de cadenas (string) en una sola variable.

Puedes imaginar los arrays de PHP como un armario con varios cajones. Cada cajón permite guardar un dato. Para poder ide­n­ti­fi­car qué contiene cada uno, se les asigna una etiqueta. De­pe­n­die­n­do del tipo de array, esta etiqueta puede ser un índice o una clave (key). Mientras que en los arrays indexados cada elemento se ide­n­ti­fi­ca mediante un número, en los arrays aso­cia­ti­vos cada elemento se ide­n­ti­fi­ca mediante una clave en forma de cadena (string).

Las su­pe­r­glo­ba­les $_GET y $_POST contienen una serie de variables al­ma­ce­na­das como claves, que permiten acceder a los valores asociados a cada una de ellas. Vo­l­ve­re­mos sobre ello cuando ana­li­ce­mos con más detalle cómo funcionan las su­pe­r­glo­ba­les $_GET y $_POST.

Tra­n­s­mi­sión de datos mediante $_GET

La su­pe­r­glo­bal $_GET re­pre­se­n­ta un array de variables que se pasan a un script de PHP mediante una URL.

Si navegas de vez en cuando por blogs, tiendas en línea o foros de Internet, es posible que hayas visto URL con una es­tru­c­tu­ra similar a la siguiente:

http://hostname/folder/filename.php?variablename=variablevalue

Aplicado a un blog, este esquema podría tener el siguiente aspecto:

http://www.example-blog.com/index.php?id=1

Una URL de este tipo se puede desglosar muy fá­ci­l­me­n­te: en un servidor web con el dominio example-blog.com, hay un archivo llamado index.php que genera una página web dinámica. Este archivo suele contener código HTML y PHP, así como re­fe­re­n­cias a pla­n­ti­llas externas y hojas de estilo; en resumen, todo lo necesario para mostrar una página web.

Que se trata de una página dinámica lo indica el añadido que aparece después del signo de in­te­rro­ga­ción (?): id=1. A esto se le llama cadena de consulta de HTTP y contiene una variable (id) y un valor (1), unidos por un signo igual (=). Este tipo de pa­rá­me­tros de URL se utiliza, por ejemplo, para generar páginas web dinámicas, cargar co­n­te­ni­dos desde una base de datos o se­le­c­cio­nar una plantilla de­te­r­mi­na­da.

Las páginas web dinámicas permiten una se­pa­ra­ción entre contenido y pre­se­n­ta­ción. Aunque index.php define la es­tru­c­tu­ra de la página web, los co­n­te­ni­dos suelen al­ma­ce­nar­se en una base de datos. Estos pueden re­cu­pe­rar­se mediante los pa­rá­me­tros de la cadena de consulta HTTP. En nuestro ejemplo, la URL envía a index.php el parámetro id=1. Este determina qué contenido debe re­cu­pe­rar­se de la base de datos y mostrarse en la página. En un blog suele tratarse del ID de un artículo concreto. En un foro podría uti­li­zar­se para recuperar una entrada es­pe­cí­fi­ca y, en una tienda en línea, un producto de­te­r­mi­na­do.

Si una URL contiene más de un parámetro, estos se separan con un ampersand (&).

www.example-blog.com/index.php?page=article&id=1

Para ilustrar el uso de $_GET con un ejemplo en este tutorial de PHP, podemos pre­s­ci­n­dir de la base de datos. En el siguiente script uti­li­za­mos la su­pe­r­glo­bal $_GET para leer los valores de las variables firstname (nombre) y lastname (apellido) de una cadena de consulta HTTP y asi­g­nar­los a las variables $firstname y $lastname:

<?php

$firstname = $_GET['firstname'];
$lastname = $_GET['lastname'];

echo "Hello " . $firstname . " " . $lastname . "!";

El script se ejecuta mediante la siguiente URL:

localhost/hello.php?firstname=John&lastname=Doe

De este modo pasamos los pa­rá­me­tros firstname=John y lastname=Doe. La salida de los valores se realiza, como en los ejemplos an­te­rio­res, mediante la co­n­s­tru­c­ción de lenguaje echo.

Close

La tra­n­s­mi­sión de datos mediante $_GET implica ne­ce­sa­ria­me­n­te que los datos enviados sean visibles en la barra de di­re­c­cio­nes. De este modo, siempre es posible ver qué pa­rá­me­tros se están tra­n­s­mi­tie­n­do. Esto tiene la ventaja de que las variables pueden in­te­grar­se di­re­c­ta­me­n­te en hi­pe­r­ví­ncu­los. Además, las personas que navegan por Internet pueden guardar URL completas, incluida la cadena de consulta, como marcador en el navegador.

Sin embargo, el hecho de que los pa­rá­me­tros GET se muestren en texto plano en la URL hace que este método no sea adecuado para tra­n­s­mi­tir datos sensibles, como los que se in­tro­du­cen en fo­r­mu­la­rios en línea. Además, la cantidad de datos que se puede tra­n­s­mi­tir mediante $_GET está limitada por la longitud máxima de las URL.

Tra­n­s­fe­re­n­cia de datos mediante $_POST

Los métodos HTTP GET y POST se di­fe­re­n­cian pri­n­ci­pa­l­me­n­te en la forma de tra­n­s­fe­rir datos: mientras que en el método GET los datos se envían como pa­rá­me­tros en la URL, con $_POST la tra­n­s­fe­re­n­cia de datos se realiza en el cuerpo de la solicitud HTTP. Esto permite enviar también grandes volúmenes de datos de un script a otro.

Un caso de uso habitual del método HTTP POST es la tra­n­s­fe­re­n­cia de datos desde fo­r­mu­la­rios HTML. Para ilu­s­trar­lo, uti­li­za­re­mos el ejemplo de un registro en una ne­w­s­le­t­ter. Crea para ello un nuevo archivo PHP llamado “page1.php” y copia el siguiente bloque de código:

<form method="post" action="page2.php">
Please send the newsletter to: <br />
Your first name: <input type="text" name="firstname" /><br />
Your last name: <input type="text" name="lastname" /><br />
Your email address: <input type="text" name="email" /><br />
<input type="submit" value="Submit form" />
</form>

Para crear fo­r­mu­la­rios se utiliza el elemento HTML <form>. Este contiene en la etiqueta de apertura dos atributos: method y action. Con el atributo method defines el método de tra­n­s­mi­sión, en este caso HTTP POST. En el atributo action se indica la URL de un script que recibirá todos los datos in­tro­du­ci­dos en los campos del fo­r­mu­la­rio. El ejemplo muestra un fo­r­mu­la­rio HTML con tres campos de entrada (input type="text") y un botón de envío (input type="submit"). Como de­s­ti­na­ta­rio de los datos se define el archivo “page2.php”.

Para ilustrar la tra­n­s­fe­re­n­cia de datos mediante $_POST, uti­li­za­re­mos un script sencillo que guarda los valores enviados como variables de PHP y los muestra como texto. Crea para ello el archivo “page2.php”. y añade el siguiente código:

<?php
$firstname = $_POST["firstname"];
$lastname = $_POST["lastname"];
$email = $_POST["email"];
echo "Hello " . $firstname . " " . $lastname . ", <br />
You have registered with the following email address: " . $email . ".";

Guarda ambos archivos PHP en la carpeta “htdocs” de tu servidor de pruebas y abre “page1.php” en el navegador mediante la siguiente URL: http://localhost/page1.php. Tu navegador mostrará ahora la interfaz in­ter­ac­ti­va del fo­r­mu­la­rio HTML.

Close

Introduce cualquier dato y pulsa el botón de envío para tra­n­s­fe­rir las variables de un script a otro. En cuanto confirmes el fo­r­mu­la­rio en “page1.php”, se te re­di­ri­gi­rá au­to­má­ti­ca­me­n­te a “page2.php”. La ventana del navegador mostrará el resultado de la ejecución del script según los datos enviados.

Close

Las entradas de usuario in­tro­du­ci­das en los campos del fo­r­mu­la­rio de “page1.php” se recuperan en “page2.php” siguiendo el siguiente esquema:

$_POST["Name of the input field"] (nombre del campo de entrada)

Así, la línea $firstname = $_POST["firstname"] recupera el valor in­tro­du­ci­do en el campo de texto firstname y lo guarda en la variable $firstname. A su vez, la variable $firstname se puede mostrar como cadena mediante echo.

La es­tru­c­tu­ra if y los ope­ra­do­res de co­m­pa­ra­ción en PHP

Hasta ahora hemos definido variables, las hemos tra­n­s­fe­ri­do de un script a otro y las hemos mostrado como texto. En el siguiente paso apre­n­de­rás a vincular la ejecución de fra­g­me­n­tos de código a de­te­r­mi­na­das co­n­di­cio­nes.

La co­n­s­tru­c­ción de lenguaje if te permite escribir scripts de modo que ciertas in­s­tru­c­cio­nes solo se ejecuten cuando se cumple una condición definida pre­via­me­n­te; por ejemplo, cuando se introduce una co­n­tra­se­ña correcta. En PHP, las co­n­di­cio­nes se definen siguiendo la siguiente es­tru­c­tu­ra básica:

<?php
if (expression)
{
statement;
}

Esto significa que la in­s­tru­c­ción statement solo se ejecuta cuando se cumple la condición definida en expression. Una condición se considera cumplida cuando la co­n­s­tru­c­ción if devuelve el resultado TRUE (verdadero). En caso contrario, se considera FALSE (falso) y la in­s­tru­c­ción se omite.

Por lo general, la co­n­s­tru­c­ción if comprueba si el valor de una variable coincide con lo que se ha definido en la condición. Esta es­tru­c­tu­ra de control suele im­ple­me­n­tar­se mediante ope­ra­do­res de co­m­pa­ra­ción.

Ope­ra­do­res de co­m­pa­ra­ción

Los ope­ra­do­res de co­m­pa­ra­ción se utilizan al formular co­n­di­cio­nes para poner dos valores en una relación lógica que puede evaluarse como verdadera (TRUE) o falsa (FALSE). Cuando se utilizan en es­tru­c­tu­ras de control de PHP, estos ope­ra­do­res comparan dos valores dentro de la expression de una co­n­s­tru­c­ción if:

if ($a == $b)
{
statement;
}

En lenguaje natural, esta es­tru­c­tu­ra se in­te­r­pre­ta así: si la variable $a es igual a la variable $b, entonces se ejecutan las in­s­tru­c­cio­nes definidas en statement.

Los ope­ra­do­res de co­m­pa­ra­ción de PHP se basan en el lenguaje de pro­gra­ma­ción C y, en parte, se di­fe­re­n­cian de los símbolos clásicos uti­li­za­dos en ma­te­má­ti­cas. La siguiente tabla ofrece una visión general:

El siguiente script pretende aclarar esta es­tru­c­tu­ra de control. En él se comparan dos números enteros uti­li­za­n­do el operador < (menor que):

<?php
$number1 = 10;
$number2 = 20;

if ($number1 < $number2) {
echo "The condition is met";
}

Definimos las variables $number1 y $number2 y les asignamos los valores 10 y 20. A co­n­ti­nua­ción, es­ta­ble­ce­mos una condición: si $number1 es menor que $number2, se mostrará el texto indicado en la in­s­tru­c­ción echo.

El resultado de la ejecución del script contiene la respuesta: 10 es menor que 20. La co­n­s­tru­c­ción if devuelve el resultado TRUE y se ejecuta el código co­rre­s­po­n­die­n­te.

Close

Si quieres definir in­s­tru­c­cio­nes que se ejecuten cuando no se cumple una condición, puedes ampliar la es­tru­c­tu­ra con la co­n­s­tru­c­ción else, formando así una in­s­tru­c­ción if-else en PHP:

<?php
if(Condition a)
{
statement b;
}
else
{
statement c;
}

Este script también comprueba si la condición a devuelve el resultado TRUE o FALSE. Si se cumple la condición a, se ejecuta la in­s­tru­c­ción b. Si la condición a no se cumple (FALSE), se omite la in­s­tru­c­ción b y en su lugar se ejecuta la in­s­tru­c­ción c.

Ampliemos el ejemplo anterior con la co­n­s­tru­c­ción else y su­s­ti­tu­ya­mos el operador < (es menor) por == (es igual):

<?php
$number1 = 10;
$number2 = 20;
if($number1 == $number2)
{
echo "The condition is met";
}
else
{
echo "The condition is not met";
}

En este caso la condición devuelve el resultado FALSE, ya que el valor de $number1 no es igual al valor de $number2. La condición no se cumple. Por lo tanto, no se ejecuta la in­s­tru­c­ción indicada en if, sino la definida en else.

Close

La negación de una condición se realiza mediante un signo de ex­cla­ma­ción (!) colocado delante:

<?php
$number1 = 10;
$number2 = 20;

if ($number1 == $number2)
{
echo "The numbers are equal.";
}

if (!($number1 == $number2))
{
echo "The numbers are not equal.";
}

El ejemplo muestra la condición $number1 == $number2 y su negación. !($number1 == $number2) equivale a ($number1 != $number2). Una apli­ca­ción práctica de if y else es, por ejemplo, la ve­ri­fi­ca­ción de una co­n­tra­se­ña mediante un fo­r­mu­la­rio HTML. Vamos a simularla de nuevo con la ayuda de nuestros archivos PHP “page1.php” y “page2.php”.

Abre “page1.php” e inserta el siguiente fo­r­mu­la­rio:

<form action="page2.php" method="post">
Please enter your password: <input type="password" name="password" />
<input type="submit" value="Submit" />
</form>

La es­tru­c­tu­ra es similar a la del fo­r­mu­la­rio anterior, pero ahora solo ne­ce­si­ta­mos un campo de entrada para la co­n­tra­se­ña. Como antes, los datos in­tro­du­ci­dos se envían al script “page2.php”.

A co­n­ti­nua­ción, ajustamos “page2.php” con el siguiente código para que la co­n­tra­se­ña in­tro­du­ci­da se compare con una co­n­tra­se­ña al­ma­ce­na­da:

<?php
$password = $_POST["password"];
if($password=="qwerty123")
{
echo "The password was correct";
}
else
{
echo "The password was incorrect";
}

El código funciona de la siguiente manera: primero asignamos a la variable $password el valor recibido mediante el método HTTP POST. A co­n­ti­nua­ción, la es­tru­c­tu­ra if comprueba si el valor de la variable $password coincide con la cadena qwerty123. Si es así, se muestra la cadena “The password was correct“ (la co­n­tra­se­ña es correcta). Si if devuelve el resultado FALSE, entra en juego else en la línea 7 y se muestra la cadena “The password was incorrect” (la co­n­tra­se­ña es in­co­rre­c­ta).

Ahora abre el script “page1.php” en el navegador mediante la URL http://localhost/page1.php.

Close

El navegador nos muestra la vista web de nuestro fo­r­mu­la­rio HTML para la solicitud de co­n­tra­se­ña. Introduce la co­n­tra­se­ña “qwerty123” definida en el script “page2.php” y haz clic en el botón de envío.

Close

El navegador te re­di­ri­gi­rá au­to­má­ti­ca­me­n­te a “page2.php”. En segundo plano, la es­tru­c­tu­ra de control if compara el valor in­tro­du­ci­do con la co­n­tra­se­ña al­ma­ce­na­da y evalúa la expresión qwerty123 == qwerty123, y muestra la cadena “The password was correct“ (la co­n­tra­se­ña es correcta). Comprueba qué ocurre cuando escribes una co­n­tra­se­ña diferente en el campo de entrada.

Ope­ra­do­res lógicos

Las co­n­di­cio­nes que defines con ope­ra­do­res de co­m­pa­ra­ción en la expresión del co­n­s­tru­c­to if pueden, si es necesario, co­m­bi­nar­se con otras co­n­di­cio­nes dentro de la misma expresión. Para ello, PHP ofrece ope­ra­do­res lógicos como AND y OR.

En PHP existen ope­ra­do­res lógicos con aso­cia­ción fuerte y con aso­cia­ción débil. Si utilizas solo una de las dos no­ta­cio­nes, en la práctica no notarás ninguna di­fe­re­n­cia. Sin embargo, si combinas ambas, verás que && y || tienen una pre­ce­de­n­cia mayor que AND y OR. Esto es co­m­pa­ra­ble al orden de pre­ce­de­n­cia de los ope­ra­do­res ma­te­má­ti­cos. Por ejemplo, la mu­l­ti­pli­ca­ción va antes que la suma: * tiene una aso­cia­ción más fuerte que +.

Un ejemplo práctico es el inicio de sesión con nombre de usuario y co­n­tra­se­ña. No­r­ma­l­me­n­te, un sistema de acceso requiere ambos datos. Solo cuando los dos coinciden con los valores al­ma­ce­na­dos, el acceso se concede.

Volvemos a abrir nuestro fo­r­mu­la­rio de solicitud de co­n­tra­se­ña en “page1.php” y añadimos un campo de entrada para el nombre de usuario:

<form action="page2.php" method="post">
Username: <input type="text" name="username" /><br />
Password: <input type="password" name="password" /><br />
<input type="submit" value="Submit" />
</form>

En el siguiente paso también tenemos que ajustar la es­tru­c­tu­ra de control del co­n­s­tru­c­to if. Para ello uti­li­za­mos el operador lógico AND y co­m­bi­na­mos la condición de la co­n­tra­se­ña con la condición del nombre de usuario:

<?php
$username = $_POST["username"];
$password = $_POST["password"];
if($username=="John Doe" AND $password=="qwerty123")
{
echo "Welcome to the members area " . $username . "!";
}
else
{
echo "Access denied";
}

Nuestro script “page2.php” recibe ahora los valores de username y password y los guarda en las variables $username y $password. La expresión del co­n­s­tru­c­to if contiene ahora dos co­n­di­cio­nes unidas por el operador lógico AND. Solo si ambas co­n­di­cio­nes se cumplen ($username == "John Doe" y $password == "qwerty123") la co­n­s­tru­c­ción if devuelve el resultado TRUE.

Como el nombre de usuario se obtiene a través del campo username, podemos uti­li­zar­lo di­re­c­ta­me­n­te en la salida de texto con echo: a “Welcome to the members area” (Bie­n­ve­ni­do al área interna) le sigue el valor de la variable $username. Si no se cumple una de las dos co­n­di­cio­nes, obtenemos la salida de texto: “Access denied” (Acceso denegado).

Close

Los ope­ra­do­res lógicos se pueden combinar li­bre­me­n­te. Ten en cuenta que && tiene una pre­ce­de­n­cia mayor que AND, y || mayor que OR. Al igual que en las ex­pre­sio­nes ma­te­má­ti­cas, en PHP también puedes utilizar pa­ré­n­te­sis para modificar el orden de eva­lua­ción.

Co­n­di­cio­nes con match

Hasta ahora hemos im­ple­me­n­ta­do de­ci­sio­nes en PHP con in­s­tru­c­cio­nes if y else. Sin embargo, cuando se evalúa un único valor y deben pro­du­ci­r­se re­su­l­ta­dos di­fe­re­n­tes según ese valor, el código con if puede volverse rá­pi­da­me­n­te confuso. Para este tipo de si­tua­cio­nes existe la in­s­tru­c­ción match.

<?php
$status = 404;
echo match ($status) {
200 => "OK",
404 => "Not found",
default => "Unknown status",
};

En este ejemplo se evalúa el valor de la variable $status. Si es igual a 200, match devuelve el texto “OK”. Si el valor es 404, se devuelve “Not found” (no en­co­n­tra­do). Si ninguno de los valores indicados coincide, se ejecuta el caso default y se devuelve “Unknown status” (de­s­co­no­ci­do).

Close

La di­fe­re­n­cia más im­po­r­ta­n­te con if-else es que match devuelve di­re­c­ta­me­n­te un valor que puede uti­li­zar­se en una expresión o asignarse a una variable. De este modo se evita escribir varias asi­g­na­cio­nes dentro de co­n­di­cio­nes in­di­vi­dua­les y el código resulta más corto, claro y fácil de mantener.

Bucles (while, for)

A veces es necesario que un script ejecute un de­te­r­mi­na­do bloque de código varias veces antes de continuar con el resto del programa. Los lenguajes de pro­gra­ma­ción utilizan para ello el concepto de bucles en PHP. Se di­s­ti­n­guen tres tipos de bucles:

• Bucles while
• Bucles do-while
• Bucles for

Bucles while

El bucle while es el tipo de bucle más sencillo di­s­po­ni­ble en PHP. Su es­tru­c­tu­ra básica sigue el siguiente esquema:

while (condition)
{
loop step and other statements
}

El bucle while indica a PHP que ejecute las in­s­tru­c­cio­nes incluidas en el bloque mientras se cumpla la condición definida. Para ello, el in­té­r­pre­te de PHP comprueba la condición al inicio de cada iteración. La ejecución del bloque solo se detiene cuando la condición deja de cumplirse. Este principio se puede ilustrar con un sencillo script de conteo:

<?php
$number = 1;
while ($number <= 10) {
echo $number++ . "<br />";
}

En el apartado “Calcular con variables” se introdujo el principio del in­cre­me­n­to. En este ejemplo lo uti­li­za­mos de nuevo, pero con el operador de po­s­ti­n­cre­me­n­to para aumentar en 1 el valor de la variable entera $number después de mostrar su valor mediante echo. La condición del bucle while es $number <= 10. Por tanto, la in­s­tru­c­ción echo se repite hasta que $number supera el valor 10.

Close

El resultado de la ejecución del script es una secuencia de números que muestra en cada iteración el valor actual de $number. De este modo, el script cuenta de 1 a 10 y finaliza la ejecución del código en cuanto deja de cumplirse la condición del bucle while.

Bucles do-while

La es­tru­c­tu­ra del bucle do-while es similar a la del bucle while. La única di­fe­re­n­cia es que la condición no se comprueba al comienzo de cada iteración, sino al final. El esquema básico de un bucle do-while es el siguiente:

do {
loop step and other statements
}
while (condition);

Si re­es­cri­bi­mos el ejemplo anterior como un bucle do-while, tendría el siguiente aspecto:

<?php
$number = 1;
do {
echo $number++ . "<br />";
}
while ($number <= 10);

En este caso el resultado es el mismo. La ca­ra­c­te­rí­s­ti­ca pa­r­ti­cu­lar del bucle do-while es que siempre se ejecuta al menos una vez, incluso si la condición no se cumple desde el principio.

Bucles for

Bá­si­ca­me­n­te, el bucle for en PHP tiene la misma fu­n­cio­na­li­dad que el bucle while. La di­fe­re­n­cia es que el valor inicial, la condición y el paso del bucle se escriben en una sola línea. La es­tru­c­tu­ra básica del bucle for es la siguiente:

for (initial value; condition; loop step)
statements

El ejemplo que ya conocemos se podría escribir como un bucle for de forma más compacta:

<?php
for($number = 1; $number <= 10; $number++) {
echo $number . "<br /> ";
}

Primero se define el valor inicial “1” para la variable $number. Después, PHP comprueba si se cumple la condición $number <= 10. Si es así, el bucle continúa y se ejecutan las in­s­tru­c­cio­nes del bloque (en este caso, la in­s­tru­c­ción echo). Después se ejecuta el paso del bucle, es decir, el in­cre­me­n­to de la variable. Cuando finaliza el paso del bucle, comienza la siguiente iteración.

El valor inicial, la condición y el paso del bucle son elementos op­cio­na­les de un bucle for. En teoría, incluso podrían definirse bucles vacíos. Sin embargo, en la práctica este tipo de es­tru­c­tu­ras suele ser in­ne­ce­sa­rio.

En general, puedes decidir li­bre­me­n­te si utilizas un bucle for o un bucle while. No obstante, existe un argumento a favor de los bucles for: permiten ver de un vistazo todos los elementos que controlan el bucle. Esto reduce el riesgo de crear ac­ci­de­n­ta­l­me­n­te un bucle infinito que se ejecute in­de­fi­ni­da­me­n­te. En el ejemplo anterior, esto podría ocurrir si olvidaras in­cre­me­n­tar el valor de la variable $number.

Si necesitas que el bucle se ejecute al menos una vez in­de­pe­n­die­n­te­me­n­te de la condición, entonces el bucle do-while es la opción adecuada.

break y continue

El flujo de un bucle while, do-while o for se puede controlar con las in­s­tru­c­cio­nes break y continue. Utiliza break para in­te­rru­m­pir la ejecución de un bucle en cualquier punto, y continue para saltar una iteración concreta del bucle. Ambas in­s­tru­c­cio­nes suelen co­m­bi­nar­se con una condición mediante if. El siguiente ejemplo muestra nuestro script de conteo uti­li­za­n­do break:

<?php
for ($number = 1; $number <= 10; $number++) {
if ($number == 5) {
echo "At 5, we break out of the loop!";
break;
}
echo $number . "<br /> ";
}

En el bucle for hemos definido que el valor de la variable $number, partiendo del valor inicial 1, se in­cre­me­n­te en 1 en cada iteración del bucle hasta alcanzar el valor 10. Ahora in­te­rru­m­pi­mos el bucle de forma an­ti­ci­pa­da con la in­s­tru­c­ción break en cuanto $number alcanza el valor 5. De este modo, la co­n­s­tru­c­ción echo solo muestra los números del 1 al 4.

Close

Si solo queremos omitir la quinta iteración, pero no detener toda la ejecución del bucle, su­s­ti­tui­mos la in­s­tru­c­ción break por continue:

<?php
for ($number=1; $number <= 10; $number++) {
if ($number == 5) {
echo "Number 5 is skipped!<br />";
continue;
}
echo $number . "<br /> ";
}

En este caso el bucle continúa eje­cu­tá­n­do­se no­r­ma­l­me­n­te. Cuando $number es 5, el script muestra el mensaje definido en if (“Number 5 is skipped!” (¡Nos saltamos el 5!)) y pasa di­re­c­ta­me­n­te a la siguiente iteración, sin ejecutar la in­s­tru­c­ción echo que mostraría el número.

Close

Ope­ra­cio­nes con archivos

Los co­n­te­ni­dos web dinámicos se basan en una se­pa­ra­ción entre contenido y pre­se­n­ta­ción. Por eso, los lenguajes de scripting como PHP ofrecen di­fe­re­n­tes funciones que permiten cargar co­n­te­ni­dos desde fuentes de datos externas en archivos de plantilla centrales (template files).

En la práctica, estas fuentes de datos suelen ser bases de datos ge­s­tio­na­das con sistemas como MySQL. Sin embargo, también es posible incluir datos di­re­c­ta­me­n­te desde archivos. A co­n­ti­nua­ción veremos cómo leer archivos como cadena (string) en un script de PHP y cómo procesar su contenido.

Leer archivos

Para leer el contenido de un archivo, PHP ofrece varias funciones. Para nuestros pro­pó­si­tos destacan file() y file_get_contents(). Mientras que la función file_get_contents() lee todo el contenido de un archivo en una cadena (string), la función file() almacena el contenido como un array. Cada elemento del array co­rre­s­po­n­de a una línea del archivo. Con file() resulta más fácil trabajar con líneas in­di­vi­dua­les.

Para demostrar las ope­ra­cio­nes con archivos en PHP uti­li­za­re­mos el archivo de texto example.txt, que guardamos en la carpeta htdocs de nuestro servidor de pruebas. El archivo contiene cuatro líneas de texto de ejemplo:

Close

Primero leemos el archivo completo como una cadena (string). Para ello, pasamos el nombre del archivo como parámetro a la función file_get_contents():

file_get_contents('example.txt')

Ahora podemos trabajar con la cadena leída. Por ejemplo, podemos asignarla a una variable y mostrarla como texto en el navegador web:

<?php
$example = file_get_contents('example.txt');
echo $example;

En el navegador veremos que la cadena se muestra sin párrafos. Los saltos de línea del archivo original no se reflejan vi­sua­l­me­n­te. Esto ocurre porque el navegador in­te­r­pre­ta la salida del script como código HTML, y los saltos de línea del archivo de texto no se co­n­vie­r­ten au­to­má­ti­ca­me­n­te en saltos de línea HTML.

Close

Si quieres mantener la es­tru­c­tu­ra original, tienes varias opciones. Puedes añadir ma­nua­l­me­n­te en el archivo de origen la co­di­fi­ca­ción HTML para el salto de línea (<br>) usando buscar y re­em­pla­zar, envolver el contenido del archivo con una etiqueta <pre>, asignar a la zona la propiedad de CSS white-space: pre-wrap o utilizar la función nl2br() para indicarle a PHP que convierta au­to­má­ti­ca­me­n­te los saltos de línea en saltos de línea HTML. La función se usa siguiendo este esquema:

<?php
$example = file_get_contents('example.txt');
echo nl2br($example);

Cuando se utiliza echo en co­m­bi­na­ción con nl2br(), PHP inserta un salto de línea HTML antes de cada nueva línea de texto.

Close

Si quieres mostrar las líneas de un archivo de forma in­di­vi­dual, la función file() es una buena opción. Esta función lee un archivo, numera todas las líneas empezando por 0 y guarda su contenido como elementos de un array. Aplicado a nuestro ejemplo, se obtiene la siguiente asi­g­na­ción:

[0] = Lorem ipsum dolor sit amet, consectetuer adipiscing elit

[1] = Aenean commodo ligula eget dolor. Aenean massa.

[2] = Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.

[3] = Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem.

Para mostrar una línea concreta con echo, solo tienes que indicar el índice co­rre­s­po­n­die­n­te. Así, por ejemplo, el siguiente script muestra úni­ca­me­n­te la primera línea del archivo “example.txt” como salida para el navegador:

<?php
$example = file("example.txt");
echo $example[0];

Close

Escribir archivos

Con PHP no solo puedes leer archivos. El lenguaje de scripting también te permite crear archivos y escribir contenido en ellos.

Para ello uti­li­za­mos la función de PHP file_put_contents(). Esta función espera dos pa­rá­me­tros: el nombre del archivo que se va a crear o ac­tua­li­zar y los datos en forma de string o array. El siguiente script crea el archivo test.txt y escribe la cadena “This is a test!” (¡Esto es una prueba!) en la primera línea. El añadido \r\n provoca un salto de línea en el archivo de destino.

<?php
file_put_contents("test.txt", "This is a test! \r\n");
echo "test.txt has been created!";

Como file_put_contents no genera ninguna salida para el navegador, añadimos una in­s­tru­c­ción echo para indicar qué acción se está rea­li­za­n­do.

Close

Si en la carpeta de destino ya existe un archivo con el mismo nombre, este se so­bre­s­cri­be. Puedes evitarlo añadiendo el parámetro FILE_APPEND:

<?php
file_put_contents("test.txt","The test was successful! \r\n", FILE_APPEND);
echo "test.txt has been updated!";

Si utilizas file_put_contents() con el parámetro FILE_APPEND, el nuevo contenido se añade al contenido ya existente.

Close

El contenido que PHP escribe en el archivo de destino no tiene por qué definirse ne­ce­sa­ria­me­n­te en el propio script. Como al­te­r­na­ti­va, también puedes copiar el contenido de un archivo a otro. El siguiente script lee el contenido de example.txt y lo inserta en el archivo test.txt:

<?php
$example = file_get_contents("example.txt");
file_put_contents("test.txt", $example, FILE_APPEND);
echo "test.txt has been updated!";

Pro­gra­ma­ción orientada a objetos

La pro­gra­ma­ción orientada a objetos (OOP) es un método para dividir los programas en unidades pequeñas y ma­ne­ja­bles, los llamados objetos. Cada objeto pertenece a una clase, que describe qué pro­pie­da­des y métodos tiene. Las pro­pie­da­des son variables que almacenan ca­ra­c­te­rí­s­ti­cas del objeto, mientras que los métodos son funciones que el objeto puede ejecutar. La OOP ayuda a es­tru­c­tu­rar mejor el código, hacerlo re­uti­li­za­ble y facilitar su ma­n­te­ni­mie­n­to, es­pe­cia­l­me­n­te en proyectos grandes.

Clases

Una clase es una plantilla para crear objetos. Puedes imaginar una clase como el plano de un coche, mientras que un objeto sería un coche concreto creado a partir de ese plano. La clase define qué datos contiene un objeto y qué funciones puede ejecutar. En el siguiente ejemplo vemos una clase Car (coche):

class Car {
public string $brand;
public string $model;
public function move () {
echo "The car is moving!";
}
}
$myCar = new Car();
$myCar->brand = "VW";
$myCar->model = "Golf";
$myCar->move();

En este ejemplo se define la clase Car, que tiene dos pro­pie­da­des, $brand (marca) y $model (modelo), así como un método move() (moverse). A co­n­ti­nua­ción, se crea un objeto de esta clase asignando la clase “Car” a $myCar (mi coche). Con el operador -> accedemos a las pro­pie­da­des del objeto y asignamos a $brand el valor VW y a $model el valor Golf. Después llamamos al método move(), que muestra el texto “The car is moving!” (¡El coche se está moviendo!). La palabra clave $this haría re­fe­re­n­cia, dentro del método, al objeto actual.

Close

Promoción de pro­pie­da­des en el co­n­s­tru­c­tor

Desde PHP 8.0 puedes definir e ini­cia­li­zar pro­pie­da­des di­re­c­ta­me­n­te en el co­n­s­tru­c­tor, es decir, en el método que se ejecuta au­to­má­ti­ca­me­n­te al crear un objeto de una clase. De este modo ya no es necesario de­cla­rar­las pre­via­me­n­te en la clase, lo que hace que el código sea más compacto y fácil de leer.

class Product {
public function __construct(
public string $name,
public float $price
) {}
}
$product = new Product("Cup", 12.99);
echo $product->name;
echo $product->price;

En este ejemplo las pro­pie­da­des name y price se declaran di­re­c­ta­me­n­te en el co­n­s­tru­c­tor. Al crear el objeto Product se pasan los valores “Cup” (taza) y “12.99”. Con $product->name y $product->price accedemos a los valores que se han es­ta­ble­ci­do au­to­má­ti­ca­me­n­te al crear el objeto. La promoción de pro­pie­da­des en el co­n­s­tru­c­tor reduce la cantidad de código necesario y hace que las clases sean más claras y fáciles de mantener.

In­te­r­fa­ces

Una interfaz define qué métodos debe tener una clase, sin es­pe­ci­fi­car su im­ple­me­n­ta­ción concreta. Las clases que im­ple­me­n­tan una interfaz deben definir estos métodos. De este modo, di­fe­re­n­tes clases pueden uti­li­zar­se de forma uniforme.

<?php
interface Movable {
    public function move();
}

class Car implements Movable {
    public function move() {
        echo "The car is moving!";
    }
}

$myCar = new Car();
$myCar->move();

En este ejemplo, la interfaz Movable (movible) define que cada clase que la im­ple­me­n­te debe tener un método move(). La clase Car im­ple­me­n­ta esta interfaz y define el método co­rre­s­po­n­die­n­te. A co­n­ti­nua­ción se crea un objeto de la clase y se llama al método, lo que provoca que se muestre el texto “The car is moving!” (¡El coche se está moviendo!).

Close

Tipos de in­te­r­se­c­ción

Los tipos de in­te­r­se­c­ción existen desde PHP 8.1. Permiten que un objeto tenga que cumplir varias in­te­r­fa­ces al mismo tiempo. Esto resulta es­pe­cia­l­me­n­te útil cuando una función necesita ga­ra­n­ti­zar que un objeto dispone de de­te­r­mi­na­das ca­pa­ci­da­des.

interface Loggable {}
function save(JsonSerializable&Loggable $object) {
echo "The object can save JSON data and log information.";
}

En este ejemplo, los objetos que se pasan a la función save() tienen que im­ple­me­n­tar tanto la interfaz JsonSerializable como Loggable. La co­m­bi­na­ción de ambas se expresa mediante el operador &. De este modo se garantiza que la función solo puede trabajar con objetos que cumplen ambos contratos al mismo tiempo.

Pro­pie­da­des de solo lectura

Las pro­pie­da­des readonly (de solo lectura) existen desde PHP 8.1. Solo pueden es­ta­ble­ce­r­se una vez al crear un objeto y no pueden mo­di­fi­car­se po­s­te­rio­r­me­n­te. Esto resulta es­pe­cia­l­me­n­te útil para proteger datos frente a cambios no in­te­n­cio­na­dos.

class User {
public function __construct(
public readonly string $name
) {}
}
$user = new User("Max");
echo $user->name;

En este ejemplo la propiedad name se define di­re­c­ta­me­n­te en el co­n­s­tru­c­tor y se marca como readonly. Esto significa que el valor “Max” no puede mo­di­fi­car­se después de crear el objeto. Si intentas cambiar el valor más adelante, se producirá un error. Las pro­pie­da­des de solo lectura son ideales para datos que deben pe­r­ma­ne­cer in­mu­ta­bles, como los ide­n­ti­fi­ca­do­res de usuario o los valores de co­n­fi­gu­ra­ción.

Property Hooks

Los Property Hooks permiten, desde la versión 8.4 de PHP, ejecutar lógica di­re­c­ta­me­n­te al asignar o leer una propiedad. Esto resulta muy práctico cuando los valores deben pro­ce­sar­se au­to­má­ti­ca­me­n­te.

class User {
public string $email {
set => strtolower($value);
get => strtoupper($this->email);
}
}
$user = new User();
$user->email = "Test@Example.com";
echo $user->email;

En este ejemplo, al asignar un valor a la propiedad email, todo se convierte au­to­má­ti­ca­me­n­te a mi­nú­s­cu­las, mientras que al leerla se muestra todo en ma­yú­s­cu­las. Así puedes procesar los datos de forma coherente sin tener que escribir métodos adi­cio­na­les.

Vi­si­bi­li­dad asi­mé­tri­ca

Con la vi­si­bi­li­dad asi­mé­tri­ca, in­tro­du­ci­da también en la versión 8.4 de PHP, puedes definir que una propiedad se pueda leer de forma pública, pero solo se pueda modificar dentro de la clase. Esto protege datos im­po­r­ta­n­tes frente a cambios no co­n­tro­la­dos.

class Account {
    public private(set) float $balance = 0.0;

    public function deposit(float $amount) {
        $this->balance += $amount;
    }
}

$account = new Account();
$account->deposit(50);
echo $account->balance;

En este ejemplo, el saldo de la cuenta puede leerse pú­bli­ca­me­n­te, pero solo puede mo­di­fi­car­se dentro de la propia clase. El método deposit() permite in­cre­me­n­tar el saldo de forma co­n­tro­la­da. Si intentas escribir di­re­c­ta­me­n­te en $balance, se producirá un error. Así se pueden proteger datos im­po­r­ta­n­tes ma­n­te­nie­n­do el acceso para las ope­ra­cio­nes pe­r­mi­ti­das.

Escribir código PHP limpio

A medida que un proyecto crece, también aumenta la im­po­r­ta­n­cia de mantener código bien es­tru­c­tu­ra­do y limpio. Un código PHP limpio es más fácil de leer, más sencillo de mantener y menos propenso a errores. Por eso, las apli­ca­cio­nes PHP siguen ciertas co­n­ve­n­cio­nes y utilizan he­rra­mie­n­tas que fomentan el orden, la claridad y la seguridad.

Composer y PSR-4 (carga au­to­má­ti­ca de clases)

Composer es una he­rra­mie­n­ta central en el de­sa­rro­llo con PHP. Sirve para gestionar bi­blio­te­cas externas y cargar au­to­má­ti­ca­me­n­te clases de PHP. Sin Composer tendrías que incluir las clases ma­nua­l­me­n­te con require o include, lo que en proyectos grandes se vuelve rá­pi­da­me­n­te difícil de mantener. Composer utiliza no­r­ma­l­me­n­te el estándar de autocarga PSR-4. Este estándar define cómo se en­cue­n­tran las clases según su nombre y su ubicación en el sistema de archivos. El nombre de una clase se co­rre­s­po­n­de con la es­tru­c­tu­ra de carpetas donde está guardada.

Un ejemplo sencillo ilustra este principio. Si una clase User se encuentra en el espacio de nombres App\Model, el archivo co­rre­s­po­n­die­n­te se ubica en una carpeta “src/Model”:

<?php
namespace App\Model;
class User {
public function getName() {
return "Max Mustermann";
}
}

Gracias a PSR-4, esta clase puede uti­li­zar­se en cualquier parte del proyecto sin tener que incluir el archivo ma­nua­l­me­n­te. PHP la carga au­to­má­ti­ca­me­n­te cuando se necesita. Esto hace que el código sea más claro y reduce posibles fuentes de errores.

Na­me­s­pa­ces para una se­pa­ra­ción clara del código

Los na­me­s­pa­ces te ayudan a agrupar clases de forma lógica y a evitar co­n­fli­c­tos de nombres. En scripts pequeños puedes llamar a una clase si­m­ple­me­n­te User o Database sin problema. Pero en apli­ca­cio­nes más grandes puede ocurrir que varias clases tengan el mismo nombre y cumplan funciones distintas. Con los na­me­s­pa­ces puedes separar cla­ra­me­n­te estas clases. Así, por ejemplo, puede existir una clase User para la base de datos y otra clase User para la pre­se­n­ta­ción en el frontend, sin que se produzcan co­n­fli­c­tos.

El siguiente ejemplo muestra el uso de un namespace:

<?php
namespace App\Service;
class Mailer {
public function send() {
echo "Email has been sent.";
}
}

Al utilizar la clase, se emplea el nombre completo incluido el namespace o se importa mediante use. De este modo, el código se mantiene ine­quí­vo­co y bien es­tru­c­tu­ra­do.

Es­tru­c­tu­ra del proyecto: archivos .env y .gitignore

Una es­tru­c­tu­ra de proyecto clara es una parte im­po­r­ta­n­te de un código PHP limpio. En los proyectos PHP se separa el propio código del programa de los archivos ac­ce­si­bles pú­bli­ca­me­n­te y de los datos de co­n­fi­gu­ra­ción. A menudo, el código PHP se encuentra en una carpeta propia, mientras que el servidor web solo puede acceder a un di­re­c­to­rio público.

Los valores de co­n­fi­gu­ra­ción como los datos de acceso a la base de datos o las claves de API no­r­ma­l­me­n­te no se guardan di­re­c­ta­me­n­te en el código. En su lugar se utilizan los llamados archivos .env, donde estos valores se almacenan de forma ce­n­tra­li­za­da. Esto aumenta la seguridad y facilita el cambio entre el entorno de de­sa­rro­llo y el de pro­du­c­ción.

Un ejemplo sencillo de un archivo .env podría tener este aspecto:

DB_HOST=localhost
DB_USER=root
DB_PASSWORD=secret

Este archivo no se guarda de­li­be­ra­da­me­n­te en el control de versiones. De ello se encarga el archivo .gitignore, que determina qué archivos o carpetas deben ser ignorados por Git. En .gitignore se excluye ex­plí­ci­ta­me­n­te el archivo .env para evitar que los datos sensibles se publiquen por accidente.

Gestión de errores y registro (logging)

El manejo de errores difiere entre el entorno de de­sa­rro­llo y el de pro­du­c­ción. Durante el de­sa­rro­llo, es útil mostrar di­re­c­ta­me­n­te los mensajes de error de PHP. Así puedes detectar y so­lu­cio­nar los problemas rá­pi­da­me­n­te.

En apli­ca­cio­nes en pro­du­c­ción, en cambio, los mensajes de error no deberían mostrarse, ya que podrían revelar in­fo­r­ma­ción interna. En su lugar, los errores se escriben en archivos de registro (logs) a los que solo tienen acceso los de­sa­rro­lla­do­res.

En un entorno de de­sa­rro­llo, la salida de errores puede activarse, por ejemplo, de la siguiente manera:

<?php
ini_set('display_errors', 1);
error_reporting(E_ALL);

En un entorno de pro­du­c­ción, la vi­sua­li­za­ción de errores se desactiva y se activa el registro (logging). PHP escribe los errores que se produzcan en un archivo de log, sin mo­s­trar­los a quienes visitan la página web. De este modo, la apli­ca­ción sigue siendo estable y segura, mientras que los errores quedan do­cu­me­n­ta­dos y se pueden rastrear.

Conceptos básicos de bases de datos con PHP: un ejemplo sencillo con PDO

Para almacenar o leer datos con PHP, necesitas una base de datos. En este ejemplo uti­li­za­mos MySQL, que viene incluido por defecto en XAMPP. PHP puede co­mu­ni­car­se de forma segura con la base de datos mediante PDO (PHP Data Objects). PDO se asegura de que los comandos se ejecuten co­rre­c­ta­me­n­te y ofrece prepared sta­te­me­nts: los ma­r­ca­do­res de posición separan el comando SQL de las entradas de los usuarios, de modo que estas no se ejecuten como parte del comando.

Crear la base de datos y la tabla

Primero creamos en ph­p­M­yA­d­min una nueva base de datos con el nombre testdb. Dentro de esta base de datos, creamos una tabla llamada users. Esta tabla contiene tres columnas: id para la ide­n­ti­fi­ca­ción única de cada usuario, username para el nombre de usuario y email para la dirección de correo ele­c­tró­ni­co. En SQL tendría el siguiente aspecto:

CREATE TABLE users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50) NOT NULL,
email VARCHAR(100) NOT NULL
);

Ope­ra­cio­nes con bases de datos en PHP

Ahora creamos un archivo “crud.php” en la carpeta “htdocs” de XAMPP. En este ejemplo es­ta­ble­ce­mos una conexión con la base de datos y mostramos primero las ope­ra­cio­nes básicas CREATE, READ, UPDATE y DELETE (CRUD):

<?php
// Establish database connection
$host = '127.0.0.1';
$db = 'testdb';
$user = 'root';
$pass = '';
$charset = 'utf8mb4';
$dsn = "mysql:host=$host;dbname=$db;charset=$charset";
$options = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION, // Make errors visible
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, // Data as array
];
try {
$pdo = new PDO($dsn, $user, $pass, $options);
} catch (PDOException $e) {
echo "Connection failed: " . $e->getMessage();
exit;
}

// CREATE: insert new user
$stmt = $pdo->prepare("INSERT INTO users (username, email) VALUES (:username, :email)");
$stmt->execute([
'username' => 'Max Mustermann',
'email' => 'max@example.com'
]);

// READ: fetch all users
$stmt = $pdo->query("SELECT * FROM users");
$users = $stmt->fetchAll();

// Output the user list
echo "<h2>User list</h2>";
foreach ($users as $user) {
echo "ID: " . $user['id'] . " – Name: " . htmlspecialchars($user['username']) . " – E-Mail: " . htmlspecialchars($user['email']) . "<br>";
}

// UPDATE: change a user's email
$stmt = $pdo->prepare("UPDATE users SET email = :email WHERE username = :username");
$stmt->execute([
'email' => 'max.mustermann@example.com',
'username' => 'Max Mustermann'
]);
echo "<p>The email address of Max Mustermann has been updated.</p>";

// DELETE: delete user
$stmt = $pdo->prepare("DELETE FROM users WHERE username = :username");
$stmt->execute([
    'username' => 'Max Mustermann'
]);
?>

Primero se establece una conexión con la base de datos mediante PDO. Para ello indicamos el host, el nombre de la base de datos, el nombre de usuario, la co­n­tra­se­ña y el juego de ca­ra­c­te­res. PDO se encarga de ejecutar los comandos SQL y de gestionar los errores.

A co­n­ti­nua­ción mostramos las cuatro ope­ra­cio­nes básicas:

• CREATE (inserción de datos): con INSERT INTO in­se­r­ta­mos un nuevo usuario. Los ma­r­ca­do­res de posición :username y :email ga­ra­n­ti­zan que las entradas de los usuarios se procesen de forma segura.
• READ (lectura de datos): con SELECT * FROM users obtenemos todos los registros exi­s­te­n­tes. Con fetchAll() guardamos los re­su­l­ta­dos en un array y los mostramos en una lista clara y ordenada.
• UPDATE (mo­di­fi­ca­ción de datos): con UPDATE podemos cambiar la dirección de correo ele­c­tró­ni­co de un usuario. Volvemos a utilizar ma­r­ca­do­res de posición para insertar los valores de forma segura.
• DELETE (eli­mi­na­ción de datos): con DELETE FROM users WHERE username = :username eli­mi­na­mos de la base de datos a un usuario concreto. El marcador de posición :username garantiza que la entrada se procese de forma segura, sin que un posible atacante pueda manipular la base de datos. Así podemos borrar registros in­di­vi­dua­les sin afectar a toda la tabla.

Entradas de usuario seguras y pro­ce­sa­mie­n­to de datos

En cuanto PHP trabaja con entradas de usuarios, surge un riesgo de seguridad. Las personas que visitan tu página pueden manipular los campos de los fo­r­mu­la­rios, enviar datos ine­s­pe­ra­dos o intentar de­li­be­ra­da­me­n­te abusar de una apli­ca­ción. Por eso, PHP ofrece varias funciones con las que se pueden comprobar, procesar y almacenar de forma segura las entradas.

Almacenar datos de forma segura en bases de datos: prepared sta­te­me­nts

Una de las vu­l­ne­ra­bi­li­da­des de seguridad más fre­cue­n­tes en apli­ca­cio­nes PHP aparece al trabajar con bases de datos. Si las entradas de los usuarios se insertan di­re­c­ta­me­n­te en consultas de SQL, puede pro­du­ci­r­se una inyección SQL. En este caso, los atacantes in­tro­du­cen su propio código SQL en la consulta.

Las prepared sta­te­me­nts (consultas pre­pa­ra­das) evitan este problema separando de forma estricta el código SQL de los datos de los usuarios. Para ello, PHP ofrece la interfaz de acceso a bases de datos PDO.

<?php
$stmt = $pdo->prepare("SELECT * FROM users WHERE username = :username");
$stmt->execute([
'username' => $username
]);

El código prepara una consulta a la base de datos para buscar a todos los usuarios de la tabla users cuyo nombre de usuario coincide con un valor de­te­r­mi­na­do. En lugar de escribir el nombre de usuario di­re­c­ta­me­n­te en la in­s­tru­c­ción SQL, se utiliza el marcador de posición :username, que solo se rellena con un valor concreto al ejecutar la consulta. De este modo, PHP separa el código SQL de los datos de los usuarios y evita que las entradas puedan manipular la in­s­tru­c­ción.

Proteger las salidas: escape de salida (output escaping)

No solo el al­ma­ce­na­mie­n­to de datos, sino también su salida puede suponer un riesgo de seguridad. Si muestras las entradas de los usuarios en el navegador sin fi­l­trar­las, puede pro­du­ci­r­se el llamado Cross-Site Scripting (XSS). En este caso, se ejecuta código malicioso en el navegador de otros usuarios. Para evitarlo, las salidas deben escaparse antes de mostrarse. En PHP esto se hace no­r­ma­l­me­n­te con la función htmlspecialchars(). De este modo, el texto se muestra en el navegador, pero no se in­te­r­pre­ta como código HTML.

<?php
echo htmlspecialchars("<h1>Hello World!</h1>", ENT_QUOTES, 'UTF-8');

Close

Filtrar las entradas de los usuarios: filter_input()

PHP ofrece con filter_input() una forma de validar y filtrar las entradas de las personas usuarias en el momento de leerlas. Así se pueden detectar pronto valores no válidos o no deseados. Un ejemplo sencillo es la lectura de una dirección de correo ele­c­tró­ni­co:

<?php
$email = filter_input(INPUT_POST, 'email', FILTER_VALIDATE_EMAIL);

Si la entrada no es una dirección de correo ele­c­tró­ni­co válida, la función devuelve false. Si el campo ni siquiera se envía, el resultado es null. Por eso, comprueba ambos casos. De este modo, el código puede reac­cio­nar de forma es­pe­cí­fi­ca antes de seguir tra­ba­ja­n­do con los datos.

Almacenar co­n­tra­se­ñas de forma segura con password_hash()

Las co­n­tra­se­ñas nunca deben al­ma­ce­nar­se en texto plano. Ni siquiera un cifrado sencillo es su­fi­cie­n­te. Para ello, PHP ofrece la función password_hash(), que genera un hash seguro de las co­n­tra­se­ñas.

<?php
$hash = password_hash($password, PASSWORD_DEFAULT);

Durante el inicio de sesión posterior, la co­n­tra­se­ña in­tro­du­ci­da se comprueba con password_verify():

<?php
if (password_verify($password, $hash)) {
echo "Login successful";
}

El valor real de la co­n­tra­se­ña nunca vuelve a ser visible. Incluso en caso de una fi­l­tra­ción de la base de datos, las co­n­tra­se­ñas siguen pro­te­gi­das.

Pro­te­c­ción frente a la ma­ni­pu­la­ción de fo­r­mu­la­rios: tokens CSRF

En los fo­r­mu­la­rios existe el riesgo de que se envíen sin que los usuarios lo sepan. Para evitarlo, se utilizan los llamados tokens CSRF. Se trata de cadenas de ca­ra­c­te­res alea­to­rias que se generan de nuevo cada vez que se carga un fo­r­mu­la­rio.

<?php
$_SESSION['token'] = bin2hex(random_bytes(32));

Esta línea genera un código de seguridad aleatorio y difícil de adivinar y lo guarda en la sesión actual del usuario. La función random_bytes(32) crea 32 bytes alea­to­rios, es decir, datos en bruto que no son di­re­c­ta­me­n­te legibles. Con bin2hex() esos datos en bruto se co­n­vie­r­ten en una cadena de ca­ra­c­te­res legible formada por letras y números. El valor generado se almacena en $_SESSION['token'] y se utiliza después para comprobar si un fo­r­mu­la­rio proviene realmente de la misma sesión.

Carga de archivos con va­li­da­ción

Las cargas de archivos también son es­pe­cia­l­me­n­te sensibles y pueden in­tro­du­cir riesgos de seguridad, ya que permiten que archivos externos lleguen al servidor. Por eso, siempre se deben comprobar el tipo de archivo y su tamaño.

Un ejemplo sencillo de co­m­pro­ba­ción del tamaño de un archivo podría tener este aspecto:

<?php
if ($_FILES['upload']['size'] > 1000000) {
echo "File is too big.";
}

El código comprueba cuál es el tamaño del archivo subido y lo compara con un valor máximo fijado de 1,000,000 bytes. Si el archivo es más grande de lo permitido, se muestra un mensaje de error y se puede rechazar la carga. De este modo se evita que se suban al servidor archivos demasiado grandes. Además, se debe verificar que realmente se trate del tipo de archivo esperado, por ejemplo, una imagen. Nunca se deben almacenar archivos subidos en ubi­ca­cio­nes eje­cu­ta­bles sin va­li­dar­los pre­via­me­n­te.