Si quieres meterte de lleno al desarrollo web y no sabes por dónde empezar, este curso es para ti. Vamos a ver PHP desde lo más básico hasta tener las herramientas suficientes para armar tus propios sistemas.
Ya sabes los fundamentos basicos puedes ir al Curso Programacion Orientada a Objeto con PHP
Antes de arrancar necesitas tres cosas: una computadora, internet, y un editor de código (yo uso Visual Studio Code, pero cualquiera sirve).
También te recomiendo instalar XAMPP o Laragon para poder correr PHP en tu máquina sin complicarte con un servidor real.
Puedes ver los videos del curso en la Lista de Reproduccion del Curso de PHP.
Lo que vamos a ver
- Lección 0: Qué es PHP y para qué sirve
- Lección 1: Hola Mundo en PHP
- Lección 2: Variables en PHP
- Lección 3: Operaciones matemáticas
- Lección 4: Incremento y decremento
- Lección 5: Cadenas (strings)
- Lección 6: Funciones de cadenas más usadas
- Lección 7: Arrays en PHP
- Lección 8: Arrays asociativos y funciones de arrays
- Lección 9: El ciclo foreach
- Lección 10: IF – ELSE
- Lección 11: Switch case
- Lección 12: Ciclo for
- Lección 13: Ciclo while
- Lección 14: Funciones propias
- Lección 15: Formularios y superglobales
- Lección 16: Manejo de errores con try/catch
- Lección 17: Includes y requires
Lección 0: Qué es PHP y para qué sirve
PHP corre del lado del servidor. Eso quiere decir que, a diferencia de HTML o CSS que el navegador procesa directamente, el código PHP se ejecuta antes en el servidor y lo que le llega al usuario ya es HTML puro. Gracias a eso puedes crear páginas que cambian según quién las visita, qué hora es, o qué hay guardado en una base de datos.
No exagero si te digo que buena parte de internet corre con PHP. WordPress lo usa, y con eso ya estamos hablando de un porcentaje enorme de las páginas que existen.
Facebook también nació sobre PHP en sus primeros años.
Y una de las razones por las que sigue tan vivo es lo fácil (y barato) que resulta conseguir hosting compatible, algo que con otras tecnologías todavía cuesta más trabajo.
Si te preguntas si vale la pena aprenderlo en pleno 2026: sí.
Además, PHP no es el mismo lenguaje de hace quince años: las versiones modernas (a partir de PHP 8) son bastante más rápidas y tienen características que antes solo veías en lenguajes como Java o C#.
Lección 1: Hola Mundo en PHP
Todo curso de programación empieza igual, y no es por flojera: el “Hola Mundo” te sirve para confirmar que tu entorno está bien configurado antes de meterte en cosas más complicadas.
Un archivo PHP siempre lleva la extensión .php, y el código va entre <?php y ?>. Un detalle que casi nadie te dice al inicio: si tu archivo es solamente PHP (sin mezclar HTML), es buena idea no cerrar la etiqueta al final. Evita espacios en blanco que a veces rompen cosas de forma silenciosa.
<?php echo "¡Hola Mundo! Este es mi primer script en PHP."; ?>
Y sí, puedes combinar PHP con HTML sin problema, cosa que harás todo el tiempo en proyectos reales:
<!DOCTYPE html> <html> <body> <h1><?php echo "Título generado con PHP"; ?></h1> </body> </html>
Si usas XAMPP o Laragon, tu archivo debe guardarse dentro de la carpeta htdocs (o www en Laragon) para poder verlo en el navegador entrando a algo como localhost/saludo.php. Si intentas abrirlo haciendo doble clic desde tu explorador de archivos, el navegador solo te va a mostrar el código en crudo, no el resultado, porque necesita pasar primero por el servidor.
Los errores más comunes al empezar suelen ser tontos pero frustrantes: olvidar el punto y coma al final de una línea, guardar el archivo con extensión .txt sin querer, o dejar el servidor de Apache apagado en el panel de XAMPP. Si algo no funciona, revisa primero esas tres cosas antes de sospechar de tu código.
Prueba crear un archivo saludo.php con tu nombre y la frase “estoy aprendiendo PHP”. Suena básico, pero es tu primera confirmación real de que todo funciona.
Lección 2: Variables en PHP
Piensa en las variables como cajas donde guardas información. En PHP no tienes que decirle de antemano si esa caja va a guardar texto, un número o algo más, el lenguaje lo descubre solo. Lo único que sí es obligatorio es empezar el nombre con $.
<?php $nombre_usuario = "Agustín"; // String $puntos = 100; // Integer $activo = true; // Boolean $precio = 19.99; // Float echo "El usuario $nombre_usuario tiene $puntos puntos.";
Una recomendación que te va a ahorrar dolores de cabeza más adelante: elige una convención de nombres (camelCase o snake_case) y quédate con ella todo el proyecto. Mezclar estilos hace que el código sea un caos de leer.
También hay reglas que sí o sí debes respetar: el nombre no puede empezar con número, y PHP distingue mayúsculas de minúsculas, así que $Nombre y $nombre son dos variables completamente distintas aunque se vean parecidas.
Si en algún momento no estás seguro de qué tipo de dato tiene una variable (algo que pasa más seguido de lo que crees, sobre todo cuando el valor viene de un formulario), puedes usar var_dump() para inspeccionarla:
<?php $edad = "25"; var_dump($edad); // te muestra: string(2) "25"
Y si necesitas un valor que jamás va a cambiar durante la ejecución, como el nombre de tu empresa o una tasa fija, existe define() o la palabra const, que crean constantes en lugar de variables normales:
<?php
define("NOMBRE_SITIO", "Mi Blog de PHP");
echo NOMBRE_SITIO; // sin el símbolo $
Como práctica, crea tres variables (edad, ciudad, profesión) y arma una sola oración que las use a todas con comillas dobles.
Lección 3: Operaciones matemáticas en PHP
Las operaciones básicas ya las conoces de la primaria: suma, resta, multiplicación, división. Lo que sí te interesa aprender aquí es el operador módulo (%), que te da el residuo de una división. Suena poco útil hasta que necesitas saber si un número es par o impar, y ahí se vuelve tu mejor amigo.
<?php $total = (5 + 5) * 2; // 20 $es_par = 10 % 2; // 0, porque la división es exacta $potencia = 2 ** 3; // 8
PHP respeta el orden habitual de las operaciones (primero multiplicación y división, luego suma y resta), pero cuando la expresión se pone larga, mejor usa paréntesis aunque no sean estrictamente necesarios. Le hace la vida más fácil a quien lea tu código después, incluyéndote a ti mismo dentro de unos meses.
Un detalle que sorprende a algunos: dividir dos enteros en PHP no siempre te da un entero. 7 / 2 te devuelve 3.5, un float. Si lo que quieres es una división entera de verdad, existe la función intdiv():
<?php echo intdiv(7, 2); // 3, sin decimales
Hay algo más que te va a simplificar la vida: los operadores de asignación combinada. En vez de escribir $saldo = $saldo + 50, puedes hacer esto:
<?php $saldo = 100; $saldo += 50; // ahora vale 150 $saldo -= 20; // ahora vale 130
Intenta esto: escribe un script que revise si un número guardado en una variable es par o impar usando el módulo.
Lección 4: Incremento y decremento
Nada del otro mundo, pero se usan tanto que merecen su propia lección. ++ suma uno, -- resta uno. Los vas a ver constantemente en contadores dentro de ciclos.
<?php $contador = 1; $contador++; // vale 2 $contador--; // vuelve a valer 1
Aquí hay un detalle que confunde a mucha gente al principio: no es lo mismo $contador++ que ++$contador. El primero usa el valor actual y luego suma; el segundo suma primero y luego usa el valor.
<?php $a = 5; echo $a++; // imprime 5, y ya después $a vale 6 echo ++$a; // ahora sí suma antes: $a vale 7 e imprime 7
En la práctica, la diferencia rara vez importa cuando el incremento va solo en su propia línea (como en un ciclo for), pero se vuelve importante en el momento en que mezclas el incremento con otra operación en la misma línea, como en los ejemplos de arriba. Si tienes dudas, lo más seguro es separar el incremento en una línea aparte.
Practica creando un contador que arranque en 10 y aplícale tres decrementos antes de mostrarlo.
Lección 5: Cadenas (strings) en PHP
Una cadena es simplemente texto. Lo interesante viene cuando entiendes la diferencia entre comillas simples y dobles: las simples (' ') son un poco más rápidas pero no interpretan variables dentro; las dobles (" ") sí las interpretan, y por eso las verás mucho más seguido.
<?php $curso = "PHP"; echo 'Bienvenido al curso de ' . $curso; // hay que concatenar con el punto echo "Bienvenido al curso de $curso"; // aquí la variable se inserta sola
El punto (.) es el operador para unir textos. Vas a usarlo todo el tiempo, así que acostúmbrate desde ya.
Si alguna vez necesitas escribir un bloque de texto largo, con saltos de línea y comillas mezcladas, pelearte con comillas dobles se vuelve incómodo. Para esos casos existe la sintaxis heredoc, que te deja escribir texto multilínea de forma más cómoda:
<?php $mensaje = <<<TEXTO Hola, este es un texto largo que puede tener "comillas" sin problema y ocupar varias líneas. TEXTO; echo $mensaje;
No la vas a usar todos los días, pero es bueno saber que existe para cuando te topes con un correo electrónico o una plantilla de texto que armar dentro de tu código.
Junta tu nombre y apellido en una variable llamada $nombreCompleto usando el operador de concatenación.
Lección 6: Funciones de cadenas más usadas
PHP trae un montón de funciones ya listas para trabajar con texto, y conocer las más comunes te va a ahorrar mucho código.
<?php
$texto = "Aprendiendo PHP";
echo strlen($texto); // 15, cuenta los caracteres
echo strtoupper($texto); // APRENDIENDO PHP
echo strtolower($texto); // aprendiendo php
echo str_replace("PHP", "JS", $texto); // Aprendiendo JS
echo trim(" hola "); // "hola", sin los espacios sobrantes
$partes = explode(" ", $texto); // ["Aprendiendo", "PHP"]
$union = implode("-", $partes); // "Aprendiendo-PHP"
Presta especial atención a explode() e implode(). Son el puente entre el mundo de los textos y el de los arrays, que es justo lo que sigue.
Otras que vas a usar seguido en proyectos reales: substr() para recortar una parte de un texto, ucfirst() para poner en mayúscula la primera letra, y str_contains() (disponible desde PHP 8) para saber si un texto contiene cierta palabra sin tener que lidiar con posiciones de índice.
<?php
echo substr("Programación", 0, 4); // "Prog"
echo ucfirst("hola mundo"); // "Hola mundo"
var_dump(str_contains("Aprendiendo PHP", "PHP")); // true
Toma la frase “El PHP es un lenguaje poderoso”, sepárala en palabras con explode() y cuenta cuántas te quedaron usando count().
Lección 7: Arrays en PHP
Un array guarda varios valores bajo un mismo nombre. Es como una lista: de compras, de usuarios, de lo que sea. Existen de dos tipos: los que usan números como índice (los que vemos aquí) y los asociativos, que usan palabras como clave y los vemos en la siguiente lección.
<?php $frutas = ["Manzana", "Pera", "Uva"]; echo $frutas[1]; // Pera, porque el conteo arranca en 0, no en 1 $frutas[] = "Sandía"; // agrega un elemento al final echo count($frutas); // 4
Para buscar si un valor específico existe dentro del array sin recorrerlo a mano, tienes in_array(), y si además necesitas saber en qué posición está, array_search():
<?php
$frutas = ["Manzana", "Pera", "Uva"];
var_dump(in_array("Pera", $frutas)); // true
echo array_search("Uva", $frutas); // 2, la posición donde está
También vas a encontrarte con arrays dentro de arrays, llamados arrays multidimensionales. Son comunes cuando representas, por ejemplo, una tabla completa de productos:
<?php
$productos = [
["nombre" => "Teclado", "precio" => 350],
["nombre" => "Mouse", "precio" => 180],
];
echo $productos[0]["nombre"]; // TecladoNo te preocupes si por ahora se ve un poco abstracto, lo vas a entender mejor cuando lo combines con foreach un poco más adelante.
Como ejercicio, arma un array con 5 películas y muestra la segunda y la última usando count() para calcular la posición final.
Si quieres saber mas sobre arrays puedes ver esta Guia Exhaustiva de funciones de arrays en PHP.
Lección 8: Arrays asociativos y funciones de arrays
Cuando en vez de números usas palabras como índice, tienes un array asociativo. Es mucho más legible cuando representas algo con varios datos, como un usuario o un producto.
<?php
$usuario = [
"nombre" => "Agustín",
"edad" => 25,
"pais" => "México"
];
echo $usuario["nombre"]; // Agustín
PHP también te da funciones para transformar arrays completos sin escribir un ciclo a mano:
<?php
$numeros = [1, 2, 3, 4, 5];
$dobles = array_map(function($n) {
return $n * 2;
}, $numeros); // [2, 4, 6, 8, 10]
$pares = array_filter($numeros, function($n) {
return $n % 2 === 0;
}); // [2, 4]
$suma = array_sum($numeros); // 15
No te preocupes si array_map y array_filter se ven raros la primera vez, casi todo el mundo tarda un rato en acostumbrarse a pasar funciones como argumento. Con la práctica se vuelve natural.
Otras funciones que te van a servir bastante seguido: array_keys() y array_values() para obtener solo las claves o solo los valores de un array asociativo, y sort() o ksort() para ordenar arrays por valor o por clave.
<?php $usuario = ["nombre" => "Agustín", "edad" => 25]; print_r(array_keys($usuario)); // ["nombre", "edad"] print_r(array_values($usuario)); // ["Agustín", 25]
Crea un array asociativo para un producto (nombre, precio, stock) y arma una oración que use los tres datos.
Lección 9: El ciclo foreach
Si tuviera que elegir el ciclo que más vas a usar en la vida real, sería este. foreach está hecho específicamente para recorrer arrays, y aparece en prácticamente cualquier proyecto donde muestres listas de datos.
<?php
$frutas = ["Manzana", "Pera", "Uva"];
foreach ($frutas as $fruta) {
echo "Me gusta la $fruta <br>";
}
Con arrays asociativos puedes pedir también la clave, no solo el valor:
<?php
$usuario = ["nombre" => "Agustín", "edad" => 25];
foreach ($usuario as $clave => $valor) {
echo "$clave: $valor <br>";
}
Si necesitas modificar los valores originales del array mientras lo recorres (y no solo leerlos), puedes usar una referencia con el símbolo &:
<?php
$numeros = [1, 2, 3];
foreach ($numeros as &$numero) {
$numero = $numero * 10;
}
unset($numero); // buena práctica: rompe la referencia al terminar
print_r($numeros); // [10, 20, 30]
Y como en cualquier ciclo, dentro de un foreach puedes usar break para salir por completo o continue para saltarte una vuelta y seguir con la siguiente.
Toma el array de producto que hiciste en la lección anterior y recórrelo con foreach, imprimiendo cada clave junto a su valor.
Lección 10: Sentencias IF – ELSE
Aquí es donde tu programa empieza a “pensar”. Un if ejecuta código solo si se cumple una condición, por ejemplo: si el usuario inició sesión, muéstrale su panel; si no, mándalo al login.
<?php
$edad = 18;
if ($edad >= 18) {
echo "Eres mayor de edad.";
} elseif ($edad >= 13) {
echo "Eres adolescente.";
} else {
echo "Eres menor de edad.";
}
Un consejo que te va a evitar bugs raros: usa === en vez de == siempre que puedas. La diferencia es que === compara valor y tipo de dato al mismo tiempo, mientras que == a veces hace conversiones que terminan dándote resultados que no esperabas.
Cuando el if es simple y solo decide entre dos valores cortos, el operador ternario te ahorra líneas:
<?php $edad = 20; $mensaje = ($edad >= 18) ? "Mayor de edad" : "Menor de edad"; echo $mensaje;
Y si lo que quieres es asignar un valor solo cuando una variable no existe o es nula, el operador de fusión de null (??) es justo para eso:
<?php $nombre = $_GET["nombre"] ?? "Invitado"; echo "Hola, $nombre";
Escribe una condición que determine si un número es positivo, negativo o cero.
Lección 11: Cómo usar switch case
Cuando necesitas comparar una misma variable contra muchas opciones, escribir un montón de if seguidos se vuelve feo de leer. Ahí es donde entra switch, ideal para menús o roles de usuario.
<?php
$rol = "admin";
switch ($rol) {
case "admin":
echo "Tienes acceso total";
break;
case "editor":
echo "Puedes editar posts";
break;
default:
echo "Eres un suscriptor";
}
No te olvides del break; en cada caso. Si lo quitas, PHP sigue ejecutando los casos de abajo aunque ya no coincidan, algo que a veces se hace a propósito pero que casi siempre es un error de principiante.
Si usas una versión reciente de PHP (8.0 en adelante), existe también match, una alternativa más moderna y compacta que no necesita break y compara siempre con tipo estricto:
<?php
$rol = "admin";
$mensaje = match ($rol) {
"admin" => "Tienes acceso total",
"editor" => "Puedes editar posts",
default => "Eres un suscriptor",
};
echo $mensaje;
Ambas formas son válidas, pero vale la pena que conozcas switch primero porque la vas a encontrar en muchísimo código antiguo que sigue en producción.
Arma un switch que reciba un número del 1 al 7 e imprima el nombre del día de la semana correspondiente.
Lección 12: Ciclo for
Usa for cuando ya sabes de antemano cuántas veces se va a repetir algo. Tiene tres partes: dónde empieza, hasta cuándo sigue, y cómo avanza.
<?php
for ($i = 1; $i <= 10; $i++) {
echo "Estamos en la repetición número $i <br>";
}
También sirve para recorrer un array cuando además del valor necesitas su posición:
<?php
$frutas = ["Manzana", "Pera", "Uva"];
for ($i = 0; $i < count($frutas); $i++) {
echo "Posición $i: $frutas[$i] <br>";
}
Los ciclos for también se pueden anidar, es decir, meter uno dentro de otro. Esto es típico cuando necesitas generar algo con dos dimensiones, como una tabla completa de multiplicar del 1 al 5:
<?php
for ($i = 1; $i <= 5; $i++) {
for ($j = 1; $j <= 5; $j++) {
echo ($i * $j) . " ";
}
echo "<br>";
}
Al igual que con foreach, dentro de un for puedes usar break para cortar el ciclo por completo o continue para saltarte una vuelta específica sin detener todo.
Usa un for para imprimir la tabla del 7, del 1 al 10.
Lección 13: Dominar el ciclo while
while se repite mientras una condición siga siendo verdadera, sin un número fijo de vueltas como el for. Es potente, pero también el ciclo más fácil de romper: si la condición nunca cambia, tu script se queda pegado en un bucle infinito.
<?php
$intentos = 1;
while ($intentos <= 3) {
echo "Intento de conexión #$intentos <br>";
$intentos++;
}
Fíjate que en el ejemplo de arriba, si por accidente olvidas la línea $intentos++;, la condición $intentos <= 3 nunca dejaría de cumplirse y el script se quedaría corriendo para siempre (hasta que el servidor lo mate por tiempo excedido). Es el error más común con este ciclo, así que cada vez que escribas un while, revisa primero que exista algo dentro que eventualmente haga falsa la condición.
Existe una variante, do...while, que garantiza al menos una ejecución antes de revisar la condición:
<?php
$clave = "";
do {
$clave = "1234"; // esto simularía lo que escribe el usuario
} while ($clave !== "1234");
echo "Acceso concedido";
Simula una cuenta regresiva del 5 al 1 usando while.
Lección 14: Funciones propias
Una función es un pedazo de código al que le pones nombre para reutilizarlo cuantas veces quieras, en vez de copiar y pegar la misma lógica por todos lados. Se define con function, puede recibir parámetros, y puede devolver algo con return.
<?php
function saludar($nombre) {
return "Hola, $nombre. Bienvenido al curso.";
}
echo saludar("Agustín");
Los parámetros pueden tener un valor por defecto, así se vuelven opcionales al llamarlos:
<?php
function calcularTotal($precio, $impuesto = 0.16) {
return $precio + ($precio * $impuesto);
}
echo calcularTotal(100); // usa 16% por defecto
echo calcularTotal(100, 0.08); // aquí sí especificamos 8%
Algo que te va a salvar de bugs raros más adelante: las variables que creas dentro de una función no existen fuera de ella. Eso se llama alcance o scope, y básicamente evita que tus funciones se pisen entre sí sin que te des cuenta.
Si trabajas con PHP moderno, también vas a toparte con las funciones flecha (fn), una forma más corta de escribir funciones pequeñas de una sola línea, muy comunes junto con array_map o array_filter:
<?php $doble = fn($n) => $n * 2; echo $doble(5); // 10
Y si quieres reforzar qué tipo de dato espera tu función (algo que ayuda mucho a evitar errores tontos), puedes agregar tipado a los parámetros y al valor de retorno:
<?php
function sumar(int $a, int $b): int {
return $a + $b;
}
Crea una función esPar($numero) que devuelva true o false, y pruébala con tres números distintos.
Lección 15: Formularios y superglobales
Esta es probablemente la lección más importante del curso, porque aquí PHP deja de ser solo teoría y empieza a recibir información real de un usuario. Para eso existen las superglobales: variables especiales que están disponibles en cualquier parte de tu script sin que tengas que declararlas.
$_GETtrae datos que viajan en la URL, comopagina.php?id=5. Son visibles a simple vista, así que nunca los uses para información sensible.$_POSTtrae datos enviados desde un formulario con métodoPOST. Es la opción correcta para logins, registros, o cualquier dato que no quieras que quede expuesto en la URL.$_SESSIONte permite guardar información del usuario mientras navega entre páginas, por ejemplo, si ya inició sesión o no.
<!-- formulario.html -->
<form action="procesar.php" method="POST">
<input type="text" name="nombre">
<button type="submit">Enviar</button>
</form>
<?php // procesar.php $nombre = $_POST["nombre"]; echo "Hola, $nombre. Gracias por escribirnos.";
Antes de usar un dato que viene de $_POST o $_GET, siempre es buena idea confirmar primero que en verdad llegó, con isset(). Si el usuario envía el formulario vacío o entra directo a procesar.php sin pasar por el formulario, tu script va a tronar con un aviso si intentas leer algo que no existe.
<?php
if (isset($_POST["nombre"]) && !empty($_POST["nombre"])) {
$nombre = $_POST["nombre"];
} else {
$nombre = "Invitado";
}
También conviene sanear lo que vas a mostrar de vuelta en pantalla con htmlspecialchars(), para que si alguien escribe código HTML en el campo de texto, no se ejecute tal cual en tu página:
<?php echo htmlspecialchars($nombre);
Para usar sesiones necesitas llamar a session_start() al principio del archivo, antes de imprimir cualquier cosa:
<?php session_start(); $_SESSION["usuario"] = "Agustín"; // en otra página del mismo sitio, con su propio session_start(): echo $_SESSION["usuario"]; // Agustín
Como práctica, arma un formulario HTML con un campo de “edad” y un archivo PHP que lo reciba con $_POST y muestre un mensaje distinto según si es mayor o menor de edad.
Lección 16: Manejo de errores con try/catch
En cualquier proyecto real vas a toparte con errores: un archivo que no aparece, una división entre cero, datos que llegan en un formato que no esperabas. En vez de dejar que tu aplicación se caiga por completo, PHP te deja manejar esto con 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, 0);
} catch (Exception $e) {
echo "Ocurrió un error: " . $e->getMessage();
}
La idea es sencilla: dentro de try va el código que podría fallar, y si algo sale mal, el control salta directo al catch, donde decides qué mostrarle al usuario en lugar de un error técnico feo.
Puedes tener varios bloques catch si esperas distintos tipos de error y quieres tratarlos de forma diferente, y también un bloque finally, que se ejecuta siempre, haya habido error o no (muy útil para cerrar una conexión o liberar un recurso):
<?php
try {
echo dividir(10, 0);
} catch (DivisionByZeroError $e) {
echo "Error específico de división: " . $e->getMessage();
} catch (Exception $e) {
echo "Error general: " . $e->getMessage();
} finally {
echo "<br>Esto se ejecuta siempre, haya fallado o no.";
}
Modifica la función dividir() para que también lance una excepción si alguno de los dos valores que recibe no es numérico.
Lección 17: Includes y requires
Cuando tu proyecto crece, mantener todo en un solo archivo se vuelve un desastre. PHP te deja dividir tu código en varios archivos y unirlos con include o require.
La diferencia entre ambos: si require no encuentra el archivo, detiene toda la ejecución con un error fatal. Si include no lo encuentra, solo muestra una advertencia y sigue corriendo el resto del script.
<?php // header.php echo "<header>Mi Sitio Web</header>";
<?php // index.php require "header.php"; echo "<main>Contenido de la página principal</main>";
En la práctica, para archivos esenciales (como la conexión a la base de datos, que veremos en otro artículo) siempre conviene usar require. Es mejor que la aplicación se detenga a que siga funcionando a medias con errores silenciosos.
También existen require_once e include_once, que hacen exactamente lo mismo pero se aseguran de no volver a cargar el mismo archivo si ya fue incluido antes en la ejecución. Esto evita errores comunes, como declarar la misma función dos veces por accidente.
Un truco útil cuando tu proyecto tiene varias carpetas y las rutas relativas empiezan a complicarse: la constante mágica __DIR__ siempre apunta a la carpeta donde está el archivo actual, sin importar desde dónde se ejecute.
<?php require __DIR__ . "/includes/header.php";
Crea un footer.php sencillo e inclúyelo al final de tu index.php con require.
Para cerrar
Con estas 18 lecciones ya tienes una base sólida de PHP: sintaxis, tipos de datos, estructuras de control, funciones, formularios, manejo de errores y organización de archivos. No es poca cosa, así que si llegaste hasta aquí practicando cada ejercicio, ya puedes armar scripts funcionales por tu cuenta.