Estructuras condicionales: if, else, elseif, switch

Las estructuras condicionales en PHP permiten controlar el flujo de ejecución de un programa en función de condiciones específicas. Utilizando if, else, elseif y switch, es posible ejecutar bloques de código basados en evaluaciones lógicas.

La estructura básica if se utiliza para ejecutar un bloque de código si una condición es verdadera:

if ($a > $b) {
    echo "$a es mayor que $b";
}

En este ejemplo, se comprueba si $a es mayor que $b y, de ser así, se imprime un mensaje.

Para manejar el caso en que la condición sea falsa, se emplea else:

if ($a > $b) {
    echo "$a es mayor que $b";
} else {
    echo "$a no es mayor que $b";
}

Aquí, si $a no es mayor que $b, se ejecuta el bloque dentro de else.

Cuando se necesitan evaluar múltiples condiciones, se utiliza elseif:

if ($a > $b) {
    echo "$a es mayor que $b";
} elseif ($a == $b) {
    echo "$a es igual a $b";
} else {
    echo "$a es menor que $b";
}

Este código evalúa si $a es mayor, igual o menor que $b, ejecutando el bloque correspondiente según la condición que se cumpla.

La estructura switch es útil para comparar una misma expresión contra múltiples valores:

$opcion = 2;

switch ($opcion) {
    case 1:
        echo "Has seleccionado la opción 1";
        break;
    case 2:
        echo "Has seleccionado la opción 2";
        break;
    case 3:
        echo "Has seleccionado la opción 3";
        break;
    default:
        echo "Opción no válida";
}

En este caso, la variable $opcion se compara con cada case, y si coincide, se ejecuta el bloque de código correspondiente. El break es importante para salir de la estructura switch después de encontrar una coincidencia.

Es posible agrupar múltiples case para un mismo bloque de código:

$letra = 'a';

switch ($letra) {
    case 'a':
    case 'e':
    case 'i':
    case 'o':
    case 'u':
        echo "$letra es una vocal";
        break;
    default:
        echo "$letra es una consonante";
}

Aquí, si $letra es una vocal, se ejecuta el mismo bloque de código para todos los case indicados.

Las estructuras condicionales también pueden anidarse para evaluar condiciones más complejas:

if ($usuario == 'admin') {
    if ($password == '1234') {
        echo "Acceso concedido";
    } else {
        echo "Contraseña incorrecta";
    }
} else {
    echo "Usuario no reconocido";
}

En este ejemplo, se verifica primero si $usuario es igual a 'admin' y luego, dentro de esa condición, se comprueba la contraseña.

Es fundamental comprender el uso adecuado de estas estructuras para escribir código que responda correctamente a diferentes escenarios y condiciones en tiempo de ejecución.

Operador ternario y elvis

El operador ternario en PHP es una forma abreviada de expresar una condición simple en una sola línea. Su sintaxis es:

$resultado = (condición) ? valor_si_verdadero : valor_si_falso;

Este operador evalúa la condición; si es verdadera, devuelve valor_si_verdadero; si es falsa, devuelve valor_si_falso. Por ejemplo:

$edad = 20;
$mensaje = ($edad >= 18) ? 'Eres mayor de edad' : 'Eres menor de edad';
echo $mensaje; // Imprime: Eres mayor de edad

En este caso, la variable $mensaje se asigna según el resultado de la condición evaluada.

El operador elvis (?:) es una simplificación del operador ternario cuando la expresión de la condición y el valor si es verdadero son idénticos. Su sintaxis es:

$resultado = expresión1 ?: expresión2;

Este operador devuelve expresión1 si es verdadera; de lo contrario, devuelve expresión2. Es especialmente útil para asignar valores por defecto cuando una variable puede ser falsa o no está definida. Por ejemplo:

$nombreUsuario = $usuarioIngresado ?: 'Invitado';
echo "Bienvenido, $nombreUsuario";

Aquí, si $usuarioIngresado tiene un valor verdadero (no es null, 0, false o una cadena vacía), se utiliza ese valor; de lo contrario, se asigna 'Invitado'.

