2.1 Fundamentos de PHP

1.1 Variables

En PHP, una variable se representa mediante un signo de dólar ($) seguido de un nombre. No es necesario declarar previamente su tipo: PHP es un lenguaje de tipado dinámico y la variable adquiere el tipo del valor que se le asigna.

• El nombre debe comenzar por una letra o un guion bajo (_), seguido de letras, números o guiones bajos.
• PHP distingue entre mayúsculas y minúsculas en los nombres de variables: $nombre y $Nombre son variables distintas.
• Se pueden asignar por valor o por referencia (con &).

Ejemplo básico

<?php
$nombre = "Ana";
$edad = 20;
$altura = 1.65;
$esAlumno = true;

echo "Nombre: $nombre\n";
echo "Edad: $edad\n";
echo "Altura: $altura\n";
echo "¿Es alumno? " . ($esAlumno ? "Sí" : "No") . "\n";
?>
				

PHP también dispone de variables predefinidas o superglobales, como $_GET, $_POST, $_SESSION o $_SERVER, accesibles desde cualquier parte del script.

Documentación oficial: Variables (php.net).

Tipos de datos en PHP

PHP es un lenguaje de tipado dinámico: el tipo de una variable se determina según el valor que se le asigna y puede cambiar a lo largo de la ejecución. Los tipos de datos principales son:

• int (entero): números sin parte decimal. Ejemplo: $edad = 20;
• float (coma flotante): números con parte decimal. Ejemplo: $precio = 19.95;
• string (cadena): secuencia de caracteres entre comillas simples o dobles. Ejemplo: $nombre = "Ana";
• bool (booleano): solo puede ser true o false. Ejemplo: $activo = true;
• array: colección ordenada de valores. Ejemplo: $colores = ["rojo", "verde"];
• object: instancia de una clase. Ejemplo: $fecha = new DateTime();
• null: representa una variable sin valor asignado. Ejemplo: $dato = null;
• callable: referencia a una función que se puede invocar. Ejemplo: $fn = "strlen";
• iterable: valor que se puede recorrer con foreach, como un array o un objeto que implementa Traversable.
• resource: referencia a un recurso externo, como un archivo abierto o una conexión a base de datos.

Ejemplo de tipos de datos

<?php
$entero = 42;
$flotante = 3.14;
$cadena = "Hola, mundo";
$booleano = false;
$array = [1, 2, 3];
$nulo = null;

// var_dump muestra el tipo y el valor de una variable
var_dump($entero);    // int(42)
var_dump($flotante);  // float(3.14)
var_dump($cadena);    // string(11) "Hola, mundo"
var_dump($booleano);  // bool(false)
var_dump($array);     // array(3) { [0]=> int(1) ... }
var_dump($nulo);      // NULL

// gettype devuelve el tipo como cadena
echo gettype($entero);   // integer
echo gettype($flotante); // double
echo gettype($cadena);   // string
?>
				

PHP permite convertir entre tipos de forma implícita (coerción) o explícita mediante casting: (int), (float), (string), (bool), (array), (object).

<?php
$numero = "123abc";
$convertido = (int) $numero;
echo $convertido; // 123

$valor = 0;
$comoBooleano = (bool) $valor;
var_dump($comoBooleano); // bool(false)
?>
				

Documentación oficial: Tipos de datos (php.net) y Conversión de tipos (php.net).

1.2 Ámbito de las variables

El ámbito determina desde qué partes del programa se puede acceder a una variable. En PHP, el ámbito depende del lugar donde se declara:

• Ámbito local: las variables declaradas dentro de una función solo existen dentro de ella.
• Ámbito global: las variables declaradas fuera de las funciones son globales, pero no se accede a ellas directamente dentro de una función.
• Superglobales: están disponibles en cualquier ámbito sin necesidad de declaración especial.
• Estáticas: conservan su valor entre llamadas a la misma función.

Ejemplo de ámbito local y global

<?php
$mensaje = "Variable global";

