PHP: la página que piensa

Cuando entras a israelrivas.org/juegos pasan tres cosas. Tu navegador (Chrome, Safari, el que uses) le pide la página a una computadora que está prendida todo el día en otro lado: el servidor. El servidor arma la página y se la manda. El navegador la pinta.

Con HTML y CSS (curso de HTML y CSS) el servidor solo entrega el archivo tal cual: la página es fija, dice lo mismo a todos y a todas horas. Con PHP, el servidor ejecuta un programa antes de mandar nada. Ese programa escribe el HTML pedazo por pedazo, y puede escribir cosas distintas según quién pregunta, qué día es o qué hay guardado. La sala de juegos y tu tablero los arma PHP antes de mandártelos: por eso tu tablero trae tu nombre y tus estrellas, y el de tu compañero trae las suyas, aunque los dos pidan la misma dirección.

Un archivo PHP termina en .php y es HTML normal con pedazos de programa adentro. Los pedazos van entre <?php y ?>. Lo que está afuera se manda tal cual; lo que está adentro se ejecuta. Para escribir algo desde el programa se usa echo. Mira la página que dice la fecha:

<p>Hoy es <?php echo date("d/m/Y"); ?></p>

Sale (lo que recibe el navegador):
<p>Hoy es 21/10/2026</p>

Fíjate: el navegador nunca ve la palabra echo ni la función date. Recibe un párrafo normal con la fecha ya escrita. Mañana, el mismo archivo, sin tocarlo, dirá otra fecha. Eso es «la página que piensa». date es una función que ya viene en PHP: le dices con letras qué quieres (d día, m mes, Y año, H hora) y te da el texto.

Cómo probarlo. Si guardas hola.php y lo abres con doble clic, el navegador te enseña el código tal cual, o una página vacía: el navegador no entiende PHP, solo el servidor. Necesitas uno de estos dos caminos:

1. Instalar un servidor en tu compu: XAMPP (gratis, para Windows y Mac). Guardas tu archivo en su carpeta htdocs y entras a localhost/hola.php en el navegador. «localhost» quiere decir «el servidor que está en esta misma máquina».
2. Un hosting con PHP (así está israelrivas.org): subes el archivo y entras desde cualquier lado.

Dos reglas de escritura desde hoy: cada instrucción de PHP termina en punto y coma (;), y lo que empieza con // es un comentario, una nota para ti que PHP ignora.

En Python escribías nombre = "Ana". En PHP es casi igual, pero toda variable lleva $ al principio: $nombre = "Ana";. El $ le dice a PHP «esto es una cajita». El signo = no es «igual a»: es «guarda esto aquí».

<?php
$nombre = "Ana";
$edad = 12;
$altura = 1.52;
$tiene_hermanos = true;
$mascota = null;
echo $nombre;
?>

Sale:
Ana

Cada valor tiene un tipo. PHP tiene cinco básicos:

Para ver qué tiene una cajita y de qué tipo es, usa var_dump. Es tu lupa; cada var_dump escribe en su propio renglón:

var_dump($edad);
var_dump($altura);
var_dump($nombre);
var_dump($tiene_hermanos);
var_dump($mascota);

Sale:
int(12)
float(1.52)
string(3) "Ana"
bool(true)
NULL

El 3 de string(3) es cuántas letras tiene. Ojo: "12" entre comillas es texto, no número: var_dump dice string(2) "12". Es la cajita con un papelito que dice «12», no doce cosas.

Comillas dobles y simples no son iguales. Con comillas dobles, PHP busca variables adentro y las cambia por su valor; también entiende \n, que es «cambio de renglón». Con comillas simples escribe todo tal cual:

echo "Hola $nombre\n";
echo 'Hola $nombre';

Sale:
Hola Ana
Hola $nombre

Para pegar textos y variables también está el punto: "Hola " . $nombre . "!" da Hola Ana!. En Python pegabas con +; en PHP el + es solo para sumar, y el punto es para pegar.

PHP convierte solo. Si sumas "3" + 4, PHP ve que "3" parece número y da 7. Y "3" . 4 da 34 (pegó, no sumó). Es cómodo, pero engaña: cuando un formulario te manda "3", tú crees que es número y es texto; con == el 7 y el "7" se ven iguales y con === no (lo ves en la lección de condicionales). Y si el texto no parece número, "hola" + 4, el programa se rompe. Por eso conviene saber siempre de qué tipo es cada cajita: var_dump, y convertir a propósito con (int) o (float) cuando haga falta: (int)"3" es el número 3.