Es importante entender que en PHP, valores como 0, '' (cadena vacía), false y null se consideran falsos. Por lo tanto, el operador elvis devolverá la segunda expresión si encuentra alguno de estos valores en la primera expresión.

Para distinguir entre una variable que es null y una que tiene un valor falso, es preferible utilizar el operador de fusión de null (??). Sin embargo, el operador elvis es útil cuando se quiere verificar si una variable tiene un valor verdadero en términos lógicos.

Ejemplo práctico del operador elvis:

$cantidad = $producto['stock'] ?: 'No disponible';
echo "Cantidad en stock: $cantidad";

En este ejemplo, si $producto['stock'] es un valor verdadero (por ejemplo, un número positivo), se muestra esa cantidad; si es 0 o un valor falso, se muestra 'No disponible'.

El operador ternario también puede utilizarse sin la parte else para expresar una condición sencilla:

($usuarioActivo) ? realizarAccion() : null;

Sin embargo, es recomendable utilizar esta sintaxis con cautela para mantener la claridad del código.

Además, es posible anidar operadores ternarios, pero puede afectar la legibilidad:

$tipoUsuario = ($edad >= 18) ? (($esEstudiante) ? 'Estudiante adulto' : 'Adulto') : 'Menor de edad';

En estos casos, podría ser más claro utilizar estructuras if...else tradicionales para mejorar la comprensión del código.

El uso adecuado del operador ternario y el operador elvis puede hacer que el código sea más conciso, pero siempre es importante considerar la legibilidad y el mantenimiento a largo plazo del código.

Bucles

Los bucles en PHP permiten ejecutar un bloque de código repetidamente mientras se cumpla una condición o para recorrer estructuras de datos como arrays. Las estructuras de bucle más comunes son while, do...while, for y foreach.

El bucle while ejecuta un bloque de código siempre que la condición sea verdadera:

$i = 1;

while ($i <= 5) {
    echo "Valor de i: $i\n";
    $i++;
}

En este ejemplo, el bucle se ejecuta mientras $i sea menor o igual a 5. La variable $i se incrementa en cada iteración hasta que la condición deja de cumplirse.

El bucle do...while es similar al while, pero garantiza que el bloque de código se ejecute al menos una vez, ya que la condición se evalúa al final de cada iteración:

$i = 1;

do {
    echo "Valor de i: $i\n";
    $i++;
} while ($i <= 5);

Aquí, el código dentro de do se ejecuta y luego se verifica la condición del while. Esto asegura que, incluso si la condición es falsa desde el inicio, el bloque se ejecutará al menos una vez.

El bucle for se utiliza cuando se conoce de antemano el número de iteraciones. Su sintaxis incluye la inicialización, la condición y el incremento o decremento:

for ($i = 1; $i <= 5; $i++) {
    echo "Valor de i: $i\n";
}

En este caso, la variable $i se inicializa en 1, y el bucle se ejecuta mientras $i sea menor o igual a 5, incrementándose $i en cada iteración.

El bucle foreach es especialmente útil para recorrer arrays y objetos iterables. Tiene una sintaxis sencilla y permite acceder directamente a los valores y/o claves de una colección:

$colores = ['rojo', 'verde', 'azul'];

foreach ($colores as $color) {
    echo "Color: $color\n";
}

En este ejemplo, $color toma el valor de cada elemento del array $colores en cada iteración.

Si se necesita acceder a las claves y a los valores, se puede utilizar la siguiente sintaxis:

$edades = ['Ana' => 25, 'Luis' => 30, 'María' => 28];

foreach ($edades as $nombre => $edad) {
    echo "$nombre tiene $edad años\n";
}

Aquí, $nombre representa la clave y $edad el valor de cada elemento del array $edades.

Es posible anidar bucles para recorrer estructuras multidimensionales. Por ejemplo, al iterar sobre un array de arrays:

$matriz = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
];

foreach ($matriz as $fila) {
    foreach ($fila as $valor) {
        echo "Valor: $valor\n";
    }
}