function mostrarMensaje() {
    // No se accede directamente a $mensaje
    // echo $mensaje; // Error

    $mensaje = "Variable local";
    echo $mensaje . "\n";
}

mostrarMensaje();        // Muestra: Variable local
echo $mensaje . "\n";    // Muestra: Variable global
?>
				

Uso de global y static

<?php
$contador = 0;

function incrementar() {
    global $contador;
    $contador++;
}

function incrementarEstatico() {
    static $veces = 0;
    $veces++;
    echo "Llamada número $veces\n";
}

incrementar();
incrementar();
echo "Contador global: $contador\n"; // 2

incrementarEstatico(); // 1
incrementarEstatico(); // 2
incrementarEstatico(); // 3
?>
				

Documentación oficial: Ámbito de las variables (php.net).

1.3 Operadores

PHP ofrece una amplia variedad de operadores. Los más habituales son:

• Aritméticos: +, -, *, /, %, **.
• Asignación: =, +=, -=, *=, /=, .=.
• Comparación: ==, ===, !=, <>, !==, <, >, <=, >=, <=>.
• Lógicos: &&, ||, !, and, or, xor.
• Incremento/decremento: ++, --.
• Concatenación de cadenas: . y .=.
• Operador ternario: ? :.
• Null coalescing: ??.

Ejemplo de operadores

<?php
$a = 10;
$b = 3;

echo $a + $b;        // 13
echo $a % $b;        // 1
echo $a ** $b;       // 1000

$nombre = "Ana";
$nombre .= " María"; // Ana María

$edad = null;
echo $edad ?? "No definida"; // No definida

$resultado = ($a > $b) ? "mayor" : "menor";
echo $resultado; // mayor
?>
				

Documentación oficial: Operadores (php.net).

1.4 Comentarios

Los comentarios permiten documentar el código y no se ejecutan. PHP admite varias formas:

• // o # para comentarios de una sola línea.
• /* ... */ para comentarios de varias líneas.
• /** ... */ para comentarios de documentación (docblocks).

Ejemplo de comentarios

<?php
// Comentario de una línea
# También válido

/*
   Comentario de varias líneas
   que explica un bloque de código
*/

/**
 * Suma dos números enteros.
 *
 * @param int $a Primer número.
 * @param int $b Segundo número.
 * @return int Resultado de la suma.
 */
function sumar($a, $b) {
    return $a + $b;
}
?>
				

Documentación oficial: Comentarios (php.net).

1.5 Directivas

Las directivas son opciones de configuración que modifican el comportamiento de PHP. Se pueden establecer en el archivo php.ini, en la configuración del servidor web, o en tiempo de ejecución mediante ini_set().

Algunas directivas habituales son:

• display_errors: muestra o no los errores en la salida.
• error_reporting: nivel de errores que se notifican.
• log_errors: guarda los errores en un archivo de registro.
• max_execution_time: tiempo máximo de ejecución de un script.
• memory_limit: memoria máxima que puede usar un script.
• upload_max_filesize: tamaño máximo de archivo subido.
• date.timezone: zona horaria por defecto.

Ejemplo de configuración en tiempo de ejecución

<?php
// Mostrar todos los errores durante el desarrollo
ini_set('display_errors', '1');
ini_set('error_reporting', E_ALL);

// Establecer la zona horaria
date_default_timezone_set('Europe/Madrid');

echo date('d/m/Y H:i:s');
?>
				

Documentación oficial: Configuración (php.net) y Directivas de php.ini (php.net).

1.6 Estructuras de decisión

Permiten ejecutar bloques de código según se cumplan o no determinadas condiciones.

• if, else, elseif.
• switch / case.
• Operador ternario ? :.
• match (PHP 8+).

Ejemplo con if / elseif / else

<?php
$nota = 7.5;

if ($nota < 5) {
    echo "Suspenso";
} elseif ($nota < 7) {
    echo "Aprobado";
} elseif ($nota < 9) {
    echo "Notable";
} else {
    echo "Sobresaliente";
}
?>
				

