En este capítulo nos adentraremos en uno de los pilares fundamentales de cualquier lenguaje de programación: los Tipos de Datos y Variables. PHP es un lenguaje flexible y potente que permite trabajar con diferentes tipos de datos para construir aplicaciones dinámicas y funcionales. Comprender cómo PHP gestiona la información es esencial para desarrollar programas eficientes.

Comenzaremos explorando los tipos de datos que PHP pone a nuestra disposición, desde los más básicos, como enteros y cadenas de texto, hasta estructuras más avanzadas, como arrays y objetos. Posteriormente, aprenderemos a declarar y usar variables, que son contenedores para almacenar y manipular datos durante la ejecución de nuestros programas. Por último, hablaremos sobre las constantes, valores inmutables que son útiles para almacenar datos que no cambian durante la ejecución del programa, como configuraciones o parámetros clave.

Este conocimiento será la base para crear nuestras aplicaciones en PHP. ¡Comencemos!

Tipos de Datos en PHP

PHP es un lenguaje dinámicamente tipado, lo que significa que no es necesario declarar explícitamente el tipo de dato que contendrá una variable; el tipo se determina automáticamente en tiempo de ejecución. Sin embargo, es crucial entender los tipos de datos que ofrece PHP para trabajar de manera eficiente y evitar errores.

Tipos de Datos Escalares

Los datos escalares son los más básicos y se utilizan para almacenar valores simples.

Enteros (Integer)
Los enteros son números sin decimales, positivos o negativos.

• Rango: Dependiente del sistema, generalmente -2^31 a 2^31-1 en sistemas de 32 bits.
• Ejemplo:

<?php $numero = 42; echo $numero; // Salida: 42 ?>

Características importantes:

• Se pueden escribir en notación decimal, octal (0) o hexadecimal (0x).

<?php $decimal = 255; // Decimal $octal = 0377; // Octal (equivale a 255) $hexadecimal = 0xFF; // Hexadecimal (equivale a 255) ?>

Flotantes (Float o Double)
Los flotantes son números con decimales.

• Utilizados para cálculos precisos.
• Ejemplo:

<?php $pi = 3.14159; echo $pi; // Salida: 3.14159 ?>

Operaciones con flotantes:

<?php
$a = 1.5;
$b = 2.3;
$suma = $a + $b;
echo $suma; // Salida: 3.8
?>

Nota: Los cálculos con flotantes pueden ser inexactos debido a las limitaciones de representación en la memoria.