Con números, PHP hace lo mismo que tu calculadora, con estos signos (en la compu no hay tecla ×, por eso el asterisco):

El % no es porcentaje: es el residuo de la división (curso de Divisiones, lección 3). Sirve, por ejemplo, para saber si un número es par: $n % 2 da 0 si es par y 1 si es impar. La división con / te da el resultado exacto, con decimales si hacen falta: 8 / 2 da 4, pero 7 / 2 da 3.5. Si solo quieres el cociente entero, intdiv.

Jerarquía. PHP respeta el orden que ya conoces de mates: primero paréntesis, luego potencias, luego * / %, al final + −. Así que 2 + 3 * 4 da 14, no 20. Si quieres que sume primero, paréntesis: (2 + 3) * 4 da 20.

Funciones que ya vienen. Una función es una orden con nombre: le pasas algo entre paréntesis y te devuelve un resultado. Estas las vas a usar a cada rato:

Las que empiezan con str trabajan con textos (string). Puedes meter una función dentro de otra: round(abs(-2.567), 1) primero quita el signo (2.567) y luego redondea (2.6). PHP resuelve de adentro hacia afuera.

Los decimales van con punto, nunca con coma: 3.5. Si escribes 3,5 PHP lo lee como dos cosas separadas y se confunde. Y fíjate en el tipo del resultado: 10 / 4 es float(2.5), pero 10 / 5 es int(2): si sale exacto, es entero.

<?php
$precio = 48.5;
$cuantos = 3;
$total = $precio * $cuantos;
echo "Total: " . $total . " pesos";
?>

Sale:
Total: 145.5 pesos

Hasta ahora el programa hace todo de arriba abajo. Con if decide. Es igual que en Python, pero con la pregunta entre paréntesis y llaves para el bloque, en vez de los dos puntos y la sangría:

$edad = 12;
if ($edad >= 12) {
    echo "Ya puedes entrar a secundaria";
} else {
    echo "Todavía no";
}

Sale:
Ya puedes entrar a secundaria

Lo que va dentro de los paréntesis es una pregunta que PHP contesta true o false. Las preguntas se hacen con comparadores:

Con más de dos caminos usas elseif, los que quieras. PHP prueba de arriba abajo y entra en el primero que sea true; los demás ya no los mira, aunque también fueran ciertos:

$calif = 8;
if ($calif >= 9) {
    echo "Excelente";
} elseif ($calif >= 7) {
    echo "Bien";
} elseif ($calif >= 6) {
    echo "Pasaste";
} else {
    echo "A estudiar";
}

Sale:
Bien

8 ≥ 9 es false; 8 ≥ 7 es true: entra ahí e imprime Bien. Ya no pregunta si 8 ≥ 6 (que también sería true). Por eso el orden de los elseif importa: del más exigente al menos.

== contra ===. Esta es la trampa famosa de PHP. Dos iguales comparan el valor y convierten los tipos si hace falta: 7 == "7" es true. Tres iguales comparan valor y tipo: 7 === "7" es false, porque uno es int y el otro string. Como los formularios te mandan todo como texto, decide con calma cuál usas. Lo más seguro: convierte primero lo que necesites con (int) y compara con ===.

Juntar preguntas. && es «y» (las dos tienen que ser true), || es «o» (basta una), ! es «no» (voltea el resultado):

$edad = 13;
$tiene_permiso = true;
if ($edad >= 12 && $tiene_permiso) {
    echo "Pasas";
}
if ($edad < 12 || !$tiene_permiso) {
    echo "No pasas";
}

Sale:
Pasas

El operador ternario es un if de una sola línea: $msj = $edad >= 12 ? "grande" : "chico"; se lee «¿edad ≥ 12? entonces grande; si no, chico». Por ahora quédate con la idea, para que cuando lo veas en código ajeno sepas qué es.

Las llaves no son adorno. PHP deja escribir un if sin llaves cuando el bloque es una sola línea, pero el día que agregas una segunda línea creyendo que está adentro, no lo está, y no hay ningún error que te avise. Ponlas siempre.

Sigue el programa con la mano. Antes de correrlo, haz una tabla: cada variable con su valor, y en cada pregunta escribe true o false. Así encuentras errores sin computadora, y así te lo voy a pedir en el examen.

