Autor: clubprogramador

Hasta ahora vimos variables, condicionales, bucles y arrays. A medida que un programa crece, aparece un problema muy común: la misma lógica empieza a repetirse en varios lugares.

Las funciones permiten agrupar instrucciones bajo un nombre, reutilizarlas y dividir un programa en partes más pequeñas y comprensibles.

¿Qué es una función?

Una función es un bloque de código que realiza una tarea concreta y que puede ejecutarse cuando sea necesario.

En vez de repetir varias veces:

$precio = 1000;
$iva = $precio * 0.21;
$total = $precio + $iva;

podemos encapsular esa lógica dentro de una función y reutilizarla.

Funciones incorporadas y funciones propias

PHP incluye muchas funciones listas para usar, como:

count()
strlen()
var_dump()
array_filter()
date()

Estas funciones ya vienen con PHP.

Pero también podemos crear nuestras propias funciones con la palabra clave function.

Crear una función

function saludar() {
    echo 'Hola desde una función';
}

Esto define la función, pero todavía no la ejecuta.

Llamar una función

saludar();

Cuando PHP encuentra esa llamada, ejecuta el código que está dentro de la función.

¿Por qué usar funciones?

Las funciones ayudan a:

• evitar código repetido;
• dividir problemas grandes en partes pequeñas;
• mejorar la lectura del código;
• facilitar pruebas y mantenimiento;
• reutilizar lógica.

Parámetros

Una función puede recibir valores desde afuera mediante parámetros.

function saludar($nombre) {
    echo 'Hola ' . $nombre;
}

saludar('Ana');

En este caso $nombre es el parámetro de la función.

Parámetros y argumentos

Aunque suelen confundirse, no son exactamente lo mismo:

• parámetro: variable declarada en la función;
• argumento: valor que enviamos al llamar la función.

Ejemplo:

function saludar($nombre) {
    // $nombre es parámetro
}

saludar('Ana'); // 'Ana' es argumento

Más de un parámetro

function sumar($a, $b) {
    return $a + $b;
}

La función recibe dos valores y los utiliza dentro de su lógica.

return

return devuelve un valor al lugar desde donde se llamó la función.

function sumar($a, $b) {
    return $a + $b;
}

$resultado = sumar(10, 5);

echo $resultado;

Resultado:

15

Diferencia entre echo y return

Esta diferencia es fundamental.

echo muestra contenido:

function saludar($nombre) {
    echo 'Hola ' . $nombre;
}

return devuelve un valor para poder seguir utilizándolo:

function obtenerSaludo($nombre) {
    return 'Hola ' . $nombre;
}

$mensaje = obtenerSaludo('Ana');

En general, una función es más reutilizable cuando devuelve datos en lugar de imprimirlos directamente.

return termina la función

Cuando PHP ejecuta return, la función finaliza.

function ejemplo() {
    return 10;

    echo 'Esto nunca se ejecuta';
}

Parámetros con valores por defecto

Podemos hacer que un parámetro sea opcional.

function saludar($nombre = 'Invitado') {
    return 'Hola ' . $nombre;
}

echo saludar();
echo saludar('Ana');

Si no enviamos un argumento, se utiliza 'Invitado'.

Los parámetros obligatorios deben ir primero

Es recomendable escribir primero los parámetros obligatorios y luego los opcionales.

function crearUsuario($nombre, $activo = true) {
    // ...
}

Ejemplo: calcular IVA

function calcularIva($importe, $porcentaje = 21) {
    return $importe * $porcentaje / 100;
}

$iva = calcularIva(10000);

echo $iva;

La lógica del cálculo queda centralizada en un único lugar.

Ejemplo: calcular total con IVA

function calcularTotalConIva($importe, $porcentaje = 21) {
    $iva = $importe * $porcentaje / 100;

    return $importe + $iva;
}

$total = calcularTotalConIva(10000);

Alcance de variables

Una variable creada fuera de una función no está disponible automáticamente dentro de ella.

$nombre = 'Ana';

function mostrarNombre() {
    echo $nombre;
}

Ese código no funciona como muchos principiantes esperan, porque $nombre pertenece al ámbito exterior.

Variables locales

Las variables creadas dentro de una función existen solamente dentro de esa función.

function calcular() {
    $resultado = 10 + 5;

    return $resultado;
}

$resultado es una variable local.

La palabra global

PHP permite acceder a una variable externa mediante global.

$iva = 21;

function mostrarIva() {
    global $iva;

    echo $iva;
}

Aunque existe, conviene evitar depender de variables globales siempre que sea posible. Las funciones suelen ser más fáciles de entender y probar cuando reciben los datos mediante parámetros.

Una alternativa mejor a global

$iva = 21;

function calcularImpuesto($importe, $iva) {
    return $importe * $iva / 100;
}

$resultado = calcularImpuesto(10000, $iva);

La dependencia queda explícita.

Variables static dentro de funciones

Una variable local normalmente se crea de nuevo cada vez que llamamos a la función.

Con static podemos conservar su valor entre llamadas.

function contador() {
    static $numero = 0;

    $numero++;

    return $numero;
}

echo contador(); // 1
echo contador(); // 2
echo contador(); // 3

Tipado de parámetros

PHP permite indicar qué tipo esperamos recibir.

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

Esto expresa que ambos parámetros deben representar enteros.

Tipado de retorno

También podemos indicar qué tipo debe devolver la función.

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

El : int indica el tipo de retorno.

Ejemplo con string

function nombreCompleto(string $nombre, string $apellido): string {
    return $nombre . ' ' . $apellido;
}

Ejemplo con bool

function esMayorDeEdad(int $edad): bool {
    return $edad >= 18;
}

Esta función no imprime un mensaje. Devuelve true o false, lo que permite reutilizarla dentro de otras condiciones.

Nullable types

En algunos casos queremos aceptar un tipo o null.

function mostrarTelefono(?string $telefono): string {
    return $telefono ?? 'Sin teléfono';
}

?string significa:

string o null

Union types

Desde PHP 8 podemos declarar más de un tipo posible utilizando |.

function mostrarId(int|string $id): string {
    return 'ID: ' . $id;
}

La función acepta un entero o un string.

Funciones que devuelven arrays

function crearUsuario(string $nombre, string $email): array {
    return [
        'nombre' => $nombre,
        'email' => $email,
        'activo' => true
    ];
}

Los arrays son un tipo de retorno muy habitual en PHP.

