Estudio de Funciones y Clases Complejas en PHP

Funciones

Funciones de Validación y Depuración

is_null()
- Entorno de uso: Validación de variables
- Utilidad: Verifica si una variable es null
- Ejemplo:
```
$var = null;
if (is_null($var)) {
    echo "La variable es null";
}
```
empty()
- Entorno de uso: Validación de formularios o datos
- Utilidad: Comprueba si una variable está vacía ("", 0, null, false, etc.)
- Ejemplo:
```
$input = "";
if (empty($input)) {
    echo "Campo vacío";
}
```
isset()
- Entorno de uso: Validación de existencia de variables
- Utilidad: Verifica si una variable está definida y no es null
- Ejemplo:
```
if (isset($_REQUEST['nombre'])) {
    echo $_REQUEST['nombre'];
}
```
var_dump()
- Entorno de uso: Depuración
- Utilidad: Muestra información detallada de una variable
- Ejemplo:
```
var_dump($array);
```

Funciones de Fecha y Texto

date()
- Entorno de uso: Manejo de fechas
- Utilidad: Formatea la fecha actual
- Ejemplo:
```
echo date("Y-m-d H:i:s");
```
nl2br()
- Entorno de uso: Salida HTML
- Utilidad: Convierte saltos de línea (\n) en etiquetas <br>
- Ejemplo:
```
echo nl2br("Línea 1\nLínea 2");
```
htmlspecialchars()
- Entorno de uso: Seguridad en formularios
- Utilidad: Convierte caracteres especiales en HTML seguro. Evita ataques XSS
- Ejemplo:
```
echo htmlspecialchars("<b>Hola</b>");
```

Funciones de Estructuras y Datos

list()
- Entorno de uso: Asignación múltiple
- Utilidad: Asigna múltiples variables desde un array
- Ejemplo:
```
list($a, $b) = [1, 2];
```
json_encode() / json_decode()
- Entorno de uso: Intercambio de datos (APIs)
- Utilidad: Convierte arrays/objetos en JSON.
- Ejemplo:
```
$json = json_encode(["nombre" => "Ana"]);
$array = json_decode($json, true);
```

Funciones de Archivos y Cabeceras

file_put_contents()
- Entorno de uso: Escritura de archivos
- Utilidad: Escribe contenido en un archivo
- Ejemplo:
```
file_put_contents("log.txt", "Registro de actividad");
```
basename()
- Entorno de uso: Manejo de rutas
- Utilidad: Extrae el nombre del archivo de una ruta
- Ejemplo:
```
echo basename("/ruta/archivo.txt");
```
header()
- Entorno de uso: Manipulación de cabeceras HTTP
- Utilidad: Modifica cabeceras HTTP
- Ejemplo:
```
header("Location: pagina.php");
```

Clases PHP

Almacenamiento de fechas en MySQL

MySQL proporciona varios tipos de datos para representar fechas:

`DATE`

Guarda únicamente la fecha (año, mes, día).
Formato: YYYY-MM-DD
Rango: del año 1000 al 9999
Usos típicos: cumpleaños, fechas de registros, vencimientos.

`DATETIME`

Guarda fecha y hora.
Formato: YYYY-MM-DD HH:MM:SS
No depende de la zona horaria del servidor.
Usos típicos: registros de eventos, logging, timestamps históricos.

`TIMESTAMP`

También guarda fecha y hora.
Formato: igual a DATETIME.
Sí depende de la zona horaria, convirtiendo valores al guardar y recuperar.
Rango limitado: 1970 a 2038.
Usos típicos: auditoría, última fecha de actualización, sincronización en sistemas distribuidos.

`TIME`

Representa solo tiempo (horas, minutos y segundos).
Usos: duración, intervalos, horas de apertura.

`YEAR`

Almacena solo el año.
Poco utilizado actualmente.

isset vs empty vs is_null

// Source - https://stackoverflow.com/a
// Posted by rjhdby, modified by community. See post 'Timeline' for change history
// Retrieved 2025-11-26, License - CC BY-SA 4.0