En Python escribías for i in range(1, 6). En PHP el for trae tres partes entre paréntesis, separadas por ;: dónde empieza, hasta cuándo sigue y cómo avanza:

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

Sale:
1 2 3 4 5 

$i++ quiere decir «súmale 1 a $i». El bucle hace esto: pone $i en 1; pregunta ¿$i ≤ 5?; si es true, ejecuta las llaves y luego avanza $i; vuelve a preguntar. Cuando $i llega a 6 la pregunta da false y se sale. Da 5 vueltas. Si escribes $i < 5 da 4: la vuelta de más o de menos es el error más común de los bucles.

while repite mientras la pregunta sea true. Lo usas cuando no sabes de antemano cuántas vueltas serán:

$ahorro = 0;
$semanas = 0;
while ($ahorro < 100) {
    $ahorro = $ahorro + 30;
    $semanas++;
}
echo "Junté $ahorro pesos en $semanas semanas";

Sale:
Junté 120 pesos en 4 semanas

Lo que hay adentro tiene que acercar el bucle a su fin (aquí $ahorro sube cada vuelta). Si nada cambia, la pregunta siempre es true, el bucle nunca termina y la página se queda colgada.

Acumular y contar. Para sumar muchas cosas, una variable empieza en 0 y en cada vuelta le agregas: $suma = $suma + $i, o más corto, $suma += $i. Es el acumulador. Para contar vueltas, $cuenta++: el contador. Los dos se declaran antes del bucle, nunca adentro.

Tabla de seguimiento. Para saber qué hace un bucle sin correrlo, una fila por vuelta:

$suma = 0;
for ($i = 1; $i <= 4; $i++) {
    $suma += $i;
}
echo $suma;

Sale:
10

foreach recorre una lista completa sin contador: «para cada $cosa de $lista». Lo ves a fondo en la lección de arreglos:

$frutas = ["mango", "uva", "kiwi"];
foreach ($frutas as $f) {
    echo $f . ", ";
}

Sale:
mango, uva, kiwi, 

Un bucle que arma HTML. Aquí es donde PHP brilla. En vez de escribir diez renglones de tabla a mano, el bucle los escribe por ti. Puedes abrir y cerrar PHP a la mitad del bucle; el HTML que queda entre las llaves se manda una vez por vuelta. Así arma el servidor la lista de juegos de la sala: un bucle, y por cada juego una tarjeta.

<table>
<?php for ($i = 1; $i <= 3; $i++) { ?>
  <tr><td>7 x <?php echo $i; ?></td><td><?php echo 7 * $i; ?></td></tr>
<?php } ?>
</table>

Sale:
<table>
  <tr><td>7 x 1</td><td>7</td></tr>
  <tr><td>7 x 2</td><td>14</td></tr>
  <tr><td>7 x 3</td><td>21</td></tr>
</table>

Un arreglo (en Python, lista) guarda varias cosas en una sola cajita, entre corchetes y separadas por comas. Para sacar una, dices su lugar:

$frutas = ["mango", "uva", "kiwi"];
echo $frutas[0] . " y " . $frutas[2];

Sale:
mango y kiwi

El número entre corchetes es el índice y empieza en 0, no en 1: el primero es [0], el segundo [1]. El último de una lista de 3 es [2]. Si pides [3], PHP avisa «Undefined array key 3» y te da nada.

count dice cuántas cosas hay, y [] = agrega una al final:

$frutas[] = "pera";
echo count($frutas) . " frutas, la última es " . $frutas[3];

Sale:
4 frutas, la última es pera

El último lugar siempre es count − 1: $frutas[count($frutas) - 1].

Arreglos con nombre (asociativos). En vez de números, cada lugar tiene una clave que tú eliges, con =>. Es como el diccionario de Python:

$alumna = ['nombre' => 'Ana', 'grupo' => '1B', 'estrellas' => 14];
echo $alumna['nombre'] . " tiene " . $alumna['estrellas'] . " estrellas";

Sale:
Ana tiene 14 estrellas

Recorrer con foreach. «Para cada clave y valor del arreglo, haz esto». $k recibe la clave y $v el valor, una vuelta por cada cosa:

foreach ($alumna as $k => $v) {
    echo "$k: $v\n";
}

Sale:
nombre: Ana
grupo: 1B
estrellas: 14