Paso por valor

Por defecto, los valores simples se pasan de forma que modificar el parámetro no altera necesariamente la variable original.

function duplicar($numero) {
    $numero *= 2;
}

$valor = 10;
duplicar($valor);

echo $valor;

El valor exterior sigue siendo 10.

Paso por referencia con &

Podemos indicar que queremos trabajar directamente sobre la variable original utilizando &.

function duplicar(&$numero) {
    $numero *= 2;
}

$valor = 10;
duplicar($valor);

echo $valor;

Ahora el resultado es:

20

El paso por referencia debe utilizarse con cuidado porque la función produce un efecto sobre una variable externa.

Funciones anónimas

Una función no siempre necesita tener un nombre.

$saludar = function ($nombre) {
    return 'Hola ' . $nombre;
};

echo $saludar('Ana');

Este tipo de función es muy utilizado en callbacks.

Callbacks

Un callback es una función que enviamos a otra función para que sea ejecutada.

Ya vimos un ejemplo con array_map():

$numeros = [1, 2, 3, 4];

$dobles = array_map(function ($numero) {
    return $numero * 2;
}, $numeros);

array_map() ejecuta nuestro callback para cada elemento.

Arrow functions

PHP permite escribir funciones anónimas simples de forma más compacta mediante fn.

$numeros = [1, 2, 3, 4];

$dobles = array_map(
    fn($numero) => $numero * 2,
    $numeros
);

Captura de variables en arrow functions

Las arrow functions pueden utilizar variables del ámbito exterior automáticamente.

$multiplicador = 3;

$resultado = array_map(
    fn($numero) => $numero * $multiplicador,
    [1, 2, 3]
);

Funciones anónimas y use

En una función anónima tradicional podemos importar variables externas mediante use.

$iva = 21;

$calcular = function ($importe) use ($iva) {
    return $importe * $iva / 100;
};

Ejemplo práctico: calcular descuento

function calcularDescuento(float $total, bool $premium): float {
    if ($premium && $total >= 100000) {
        return $total * 0.20;
    }

    if ($total >= 100000) {
        return $total * 0.10;
    }

    return 0;
}

La función recibe toda la información necesaria y devuelve únicamente el descuento calculado.

Ejemplo práctico: total de productos

function calcularTotal(array $productos): float {
    $total = 0;

    foreach ($productos as $producto) {
        $total += $producto['precio'] * $producto['cantidad'];
    }

    return $total;
}

Una función debería hacer una tarea clara

En general, una función es más fácil de mantener cuando tiene una responsabilidad bien definida.

Es mejor tener:

calcularSubtotal()
calcularIva()
calcularDescuento()

que una función gigantesca llamada:

procesarTodo()

Nombres descriptivos

El nombre debería explicar qué hace la función.

Buenos ejemplos:

calcularTotal()
esMayorDeEdad()
obtenerNombreCompleto()
filtrarProductosActivos()

Nombres poco claros:

hacer()
procesar()
x()

Errores comunes

• confundir echo con return;
• olvidar llamar la función después de crearla;
• depender demasiado de variables globales;
• crear funciones que hacen demasiadas cosas;
• no usar nombres descriptivos;
• usar paso por referencia sin necesidad;
• declarar tipos incompatibles con lo que realmente devuelve la función;
• duplicar lógica en vez de reutilizar una función existente.

Buenas prácticas

• dar a cada función una responsabilidad clara;
• preferir parámetros frente a variables globales;
• devolver datos con return cuando sea posible;
• usar tipos cuando ayuden a expresar la intención;
• mantener funciones relativamente pequeñas;
• elegir nombres que describan la acción.

Ejercicios

1. crear una función que salude a una persona;
2. crear una función que sume dos números;
3. calcular IVA utilizando un parámetro opcional;
4. crear una función que determine si una persona es mayor de edad;
5. crear una función que devuelva nombre y apellido unidos;
6. crear una función que reciba un array y devuelva su suma;
7. declarar tipos de parámetros y retorno;
8. crear una función que acepte string|null;
9. crear una función que acepte un id int|string;
10. probar paso por valor y paso por referencia;
11. duplicar un array de números usando array_map() y una función anónima;
12. reescribir el ejercicio anterior mediante una arrow function;
13. crear una función para calcular descuentos;
14. crear una función que calcule el total de un array de productos.

Qué aprendimos

• qué es una función;
• funciones incorporadas y propias;
• parámetros y argumentos;
• return;
• diferencia entre echo y return;
• valores por defecto;
• alcance de variables;
• global y static;
• tipado de parámetros y retorno;
• nullable y union types;
• paso por valor y por referencia;
• funciones anónimas;
• callbacks;
• arrow functions.

¿Qué sigue?

En la próxima guía comenzaremos a trabajar con formularios HTML y PHP: métodos GET y POST, las variables $_GET y $_POST, validación y procesamiento de datos enviados por el usuario.

¿Te sirvió esta guía? ☕

Si este contenido te ayudó y querés apoyar a Club Programador, podés colaborar mediante:

☕ Apoyar con Mercado Pago

🌎 Apoyar con PayPal

Hasta ahora trabajamos con variables que guardaban un solo valor. Pero en muchas situaciones necesitamos almacenar varios datos relacionados dentro de una misma estructura.

Para eso PHP utiliza los arrays. Son fundamentales porque aparecen constantemente en formularios, resultados de bases de datos, APIs, configuraciones y colecciones de objetos.

¿Qué es un array?

Un array es una estructura que permite guardar varios valores dentro de una misma variable.

En lugar de hacer esto:

$color1 = 'rojo';
$color2 = 'verde';
$color3 = 'azul';

podemos agruparlos:

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

Ahora $colores contiene tres elementos.

Array indexado

Un array indexado utiliza posiciones numéricas para identificar cada elemento.

$frutas = ['Manzana', 'Pera', 'Naranja'];

PHP comienza los índices numéricos en 0.

0 → Manzana
1 → Pera
2 → Naranja

Acceder a un elemento

$frutas = ['Manzana', 'Pera', 'Naranja'];

echo $frutas[0];

Resultado:

Manzana

Modificar un elemento

$frutas[1] = 'Banana';

Ahora el array contiene:

Manzana
Banana
Naranja

Agregar elementos

La forma más simple es utilizar corchetes vacíos:

$frutas[] = 'Kiwi';

PHP agrega el nuevo valor al final del array.

Array asociativo

