Variables, tipos de datos y constantes en PHP

Una variable es un nombre que guarda un dato para usarlo más tarde: el precio de un producto, el nombre de un socio, si ha pagado o no. En esta lección aprenderás a crear variables en PHP, qué tipos de datos existen, cómo inspeccionarlos con var_dump, cómo convierte PHP unos tipos en otros (y las sorpresas que eso puede dar), cómo crear constantes y qué hace declare(strict_types=1).

Crear variables

En PHP todas las variables empiezan por el signo $. Se crean al darles un valor con =, sin escribir ninguna palabra delante ni indicar el tipo:

$nombre = "Irene";
$edad = 31;
$cuotaMensual = 39.90;
$alCorriente = true;

echo "$nombre tiene $edad años y paga $cuotaMensual € al mes\n";
// Irene tiene 31 años y paga 39.9 € al mes

El = no significa “es igual”, sino “guarda este valor en esta variable”. Por eso puedes usar el valor anterior para calcular el nuevo:

$puntos = 100;
$puntos = $puntos + 25;
echo $puntos, "\n";
// 125

Reglas para los nombres

• Después del $ va una letra o un guion bajo, y luego letras, números o guiones bajos: $precio1 vale, $1precio no.
• Sin espacios ni guiones: $precio-total se interpretaría como una resta.
• Distinguen mayúsculas y minúsculas: $total y $Total son variables distintas.
• La convención más extendida en PHP moderno es camelCase: $precioTotal, $numeroDeSocios. En WordPress y algunos proyectos antiguos verás snake_case ($precio_total). Elige una y sé coherente.

Consejo: PHP admite tildes y eñes en los nombres ($año), pero evítalas. Usa $anio o, mejor, $anyo… o directamente un nombre en otro formato, como $ejercicio. Te ahorrarás problemas con codificaciones y teclados.

Los tipos de datos

PHP tiene estos tipos básicos:

Tipo	Qué guarda	Ejemplos
int	Números enteros	42, -7, 1_000_000
float	Números con decimales	3.14, 19.99, 1.5e3
string	Texto	"hola", 'hola'
bool	Verdadero o falso	true, false
null	Ausencia de valor	null
array	Colección de valores	[10, 20, 30]

Hay más (objetos, callable, recursos…), que irás viendo a lo largo del curso.

Números: int y float

Los enteros (int) no tienen decimales. Los decimales se escriben con punto, nunca con coma:

$plazas = 24;
$precio = 12.50;
$poblacion = 1_250_000;   // el _ solo ayuda a leer; PHP lo ignora

echo $poblacion + 1, "\n";
echo 7 / 2, "\n";
// 1250001
// 3.5

Fíjate en que dividir dos enteros puede dar un float: 7 / 2 es 3.5. La división entera la verás en Operadores.

Los float tienen una limitación que comparten casi todos los lenguajes: algunos decimales no se pueden guardar de forma exacta en binario.

var_dump(0.1 + 0.2);
var_dump(0.1 + 0.2 == 0.3);
// float(0.30000000000000004)
// bool(false)

Para cálculos de dinero, una solución habitual es trabajar en céntimos con enteros (1250 en lugar de 12.50) y redondear solo al mostrar.

Texto: string

Una cadena (string) es texto entre comillas, simples o dobles:

$ciudad = "Santander";
$codigo = 'ES-39';

Con comillas dobles, PHP sustituye las variables que haya dentro; con simples, no. Lo verás a fondo en Cadenas.

Booleanos: bool

Solo dos valores, true y false (se pueden escribir en mayúsculas, pero lo normal es en minúsculas). Son el resultado de las comparaciones y la base de los condicionales.

$esSocio = true;
$mayorDeEdad = 17 >= 18;

Ausencia de valor: null

null significa “aquí no hay nada”. Una variable vale null si le asignas null expresamente. Es útil, por ejemplo, para un dato que todavía no se conoce:

$fechaBaja = null;   // el socio sigue activo

Si usas una variable que nunca has creado, PHP la trata como null pero te avisa con un Warning: Undefined variable. Ese aviso casi siempre indica una errata.

Colecciones: array

Un array guarda varios valores en una sola variable. Tiene su propia lección, Arrays; de momento basta con reconocerlo:

$notas = [7.5, 8, 6.25];
$socio = ["nombre" => "Irene", "cuota" => 39.90];

Ver el tipo y el valor: var_dump y gettype

echo es para mostrar datos al usuario; para depurar, es decir, para averiguar qué contiene exactamente una variable, se usa var_dump. Muestra el tipo y el valor:

var_dump(42);
var_dump(9.99);
var_dump("Bilbao");
var_dump(true);
var_dump(null);
var_dump([3, 5]);
// int(42)
// float(9.99)
// string(6) "Bilbao"
// bool(true)
// NULL
// array(2) {
//   [0]=>
//   int(3)
//   [1]=>
//   int(5)
// }

En las cadenas, el número entre paréntesis es su longitud en bytes.

¿Por qué no basta con echo? Porque echo convierte todo a texto y esconde información:

echo true, "\n";
echo false, "\n";
echo null, "\n";
// 1
//
//

true se muestra como 1, y false y null como una cadena vacía. Si estás comprobando un valor que no se ve, usa var_dump.

Para obtener solo el nombre del tipo tienes dos funciones:

$precio = 12.5;
echo gettype($precio), "\n";
echo get_debug_type($precio), "\n";
// double
// float

gettype() es antigua y devuelve algunos nombres históricos (double en lugar de float, NULL en lugar de null). get_debug_type(), de PHP 8, devuelve los nombres que usarás al escribir tipos. Para comprobar un tipo concreto dentro de un programa están is_int(), is_float(), is_string(), is_bool(), is_null(), is_array() y is_numeric() (que dice si un valor es un número o una cadena con un número).

var_dump(is_numeric("42"), is_numeric("42 kg"), is_int("42"));
// bool(true)
// bool(false)
// bool(false)

Tipado dinámico y conversiones

PHP es de tipado dinámico: el tipo va con el valor, no con la variable. La misma variable puede contener un número y después un texto (aunque cambiar el tipo de una variable rara vez es buena idea).

Además, PHP es flexible con los tipos: si una operación necesita un número y le das un texto con un número, lo convierte por su cuenta. A esto se le llama conversión implícita o type juggling:

var_dump("5" + 3);
var_dump("2.5" * 2);
var_dump(10 . " km");
// int(8)
// float(5)
// string(5) "10 km"

Es cómodo, porque todo lo que llega de un formulario es texto, pero tiene límites. Si el texto no es un número, PHP 8 se queja:

var_dump("5 manzanas" + 3);
// Warning: A non-numeric value encountered in ... on line 1
// int(8)

Y si no hay ningún número al principio, la operación falla con un TypeError (Unsupported operand types) en lugar de inventarse un resultado.

Conversión explícita (casting)

Para convertir un valor tú mismo, pon el tipo entre paréntesis delante. Es lo recomendable: deja claro qué esperas.

var_dump((int) "42");
var_dump((int) 12.9);
var_dump((float) "3.75");
var_dump((string) 2026);
var_dump((bool) "0");
var_dump((bool) "false");
// int(42)
// int(12)
// float(3.75)
// string(4) "2026"
// bool(false)
// bool(true)

Ojo a dos detalles:

• (int) 12.9 da 12: corta los decimales, no redondea. Para redondear usa round().
• (bool) "false" es true: es una cadena con texto, y para PHP eso es verdadero.

Valores que cuentan como falsos

Al convertir a bool, estos valores dan false. Todo lo demás da true:

Valor	Tipo
false	bool
0 y 0.0	int y float
"" (cadena vacía)	string
"0"	string
null	null
[] (array vacío)	array

El caso raro es "0": una cadena con un cero es falsa, pero "0.0" o " " (un espacio) son verdaderas.

Comparación débil y estricta

Esta flexibilidad también afecta a las comparaciones. El operador == (igualdad débil) convierte los tipos antes de comparar; === (igualdad estricta) exige que coincidan valor y tipo:

var_dump("1" == "01");
var_dump(100 == "1e2");
var_dump(null == false);
var_dump(100 === "1e2");
// bool(true)
// bool(true)
// bool(true)
// bool(false)

"1e2" es notación científica de 100, así que == los considera iguales. Este tipo de sorpresas son la razón por la que en PHP moderno se usa === por defecto. Tienes la explicación completa en Operadores.

Nota: PHP 8 corrigió la sorpresa más famosa. En PHP 7, 0 == "hola" era true; en PHP 8 es false. Si lees código antiguo, recuerda que las reglas eran todavía más laxas.

Constantes

Una constante es un valor con nombre que no puede cambiar una vez definido: el IVA, el nombre de la web, el número máximo de intentos. No lleva $ y, por convención, se escribe en MAYÚSCULAS. Hay dos formas de crearlas:

const IVA = 0.21;
define('NOMBRE_WEB', 'Rocódromo Vertical');

$base = 50;
echo NOMBRE_WEB, ": ", $base * (1 + IVA), " €\n";
// Rocódromo Vertical: 60.5 €

	const	define()
Cuándo se define	Al compilar el archivo	Al ejecutar esa línea
Dentro de un if o una función	No	Sí
Dentro de una clase	Sí	No
Uso recomendado	El habitual	Cuando el valor o el nombre se deciden en tiempo de ejecución