Ejemplo con switch y match

<?php
$dia = "martes";

switch ($dia) {
    case "lunes":
        echo "Inicio de semana";
        break;
    case "viernes":
        echo "Fin de semana a la vista";
        break;
    default:
        echo "Día entre semana";
}

$resultado = match ($dia) {
    "lunes" => "Inicio de semana",
    "viernes" => "Fin de semana a la vista",
    default => "Día entre semana",
};

echo $resultado;
?>
				

Documentación oficial: if (php.net), switch (php.net) y match (php.net).

1.7 Bucles

Los bucles permiten repetir un bloque de código mientras se cumpla una condición o para recorrer colecciones de datos.

• while: comprueba la condición antes de cada iteración.
• do...while: ejecuta al menos una vez y comprueba después.
• for: ideal cuando se conoce el número de iteraciones.
• foreach: específico para recorrer arrays y objetos.
• break y continue: alteran el flujo del bucle.

Ejemplo de while y for

<?php
$i = 1;
while ($i <= 5) {
    echo $i . " ";
    $i++;
}

for ($j = 10; $j >= 1; $j--) {
    echo $j . " ";
}
?>
				

Ejemplo de foreach

<?php
$frutas = ["manzana", "pera", "plátano"];

foreach ($frutas as $indice => $fruta) {
    echo "$indice: $fruta\n";
}
?>
				

Documentación oficial: while (php.net), for (php.net) y foreach (php.net).

1.8 Arrays

Un array es una estructura que permite almacenar múltiples valores en una sola variable. PHP admite arrays indexados, asociativos y multidimensionales.

• Indexados: las claves son números enteros que comienzan en 0.
• Asociativos: las claves son cadenas de texto.
• Multidimensionales: contienen otros arrays como valores.

Ejemplo de arrays

<?php
// Array indexado
$colores = ["rojo", "verde", "azul"];
echo $colores[1]; // verde

// Array asociativo
$alumno = [
    "nombre" => "Ana",
    "edad" => 20,
    "ciclo" => "DAW"
];
echo $alumno["nombre"]; // Ana

// Array multidimensional
$alumnos = [
    ["nombre" => "Ana", "edad" => 20],
    ["nombre" => "Luis", "edad" => 22],
];

foreach ($alumnos as $a) {
    echo $a["nombre"] . " tiene " . $a["edad"] . " años\n";
}
?>
				

PHP incluye numerosas funciones para trabajar con arrays: count(), array_push(), array_pop(), array_keys(), array_values(), sort(), array_map(), entre muchas otras.

Documentación oficial: Arrays (php.net) y Funciones de arrays (php.net).

1.9 Funciones

Una función es un bloque de código con un nombre que se puede invocar desde cualquier parte del programa. Permiten reutilizar código, organizarlo y evitar repeticiones.

• Se definen con la palabra clave function.
• Pueden recibir parámetros y devolver un valor con return.
• Los parámetros pueden tener valores por defecto y declaraciones de tipo.
• Existen funciones anónimas (closures) y funciones flecha (fn).

Ejemplo de función básica

<?php
function saludar($nombre = "visitante") {
    return "Hola, $nombre";
}

echo saludar();          // Hola, visitante
echo saludar("Ana");     // Hola, Ana
?>
				

Ejemplo con tipos y valor por defecto

<?php
function sumar(int $a, int $b = 0): int {
    return $a + $b;
}

echo sumar(5, 3); // 8
echo sumar(5);    // 5
?>
				

Ejemplo de función anónima y flecha

<?php
$cuadrado = function ($n) {
    return $n * $n;
};

echo $cuadrado(4); // 16

$doble = fn($n) => $n * 2;
echo $doble(5); // 10
?>
				

Documentación oficial: Funciones (php.net) y Funciones flecha (php.net).

1.10 Excepciones

Una excepción es un objeto que representa un error o una situación anómala que ocurre durante la ejecución de un programa. A diferencia de los errores tradicionales, las excepciones se pueden lanzar (throw) de forma controlada y capturar (catch) para decidir qué hacer ante el problema.