Un array asociativo utiliza claves con significado en lugar de índices numéricos.

$persona = [
    'nombre' => 'Ana',
    'edad' => 25,
    'ciudad' => 'Santa Rosa'
];

En este caso las claves son:

nombre
edad
ciudad

Acceder por clave

echo $persona['nombre'];

Resultado:

Ana

Modificar un valor asociativo

$persona['edad'] = 26;

Agregar una nueva clave

$persona['email'] = 'ana@email.com';

Clave y valor

En un array asociativo cada elemento se compone de dos partes:

clave => valor

Por ejemplo:

'nombre' => 'Ana'

La clave identifica el dato y el valor contiene la información.

Arrays multidimensionales

Un array puede contener otros arrays.

$usuarios = [
    [
        'nombre' => 'Ana',
        'edad' => 25
    ],
    [
        'nombre' => 'Juan',
        'edad' => 31
    ]
];

Esto permite representar estructuras más complejas.

Acceder a un array multidimensional

echo $usuarios[0]['nombre'];

Resultado:

Ana

Primero seleccionamos el elemento 0 del array principal y luego la clave nombre.

Ejemplo real: productos

$productos = [
    [
        'nombre' => 'Teclado',
        'precio' => 25000,
        'stock' => 10
    ],
    [
        'nombre' => 'Mouse',
        'precio' => 15000,
        'stock' => 25
    ]
];

Este formato es muy parecido a la información que luego podemos obtener desde una base de datos.

Recorrer arrays con foreach

foreach es la estructura más cómoda para recorrer arrays.

$frutas = ['Manzana', 'Pera', 'Naranja'];

foreach ($frutas as $fruta) {
    echo $fruta . '
';
}

Recorrer clave y valor

foreach ($persona as $clave => $valor) {
    echo $clave . ': ' . $valor . '
';
}

Recorrer arrays multidimensionales

foreach ($productos as $producto) {
    echo $producto['nombre'] . ' - $' . $producto['precio'] . '
';
}

count()

count() devuelve la cantidad de elementos de un array.

$frutas = ['Manzana', 'Pera', 'Naranja'];

echo count($frutas);

Resultado:

3

in_array()

in_array() permite saber si un valor existe dentro de un array.

$roles = ['admin', 'editor', 'usuario'];

if (in_array('admin', $roles, true)) {
    echo 'Existe el rol admin';
}

El tercer parámetro true solicita comparación estricta.

array_key_exists()

En arrays asociativos podemos comprobar si existe una clave.

if (array_key_exists('email', $persona)) {
    echo $persona['email'];
}

isset() y una diferencia importante

isset() también suele utilizarse para comprobar datos:

if (isset($persona['email']))) {
    echo 'Existe y no es NULL';
}

Pero isset() devuelve falso si la clave existe y su valor es null. array_key_exists(), en cambio, verifica la existencia de la clave independientemente de su valor.

Eliminar elementos con unset()

$frutas = ['Manzana', 'Pera', 'Naranja'];

unset($frutas[1]);

El elemento se elimina, pero PHP no necesariamente reordena automáticamente los índices existentes.

Agregar con array_push()

array_push($frutas, 'Kiwi');

Aunque funciona, para agregar un único elemento suele ser más simple:

$frutas[] = 'Kiwi';

array_pop()

Elimina y devuelve el último elemento.

$ultimo = array_pop($frutas);

array_shift()

Elimina y devuelve el primer elemento.

$primero = array_shift($frutas);

array_unshift()

Agrega uno o más elementos al comienzo.

array_unshift($frutas, 'Frutilla');

Ordenar arrays

sort()

Ordena un array indexado de menor a mayor.

$numeros = [5, 2, 9, 1];

sort($numeros);

rsort()

Ordena en sentido descendente.

rsort($numeros);

Ordenar arrays asociativos

asort() ordena por valor manteniendo la relación con las claves.

$precios = [
    'teclado' => 25000,
    'mouse' => 15000,
    'monitor' => 180000
];

asort($precios);

ksort() ordena por clave.

ksort($precios);

array_merge()

Permite combinar arrays.

$grupo1 = ['Ana', 'Juan'];
$grupo2 = ['Lucía', 'Pedro'];

$todos = array_merge($grupo1, $grupo2);

implode()

implode() convierte un array en un string utilizando un separador.

$nombres = ['Ana', 'Juan', 'Lucía'];

$texto = implode(', ', $nombres);

echo $texto;

Resultado:

Ana, Juan, Lucía

explode()

explode() realiza la operación inversa: separa un string y devuelve un array.

$texto = 'Ana,Juan,Lucía';

$nombres = explode(',', $texto);

array_map()

array_map() permite transformar cada elemento de un array.

$numeros = [1, 2, 3, 4];

$dobles = array_map(function ($numero) {
    return $numero * 2;
}, $numeros);

El resultado será:

[2, 4, 6, 8]

¿Qué es un callback?

En el ejemplo anterior, array_map() recibe una función que PHP ejecutará para cada elemento.

A una función que se entrega a otra función para que sea ejecutada posteriormente se la suele llamar callback.

Más adelante veremos funciones con mayor profundidad.

array_filter()

array_filter() permite conservar únicamente los elementos que cumplen una condición.

$numeros = [1, 2, 3, 4, 5, 6];

$pares = array_filter($numeros, function ($numero) {
    return $numero % 2 === 0;
});

Ejemplo práctico: filtrar productos con stock

$productos = [
    ['nombre' => 'Teclado', 'stock' => 10],
    ['nombre' => 'Mouse', 'stock' => 0],
    ['nombre' => 'Monitor', 'stock' => 5]
];

$disponibles = array_filter($productos, function ($producto) {
    return $producto['stock'] > 0;
});

Ahora $disponibles contiene solamente productos con stock.

Acceso seguro con ??

Cuando una clave puede no existir, podemos usar el operador ??.

$telefono = $persona['telefono'] ?? 'Sin teléfono';

Si la clave no existe o contiene null, se utiliza el valor alternativo.

Arrays y datos de formularios

Cuando trabajemos con formularios veremos variables como:

$_GET
$_POST
$_FILES
$_SESSION

Varias de estas estructuras son arrays asociativos proporcionados por PHP.

Por eso dominar arrays es fundamental antes de avanzar hacia formularios y aplicaciones reales.

Arrays y bases de datos

Cuando consultamos una base de datos desde PHP, es habitual recibir resultados con una estructura similar a:

[
    ['id' => 1, 'nombre' => 'Ana'],
    ['id' => 2, 'nombre' => 'Juan']
]

Luego podemos recorrer esos registros con foreach.

Errores comunes

• olvidar que los arrays indexados comienzan en 0;
• intentar acceder a una clave que no existe;
• confundir índice con valor;
• usar sort() sobre un array asociativo cuando queremos conservar sus claves;
• no diferenciar isset() de array_key_exists();
• crear estructuras multidimensionales innecesariamente complejas;
• modificar un array sin comprender cómo afecta sus índices.

Buenas prácticas

• usar claves descriptivas;
• mantener estructuras consistentes;
• usar foreach para recorrer colecciones;
• comprobar claves opcionales antes de acceder;
• evitar demasiados niveles de anidación;
• utilizar funciones de arrays cuando expresen mejor la intención del código.

Ejercicios

1. crear un array con cinco nombres y recorrerlo;
2. mostrar el tercer elemento de un array indexado;
3. crear un array asociativo con nombre, edad y email;
4. agregar una nueva clave al array;
5. crear un array de productos con nombre, precio y stock;
6. recorrer productos con foreach;
7. contar productos utilizando count();
8. comprobar si existe un valor con in_array();
9. comprobar una clave con array_key_exists();
10. ordenar números ascendente y descendentemente;
11. convertir un array de nombres a texto con implode();
12. convertir un texto separado por comas en array con explode();
13. duplicar números utilizando array_map();
14. filtrar números pares con array_filter();
15. filtrar productos con stock mayor a cero.

Qué aprendimos

• qué es un array;
• arrays indexados;
• arrays asociativos;
• arrays multidimensionales;
• clave y valor;
• recorrido con foreach;
• count();
• in_array();
• array_key_exists();
• isset();
• ordenamiento;
• array_merge();
• implode() y explode();
• array_map() y array_filter();
• callbacks;
• relación de los arrays con formularios y bases de datos.

¿Qué sigue?

En la próxima guía veremos funciones en PHP: cómo crear nuestras propias funciones, parámetros, valores de retorno, alcance de variables y tipado.

¿Te sirvió esta guía? ☕

Si este contenido te ayudó y querés apoyar a Club Programador, podés colaborar mediante:

☕ Apoyar con Mercado Pago

🌎 Apoyar con PayPal

Muchas tareas de programación requieren repetir instrucciones: mostrar una lista, recorrer productos, sumar valores, buscar un dato o ejecutar una acción varias veces.

En PHP estas repeticiones se realizan mediante bucles. En esta guía vamos a aprender cómo funcionan for, while, do while y foreach, cuándo conviene usar cada uno y cómo controlar su ejecución.

¿Qué es un bucle?

Un bucle es una estructura que permite ejecutar un bloque de código varias veces.

Por ejemplo, si queremos mostrar los números del 1 al 5, podríamos escribir:

echo 1;
echo 2;
echo 3;
echo 4;
echo 5;

Pero eso es repetitivo. Un bucle permite expresar la misma idea de forma más compacta y flexible.

Dos formas comunes de repetir

Podemos pensar los bucles de dos maneras principales:

• por cantidad: repetir un número conocido de veces;
• por condición: repetir mientras algo siga siendo verdadero.

Por ejemplo:

• mostrar del 1 al 10 → cantidad conocida;
• seguir leyendo hasta encontrar un dato → depende de una condición.

El bucle for

for es ideal cuando sabemos cuántas veces queremos repetir algo.

for ($i = 1; $i <= 5; $i++) {
    echo $i;
}

Este bucle muestra:

12345

Las tres partes del for

La estructura general es:

for (inicialización; condición; actualización) {
    // instrucciones
}

En:

for ($i = 1; $i <= 5; $i++)

tenemos:

• $i = 1: valor inicial;
• $i <= 5: condición para seguir;
• $i++: incremento después de cada vuelta.

¿Qué es una iteración?

Cada repetición completa del bucle se denomina iteración.

En un for del 1 al 5 hay cinco iteraciones.

Mostrar números del 1 al 10

for ($i = 1; $i <= 10; $i++) {
    echo $i . ' ';
}

Contar hacia atrás

for ($i = 10; $i >= 1; $i--) {
    echo $i . ' ';
}

En este caso utilizamos $i-- para disminuir el contador.

Tabla de multiplicar

$numero = 7;

for ($i = 1; $i <= 10; $i++) {
    $resultado = $numero * $i;
    echo "$numero x $i = $resultado" . '
';
}

El contador cambia en cada iteración y permite calcular una fila diferente.

Contadores y acumuladores

Un contador normalmente aumenta o disminuye para controlar repeticiones.

$contador = 0;
$contador++;

Un acumulador guarda un resultado que se va construyendo.

$suma = 0;

for ($i = 1; $i <= 100; $i++) {
    $suma += $i;
}

echo $suma;

En cada vuelta sumamos el valor actual de $i al acumulador.

El bucle while

while repite un bloque mientras una condición sea verdadera.

$i = 1;

while ($i <= 5) {
    echo $i;
    $i++;
}

Antes de cada iteración, PHP evalúa la condición.

¿Cuándo conviene while?

while es útil cuando no sabemos exactamente cuántas repeticiones serán necesarias.

Por ejemplo:

• esperar hasta encontrar un valor;
• procesar datos mientras existan;
• repetir una operación hasta alcanzar una condición.

El peligro de un bucle infinito

Si la condición nunca se vuelve falsa, el bucle puede ejecutarse indefinidamente.

$i = 1;

while ($i <= 5) {
    echo $i;
}

Este ejemplo es incorrecto porque $i nunca cambia.

La versión correcta sería:

$i = 1;

while ($i <= 5) {
    echo $i;
    $i++;
}

do while

do while es parecido a while, pero garantiza que el bloque se ejecute al menos una vez.

$i = 1;

do {
    echo $i;
    $i++;
} while ($i <= 5);

Diferencia entre while y do while

Con while la condición se evalúa antes de ejecutar el bloque.

Con do while la condición se evalúa después.

while → evalúa → ejecuta

do while → ejecuta → evalúa

Por eso do while siempre ejecuta al menos una iteración.

Ejemplo donde do while ejecuta una vez

$numero = 10;

do {
    echo 'Se ejecutó una vez';
} while ($numero < 5);

Aunque la condición sea falsa desde el principio, el bloque se ejecuta una vez.