Cadenas (String)
Las cadenas son secuencias de caracteres, encerradas entre comillas simples (') o dobles (").

• Ejemplo:

<?php $nombre = "Juan"; echo "Hola, $nombre"; // Salida: Hola, Juan ?>

Diferencias entre comillas simples y dobles:

Comillas dobles permiten interpolación de variables:

<?php $numero=3
$mensaje = "El número es $numero"; // El número es 3?>

Comillas simples no interpretan variables:

<?php $numero=3
$mensaje = 'El número es $numero'; // El número es $numero?>

Funciones útiles para cadenas:

• Obtener longitud: strlen($cadena)
• Convertir a mayúsculas: strtoupper($cadena)
• Subcadena: substr($cadena, inicio, longitud)

Booleanos (Boolean)
Los booleanos solo tienen dos valores posibles: true o false.

• Utilizados principalmente en estructuras de control como if.
• Ejemplo:

<?php 
$esVerdadero = true; if ($esVerdadero) {                echo "Es verdadero"; 
} 
?>

Conversión implícita a booleanos:

• Valores evaluados como false:
  • 0 (entero o flotante).
  • "" (cadena vacía).
  • null.
• Todo lo demás se evalúa como true.

Tipos de Datos Compuestos

Arrays
Un array es una colección de elementos, que pueden ser de cualquier tipo de dato.

• Ejemplo:

<?php $numeros = array(1, 2, 3, 4, 5); echo $numeros[0]; // Salida: 1 ?>

Tipos de arrays en PHP:

• Indexados: Índices numéricos.
• Asociativos: Claves personalizadas.

<?php $persona = array("nombre" => "Juan", "edad" => 30); echo $persona["nombre"]; // Salida: Juan ?>

Funciones útiles para arrays:

• count($array) – Obtener la cantidad de elementos.
• array_push($array, $valor) – Agregar un elemento al final.

Objetos
Los objetos son instancias de una clase y permiten representar entidades complejas.

• Ejemplo:

<?php 
class Persona {   public $nombre;    
  public function saludar() {    
      echo "Hola, soy $this->nombre";   } }
$juan = new Persona(); $juan->nombre = "Juan"; $juan->saludar(); // Salida: Hola, soy Juan ?>

Tipos de Datos Especiales

Null
Representa la ausencia de valor.

• Ejemplo:

<?php $variable = null; echo $variable; // Salida: (nada) ?>

Recursos (Resource)
Representan referencias a recursos externos, como conexiones a bases de datos o archivos abiertos.

Declaración y Uso de Variables

Las variables en PHP son contenedores que almacenan datos para ser utilizados y manipulados durante la ejecución de un script. Son fundamentales en cualquier programa, ya que permiten guardar información temporalmente para realizar cálculos, tomar decisiones y estructurar la lógica de la aplicación.

Características de las Variables en PHP

1. Simbología:
   En PHP, las variables siempre comienzan con el símbolo de dólar ($). Esto las diferencia claramente de otros elementos en el código.
2. Tipado Dinámico:
   PHP es un lenguaje dinámicamente tipado, lo que significa que no es necesario declarar explícitamente el tipo de dato de una variable. El tipo se asigna automáticamente según el valor que se le asigne.
3. Sensibilidad a Mayúsculas y Minúsculas:
   Los nombres de las variables son sensibles a las mayúsculas y minúsculas. Por ejemplo, $edad y $Edad son variables diferentes.

Declaración de Variables

En PHP, una variable se declara simplemente asignándole un valor. No se necesita ninguna palabra clave previa.

Ejemplo de Declaración y Asignación de Variables:

<?php
$nombre = "Juan";  // Variable de tipo string
$edad = 30;        // Variable de tipo entero
$altura = 1.75;    // Variable de tipo float
$esEstudiante = true; // Variable de tipo booleano
?>

Nota:

• El tipo de dato se asigna automáticamente según el valor asignado.
• Es posible cambiar el tipo de dato asignando un valor diferente en tiempo de ejecución.

Reglas para Nombrar Variables

Al nombrar variables en PHP, es importante seguir ciertas reglas para garantizar que el código sea legible y funcional:

Debe comenzar con un carácter alfabético o un guion bajo (_).
Ejemplos válidos:

$miVariable; $_variablePrivada;

Puede contener letras, números y guiones bajos, pero no espacios ni caracteres especiales.
Ejemplo válido: $variable1.
Ejemplo inválido: $mi variable.

No puede ser una palabra reservada de PHP.
Palabras como echo, for, class no pueden ser usadas como nombres de variables.

Es sensible a mayúsculas y minúsculas.

<?php $usuario = "Juan"; $Usuario = "Pedro"; echo $usuario; // Salida: Juan echo $Usuario; // Salida: Pedro ?>

Ámbito de las Variables

El ámbito define la región del script donde una variable es válida y accesible. PHP tiene cuatro tipos principales de ámbito:

Ámbito Local:

Variables definidas dentro de una función o bloque solo son accesibles dentro de esa función o bloque.

Ejemplo:

<?php function saludar() {    $mensaje = "Hola"; // Variable local echo $mensaje; } saludar(); // Salida: Hola // echo $mensaje; // Error: Variable no definida ?>

Ámbito Global:

Variables definidas fuera de cualquier función son accesibles en todo el script, excepto dentro de funciones (a menos que se declaren explícitamente como globales).

Ejemplo:

<?php 
$mensaje = "Hola Mundo"; // Variable global 
function mostrarMensaje() {    global $mensaje; 
   echo $mensaje; // Salida: Hola Mundo } 
mostrarMensaje(); ?>

Ámbito Estático:

Una variable declarada como static dentro de una función conserva su valor entre llamadas sucesivas a la función.

Ejemplo:

<?php 
function contador() {    static $conteo = 0; 
   $conteo++; echo $conteo; } 
contador(); // Salida: 1 contador(); // Salida: 2 ?>

Ámbito de Parámetros:

Las variables definidas como parámetros en una función solo existen dentro de esa función.

Ejemplo:

<?php 
function sumar($a, $b) {  return $a + $b; 
} 
echo sumar(5, 10); // Salida: 15 ?>

Uso de Variables Dinámicas

PHP permite el uso de variables dinámicas, lo que significa que el nombre de una variable puede generarse de manera dinámica durante la ejecución.

Ejemplo:

<?php 
$nombre = "usuario"; $$nombre = "Juan"; echo $usuario; // Salida: Juan ?> En este caso se crea una variable llamada $usuario cuyo valor es "Juan".

Funciones para Manipular Variables

PHP proporciona una serie de funciones útiles para trabajar con variables:

Comprobación del tipo de dato:

is_int($variable): Verifica si es entero.

is_string($variable): Verifica si es cadena.

is_bool($variable): Verifica si es booleano.

Verificación de existencia:

isset($variable): Verifica si una variable está definida y no es null.

Ejemplo:

<?php $edad = 25; echo isset($edad); // Salida: 1 (true) ?>

Eliminación de variables:

unset($variable): Elimina una variable de la memoria.

Ejemplo:

<?php $nombre = "Ana"; unset($nombre); echo isset($nombre); // Salida: (nada) ?>

Ejemplo Práctico Completo

<?php
// Declaración de variables
$nombre = "Carlos";
$edad = 29;
$altura = 1.82;

// Mostrar información
echo "Nombre: $nombre" . PHP_EOL;
echo "Edad: $edad años" . PHP_EOL;
echo "Altura: $altura metros" . PHP_EOL;

// Función con variables locales y globales
$saludo = "¡Bienvenido!";

function mostrarSaludo() {
    global $saludo; // Acceso a la variable global
    echo $saludo;
}

mostrarSaludo(); // Salida: ¡Bienvenido!

// Uso de variables estáticas
function incrementar() {
    static $contador = 0;
    $contador++;
    echo "Contador: $contador" . PHP_EOL;
}

incrementar(); // Salida: Contador: 1
incrementar(); // Salida: Contador: 2
?>

Constantes en PHP

Las constantes en PHP son valores que no cambian durante la ejecución del script. A diferencia de las variables, las constantes no comienzan con el signo de dólar ($) y se definen utilizando funciones o palabras clave específicas. Son útiles para almacenar datos que permanecen inmutables, como configuraciones, rutas o claves de acceso.

Características de las Constantes

1. Inmutables:
   Una vez que se define una constante, no es posible cambiar su valor ni volver a declararla.
2. Globales:
   Las constantes son accesibles desde cualquier parte del script, independientemente del ámbito donde se definan.
3. Definición única:
   No pueden ser eliminadas ni redefinidas una vez declaradas.

Definición de Constantes

PHP ofrece dos formas principales para definir constantes:

1. Mediante la función define().
2. Utilizando la palabra clave const.

Definir constantes con define()

La función define() permite crear una constante asignándole un nombre y un valor.

Sintaxis:

define(string $nombre, mixed $valor, bool $sensible_a_mayusculas = false);

$nombre: El nombre de la constante.

$valor: El valor que se asignará a la constante.

$sensible_a_mayusculas: (opcional) Define si la constante distingue entre mayúsculas y minúsculas (por defecto es false).

Ejemplo básico:

<?php define("PI", 3.14159); echo PI; // Salida: 3.14159 ?>

Ejemplo con sensibilidad a mayúsculas:

<?php define("SALUDO", "Hola Mundo", true); // Sensible a mayúsculas echo SALUDO; // Salida: Hola Mundo echo saludo; // También imprime: Hola Mundo ?> 

@Tip: Definir constantes insensibles a mayúsculas está obsoleto desde PHP 7.3. Se recomienda evitar esta práctica.

Definir constantes con const

La palabra clave const se utiliza para definir constantes en tiempo de compilación y tiene algunas diferencias con define().

Restricciones: Solo permite valores escalares (int, float, string, bool).

Ámbito: Solo se puede usar dentro de clases o scripts principales.

Ejemplo:

<?php const VERSION = "1.0.0"; echo VERSION; // Salida: 1.0.0 ?>

Uso en clases:

<?php const VERSION = "1.0.0";echo VERSION; // Salida: 1.0.0 ?>

Diferencias entre define() y const

Característica	define()	const
Definición dinámica	Sí	No
Disponible en expresiones	No	Sí
Uso en clases	No	Sí
Ámbito	Global	Depende del contexto

Constantes Predefinidas

PHP proporciona un conjunto de constantes predefinidas que ofrecen información sobre el entorno o la configuración del servidor:

Constantes Mágicas:
Son constantes especiales que cambian dependiendo del contexto donde se utilizan.

• Ejemplo:

<?php
echo __FILE__; // Ruta completa del archivo actual
echo __LINE__; // Número de línea donde se encuentra esta constante
?>

Principales constantes mágicas:

__DIR__: Directorio del archivo.

__FILE__: Ruta completa del archivo.

__LINE__: Línea actual.

__FUNCTION__: Nombre de la función en uso.

Constantes del Lenguaje:
Proporcionan información sobre el entorno de PHP.

Ejemplo:

<?php echo PHP_VERSION; // Versión actual de PHP echo PHP_OS; // Sistema operativo del servidor ?>

Ventajas del Uso de Constantes

• Inmutabilidad: Garantiza que los valores no serán modificados accidentalmente durante la ejecución del script.
• Legibilidad: Los nombres de las constantes suelen ser autodescriptivos, mejorando la comprensión del código.
• Reusabilidad: Evitan repetir valores en diferentes partes del código, centralizando configuraciones.
• Eficiencia: Al ser globales, las constantes son fáciles de acceder y no requieren sobrecarga en memoria.

Buenas Prácticas para el Uso de Constantes

Utiliza nombres descriptivos y en mayúsculas:

<?php define("TASA_IVA", 0.21); ?>

Centraliza la declaración de constantes en un archivo de configuración:

<?php // config.php define("BASE_URL", "https://miaplicacion.com"); define("DB_HOST", "localhost"); ?>

@Tip. Evita redefinir constantes dentro del código para mantener la consistencia.

Usa const siempre que sea posible, especialmente en clases y estructuras de configuración.

Ejemplo Práctico Completo

<?php
// Definición de constantes
define("APP_NOMBRE", "MiAplicación");
const VERSION = "1.2.0";

// Uso de constantes predefinidas
echo "Aplicación: " . APP_NOMBRE . PHP_EOL;
echo "Versión: " . VERSION . PHP_EOL;
echo "Este archivo está en: " . __DIR__ . PHP_EOL;

// Clase con constantes
class Configuracion {
    const BASE_DATOS = "MySQL";
    const MAX_CONEXIONES = 10;
}

echo "Base de datos: " . Configuracion::BASE_DATOS . PHP_EOL;
echo "Máx. conexiones permitidas: " . Configuracion::MAX_CONEXIONES . PHP_EOL;
?>

---

En este capítulo, hemos explorado uno de los fundamentos más importantes de PHP: los tipos de datos, las variables y las constantes. Comprender cómo declarar, asignar y utilizar variables es clave para manejar información en un programa, mientras que el uso correcto de constantes asegura la integridad de los valores inmutables a lo largo del script.

Además, hemos aprendido sobre las reglas de nomenclatura de las variables, los diferentes ámbitos en los que pueden existir, y cómo manipularlas para construir aplicaciones dinámicas y funcionales. Esta base sólida nos permitirá avanzar hacia el uso de operadores y estructuras de control, herramientas esenciales para darle lógica y flexibilidad a nuestros programas en PHP.

En el próximo capítulo, profundizaremos en los operadores en PHP, aprendiendo cómo realizar cálculos, comparar valores y manipular datos para tomar decisiones y controlar el flujo de nuestros scripts. ¡Sigamos aprendiendo!

Bibliografía de programación en PHP.

• Aprende PHP desde Cero: Todo lo que necesitas para programar en PHP. Autor: Gerardo G. Urtiaga (Editorial: Editorior Independiente)
• PHP y MySQL: Domine el desarrollo de un sitio web dinámico e interactivo. Autor: Olivier Heurtel (Editorial: Ediciones ENI)
• PHP 8: Programación de aplicaciones web en el servidor: Guía paso a paso con ejemplos y proyectos prácticos. Autor: Jose Vicente Cerratlá.

SanDisk Pendrive 64 GB Ultra Memoria flash USB 3.0 hasta 130 MB/s

5,90€

(SecureAccess Software, Protección de contraseñas) Negro.

Toshiba Canvio Partner 1TB Disco Duro Externo portátil de 2,5», USB 3.2

63,99€

(Toshiba Canvio Partner 1TB Disco Duro Externo portátil de 2,5», USB 3.2, Compatible con Mac y Windows. Xbox, PS4, PS5 (HDTB510EK3AB)

TP-Link LS105G – Switch Ethernet 5 Puertos (10/100/1000Mbps), Switch Gigabit, Switch WiFi

11,99€

TP-Link LS105G – Switch Ethernet 5 Puertos (10/100/1000Mbps), Switch Gigabit, Switch WiFi, Carcasa metálica, Ultraligero, Disipación de Calor, QoS, Ahorro de Energía, Silencioso, No Gestionado, Azul