--- title: 'PHP 7.1 from 7.0: Nullables, void, Symmetric Destructuring & Migration | DevSense' description: 'Guía de actualización de PHP 7.1: tipos nullables, retornos void, visibilidad de constantes de clase, desestructuración simétrica de arrays, pseudo-tipo iterable, multi-catch y compensaciones de cadena negativas.' faq: - { question: '¿Qué son los tipos nullables en PHP 7.1?', answer: "Los tipos nullables permiten que los parámetros y los tipos de retorno acepten el tipo especificado o null, anteponiendo un signo de interrogación al nombre del tipo (por ejemplo, '?string')." } - { question: "¿Cómo se comporta el tipo de retorno 'void'?", answer: "Una función declarada con tipo de retorno 'void' debe omitir la sentencia return o usar un 'return;' vacío. Devolver cualquier valor, incluido 'null', provocará un Fatal Error." } - { question: '¿Qué es la desestructuración simétrica de arrays?', answer: "La desestructuración simétrica de arrays permite usar la sintaxis corta de arrays ('[]') en lugar de 'list()' para desempaquetar arrays (por ejemplo, '[$a, $b] = $arr'), y admite especificar claves." } - { question: '¿Cómo funciona la visibilidad de las constantes de clase?', answer: "PHP 7.1 introduce la posibilidad de declarar constantes de clase como 'public', 'protected' o 'private', coincidiendo con las reglas de visibilidad de propiedades y métodos." } published: '2026-05-31' --- # PHP 7.1: Características Principales ¿Qué pasaría si pudiera capturar tres tipos de excepción diferentes en un solo bloque sin repetir los redundantes bloques catch? ¿O definir constantes de clase que estén estrictamente protegidas del acceso externo? PHP 7.1 introduce estas capacidades, aportando un tipado seguro robusto y mayor expresividad a las arquitecturas PHP modernas. Mejora los sistemas de tipos y la sintaxis con tipos nullables, funciones void, desestructuración simétrica de arrays con claves, visibilidad de constantes de clase y captura de excepciones múltiples (multi-catch). ## Índice * [Tipos nullables](#nullable-types) * [Funciones void](#void-functions) * [Desestructuración simétrica de arrays](#symmetric-destructuring) * [Visibilidad de constantes de clase](#constant-visibility) * [Pseudo-tipo `iterable`](#iterable-type) * [Capturar múltiples tipos de excepciones (Multi-catch)](#multi-catch) * [Claves en list / desestructuración corta](#destructuring-keys) * [Soporte para offsets de cadena negativos](#negative-offsets) * [Extensiones destacadas y stdlib](#extensions-stdlib) * [Recetas prácticas](#practical-recipes) * [Errores Comunes](#common-mistakes) * [Limitaciones](#limitations) * [Cambios incompatibles con versiones anteriores](#backward-incompatible) * [Depreciaciones (corregir pronto)](#deprecations) * [Otros cambios](#other-changes) * [Quiz interactivo](#interactive-quiz) * [Reflexiones finales](#closing-thoughts) --- ## Tipos nullables Puede anteponer **`?`** a cualquier indicación de tipo para permitir **`null`** como un valor válido además del tipo primario: ```php // src/UserService.php function findUser(int $id): ?User { return $id === 0 ? null : new User($id); } ``` > [!NOTE] > ¿Sabía que? En PHP 7.0, una indicación de tipo de `User` era absoluta: devolver `null` lanzaba un TypeError. Los tipos nullables resuelven esto sin obligar a los desarrolladores a prescindir por completo del tipado. --- ## Funciones void Las funciones que no devuelven nada utilizan **`void`**. Solo se permite un **`return;`** vacío o la omisión total de la sentencia return. Devolver cualquier otra cosa (incluido un **`return null;`** explícito) constituye un fallo en tiempo de compilación. ```php // src/Notifier.php function notify(string $message): void { echo $message; return; // Un return vacío es válido; devolver cualquier valor es un error de tipo } ``` > [!NOTE] > ¿Sabía que? `void` es un tipo solo de retorno. No puede utilizarlo para indicar el tipo de un parámetro de función (por ejemplo, `function foo(void $x)` no es válido). --- ## Desestructuración simétrica de arrays Desempaquete arrays usando la sintaxis corta de arrays **`[]`** como alternativa a **`list()`**: ```php // src/Config.php [$host, $port] = ['127.0.0.1', 3306]; ``` Esta sintaxis también se puede utilizar en bucles `foreach`: `foreach ($data as [$id, $name])`. --- ## Visibilidad de constantes de clase Las constantes pueden tener visibilidad **`public`**, **`protected`** o **`private`**: ```php // src/PaymentGateway.php class PaymentGateway { private const API_KEY = 'secret-key'; public const DEFAULT_TIMEOUT = 30; } ``` > [!NOTE] > ¿Sabía que? Las constantes tienen visibilidad `public` de forma predeterminada si no se declara ningún modificador, manteniendo la compatibilidad con versiones anteriores de PHP. --- ## Pseudo-tipo `iterable` Coincide con cualquier valor que satisfaga **`is_array()`** o sea una instancia de **`\Traversable`**: ```php // src/Collection.php function processItems(iterable $items): void { foreach ($items as $item) { // Funciona tanto para arrays como para objetos generadores/iteradores } } ``` --- ## Capturar múltiples tipos de excepciones (Multi-catch) Capture diferentes excepciones en un solo bloque usando el operador **`|`**: ```php // src/ApiConnector.php try { // Realizar petición API } catch (ConnectionException | ResponseException $e) { // Manejar cualquiera de los dos tipos de excepción aquí } ``` --- ## Claves en list / desestructuración corta Puede especificar claves al desestructurar arrays: ```php // src/UserProfile.php ['id' => $userId, 'name' => $username] = $user; ``` Esto funciona tanto para `list()` como para la nueva sintaxis corta `[]`. --- ## Soporte para offsets de cadena negativos Indexe cadenas desde el final utilizando números negativos: ```php // src/StrHelper.php $lastChar = 'abcdef'[-1]; // 'f' $sub = substr('abcdef', -3, -1); // 'de' ``` Los offsets negativos también se admiten para el acceso a caracteres de una cadena: `$str[-2] = 'z';`. --- ## Extensiones destacadas y stdlib * **cURL HTTP/2**: Soporte para push HTTP/2 y características de múltiples servidores. * **OpenSSL AEAD**: Añadido soporte para modos AEAD (GCM y CCM). * **`session_gc()`**: Expone de forma explícita la recolección de basura de sesiones estándar. --- ## Recetas prácticas ### Firma de método nullable ```php // src/recipes.php public function setName(?string $name): void { $this->name = $name; } ``` ### Desempaquetar filas de base de datos con claves ```php // src/recipes.php foreach ($rows as ['id' => $id, 'role' => $role]) { // ... } ``` --- ## ⚠️ Errores Comunes Aquí tiene los fallos típicos en PHP 7.1: ### 1. Devolver `null` desde una función `void` En PHP 7.1, devolver `null` explícitamente desde una función marcada como `void` provoca un error fatal. ```php // src/BadVoid.php // Malo: Devolver explícitamente null está prohibido en retornos void function doNothing(): void { return null; // Fatal Error: A void function must not return a value } ``` ```php // src/GoodVoid.php // Bueno: Use un return vacío o elimínelo por completo function doNothingGood(): void { return; } ``` ### 2. Asumir que `iterable` solo acepta arrays Comprobar `is_array()` en un parámetro `iterable` podría omitir generadores o clases iteradoras, causando errores de ejecución inesperados. ```php // src/BadIterable.php // Malo: Lanza errores si $items es un objeto Traversable en lugar de un array function dumpItems(iterable $items) { echo count($items); // Fatal Error si $items es un generador (no implementa Countable) } ``` ```php // src/GoodIterable.php // Bueno: Convierta a array si es necesario o use foreach (que maneja ambos casos) function dumpItemsGood(iterable $items) { foreach ($items as $item) { echo $item; } } ``` --- ## Limitaciones * **Tipos nullables**: No puede combinar tipos nullables con tipos Unión. Escribir `?int|string` es un error de sintaxis (los tipos unión se introducen en PHP 8.0). * **Visibilidad de constantes**: Fuerza el control de acceso pero no admite el tipado de las constantes de clase. Escribir `public const int TIMEOUT = 10;` sigue siendo un error de sintaxis hasta PHP 8.3. --- ## Cambios incompatibles con versiones anteriores ### Núcleo y tipos * **Lanzar error con muy pocos argumentos**: pasar demasiados pocos argumentos a una función definida por el usuario ahora lanza una excepción **`ArgumentCountError`** (en lugar de una advertencia). * **Comportamiento de los offsets de cadena**: el acceso a índices vacíos `[]` en cadenas **ya no es silencioso** ni se tolera de forma automática. * **`iterable` es una palabra reservada**: no puede nombrar una clase, interfaz o trait como `iterable`. --- ## Quiz interactivo Ponga a prueba sus conocimientos sobre PHP 7.1: 1. **¿Cuál de las siguientes afirmaciones es correcta acerca de una función con tipo de retorno `void`?** * A) Debe devolver `null` explícitamente. * B) No puede tener ninguna sentencia `return`. * C) Puede usar un `return;` vacío u omitirlo. * D) Devuelve `false` de forma predeterminada.
Haga clic para ver la respuesta **Respuesta correcta: C** Una función `void` puede usar una sentencia `return;` vacía para salir antes u omitirla por completo, pero devolver cualquier valor (incluso `null`) es un error de sintaxis.
2. **¿Qué excepción se lanza cuando se pasan muy pocos argumentos a una función de usuario en PHP 7.1?** * A) TypeError * B) ArgumentCountError * C) WarningException * D) Error
Haga clic para ver la respuesta **Respuesta correcta: B** PHP 7.1 eleva las advertencias por argumentos faltantes a una excepción capturable de tipo `ArgumentCountError`.
3. **¿Cómo se define una constante de clase a la que solo se puede acceder desde la propia clase?** * A) `private const MY_CONST = 1;` * B) `const private MY_CONST = 1;` * C) `protected const MY_CONST = 1;` * D) `private MY_CONST = 1;`
Haga clic para ver la respuesta **Respuesta correcta: A** PHP 7.1 permite que las constantes de clase utilicen modificadores de visibilidad estándar: `public const`, `protected const` o `private const`.
--- ## Reflexiones finales PHP 7.1 es una versión fundamental para lograr una **higiene estricta de tipos** y estructuras de datos más limpias. Convierta las estructuras `list()` antiguas a `[]`, añada el prefijo `?` a los argumentos opcionales y adapte sus capturas de excepciones para preparar su aplicación para PHP 7.2+.