foreach

foreach está diseñado especialmente para recorrer arrays y estructuras iterables.

$nombres = ['Ana', 'Juan', 'Lucía'];

foreach ($nombres as $nombre) {
    echo $nombre . '
';
}

En cada iteración, $nombre toma el valor de un elemento del array.

¿Qué significa as?

La palabra as indica qué variable utilizar para representar el elemento actual.

foreach ($nombres as $nombre)

Puede leerse como:

“por cada elemento de $nombres, guardalo temporalmente en $nombre”.

foreach con clave y valor

También podemos obtener la clave de cada elemento.

$persona = [
    'nombre' => 'Ana',
    'edad' => 25,
    'ciudad' => 'Santa Rosa'
];

foreach ($persona as $clave => $valor) {
    echo $clave . ': ' . $valor . '
';
}

En cada vuelta:

• $clave recibe la clave;
• $valor recibe el contenido.

Recorrer productos

$productos = [
    ['nombre' => 'Teclado', 'precio' => 25000],
    ['nombre' => 'Mouse', 'precio' => 15000],
    ['nombre' => 'Monitor', 'precio' => 180000]
];

foreach ($productos as $producto) {
    echo $producto['nombre'] . ' - $' . $producto['precio'] . '
';
}

Este tipo de estructura es muy común al trabajar con resultados de bases de datos o APIs.

break

break permite finalizar un bucle antes de que termine normalmente.

for ($i = 1; $i <= 10; $i++) {
    if ($i === 5) {
        break;
    }

    echo $i . ' ';
}

Resultado:

1 2 3 4

Buscar un valor con break

$numeros = [3, 8, 12, 20, 25];
$buscado = 12;

foreach ($numeros as $numero) {
    if ($numero === $buscado) {
        echo 'Encontrado';
        break;
    }
}

Una vez encontrado el valor, no tiene sentido seguir recorriendo el array.

continue

continue salta la iteración actual y pasa a la siguiente.

for ($i = 1; $i <= 10; $i++) {
    if ($i === 5) {
        continue;
    }

    echo $i . ' ';
}

Resultado:

1 2 3 4 6 7 8 9 10

Ejemplo: mostrar solo números pares

for ($i = 1; $i <= 20; $i++) {
    if ($i % 2 !== 0) {
        continue;
    }

    echo $i . ' ';
}

Los números impares se saltan y solamente se muestran los pares.

Bucles anidados

Un bucle puede contener otro bucle.

for ($fila = 1; $fila <= 3; $fila++) {
    for ($columna = 1; $columna <= 3; $columna++) {
        echo "($fila,$columna) ";
    }

    echo '
';
}

Por cada iteración del bucle exterior, el bucle interior se ejecuta completo.

¿Cuántas veces se ejecuta un bucle anidado?

Si el bucle exterior se ejecuta 3 veces y el interior 4 veces, el bloque interior se ejecuta:

3 × 4 = 12 veces

Esto es importante porque los bucles anidados pueden aumentar rápidamente el trabajo realizado.

for, while, do while o foreach

Una guía rápida:

• for: cuando tenemos un contador o cantidad conocida;
• while: cuando repetimos mientras una condición sea verdadera;
• do while: cuando necesitamos ejecutar al menos una vez;
• foreach: cuando recorremos arrays u objetos iterables.

Ejemplo completo: total de una compra

$productos = [
    ['nombre' => 'Teclado', 'precio' => 25000, 'cantidad' => 2],
    ['nombre' => 'Mouse', 'precio' => 15000, 'cantidad' => 1],
    ['nombre' => 'Monitor', 'precio' => 180000, 'cantidad' => 1]
];

$total = 0;

foreach ($productos as $producto) {
    $subtotal = $producto['precio'] * $producto['cantidad'];
    $total += $subtotal;

    echo $producto['nombre'] . ' - $' . $subtotal . '
';
}

echo 'Total: $' . $total;

En este ejemplo usamos:

• un array de productos;
• foreach para recorrerlo;
• una variable $subtotal;
• un acumulador $total.

Errores comunes

• crear un bucle infinito;
• olvidar incrementar el contador en un while;
• usar for cuando foreach sería más claro;
• confundir break con continue;
• modificar accidentalmente variables de control;
• crear demasiados niveles de bucles anidados;
• usar nombres poco descriptivos para los elementos recorridos.

Buenas prácticas

• usar nombres claros como $producto en lugar de $x;
• mantener simple la condición del bucle;
• evitar trabajo innecesario dentro de cada iteración;
• usar break cuando ya no sea necesario continuar;
• preferir foreach para recorrer arrays.

Ejercicios

1. mostrar los números del 1 al 20 con for;
2. mostrar los números del 20 al 1;
3. sumar los números del 1 al 100;
4. mostrar una tabla de multiplicar;
5. resolver los ejercicios anteriores utilizando while;
6. crear un ejemplo donde do while se ejecute una sola vez;
7. recorrer un array de nombres con foreach;
8. recorrer un array asociativo mostrando clave y valor;
9. buscar un número y detener el recorrido con break;
10. mostrar únicamente números pares utilizando continue;
11. crear una matriz 3 × 3 mediante bucles anidados;
12. calcular el total de un listado de productos.

Qué aprendimos

• qué es un bucle;
• qué es una iteración;
• cómo funciona for;
• contadores y acumuladores;
• while;
• do while;
• foreach;
• clave y valor;
• break;
• continue;
• bucles anidados;
• cuándo conviene cada estructura.

¿Qué sigue?

En la próxima guía profundizaremos en arrays en PHP: arrays indexados, asociativos, multidimensionales y las funciones más importantes para trabajar con ellos.

¿Te sirvió esta guía? ☕

Si este contenido te ayudó y querés apoyar a Club Programador, podés colaborar mediante:

☕ Apoyar con Mercado Pago

🌎 Apoyar con PayPal

Los programas no siempre ejecutan exactamente las mismas instrucciones. Muchas veces necesitan tomar decisiones según los datos disponibles: permitir o negar acceso, aplicar un descuento, mostrar un mensaje distinto o ejecutar una acción determinada.

En PHP estas decisiones se construyen mediante condicionales. En esta guía vamos a aprender cómo funcionan if, elseif, else, switch, match y el operador ternario.

¿Qué es una condición?

Una condición es una expresión que PHP puede evaluar como verdadera o falsa.

Por ejemplo:

$edad = 20;

$edad >= 18

La expresión $edad >= 18 produce un valor booleano:

true

Ese resultado puede utilizarse para decidir qué bloque de código ejecutar.

Recordatorio: operadores de comparación

Las condiciones suelen construirse con operadores como:

• ==: igualdad flexible;
• ===: igualdad estricta;
• !=: distinto;
• !==: distinto en valor o tipo;
• >: mayor;
• <: menor;
• >=: mayor o igual;
• <=: menor o igual.

La estructura if

if ejecuta un bloque de código solamente cuando una condición es verdadera.

<?php

$edad = 20;

if ($edad >= 18) {
    echo 'Es mayor de edad';
}

PHP evalúa primero:

$edad >= 18

Como el resultado es true, ejecuta el contenido entre llaves.

¿Qué representan las llaves?

Las llaves { } delimitan el bloque de instrucciones que pertenece al condicional.

if ($condicion) {
    echo 'Primera instrucción';
    echo 'Segunda instrucción';
}

Si la condición es falsa, ninguna de esas instrucciones se ejecuta.

if y else

else permite definir qué debe ocurrir cuando la condición del if es falsa.

$edad = 16;

if ($edad >= 18) {
    echo 'Es mayor de edad';
} else {
    echo 'Es menor de edad';
}

Solo uno de los dos bloques será ejecutado.

if, elseif y else

Cuando existen más de dos posibilidades podemos utilizar elseif.

$nota = 8;

if ($nota >= 9) {
    echo 'Excelente';
} elseif ($nota >= 6) {
    echo 'Aprobado';
} else {
    echo 'Desaprobado';
}

PHP evalúa las condiciones de arriba hacia abajo y ejecuta el primer bloque cuya condición sea verdadera.

El orden de las condiciones importa

Este ejemplo está mal planteado:

if ($nota >= 6) {
    echo 'Aprobado';
} elseif ($nota >= 9) {
    echo 'Excelente';
}

Si la nota es 10, la primera condición ya es verdadera y PHP nunca llega al segundo bloque.

Por eso conviene ordenar primero las condiciones más específicas.

Condiciones compuestas

Podemos combinar varias condiciones mediante operadores lógicos.

AND con &&

$edad = 20;
$tieneDocumento = true;

if ($edad >= 18 && $tieneDocumento === true) {
    echo 'Puede ingresar';
}

Ambas condiciones deben ser verdaderas.

OR con ||

$esAdmin = false;
$esSupervisor = true;

if ($esAdmin || $esSupervisor) {
    echo 'Tiene permisos';
}

Alcanza con que una de las dos condiciones sea verdadera.

NOT con !

$bloqueado = false;

if (!$bloqueado) {
    echo 'Usuario habilitado';
}

El operador ! invierte un valor booleano.

Usar paréntesis para expresar la lógica

Cuando combinamos varias condiciones, los paréntesis ayudan a dejar claro el orden de evaluación.

if (($edad >= 18 && $tieneDocumento) || $esAdmin) {
    echo 'Acceso permitido';
}

La intención resulta mucho más clara que en una expresión larga sin agrupación visual.

Comparación estricta dentro de condicionales

Cuando queremos comparar no solo el valor sino también el tipo, utilizamos ===.

$estado = '1';

if ($estado === 1) {
    echo 'Activo';
}

Este bloque no se ejecuta porque '1' es un string y 1 es un entero.

Valores truthy y falsy

PHP puede interpretar ciertos valores como verdaderos o falsos incluso si no son booleanos explícitos.

Por ejemplo, estos valores suelen evaluarse como falsos:

• false;
• 0;
• 0.0;
• '';
• '0';
• null;
• un array vacío.

Ejemplo:

$nombre = '';

if ($nombre) {
    echo 'Hay un nombre';
} else {
    echo 'El nombre está vacío';
}

Esto puede ser útil, pero también puede generar confusión. Cuando el tipo importa, conviene escribir condiciones explícitas.

switch

switch resulta útil cuando queremos comparar una misma variable contra varios valores posibles.

$estado = 'pendiente';

switch ($estado) {
    case 'pendiente':
        echo 'Pedido pendiente';
        break;

    case 'pagado':
        echo 'Pedido pagado';
        break;

    case 'cancelado':
        echo 'Pedido cancelado';
        break;

    default:
        echo 'Estado desconocido';
}

¿Para qué sirve break?

break detiene la ejecución del switch una vez encontrada una coincidencia.

Si lo omitimos, PHP puede continuar ejecutando los siguientes casos. Este comportamiento se denomina fall-through.

default

default funciona como un caso alternativo cuando ningún case coincide.

Es comparable al else de una estructura if.

¿Cuándo conviene switch?

Puede ser más legible que muchos elseif cuando comparamos una misma variable contra valores concretos.

Por ejemplo, estados como:

pendiente
pagado
cancelado
enviado

son un buen caso de uso.

match en PHP moderno

Desde PHP 8 existe match, una expresión más moderna para resolver ciertos casos similares a switch.

$estado = 'pagado';

$mensaje = match ($estado) {
    'pendiente' => 'Pedido pendiente',
    'pagado' => 'Pedido pagado',
    'cancelado' => 'Pedido cancelado',
    default => 'Estado desconocido',
};

echo $mensaje;

match devuelve un valor, por eso podemos asignar directamente su resultado a una variable.

Diferencias importantes entre switch y match

match tiene algunas ventajas:

• utiliza comparación estricta;
• no necesita break;
• devuelve un valor;
• suele ser más compacto.

Para código PHP moderno suele ser una alternativa muy clara cuando necesitamos mapear un valor a otro.

Operador ternario

El operador ternario permite expresar una decisión simple en una sola expresión.

$edad = 20;

$mensaje = $edad >= 18 ? 'Mayor de edad' : 'Menor de edad';

echo $mensaje;

Su estructura es:

condición ? valor_si_true : valor_si_false

¿Cuándo usar el ternario?

Conviene utilizarlo para decisiones breves y fáciles de leer.

Si la condición se vuelve compleja, un if suele ser más claro.

Ternario corto

PHP también permite:

$nombreMostrado = $nombre ?: 'Sin nombre';

Si $nombre es evaluado como verdadero, se utiliza su valor. De lo contrario, se utiliza 'Sin nombre'.

Ternario corto vs operador ??

No hacen exactamente lo mismo.