El uso de excepciones permite separar el código normal del código encargado de gestionar errores, mejorando la legibilidad y el mantenimiento de las aplicaciones.

Estructura try / catch / finally

PHP ofrece el bloque try...catch para capturar excepciones. Opcionalmente, se puede añadir un bloque finally que se ejecuta siempre, haya o no excepción.

• try: contiene el código que puede lanzar una excepción.
• catch: captura la excepción y decide cómo actuar.
• finally: se ejecuta siempre, tanto si se lanza la excepción como si no.
• throw: lanza una excepción de forma manual.

Ejemplo básico de try / catch

<?php
function dividir($a, $b) {
    if ($b == 0) {
        throw new Exception("No se puede dividir entre cero.");
    }
    return $a / $b;
}

try {
    echo dividir(10, 2) . "\n"; // 5
    echo dividir(10, 0) . "\n"; // Lanza excepción
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}
?>
				

Métodos habituales de una excepción

• getMessage(): devuelve el mensaje de la excepción.
• getCode(): devuelve el código numérico asociado.
• getFile(): archivo donde se lanzó.
• getLine(): línea donde se lanzó.
• getTrace() y getTraceAsString(): traza de la pila de llamadas.

Uso de finally

<?php
function procesar($valor) {
    if ($valor < 0) {
        throw new Exception("El valor no puede ser negativo.");
    }
    return $valor * 2;
}

try {
    echo procesar(5) . "\n";  // 10
    echo procesar(-3) . "\n"; // Lanza excepción
} catch (Exception $e) {
    echo "Se ha producido un error: " . $e->getMessage() . "\n";
} finally {
    echo "Fin del procesamiento.\n";
}
?>
				

En el ejemplo anterior, el bloque finally se ejecuta tanto si la excepción se lanza como si no, lo que resulta útil para liberar recursos (cerrar archivos, conexiones, etc.).

Excepciones personalizadas

Se pueden definir excepciones propias extendiendo la clase Exception. Esto permite distinguir distintos tipos de errores y tratarlos de forma específica.

<?php
class MiExcepcion extends Exception {}

function validarEdad($edad) {
    if ($edad < 0) {
        throw new MiExcepcion("La edad no puede ser negativa.");
    }
    if ($edad > 120) {
        throw new MiExcepcion("La edad parece demasiado alta.");
    }
    return true;
}

try {
    validarEdad(-5);
} catch (MiExcepcion $e) {
    echo "Error de validación: " . $e->getMessage() . "\n";
}
?>
				

Capturar varios tipos de excepción

Es posible encadenar varios bloques catch para tratar distintos tipos de excepción. El orden importa: los tipos más específicos deben ir antes que los más generales.

<?php
class ErrorDeValidacion extends Exception {}
class ErrorDeConexion extends Exception {}

try {
    $tipo = "conexion";
    if ($tipo == "validacion") {
        throw new ErrorDeValidacion("Datos incorrectos.");
    } else {
        throw new ErrorDeConexion("No se pudo conectar al servidor.");
    }
} catch (ErrorDeValidacion $e) {
    echo "Validación: " . $e->getMessage() . "\n";
} catch (ErrorDeConexion $e) {
    echo "Conexión: " . $e->getMessage() . "\n";
} catch (Exception $e) {
    echo "Error genérico: " . $e->getMessage() . "\n";
}
?>
				

Excepciones frente a errores

En PHP, las excepciones (Exception) y los errores (Error) son clases distintas, aunque ambas implementan la interfaz Throwable. Desde PHP 7, es posible capturar ambas con Throwable.

<?php
try {
    $resultado = 10 / 0; // En PHP 8 lanza DivisionByZeroError
} catch (Throwable $e) {
    echo "Capturado: " . $e->getMessage() . "\n";
}
?>
				

Documentación oficial: Excepciones (php.net), La clase Exception (php.net) y Errores (php.net).