1.1Variables, tipos y operadores
Lo esencial en 30 segundos
- Variable = $ + nombre claro, tipado dinámico: $prixTotal = 1200; — PHP deduce el tipo del valor (string, int, float, bool, array, null, object).
- Concatenar con el PUNTO, nunca con +: 'Bonjour ' . $nom — el + no une las cadenas en PHP.
- Comparar en ESTRICTO por defecto: === (valor Y tipo, previsible) en lugar de == (conversión automática, errores y fallos).
Minicaso hilado — Riad, desarrollador web en Constantine
Riad, desarrollador web en Constantine, prepara el presupuesto de un sitio vitrina: guarda el precio sin impuestos en $prixHT, calcula el IVA con los operadores aritméticos y luego muestra « Total : » seguido del importe. Con prisa, une el mensaje con + y compara el código promocional introducido ("5") con el número 5 usando ==: la visualización muestra 0 en lugar del texto, y un código promocional inesperado supera la comparación. Lo corrige concatenando con el punto y comparando con ===: el presupuesto se muestra correctamente y solo se aceptan los verdaderos códigos promocionales.
Este mismo caso reaparece en el curso, el esquema, el script y el reto 48h — y continúa en 1.2, 1.3, 1.4 y 1.5.
1. Variables y tipos
Una variable empieza siempre por $ ($nom), asignada con = ($age = 30;). PHP tiene un tipado dinámico: el tipo sigue al valor, sin declaración previa — una variable puede cambiar de tipo a lo largo del código. Tipos a conocer: string (texto), int (entero), float (decimal), bool (true/false), array (array), null, object. Ponga nombres claros a sus variables ($prixTotal en lugar de $x): el nombrado explícito es una clave de legibilidad.
Riad guarda $prixHT = 10000; y $client = "Yasmine";: nombres que dicen lo que contienen, releídos sin esfuerzo tres semanas después cuando el cliente pide una modificación.
2. Operadores, === y comillas
Operadores: aritméticos (+ - * / % **), asignación (=, +=…), comparación, lógicos (&& || !). La concatenación usa el PUNTO . (¡no +!). CRUCIAL: == compara con conversión de tipo (« flexible », resultados sorprendentes); === compara valor Y tipo (« estricto ») — priorice ===. Las comillas dobles interpretan las variables ("Bonjour $nom"); las simples = literal ('Bonjour $nom').
Riad sustituye su + por un . para unir « Total : » y el importe, y su == por === para el código promocional: la visualización se vuelve correcta y la comparación previsible.
🔎 Ejemplo concreto — 🔎 Ejemplo concreto — === vs == y comillas
Evitar las sorpresas, como Riad con su presupuesto.
$nom = 'Riad';
echo "Bonjour $nom"; // Hola Riad (interpreta)
echo 'Bonjour $nom'; // Bonjour $nom (literal)
$message = 'Total : ' . 12000; // concatenación con el punto
echo $message;
var_dump('5' == 5); // true (conversión flexible)
var_dump('5' === 5); // false (tipo diferente)Lectura: las dobles muestran el valor, las simples el texto bruto; el punto une, === fija el tipo.
Lección: comparaciones previsibles y visualización dominada — el reflejo === por defecto.
Vocabulario de la sección
- Variable ($)
- Almacena un dato; empieza siempre por $ ($nom), asignada con =. Nombre sensible a mayúsculas, a elegir claro y expresivo.
Ejemplo sencillo: El $prixHT y el $client del presupuesto de Riad.
Lo que no es: un $x críptico cuyo contenido nadie adivina.
Reflejo: siempre $, nombre explícito, mayúsculas coherentes.
- Tipado dinámico
- PHP determina el tipo según el valor (sin declaración previa); una variable puede cambiar de tipo. Tipos: string, int, float, bool, array, null, object.
Ejemplo sencillo: El $prixHT de Riad, entero y luego decimal tras el IVA.
Lo que no es: declarar el tipo por adelantado como en un lenguaje compilado.
Reflejo: pensar primero en el valor, verificar con var_dump en caso de duda.
- Operadores
- Aritméticos (+ - * / % **), asignación (=, +=…), comparación (==, ===, !=, <, >…), lógicos (&& || !).
Ejemplo sencillo: El cálculo del IVA de Riad ($prixHT * 1.19).
Lo que no es: usar + para unir dos cadenas.
Reflejo: calcular con los operadores, unir con el punto.
- Concatenación (.)
- En PHP, las cadenas se unen con el PUNTO . (no +): 'Bonjour ' . $nom.
Ejemplo sencillo: El « Total : » . $montant mostrado por Riad.
Lo que no es: 'Total : ' + $montant, que calcula en lugar de unir.
Reflejo: cadenas a unir = punto, siempre.
- == vs === / comillas
- == compara con conversión de tipo (flexible, sorprendente); === compara valor Y tipo (estricto, a priorizar). Las dobles interpretan las variables, las simples = literal.
Ejemplo sencillo: El código promocional probado en === por Riad; su mensaje en dobles.
Lo que no es: validar un token sensible con ==.
Reflejo: === por defecto; dobles para interpretar, simples si no.
En la práctica — En la práctica — Manipular variables, tipos y operadores
- Declare variables de distintos tipos (string, int, float, bool) con `$` y muéstrelas; observe el tipado dinámico.
- Haga cálculos con los operadores aritméticos (incluido % módulo) y concatene cadenas con el PUNTO `.` (no `+`).
- Compare con `==` y luego `===` una cadena y un número (ej. '5' y 5): observe la diferencia (conversión vs estricto) y priorice `===`.
- Pruebe las comillas: `"Bonjour $nom"` (interpreta la variable) vs `'Bonjour $nom'` (literal) — constate la diferencia.
Script listo para decir — justificar === en revisión de código (30 s)
« Propongo que comparemos en === en todas partes aquí: con ==, PHP convierte los tipos y un código promocional inesperado puede colarse. Lo estricto hace la comparación previsible, y para los valores sensibles también es una cuestión de seguridad. »
Para decir en revisión de código; mostrar el var_dump('5' == 5) frente a ===.
Modelo copiar-pegar — variables, concatenación, comparación estricta
Presupuesto en Constantine
Como Riad: precio sin impuestos, IVA y total en variables con nombre, mensaje unido con el punto — el cliente relee un presupuesto nítido, sin cifras fantasiosas.
Código promocional a validar
Comparar lo introducido con el código esperado en ===: ninguna conversión sorpresa, solo pasan los códigos exactos.
Visualización con variables
Dobles cuando el texto contiene variables ("Bonjour $nom"), simples para el texto puro — y concatenación explícita como alternativa.
Duda sobre un tipo
Un var_dump($variable) en local lo aclara: el tipado dinámico se verifica, no se adivina.
✓ Buenas prácticas
- Priorizar === / !== por defecto (comparación estricta, previsible).
- Concatenar las cadenas con el punto (nunca +).
- Nombrar las variables con claridad y mantener la coherencia (mayúsculas).
✗ Errores frecuentes
- Usar == y sufrir una conversión de tipo sorprendente.
- Concatenar con + (no existe para las cadenas en PHP).
- Esperar que 'Bonjour $nom' (comillas simples) muestre el valor.
Puntos clave
- Una VARIABLE empieza siempre por `$` (`$nom`), asignada con `=`. PHP tiene un TIPADO DINÁMICO (el tipo sigue al valor). Tipos: string, int, float, bool, array, null, object.
- CONCATENACIÓN de las cadenas con el PUNTO `.` (¡NO `+`!). Operadores: aritméticos (+ - * / % **), asignación (+=…), comparación, lógicos (&& || !).
- CRUCIAL: `==` compara con conversión de tipo (flexible, sorprendente); `===` compara valor Y tipo (estricto) — PRIORIZAR `===` / `!==`.
- Las comillas DOBLES interpretan las variables (`"Bonjour $nom"`); las comillas SIMPLES = literal (`'Bonjour $nom'`). Nombrar las variables con claridad (legibilidad).
Reto 48h — aplique mañana
Retome uno de sus scripts (modelo anterior): sustituya cada == por === (salvo conversión deseada), cada + entre cadenas por un punto, y renombre una variable críptica. Ejecute en local y verifique la visualización. 20 minutos bastan.
- Puedo explicar $, el tipado dinámico y la concatenación con el punto.
- Comparo en === por defecto y sé por qué.
- Elijo dobles (interpretan) vs simples (literal) sin dudar.
Preguntas frecuentes
¿Por qué priorizar === en lugar de == en PHP, y qué errores evita?
`==` compara dos valores efectuando una CONVERSIÓN automática de tipo si los tipos difieren (comparación « flexible »), lo que da resultados sorprendentes y contraintuitivos. `===` compara el valor Y el tipo, SIN conversión (« estricto »), por tanto previsible. Los errores que `==` puede causar: comparar una cadena y un número (conversiones desconcertantes), las trampas de los valores « falsy » (0, '', '0', null, [] considerados « falsos »), y sobre todo casos peligrosos — históricamente, comparaciones de hashes o tokens mal hechas con `==` han causado fallos de seguridad. PHP 8 corrigió algunos casos absurdos, pero el principio permanece: `==` convierte, `===` no. Buena práctica: use `===` (y `!==`) por DEFECTO; si debe comparar tipos mezclados, CONVIERTA explícitamente primero (control) en lugar de sufrir la conversión implícita.
¿Comillas simples o dobles: qué diferencia hay y cuál usar?
Comillas DOBLES `"..."`: INTERPRETAN el contenido — las variables (`"Bonjour $nom"` inserta el valor) y las secuencias de escape (`\n`, `\t`). Comillas SIMPLES `'...'`: toman el contenido LITERALMENTE — `'Bonjour $nom'` muestra el texto « Bonjour $nom » (no el valor). Buenas prácticas: comillas SIMPLES por defecto para texto puro (más previsible); comillas DOBLES cuando quiera interpretar variables; alternativa recomendada: la CONCATENACIÓN con el punto (`'Bonjour ' . $nom`), explícita y previsible. Vigilancia: un `$` accidental en comillas dobles puede causar un comportamiento inesperado.
¿Qué comparación priorizar en PHP moderno?