$valor = $nombre ?: 'Sin nombre';
$valor = $nombre ?? 'Sin nombre';

?: utiliza el valor alternativo cuando el primero es falsy.

?? utiliza el alternativo solamente cuando la variable no existe o es null.

Ejemplo: sistema de descuentos

$total = 150000;
$esClientePremium = true;

if ($esClientePremium && $total >= 100000) {
    $descuento = 20;
} elseif ($total >= 100000) {
    $descuento = 10;
} else {
    $descuento = 0;
}

echo "Descuento: $descuento%";

Acá combinamos una condición numérica con una condición booleana.

Ejemplo: permisos de usuario

$rol = 'admin';
$activo = true;

if ($activo && $rol === 'admin') {
    echo 'Acceso completo';
} elseif ($activo && $rol === 'editor') {
    echo 'Acceso de edición';
} else {
    echo 'Acceso limitado';
}

Errores comunes

• confundir = con == o ===;
• ordenar mal los elseif;
• olvidar break dentro de un switch;
• escribir condiciones demasiado largas;
• abusar del operador ternario;
• no tener en cuenta los valores truthy y falsy;
• usar comparaciones flexibles cuando el tipo importa.

Ejercicios

1. determinar si una persona es mayor de edad;
2. indicar si un número es positivo, negativo o cero;
3. clasificar una nota como desaprobada, aprobada o excelente;
4. determinar si un número es par utilizando %;
5. crear un sistema de descuento según importe;
6. mostrar un mensaje diferente según el rol del usuario;
7. resolver un estado de pedido con switch;
8. reescribir ese mismo ejemplo utilizando match;
9. mostrar “Activo” o “Inactivo” mediante un ternario;
10. comparar el comportamiento de ?: y ??.

Qué aprendimos

• qué es una condición;
• cómo funciona if;
• else y elseif;
• condiciones compuestas;
• operadores lógicos;
• truthy y falsy;
• switch y break;
• match;
• operador ternario;
• diferencias entre ?: y ??.

¿Qué sigue?

En la próxima guía veremos bucles en PHP: for, while, do while y foreach, para repetir instrucciones de forma controlada.

¿Te sirvió esta guía? ☕

Si este contenido te ayudó y querés apoyar a Club Programador, podés colaborar mediante:

☕ Apoyar con Mercado Pago

🌎 Apoyar con PayPal

En PHP, casi cualquier programa necesita guardar valores, operar con ellos y tomar decisiones a partir de esos datos. Para eso utilizamos variables, tipos de datos y operadores.

Esta guía parte desde cero y explica no solo la sintaxis, sino también qué representa cada concepto y por qué PHP se comporta de determinada manera.

¿Qué es una variable?

Una variable es un nombre que utilizamos para referirnos a un valor durante la ejecución de un programa.

Por ejemplo, en vez de escribir el nombre de una persona muchas veces podemos guardarlo una sola vez:

<?php

$nombre = 'Ana';

echo $nombre;

En este ejemplo:

• $nombre es la variable;
• = es el operador de asignación;
• 'Ana' es el valor almacenado.

¿Por qué las variables comienzan con $?

En PHP todas las variables comienzan con el símbolo $.

$nombre
$edad
$precio
$activo

El símbolo forma parte de la sintaxis del lenguaje y permite identificar rápidamente una variable.

Asignar un valor

El operador = asigna el valor de la derecha a la variable de la izquierda.

$edad = 25;

No significa “es igual a” en el sentido matemático. Significa:

guardá el valor 25 dentro de la variable $edad.

Reglas para nombrar variables

Un nombre de variable:

• debe comenzar con $;
• después del símbolo debe comenzar con una letra o guion bajo;
• puede contener números después del primer carácter;
• no puede contener espacios;
• distingue mayúsculas y minúsculas.

Ejemplos válidos:

$nombre
$nombreCompleto
$_usuario
$precio2

Ejemplos incorrectos:

$2precio
$nombre completo

PHP distingue mayúsculas y minúsculas en variables

Estas dos variables son diferentes:

$nombre = 'Ana';
$Nombre = 'Juan';

Por claridad, suele utilizarse camelCase:

$nombreCompleto
$precioFinal
$cantidadProductos

¿Qué es un tipo de dato?

El tipo indica qué clase de información representa un valor.

No es lo mismo guardar:

25
'25'
true
25.50

Aunque algunos valores parezcan similares, PHP puede tratarlos de manera diferente.

Tipos de datos básicos en PHP

String

Un string representa texto.

$nombre = 'Ana';
$ciudad = "Santa Rosa";

Integer

Un int representa números enteros.

$edad = 25;
$cantidad = 10;

Float

Un float representa números con decimales.

$precio = 1250.50;
$altura = 1.78;

Boolean

Un bool solo puede representar verdadero o falso.

$activo = true;
$bloqueado = false;

Los booleanos son fundamentales para condiciones que veremos en la próxima guía.

NULL

null representa ausencia de valor.

$telefono = null;

No significa cero ni una cadena vacía. Significa que la variable no posee actualmente un valor útil.

Array

Un array permite almacenar varios valores dentro de una misma variable.

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

Más adelante dedicaremos una guía completa a arrays.

PHP tiene tipado dinámico

En PHP no necesitamos declarar de antemano el tipo de una variable en los casos simples.

$dato = 10;
$dato = 'Ahora soy texto';

La misma variable primero contiene un entero y luego un string.

Esto se conoce como tipado dinámico: el tipo está asociado al valor en tiempo de ejecución.

¿Qué significa que PHP tenga coerción de tipos?

PHP puede convertir automáticamente ciertos valores cuando una operación lo requiere.

$numero = '10';
$resultado = $numero + 5;

echo $resultado;

En este caso PHP puede interpretar el string '10' como número y producir:

15

Esta flexibilidad puede ser útil, pero también producir errores difíciles de detectar. Por eso conviene entender siempre con qué tipos estamos trabajando.

Funciones incorporadas de PHP

PHP incluye una gran cantidad de funciones listas para usar. Estas funciones forman parte del propio lenguaje o de sus extensiones estándar y permiten realizar tareas frecuentes sin tener que programarlas desde cero.

Algunos ejemplos son:

• var_dump(): permite inspeccionar una variable y ver su tipo y valor;
• gettype(): devuelve el tipo de dato de una variable;
• strlen(): obtiene la longitud de un texto;
• count(): cuenta los elementos de un array;
• date(): permite trabajar con fechas y formatos de fecha.