Este código recorre cada fila del array $matriz y luego cada valor dentro de esa fila.

Al escribir bucles, es importante asegurarse de que la condición eventualmente se vuelva falsa para evitar bucles infinitos que pueden consumir recursos del sistema.

Los bucles son una herramienta fundamental en PHP para automatizar tareas repetitivas y manipular estructuras de datos de manera eficiente.

Operador de fusión de null ??

El operador de fusión de null (??) en PHP es una herramienta que simplifica la comprobación de si una expresión es null y proporciona un valor predeterminado en caso afirmativo. Este operador devuelve el valor de su operando izquierdo si este no es null; de lo contrario, devuelve el operando derecho. Su uso es especialmente útil para evitar errores al trabajar con variables no definidas o posibles valores null.

La sintaxis básica es:

$resultado = $variable ?? $valorPorDefecto;

En este ejemplo, $resultado obtendrá el valor de $variable si esta no es null; de lo contrario, recibirá $valorPorDefecto. El operador de fusión de null es una alternativa más concisa a utilizar una estructura isset combinada con un operador ternario:

// Forma tradicional
$resultado = isset($variable) ? $variable : $valorPorDefecto;

// Con el operador de fusión de null
$resultado = $variable ?? $valorPorDefecto;

El operador de fusión de null es asociativo por naturaleza, lo que permite encadenarlo para evaluar múltiples variables y obtener el primer valor que no sea null:

$valor = $opcion1 ?? $opcion2 ?? $opcion3 ?? 'Valor predeterminado';

En este caso, $valor tomará el primer valor que no sea null entre $opcion1, $opcion2 y $opcion3; si todos son null, se asignará 'Valor predeterminado'.

Es importante destacar que el operador de fusión de null solo considera null como valor nulo y no otros valores que puedan evaluarse como false en un contexto booleano, como 0, false o cadenas vacías ''. Por ejemplo:

$a = 0;
$b = $a ?? 'Valor predeterminado';
echo $b; // Imprime: 0

Aquí, aunque $a es 0 (que en un contexto booleano es false), el operador de fusión de null lo considera un valor válido ya que no es null, por lo que $b toma el valor 0.

El operador de fusión de null es especialmente útil al trabajar con arrays asociativos o al manejar datos provenientes de formularios o peticiones:

// Supongamos que $_GET['usuario'] puede no estar definido
$usuario = $_GET['usuario'] ?? 'Invitado';
echo "Bienvenido, $usuario";

En este ejemplo, si el parámetro 'usuario' no está presente en la URL, $usuario se establecerá en 'Invitado'. De lo contrario, tomará el valor proporcionado en $_GET['usuario'].

Al utilizar el operador de fusión de null, se mejora la legibilidad y se reduce la verbosidad del código, evitando comprobaciones adicionales con isset() o estructuras condicionales:

// Sin el operador de fusión de null
if (isset($config['tema'])) {
    $tema = $config['tema'];
} else {
    $tema = 'predeterminado';
}

// Con el operador de fusión de null
$tema = $config['tema'] ?? 'predeterminado';

Además, a partir de PHP 7.4, se introdujo el operador de asignación de fusión de null (??=), que permite asignar un valor a una variable solo si esta es null:

$opciones['limite'] ??= 10;

Este código es equivalente a:

if ($opciones['limite'] === null) {
    $opciones['limite'] = 10;
}

El operador de asignación de fusión de null es útil para establecer valores predeterminados sin sobrescribir valores ya existentes:

$usuario ??= 'Anónimo';
echo "Usuario: $usuario";

Si $usuario no está definido o es null, se le asigna 'Anónimo'; si ya tiene un valor, se conserva.

Es fundamental comprender la diferencia entre el operador de fusión de null (??) y el operador elvis (?:). Mientras que el primero solo considera null como valor nulo, el segundo evalúa cualquier valor que sea false en un contexto booleano:

$a = '';
$b = $a ?? 'Valor con ??';
$c = $a ?: 'Valor con ?:';

echo "Con ?? : $b\n"; // Imprime: Con ?? :
echo "Con ?: $c\n";   // Imprime: Con ?: Valor con ?:

En este ejemplo, $a es una cadena vacía. El operador de fusión de null considera que $a no es null, por lo que $b toma el valor de $a. Sin embargo, el operador elvis interpreta la cadena vacía como false, por lo que $c toma el valor 'Valor con ?:'.

Al utilizar el operador de fusión de null, se logra un código más limpio y eficiente, especialmente en aplicaciones donde es común trabajar con valores que pueden ser null debido a entradas de usuario, datos externos o variables opcionales.

Expresiones de control (break, continue, return)

Las expresiones de control en PHP como break, continue y return permiten alterar el flujo normal de ejecución de un programa, ofreciendo mayor flexibilidad en la lógica de aplicaciones.

La expresión break se utiliza para interrumpir la ejecución de un bucle o una estructura switch antes de que haya completado todas sus iteraciones o casos. Por ejemplo, en un bucle for:

for ($i = 0; $i < 10; $i++) {
    if ($i === 5) {
        break; // Se detiene el bucle cuando $i es igual a 5
    }
    echo "Valor de i: $i\n";
}

En este código, el bucle se interrumpe cuando $i alcanza el valor 5, evitando que se ejecuten iteraciones adicionales.

Por otro lado, la expresión continue permite saltar a la siguiente iteración de un bucle, omitiendo el código restante en la iteración actual. Por ejemplo:

for ($i = 0; $i < 10; $i++) {
    if ($i % 2 === 0) {
        continue; // Se salta la iteración si $i es par
    }
    echo "Número impar: $i\n";
}

Aquí, cuando $i es un número par, se utiliza continue para omitir el resto del código y pasar a la siguiente iteración, imprimiendo solo los números impares.

La expresión return se emplea para finalizar la ejecución de una función y, opcionalmente, devolver un valor al llamante. Por ejemplo:

function obtenerRaizCuadrada($numero) {
    if ($numero < 0) {
        return null; // No se puede calcular la raíz cuadrada de un número negativo
    }
    return sqrt($numero);
}

$resultado = obtenerRaizCuadrada(16);
echo "La raíz cuadrada es: $resultado\n";

En esta función, return se usa para salir de la función si el número es negativo y para devolver el resultado de sqrt($numero) cuando el cálculo es posible.

Es posible utilizar return sin un valor explícito para simplemente salir de una función:

function mostrarMensaje($mensaje) {
    if (empty($mensaje)) {
        return; // Termina la función si $mensaje está vacío
    }
    echo "Mensaje: $mensaje\n";
}

En este caso, si $mensaje está vacío, la función finaliza sin realizar ninguna acción.

Las expresiones break y continue también pueden recibir un argumento numérico para especificar cuántos niveles de bucle deben afectarse. Por ejemplo:

for ($i = 0; $i < 3; $i++) {
    echo "i: $i\n";
    for ($j = 0; $j < 3; $j++) {
        if ($j === 1) {
            break 2; // Sale de ambos bucles cuando $j es igual a 1
        }
        echo "  j: $j\n";
    }
}

Aquí, break 2 interrumpe tanto el bucle interno como el externo cuando $j es igual a 1. Del mismo modo, continue puede utilizarse con un argumento numérico:

for ($i = 0; $i < 3; $i++) {
    for ($j = 0; $j < 3; $j++) {
        if ($j === 1) {
            continue 2; // Salta a la siguiente iteración del bucle externo
        }
        echo "i: $i, j: $j\n";
    }
}

En este ejemplo, continue 2 omite el resto de la iteración actual de ambos bucles y continúa con la siguiente iteración del bucle externo.

Es importante utilizar estas expresiones de control con precaución para mantener la legibilidad y el mantenimiento del código. Un uso excesivo puede dificultar la comprensión de la lógica del programa.

Expresiones de control con try-catch

Las expresiones de control con try-catch en PHP permiten gestionar excepciones y manejar errores que pueden ocurrir durante la ejecución de un programa. Mediante el uso de bloques try y catch, es posible controlar el flujo del programa cuando se producen situaciones inesperadas o excepcionales.