Si no necesitas la clave, foreach ($lista as $v) a secas.

Arreglos dentro de arreglos. Un grupo es una lista de alumnos, y cada alumno es un arreglo con nombre. Así está guardada la sala de juegos de este sitio: una lista de juegos, cada uno con su clave, su nombre y qué hace. Para llegar adentro, dos pares de corchetes:

$grupo = [
  ['nombre' => 'Ana', 'estrellas' => 14],
  ['nombre' => 'Beto', 'estrellas' => 9],
  ['nombre' => 'Caro', 'estrellas' => 20],
];
echo $grupo[1]['nombre'];

Sale:
Beto

foreach ($grupo as $a) {
    echo "<li>" . $a['nombre'] . ": " . $a['estrellas'] . "</li>";
}

Sale:
<li>Ana: 14</li><li>Beto: 9</li><li>Caro: 20</li>

Ya usaste funciones hechas: round, strlen, date. Ahora haces las tuyas. En Python era def; en PHP es function, con llaves:

function doble($x) {
    return $x * 2;
}
echo doble(4) . " y " . doble(doble(5));

Sale:
8 y 20

$x es el parámetro: una cajita que se llena con lo que le mandes al llamar. doble(4) pone 4 en $x y devuelve 8. doble(doble(5)) primero resuelve la de adentro (10) y luego la de afuera (20). return entrega el resultado y termina la función: lo que escribas después de return ya no corre. Si una función no tiene return, devuelve null, o sea nada.

Puede recibir varios parámetros, separados por coma:

function area_triangulo($base, $altura) {
    return $base * $altura / 2;
}
echo area_triangulo(10, 4);

Sale:
20

Valores por omisión. Si un parámetro casi siempre vale lo mismo, dale un valor de fábrica con =. Al llamar, puedes mandarlo o no:

function saluda($nombre, $saludo = "Hola") {
    return "$saludo, $nombre!\n";
}
echo saluda("Ana");
echo saluda("Beto", "Buenas");

Sale:
Hola, Ana!
Buenas, Beto!

echo o return. Una función que hace echo escribe de inmediato y no te deja nada en la mano. Una que hace return te da el valor para que tú decidas: guardarlo, sumarlo, imprimirlo. Casi siempre quieres return.

Funciones que arman HTML. Aquí está el truco de todo este sitio. Una tarjeta de juego es el mismo HTML con otro título y otro texto. Entonces una función la arma y la devuelve como texto:

function tarjeta($titulo, $texto) {
    return '<div class="tarjeta"><h3>' . $titulo . '</h3><p>' . $texto . '</p></div>';
}
echo tarjeta("El blanco", "Llega al objetivo con operaciones");
echo tarjeta("La recta", "Ubica el número");

Sale:
<div class="tarjeta"><h3>El blanco</h3><p>Llega al objetivo con operaciones</p></div><div class="tarjeta"><h3>La recta</h3><p>Ubica el número</p></div>

Por eso en el código de israelrivas.org hay funciones como barra_sitio(), que arma la barra de arriba, o es_pastel(), que dibuja un pastel partido en rebanadas. La barra se escribió una sola vez y aparece en todas las páginas: si la cambio en la función, cambia en todas. Sin funciones tendría que corregir cien archivos uno por uno.

Lo de adentro se queda adentro. Las variables que creas dentro de una función no existen afuera, y las de afuera no se ven adentro. Todo entra por los parámetros y sale por el return. Eso es bueno: la función no rompe nada ajeno, y la puedes usar sin recordar cómo está hecha por dentro.

Hasta aquí tus programas no hablan con nadie. Un formulario (curso de HTML y CSS) deja que el usuario escriba y mande. Con method="post", lo que escribió viaja al servidor y PHP lo encuentra en un arreglo especial: $_POST, con la clave igual al name del campo.

<form method="post">
  <input name="nombre">
  <button>Enviar</button>
</form>
<?php
if (isset($_POST['nombre'])) {
    echo "<p>Hola, " . htmlspecialchars($_POST['nombre']) . "</p>";
}
?>

Sale (después de escribir Ana y apretar Enviar):
<form method="post">
  <input name="nombre">
  <button>Enviar</button>
</form>
<p>Hola, Ana</p>