$a - variable con un valor distinto de null (e.g. TRUE)
$b - variable con valor null. `$b = null;`
$c - variable no declarada
$d - variable con valor que devuelve FALSE (ej. string vacío, FALSE o array vacío)
$e - variable declarada pero sin valor asignado
$a->a - declarada, pero no asignada propiedad object. (`public $a;`)
A::$a - declarada, pero no asignada propiedad static class.

         |   $a  |   $b  |   $c  |   $d  |   $e  | $a->a | A::$a |
---------+-------+-------+-------+-------+-------+-------+-------+
is_null()| FALSE | TRUE  |TRUE*W | FALSE | TRUE*W| TRUE  | TRUE  |
---------+-------+-------+-------+-------+-------+-------+-------+
isset()  | TRUE  | FALSE | FALSE | TRUE  | FALSE | FALSE | FALSE |
---------+-------+-------+-------+-------+-------+-------+-------+
empty()  | FALSE | TRUE  | TRUE  | TRUE  | TRUE  | TRUE  | TRUE  |
---------+-------+-------+-------+-------+-------+-------+-------+
null === | FALSE | TRUE  |TRUE*W | FALSE | TRUE*W| TRUE  | TRUE  |
---------+-------+-------+-------+-------+-------+-------+-------+
null ==  | FALSE | TRUE  |TRUE*W | TRUE  | TRUE*W| TRUE  | TRUE  |
---------+-------+-------+-------+-------+-------+-------+-------+

TRUE*W - function return TRUE, but same time emits WARNING.

`DateTime`

Entorno de uso: Fechas y marcas de tiempo
¿Cuándo se instancia?: new DateTime()
Utilidad: Manipulación avanzada de fechas
Atributos utilizados: timezone, date
Métodos utilizados:
- format()
- modify()
- add()
- diff()

Ejemplo:

$fecha = new DateTime();
echo $fecha->format('Y-m-d');

`PDO`

Entorno de uso: Conexión a bases de datos
¿Cuándo se instancia?: Al crear una nueva conexión con new PDO($dsn, $usuario, $contraseña)
Utilidad: Abstrae el acceso a múltiples motores de bases de datos (MySQL, PostgreSQL, SQLite, etc.)
Atributos utilizados:
- DSN (Data Source Name)
- Usuario
- Contraseña
Métodos utilizados:
- query($sql) — Ejecuta una consulta SQL directamente
- prepare($sql) — Prepara una consulta para ejecución segura
- exec($sql) — Ejecuta una consulta sin retorno de resultados
- setAttribute($clave, $valor) — Configura opciones de conexión

Ejemplo:

try {
    $pdo = new PDO("mysql:host=localhost;dbname=tienda", "username", "paso");
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    echo "Conexión exitosa";
} catch (PDOException $e) {
    echo "Error de conexión: " . $e->getMessage();
}

`PDO Statement`

Entorno de uso: Ejecución de consultas preparadas en PDO
¿Cuándo se instancia?: Al llamar a $pdo->prepare($sql)
Utilidad: Representa una sentencia preparada, permitiendo ejecutar consultas seguras con parámetros
Atributos utilizados:
- Parámetros de consulta (bindParam, bindValue)
- Modo de obtención (setFetchMode)
Métodos utilizados: (Los heredados de Exception)
- execute([$params]) — Ejecuta la sentencia preparada
- fetch($modo) — Obtiene una fila del resultado
- fetchAll($modo) — Obtiene todas las filas
- bindParam($clave, $variable) — Vincula un parámetro por referencia
- bindValue($clave, $valor) — Vincula un valor directamente
- rowCount() — Devuelve el número de filas afectadas
- closeCursor() — Libera la conexión para nuevas consultas
Ejemplo:

$pdo = new PDO("mysql:host=localhost;dbname=tienda", "user", "pass");

$sentencia = $pdo->prepare("SELECT * FROM productos WHERE categoria = :cat");
$sentencia->bindValue(":cat", "tecnologia");
$sentencia->execute();

$resultados = $sentencia->fetchAll(PDO::FETCH_ASSOC);
print_r($resultados);