El bloque try contiene el código que podría generar una excepción. Si ocurre una excepción dentro del bloque try, la ejecución salta inmediatamente al bloque catch correspondiente, donde se puede manejar el error de forma adecuada:

try {
    // Código que puede generar una excepción
    $resultado = $dividendo / $divisor;
    echo "El resultado es $resultado";
} catch (DivisionByZeroError $e) {
    // Manejo de la excepción
    echo "Error: No se puede dividir entre cero.";
}

En este ejemplo, si $divisor es cero, se lanzará una excepción de tipo DivisionByZeroError, que es capturada por el bloque catch. De esta manera, se evita que el programa termine abruptamente y se puede proporcionar un mensaje de error más informativo.

Las excepciones pueden ser de distintos tipos, y es posible capturar diferentes excepciones utilizando varios bloques catch:

try {
    // Código que puede generar excepciones
    $archivo = fopen($nombreArchivo, 'r');
    $contenido = fread($archivo, filesize($nombreArchivo));
    fclose($archivo);
} catch (FileNotFoundException $e) {
    echo "Error: El archivo no existe.";
} catch (Exception $e) {
    echo "Error inesperado: " . $e->getMessage();
}

Aquí, se intenta abrir y leer un archivo. Si el archivo no existe, se lanza una excepción FileNotFoundException. Cualquier otra excepción general es capturada por el bloque catch que maneja la clase base Exception.

El bloque finally es opcional y se ejecuta siempre, independientemente de si se produjo una excepción o no. Es útil para liberar recursos o realizar tareas que deben ejecutarse en cualquier caso:

try {
    // Código que puede generar una excepción
    realizarTransaccion();
} catch (TransactionException $e) {
    echo "Error en la transacción: " . $e->getMessage();
} finally {
    finalizarConexion();
    // Este código se ejecuta siempre
}

En este caso, la función finalizarConexion() se ejecutará siempre, asegurando que la conexión se cierre correctamente incluso si se produjo un error durante la transacción.

Es posible lanzar una excepción de forma manual utilizando la palabra clave throw. Esto permite generar excepciones personalizadas para controlar situaciones específicas en el flujo del programa:

function validarUsuario($usuario) {
    if (empty($usuario)) {
        throw new Exception("El nombre de usuario no puede estar vacío.");
    }
    // Continúa con la validación
}

try {
    validarUsuario($nombreUsuario);
    echo "Usuario válido";
} catch (Exception $e) {
    echo "Error de validación: " . $e->getMessage();
}

Aquí, si el nombre de usuario está vacío, se lanza una excepción que es capturada en el bloque catch, permitiendo manejar el error y controlar el flujo adecuadamente.

Las expresiones de control con try-catch también pueden combinarse con otras estructuras de control como bucles o condicionales. Por ejemplo, al procesar una serie de operaciones donde puede ocurrir una excepción en cualquier iteración:

$datos = [10, 0, 5];

foreach ($datos as $valor) {
    try {
        $resultado = 100 / $valor;
        echo "Resultado: $resultado\n";
    } catch (DivisionByZeroError $e) {
        echo "Error: División por cero.\n";
        continue;
    }
    // Código adicional que se ejecuta si no hay excepción
    echo "Cálculo realizado con éxito.\n";
}

En este ejemplo, si se intenta dividir por cero, se captura la excepción y se utiliza continue para saltar a la siguiente iteración del bucle, manteniendo el flujo sin detener el programa.

El uso de try-catch como expresión de control mejora la fiabilidad y la seguridad de las aplicaciones, permitiendo que los programas manejen los errores de manera controlada y evitando comportamientos inesperados. Sin embargo, es importante utilizar las excepciones de forma adecuada y no emplearlas para controlar flujos normales del programa, ya que pueden afectar al rendimiento y la legibilidad del código.

Finalmente, las expresiones de control con try-catch son una herramienta poderosa que, cuando se utiliza correctamente, contribuye a crear aplicaciones robustas y resilientes frente a errores y situaciones excepcionales.