Apuntes php

PHP: Porque a veces necesitas un poco de caos en tu vida.

Introducción a las Variables

Las variables son una de las bases de PHP, y de todo lenguaje de programación.
Imagina que tuvieses una calculadora que solo pudiera multiplicar 3x4. No sería nada útil.
Todo lenguaje de programación necesita una forma temporal de almacenar valores variables y ser capaz de operar con ellos. En esta lección aprenderás qué son, cómo crearlas, y cómo utilizarlas.

Concepto

Una variable es un espacio en la memoria donde guardas un valor (como un número o texto) y le das un nombre para usarlo en tu script.
En PHP, las variables son muy flexibles: no necesitas declararlas antes ni decir de qué tipo son.

Reglas para nombrar variables

  • Siempre empiezan con un signo $ (por ejemplo, $ciudad).
  • El nombre puede incluir letras (a-Z), números (0-9), o guiones bajos (_).
  • El primer carácter no puede ser un número.
  • PHP distingue entre mayúsculas y minúsculas: $var y $Var son diferentes.
  • No uses espacios ni caracteres especiales (como @, #).

Ejemplo:

<?php
$ciudad = "Madrid";     // Válido
$edad_2 = 25;           // Válido
$_contador = 0;         // Válido
$2edad = 30;            // ¡Inválido! No puede empezar con número
$mi_nombre = "Juan";    // Válido (guion bajo en lugar de espacio)
?>

Para crear una variable, usa el operador = para asignarle un valor:

<?php
$ciudad = "Madrid";     // $ciudad vale "Madrid"
$ciudad = "Zaragoza";   // Ahora vale "Zaragoza"
$Ciudad = "Barcelona";  // Variable distinta por la mayúscula
?>

Si el valor es texto (una cadena, o string), debe ir entre comillas (" o '). Los números no necesitan comillas.

Tipos de variables

Las variables pueden guardar diferentes tipos de valores:

  • Integer: Número entero (por ejemplo, 5).
  • Float: Número con decimales (por ejemplo, 3.14).
  • String: Texto o caracteres (por ejemplo, "Hola").
  • Boolean: Verdadero (true) o falso (false).
  • Array: Lista de valores (lo veremos más adelante).
  • Null: Sin valor.

Ejemplo:

<?php
$entero = 1;            // Integer
$decimal = 1.5;         // Float
$texto = "Hola";        // String
$es_verdadero = true;   // Boolean
$sin_valor = null;      // Null
$fecha = date("Y");     // String (año actual)
?>

Nota: Usa comillas para cadenas y resultados de funciones que devuelven texto. Números, true, false, y null van sin comillas.

Operaciones con variables

Puedes usar variables para cálculos o combinar texto:

<?php
$precio = 10;
$cantidad = 3;
$total = $precio * $cantidad;
echo "El total es: $total\n"; // Imprime: El total es: 30

$nombre = "Ana";
$saludo = "¡Hola, " . $nombre . "!";
echo $saludo; // Imprime: ¡Hola, Ana!
?>

En el ejemplo, $total almacena el resultado de multiplicar $precio y $cantidad. Luego, se imprime el resultado.

El operador . une cadenas (concatenación). También puedes incluir variables dentro de comillas dobles:

<?php
$nombre = "Ana";
echo "¡Hola, $nombre!\n"; // Imprime: ¡Hola, Ana!
?>

Tipado (casting) de variables

PHP decide el tipo de una variable según su valor y el contexto. Por ejemplo, si sumas una cadena numérica ("5") con un número (3), PHP convierte la cadena a número:

<?php
$cadena = "5";          // String
$entero = 3;            // Integer
echo $cadena + $entero; // Imprime: 8 (convierte "5" a 5)
?>

A veces demasiada flexibilidad puede provocar errores. Como ves en el ejemplo anterior, un número, según los casos, puede ser un entero, o puede ser un caracter de texto. Si tu programa espera un número entero y recibe una cadena, mostrará error.
Es buena práctica por eso comprobar el tipo de valor almacenado en la variable antes de operar con ella. Para ello usamos casting o settype(): Casting: Pones el tipo entre paréntesis, como (int)$variable. Es rápido, claro y la forma más común. - settype(): cambia el tipo con una función, como settype($variable, "integer"). También unciona, pero es menos usado.

Ejemplo:

<?php
$mivar = "3";           // String
$mivar = 2 + $mivar;    // Se convierte a integer (vale 5)

$mivar = (string)123;   // Forzamos a string ("123")
settype($mivar, "float"); // Cambiamos a float (123.0)

$mivar = (int)3.5;      // Forzamos a integer (3)
$mivar = (bool)3.5;     // Forzamos a boolean (true)
?>

Nota: Usa (int), (string), (float), etc., para mantener el código limpio.
settype() es una alternativa, pero menos común.

Averiguando el tipo de una variable

Para saber el tipo de una variable, usa gettype():

<?php
$mivar = "123";
echo gettype($mivar) . "\n"; // Imprime: string
$mivar = 123;
echo gettype($mivar) . "\n"; // Imprime: integer
?>

Chequeando tipos concretos

Si quieres verificar si una variable es de un tipo específico, usa funciones como is_string(), is_int(), etc. Devuelven true (1) o false (0):

<?php
$mivar = "123";                // entrecomillado: es una cadena
echo is_string($mivar) . "\n"; // Imprime: 1 (true)
echo is_int($mivar) . "\n";    // Imprime: 0 (false)

$mivar = 123;
echo is_int($mivar) . "\n";    // Imprime: 1 (true)
?>

Otras funciones útiles para trabajar con variables:

  • is_array() - Verifica si es un array.
  • is_bool() - Comprueba si es un booleano.
  • is_float() - Determina si es un número decimal (también para doubles).
  • is_int() (o is_integer()) - Indica si es un entero.
  • is_null() - Comprueba si el valor es null.
  • is_numeric() - Verifica si el valor es un número o si puede interpretarse como un número, incluyendo cadenas numéricas.
  • is_string() - Determina si el valor es una cadena de texto.
  • is_object() - Indica si es un objeto.
  • is_resource() - Comprueba si es un recurso.
  • is_scalar() - Verifica si es un integer, float, string o boolean.

Nota importante: Los datos de formularios (GET o POST) siempre llegan como string. Un número enviado por un formulario no pasará is_int(), pero sí is_numeric(): 

<?php
$entrada = "123"; // Simula un dato de formulario
echo is_int($entrada) . "\n";    // Imprime: 0 (false)
echo is_numeric($entrada) . "\n"; // Imprime: 1 (true)
?>

Valores por referencia

Normalmente, asignar un valor a una variable crea una copia. Pero con referencias, haces que dos variables apunten al mismo valor, como si fueran apodos para el mismo dato. Usa el operador &: 

<?php
$puntos = 10;           // Puntos iniciales
$mostrar = &$puntos;    // Referencia a $puntos
$mostrar += 5;          // Sumamos 5
echo "$puntos, $mostrar"; // Imprime: 15, 15 (¡ambos cambiaron!)
?>

Ejemplo práctico (contador en función): Imagina que quieres contar visitas sin devolver el valor:

<?php
function contar_visita(&$contador) { // & modifica la variable original
    $contador++;
}

$visitas = 0;
contar_visita($visitas);
echo $visitas; // Imprime: 1

//ahora a la misma función pasamos una variable. El valor original no se modifica
function contar_visitas($contador) {
    $contador++;
}

$visitas = 10;
contar_visitas($visitas);
echo $numero; // Salida: 10 (la función no modificó la variable original)

?>

Las referencias son útiles para: - Modificar variables dentro de funciones. - Ahorrar memoria con datos grandes. - Sincronizar cambios entre variables.

Variables constantes

Las constantes son valores que una vez definidas no cambian durante la ejecución del script. Se definen con define() o const y no usan $:

<?php
define("AUTOR_EMAIL", "blah@miemail.com"); // Con define()
const SITIO = "miweb.com";                // Con const

echo AUTOR_EMAIL . "\n"; // Imprime: blah@miemail.com
echo SITIO . "\n";       // Imprime: miweb.com
                         // "\n" inserta un salto de línea
?>

Diferencias: - define(): Flexible, se usa en cualquier parte (incluso en condicionales).
- const: Más limpio, pero solo en el ámbito global o clases.


Verificar constantes: Usa defined() para comprobar si existe:

<?php
if (defined("AUTOR_EMAIL")) {
    echo "La constante está definida.\n";
}
?>

Constantes predefinidas:
PHP ofrece muchas constantes predefinidas, estos son solo algunos ejemplos: 

<?php
echo __FILE__ . "\n";    // Nombre del archivo
echo __LINE__ . "\n";    // Línea actual
echo PHP_VERSION . "\n"; // Versión de PHP
echo PHP_OS . "\n";      // Sistema operativo
echo TRUE . "\n";        // 1 (verdadero)
echo FALSE . "\n";       // (vacío, falso)
echo NULL . "\n";        // (vacío, sin valor)
?>

Variables de variables

Puedes usar el valor de una variable como el nombre de otra variable: 

<?php
$var = "ciudad";
$$var = "Madrid"; // Crea $ciudad con valor "Madrid"
echo $ciudad;     // Imprime: Madrid
?>

Ejemplo práctico (formulario): Supongamos que procesas campos de un formulario dinámicamente:

<?php
$campo = "nombre";
$$campo = "Ana"; // Crea $nombre con valor "Ana"
echo $nombre;    // Imprime: Ana

$campo = "edad";
$$campo = 25;    // Crea $edad con valor 25
echo $edad;      // Imprime: 25
?>

Esto es útil para: - Crear variables dinámicamente (por ejemplo, desde formularios). - Configurar nombres basados en bucles o datos externos.

Advertencia: Úsalas con cuidado, porque pueden hacer el código confuso.

Siguiente

Alcance de variables (global, local, estático) y su uso.

TOP