Si intentas cambiar una constante, PHP da un error. Esa es justamente su ventaja: nadie puede modificar el IVA por accidente a mitad del programa.

PHP trae muchas constantes predefinidas. Algunas útiles:

echo PHP_VERSION, "\n";    // versión de PHP
echo PHP_INT_MAX, "\n";    // entero más grande posible
echo M_PI, "\n";           // número pi
// 8.4.21
// 9223372036854775807
// 3.1415926535898

También PHP_EOL, que es el salto de línea del sistema operativo. Verás constantes “mágicas” como __DIR__ en include y require.

declare(strict_types=1)

Has visto que PHP convierte tipos por su cuenta. Cuando una función declara qué tipos acepta, por defecto PHP también convierte lo que le pasas si puede. A esto se le llama modo coercitivo:

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

echo sumarPlazas("5", 3), "\n";
// 8

La función pedía dos int y le has pasado la cadena "5". PHP la ha convertido en silencio. Parece cómodo, pero puede esconder errores: quizá ese "5" venía de un sitio donde no debía haber texto.

Si escribes declare(strict_types=1); como primera instrucción del archivo, PHP pasa a modo estricto y deja de convertir: un tipo incorrecto lanza un error.

<?php
declare(strict_types=1);

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

echo sumarPlazas("5", 3), "\n";
// Fatal error: Uncaught TypeError: sumarPlazas(): Argument #1 ($a) must be of type int, string given, called in ...

Lo que debes saber:

• Tiene que ir justo después de <?php, antes de cualquier otra instrucción.
• Solo afecta a las llamadas a funciones hechas desde ese archivo; no cambia cómo funcionan + o ==.
• Una excepción razonable: un int se acepta donde se pide float.
• La mayoría de proyectos modernos lo ponen en todos sus archivos. Detecta errores pronto, cuando son fáciles de arreglar.

Lo usarás mucho en Funciones, donde verás los tipos de parámetros y de retorno.

Variables superglobales

PHP crea automáticamente unas variables especiales, las superglobales, que están disponibles en cualquier parte del código. Todas son arrays y su nombre empieza por $_:

Superglobal	Qué contiene	Dónde la verás
$_GET	Datos enviados en la URL (?buscar=cuerda)	Formularios
$_POST	Datos enviados por un formulario con method="post"	Formularios
$_SERVER	Información del servidor y de la petición	Formularios
$_SESSION	Datos de la sesión del usuario	Sesiones y cookies
$_COOKIE	Cookies que envía el navegador	Sesiones y cookies
$_FILES	Archivos subidos	Ficheros y subidas

No las crees ni las sobrescribas tú; se leen. Y recuerda que todo lo que llega en ellas viene del usuario, así que nunca debes fiarte sin validarlo.

Errores frecuentes

• Olvidar el $: precio = 10; da un error de sintaxis. Todas las variables llevan $; las constantes, no.
• Escribir decimales con coma: $precio = 12,50; es un error. Usa punto: 12.50.
• Usar una variable con una errata: $totla en lugar de $total da Undefined variable. Lee el aviso: dice el nombre exacto.
• Fiarse de echo para depurar: false y null no se ven. Usa var_dump.
• Comparar con == y llevarse sorpresas: usa === salvo que quieras la conversión a propósito.
• Esperar que (int) redondee: corta los decimales. Usa round().
• Poner declare(strict_types=1) después de otro código: debe ser la primera instrucción del archivo o PHP da un error.

Resumen

Concepto	Lo esencial
Variable	$nombre = valor;, distingue mayúsculas, camelCase
Tipos básicos	int, float, string, bool, null, array
Depurar	var_dump($x) muestra tipo y valor
Tipo	get_debug_type(), is_int(), is_numeric()…
Conversión implícita	PHP convierte tipos solo si puede; con texto no numérico avisa o falla
Casting	(int), (float), (string), (bool)
Falsos	false, 0, 0.0, "", "0", null, []
Comparar	=== compara valor y tipo; úsalo por defecto
Constantes	const IVA = 0.21; o define('IVA', 0.21);, sin $
strict_types	declare(strict_types=1); al principio; las funciones no convierten tipos
Superglobales	$_GET, $_POST, $_SESSION… disponibles en todo el código

Con las variables listas, en la siguiente lección aprenderás a operar con ellas: operadores.

var_dump("5" + 3);

var_dump((bool) "0");
var_dump((bool) "false");

var_dump(0.1 + 0.2);
var_dump(0.1 + 0.2 == 0.3);

<?php
declare(strict_types=1);

function doble(int $n): int { return $n * 2; }

echo doble("5");