Estas son funciones propias de PHP y podemos utilizarlas directamente. Más adelante también veremos cómo crear nuestras propias funciones mediante la palabra clave function.

Podés consultar muchas más funciones y su documentación en el Manual oficial de PHP: referencia de funciones.

var_dump()

var_dump() muestra el tipo y el valor de una variable.

$edad = 25;

var_dump($edad);

El resultado será similar a:

int(25)

Con un string:

$nombre = 'Ana';
var_dump($nombre);

podríamos obtener:

string(3) "Ana"

gettype()

gettype() devuelve el nombre del tipo.

$precio = 1500.50;

echo gettype($precio);

Resultado:

double

En PHP, los valores que normalmente llamamos float pueden aparecer como double en ciertas funciones históricas.

Conversión explícita de tipos

También podemos indicar manualmente el tipo que queremos.

$texto = '25';
$edad = (int) $texto;

Otros casts habituales son:

(int)
(float)
(string)
(bool)
(array)

Strings: comillas simples y dobles

PHP permite escribir strings con comillas simples o dobles.

$nombre = 'Ana';

echo 'Hola $nombre';

Con comillas simples, PHP muestra literalmente:

Hola $nombre

En cambio:

echo "Hola $nombre";

produce:

Hola Ana

Interpolación de variables

La posibilidad de incluir una variable dentro de un string con comillas dobles se llama interpolación.

$nombre = 'Ana';
$edad = 25;

echo "$nombre tiene $edad años";

Concatenación con .

PHP utiliza el punto . para unir strings.

$nombre = 'Ana';

echo 'Hola ' . $nombre;

Resultado:

Hola Ana

Operadores aritméticos

Permiten realizar cálculos.

• + suma;
• - resta;
• * multiplicación;
• / división;
• % resto;
• ** potencia.

$a = 10;
$b = 3;

echo $a + $b;
echo $a - $b;
echo $a * $b;
echo $a / $b;
echo $a % $b;
echo $a ** $b;

El operador módulo %

El operador módulo devuelve el resto de una división.

10 % 3

devuelve:

1

Es muy útil, por ejemplo, para comprobar si un número es par:

$numero = 8;

$resto = $numero % 2;

Si el resto es cero, el número es divisible por 2.

Operadores de asignación

Podemos combinar una operación con la asignación.

$numero = 10;

$numero += 5;

Es equivalente a:

$numero = $numero + 5;

También existen:

+=
-=
*=
/=
%=

Incremento y decremento

$contador = 1;

$contador++;
$contador--;

++ aumenta en uno y -- disminuye en uno.

Operadores de comparación

Los operadores de comparación producen un valor booleano: true o false.

== igualdad flexible

var_dump(10 == '10');

Puede devolver true porque PHP convierte tipos para comparar.

=== igualdad estricta

var_dump(10 === '10');

Devuelve false porque uno es entero y el otro string.

Por qué suele preferirse ===

La comparación estricta exige que coincidan valor y tipo.

Esto evita resultados inesperados producidos por conversiones automáticas.

Otros operadores de comparación

• !=: distinto;
• !==: distinto en valor o tipo;
• >: mayor;
• <: menor;
• >=: mayor o igual;
• <=: menor o igual.

Operador spaceship <=>

El operador <=> compara dos valores y devuelve:

• -1 si el primero es menor;
• 0 si son equivalentes;
• 1 si el primero es mayor.

$resultado = 10  20;

echo $resultado;

Resultado:

-1

Operadores lógicos

Permiten combinar condiciones booleanas.

• &&: AND;
• ||: OR;
• !: NOT.

$mayorDeEdad = true;
$tienePermiso = false;

$puedeEntrar = $mayorDeEdad && $tienePermiso;

El resultado será false porque ambas condiciones deberían ser verdaderas.

Operador ??

El operador de coalescencia nula ?? permite usar un valor alternativo cuando una variable o clave no existe o contiene NULL.

$nombre = null;

echo $nombre ?? 'Sin nombre';

Resultado:

Sin nombre

Más adelante resulta especialmente útil al trabajar con formularios.

Precedencia de operadores

PHP no evalúa todas las operaciones simplemente de izquierda a derecha. Algunos operadores tienen mayor prioridad.

$resultado = 2 + 3 * 4;

El resultado es:

14

porque primero se realiza la multiplicación.

Si queremos cambiar el orden usamos paréntesis:

$resultado = (2 + 3) * 4;

Ahora el resultado es:

20

Ejemplo completo

<?php

$nombre = 'Ana';
$edad = 25;
$precio = 1250.50;
$cantidad = 3;
$activo = true;

$total = $precio * $cantidad;

echo "Cliente: $nombre" . '\n';
echo "Edad: $edad" . '\n';
echo "Total: $total";

En este ejemplo:

1. creamos variables de distintos tipos;
2. multiplicamos precio por cantidad;
3. guardamos el resultado en otra variable;
4. mostramos los valores mediante echo.

Buenas prácticas iniciales

• usar nombres descriptivos;
• evitar variables como $x salvo casos muy simples;
• preferir comparaciones estrictas cuando corresponda;
• usar paréntesis cuando una expresión pueda resultar ambigua;
• comprobar tipos con var_dump() durante el aprendizaje y depuración.

Ejercicios

1. crear variables para nombre, edad y ciudad y mostrarlas;
2. calcular el área de un rectángulo;
3. calcular el total de una compra usando precio y cantidad;
4. convertir un string numérico a entero;
5. comparar 10 == '10' y 10 === '10';
6. comprobar el resto de dividir un número por 2;
7. usar ?? para mostrar un valor alternativo;
8. crear una expresión que combine operadores aritméticos y paréntesis.

Qué aprendimos

• qué es una variable;
• cómo funciona $;
• qué son los tipos de datos;
• strings, enteros, floats, booleanos, NULL y arrays;
• tipado dinámico y coerción;
• var_dump() y gettype();
• concatenación e interpolación;
• operadores aritméticos;
• operadores de comparación;
• operadores lógicos;
• ??;
• precedencia de operadores.

¿Qué sigue?

En la próxima guía veremos condicionales en PHP: if, elseif, else, switch y operadores ternarios.

¿Te sirvió esta guía? ☕

Si este contenido te ayudó y querés apoyar a Club Programador, podés colaborar mediante:

☕ Apoyar con Mercado Pago

🌎 Apoyar con PayPal