`PDO Exception`

Entorno de uso: Manejo de errores en operaciones con PDO
¿Cuándo se instancia?: Automáticamente cuando ocurre un error en PDO y el modo de error está configurado como PDO::ERRMODE_EXCEPTION
Utilidad: Representa las excepciones generadas por PDO, permitiendo capturar errores de conexión o consultas
Atributos utilizados:
- message — Mensaje descriptivo del error
- code — Código numérico del error
- file — Archivo donde ocurrió el error
- line — Línea donde ocurrió el error
Métodos utilizados: (Los heredados de Exception)
- getMessage() — Devuelve el mensaje del error
- getCode() — Devuelve el código del error
- getTrace() — Devuelve el seguimiento de pila
- getTraceAsString() — Devuelve el seguimiento como cadena
Ejemplo:

try {
      /* Contenido */
  } catch (PDOException $e) {
      echo "Error de conexión: " . $e->getMessage();
  }

`DOMDocument`

Entorno de uso: Manipulación y procesamiento de documentos XML y HTML
¿Cuándo se instancia?: Al crear un nuevo objeto con new DOMDocument()
Utilidad: Permite cargar, crear, modificar y guardar documentos XML/HTML mediante una API basada en nodos
Atributos utilizados:
- preserveWhiteSpace — Controla espacios en blanco
- formatOutput — Formatea la salida para que sea legible
Métodos utilizados: (Los heredados de Exception)
- load($archivo) — Carga un documento XML/HTML desde archivo
- loadXML($cadena) — Carga un documento desde una cadena
- save($archivo) — Guarda el documento en archivo
- saveXML() — Devuelve el XML como cadena
- createElement($nombre, $valor) — Crea un nuevo nodo
- appendChild($nodo) — Agrega un nodo al documento
Ejemplo:

$doc = new DOMDocument();
$doc->formatOutput = true;

$raiz = $doc->createElement("tienda");
$doc->appendChild($raiz);

$producto = $doc->createElement("producto", "Ordenador");
$raiz->appendChild($producto);

echo $doc->saveXML();

Entorno de uso	Clase	¿Cuándo se instancia?	Utilidad	Atributos utilizados	Métodos utilizados
Al trabajar con fechas y marcas de tiempo	DateTime	new	Manejo de fechas	timezone, date	format(), modify(), setDate(), setTime()
Al trabajar con bases de datos MySQL del modo viejo	MySQLi	new	Manejo de comunicaciones con una base de datos MySQL	host, username, password, dbname	query(), prepare(), connect(), close()
Al trabajar con bases de datos modernamente	PDO	new	Manejo de comunicaciones con una base de datos relacional	DSN, usuario, contraseña	query(), prepare(), exec(), setAttribute()
Al recibir resultados de un query	PDOStatement	Al utilizar el método prepare() o query() en un objeto PDO	Trabajar con el conjunto de resultados de un query	Parámetros de consulta, modo de obtención	fetchObject(), fetchAll(), execute(), bindValue()
Al ocurrir un error del SGBD	PDOException	Al saltar una excepción de PDO en un try	Controlar excepciones producidas en una base de datos relacional	message, code	getMessage(), getCode(), getTrace()
Al trabajar con documentos almacenamiento de datos	DOMDocument	new	Trabajar con documentos XML/HTML de forma cómoda y global	preserveWhiteSpace, formatOutput	createElement(), load(), save(), appendChild()
Al definir elementos en un fichero	DOMElement	Al usar el método createElement() en un objeto DOMDocument	Definir elementos DOM para estructurar un fichero de almacenamiento	tagName, attributes	appendChild(), setAttribute()
Al usar el método appendChild() en un objeto DOMElement	DOMNode	Al usar el método appendChild() en un objeto DOMDocument o DOMElement	Definir cualquier nodo dentro de un documento para estructurar el fichero	nodeName, nodeValue, nodeType	appendChild(), cloneNode(), removeChild()
Al trabajar con ficheros XML	SimpleXMLElement	new	Trabajar cómodamente con ficheros XML	children, attributes	asXML(), xpath(), children()