Esta página se pide dos veces. La primera, el usuario solo llega: $_POST está vacío, isset da false y no se imprime el párrafo; solo ve el formulario. La segunda, apretó Enviar: llega $_POST['nombre'] con "Ana" y la página responde. Mismo archivo, dos comportamientos. Es el ciclo de todo formulario:

isset pregunta «¿existe esta cajita?». Sin él, en la primera visita PHP se queja: Undefined array key "nombre", porque todavía nadie ha mandado nada.

Revisar antes de usar. Lo que manda el usuario puede ser cualquier cosa: vacío, letras donde esperabas número, o algo peor. Antes de usarlo, tres preguntas:

1. ¿Viene vacío? trim($_POST['nombre']) === '' (trim quita los espacios de las orillas). Si sí, pide que lo llene.
2. ¿Es número? is_numeric($_POST['edad']). Si no, avisa. Y si sí, conviértelo: (int)$_POST['edad'], porque llega como texto.
3. ¿Está en el rango que esperas? Una edad entre 1 y 120, una calificación entre 0 y 10.

htmlspecialchars. Si el usuario escribe <b>hola</b> y tú lo imprimes tal cual, el navegador lo entiende como etiqueta: sale «hola» en negritas. Y si escribe una etiqueta <script>, mete un programa en tu página, que verán todos los demás. htmlspecialchars cambia cada < por &lt; y cada > por &gt;, y entonces el navegador los muestra como texto, no los ejecuta. En este sitio, todo lo que escribe un alumno (su nombre, lo que pone en la pizarra) pasa por ahí antes de pintarse.

$texto = "<b>hola</b>";
echo $texto . "\n";
echo htmlspecialchars($texto);

Sale:
<b>hola</b>
&lt;b&gt;hola&lt;/b&gt;

El navegador pinta el primer renglón como hola en negritas (obedeció la etiqueta) y el segundo como <b>hola</b> escrito letra por letra (lo mostró, no lo obedeció). Eso es lo que quieres cuando el texto viene de afuera.

Con method="get" los datos viajan en la dirección (pagina.php?edad=12) y llegan en $_GET. Sirve para búsquedas que se puedan compartir; para contraseñas o datos personales, siempre post.

Equivocarse es parte de programar; lo que distingue a quien sabe es que lee el mensaje en vez de asustarse. Un error de PHP siempre trae tres datos: qué pasó, en qué archivo y en qué línea. Ve primero a esa línea; si ahí no ves nada raro, mira la de arriba, porque muchas veces lo que falta estaba en la anterior.

Parse error: el programa ni empieza. PHP lee todo el archivo antes de ejecutar nada; si hay algo que no entiende, no corre ni una línea:

1  <?php
2  $nombre = "Ana"
3  echo "Hola $nombre";

Sale:
Parse error: syntax error, unexpected token "echo", expecting "," or ";" in hola.php on line 3

Dice línea 3, pero el ; faltaba en la 2: PHP se dio cuenta hasta que encontró echo donde esperaba el punto y coma. «unexpected» es «no esperaba esto»; «expecting» es «esperaba esto otro». Con esas dos palabras ya sabes qué buscar.

Warning contra Fatal. Un Warning avisa y sigue: la página sale, pero algo quedó vacío o mal. Un Fatal error detiene todo en ese punto: lo de arriba ya salió, lo de abajo no. Un Parse error no deja salir nada.

Comillas sin cerrar. Es la más traicionera: PHP cree que todo lo que sigue es parte del texto, y el error aparece lejos, a veces como «unexpected end of file». Si el mensaje no tiene sentido en su línea, cuenta las comillas de las líneas de arriba.

Buscar el error a la mitad. A veces el programa corre pero da mal, y no hay mensaje. Entonces pones un echo de prueba (o var_dump) a la mitad, para ver qué vale una variable en ese punto: echo "aquí total = $total";. Lo vas moviendo hasta encontrar dónde cambió lo que no debía. Cuando lo arregles, quítalo.

La pantalla en blanco. A veces no sale ni error: la página queda vacía. Es que el servidor tiene los errores escondidos; así se configuran los servidores de verdad, para no enseñarle las tripas a los visitantes, y el error se anota en un archivo (el log). Cuando estés practicando, pon al principio del archivo:

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

y los errores vuelven a aparecer en pantalla. En israelrivas.org están escondidos: si un alumno llega a ver una pantalla en blanco, el error quedó anotado en el servidor y yo lo leo ahí.