---
title: 'PHP 7.0 from 5.6: Zend Engine 3, Scalar Types, ??, <=> & Migration | DevSense'
description: 'Guía de actualización de PHP 7.0: declaraciones de tipos escalares, tipos de retorno, coalescencia nula (??), operador spaceship (<=>), clases anónimas, Throwable, CSPRNG y cambios incompatibles importantes.'
faq:
    - { question: '¿Qué son las declaraciones de tipo escalar en PHP 7.0?', answer: "PHP 7.0 permite a los desarrolladores forzar tipos (int, float, string, bool) en los parámetros de las funciones. Al declarar 'declare(strict_types=1);' al comienzo de un archivo, se desactiva la conversión automática de tipos." }
    - { question: '¿Cómo funciona el operador de coalescencia nula (??)?', answer: "El operador de coalescencia nula ('??') devuelve su primer operando si existe y no es nulo; de lo contrario, devuelve su segundo operando. Es una abreviatura para las comprobaciones comunes con 'isset()'." }
    - { question: '¿Para qué se utiliza el operador spaceship (<=>)?', answer: "El operador spaceship ('<=>') compara dos expresiones. Devuelve -1 si el lado izquierdo es menor que el derecho, 0 si son iguales y 1 si el izquierdo es mayor, haciendo que las funciones de ordenación sean muy legibles." }
    - { question: '¿Cuál es la diferencia entre Exception y Throwable en PHP 7.0?', answer: "PHP 7.0 introduce la interfaz 'Throwable'. Tanto 'Exception' como la nueva clase 'Error' (que representa los errores del motor) implementan 'Throwable'. Debe capturar 'Throwable' para manejar ambas clases." }
published: '2026-05-31'
---
# PHP 7.0: Características Principales

¿Qué pasaría si pudiera duplicar el rendimiento de su aplicación de la noche a la mañana simplemente actualizando el motor de su lenguaje? PHP 7.0 logró exactamente eso. Impulsado por el nuevo Zend Engine 3, introdujo mejoras masivas de velocidad al tiempo que trajo tipos escalares estrictos, declaraciones de tipo de retorno y operadores modernos como la coalescencia nula. PHP 7.0 marca un salto monumental en la historia de PHP, estableciendo las bases para las aplicaciones web modernas de alto rendimiento y tipado seguro.

## Índice
* [Declaraciones de tipo escalar](#scalar-types)
* [Declaraciones de tipo de retorno](#return-types)
* [Operador de coalescencia nula (`??`)](#null-coalescing)
* [Operador spaceship (`<=>`)](#spaceship-operator)
* [Arrays constantes mediante `define()`](#constant-arrays)
* [Clases anónimas](#anonymous-classes)
* [Sintaxis de escape para puntos de código Unicode](#unicode-escape)
* [Declaraciones de uso agrupadas (Group use)](#group-use)
* [Interfaz Throwable y excepciones del motor (Engine Exceptions)](#throwable-exceptions)
* [Funciones CSPRNG](#csprng-functions)
* [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)

---

<a id="scalar-types"></a>
## Declaraciones de tipo escalar

Los parámetros escalares pueden usar indicaciones de tipo: **`int`**, **`float`**, **`string`** y **`bool`**:

```php
// src/Math.php
declare(strict_types=1);

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

> [!NOTE]
> ¿Sabía que? Sin `declare(strict_types=1);` al comienzo del archivo, PHP permanece en **modo coercitivo**, lo que significa que convertirá silenciosamente cadenas como `"5"` en enteros para cumplir con las comprobaciones de parámetros.

---

<a id="return-types"></a>
## Declaraciones de tipo de retorno

Definen qué tipo debe devolver obligatoriamente una función:

```php
// src/Generator.php
function generateId(): string 
{
    return uniqid();
}
```

Si una sentencia de retorno no coincide con este tipo, PHP lanzará una excepción **`TypeError`**.

---

<a id="null-coalescing"></a>
## Operador de coalescencia nula (`??`)

Azúcar sintáctico para las comprobaciones `isset()`:

```php
// src/Config.php
$username = $_GET['user'] ?? 'anonymous';
```

Se puede encadenar: `$value = $a ?? $b ?? $default;`.

---

<a id="spaceship-operator"></a>
## Operador spaceship (`<=>`)

Comparación de tres vías que devuelve `-1`, `0` o `1`:

```php
// src/SortHelper.php
usort($list, function($a, $b) {
    return $a <=> $b;
});
```

Útil para operaciones de ordenación donde las comparaciones estándar requerirían una lógica condicional verbosa.

---

<a id="constant-arrays"></a>
## Arrays constantes mediante `define()`

Define constantes de tipo array en tiempo de ejecución:

```php
// src/Constants.php
define('ALLOWED_ROLES', ['admin', 'editor', 'guest']);
```

Anteriormente, los arrays solo se podían definir como constantes dentro de clases usando `const`.

---

<a id="anonymous-classes"></a>
## Clases anónimas

Instancia objetos simples y desechables:

```php
// src/LoggerProvider.php
$logger = new class {
    public function log(string $msg) {
        echo $msg;
    }
};
```

Útil para simular (mock) interfaces durante las pruebas unitarias.

---

<a id="unicode-escape"></a>
## Sintaxis de escape para puntos de código Unicode

Incrusta símbolos Unicode directamente dentro de cadenas de texto:

```php
// src/Emoji.php
echo "\u{1F600}"; // Muestra un emoji sonriente 😀
```

---

<a id="group-use"></a>
## Declaraciones de uso agrupadas (Group use)

Importa limpiamente varias clases desde el mismo espacio de nombres:

```php
// src/Controller.php
use App\Models\{User, Post, Comment};
```

---

<a id="throwable-exceptions"></a>
## Interfaz Throwable y excepciones del motor (Engine Exceptions)

Los errores fatales y recuperables ahora se lanzan como excepciones de tipo **`Error`**. Captúrelos usando la interfaz **`Throwable`**:

```php
// src/ErrorHandler.php
try {
    nonExistentFunction();
} catch (Throwable $t) {
    // Captura tanto los errores del motor como las excepciones del usuario
    echo "Caught: " . $t->getMessage();
}
```

> [!NOTE]
> ¿Sabía que? `Error` no extiende de `Exception`. Capturar `Exception` no evitará que los errores del motor, como llamar a una función no definida, interrumpan la ejecución de su script. Use `Throwable` en su lugar.

---

<a id="csprng-functions"></a>
## Funciones CSPRNG

Genera valores aleatorios criptográficamente seguros directamente desde el sistema operativo:

```php
// src/TokenGenerator.php
$bytes = random_bytes(32);
$number = random_int(1, 100);
```

Estas funciones reemplazan a los generadores inseguros como `rand()` o `mt_rand()` para contextos de seguridad.

---

<a id="common-mistakes"></a>
## ⚠️ Errores Comunes

Aquí tiene los fallos típicos al migrar a PHP 7.0:

### 1. Olvidar declarar tipos estrictos
Sin declarar explícitamente los tipos estrictos por archivo, PHP se ejecuta en modo coercitivo y convierte silenciosamente los valores de los argumentos.
```php
// src/BadStrict.php
// Malo: El modo coercitivo está activo, la cadena \"10\" se convierte a entero de forma silenciosa
function setAge(int $age) {
    return $age;
}
setAge("10"); // No se lanza ningún error
```
```php
// src/GoodStrict.php
// Bueno: Active los tipos estrictos al principio del archivo
declare(strict_types=1);

function setAgeGood(int $age) {
    return $age;
}
// setAgeGood("10"); // Lanza un TypeError
```

### 2. Capturar `Exception` para manejar fallos del motor
Muchos desarrolladores capturaban `Exception` esperando que manejara errores como la división por cero, lo cual falla porque los errores del motor implementan `Error`.
```php
// src/BadCatch.php
// Malo: La división por cero lanza un DivisionByZeroError (que extiende de Error), el cual evade a Exception
try {
    $value = 1 / 0;
} catch (Exception $e) {
    echo "¡Este bloque no se ejecuta!";
}
```
```php
// src/GoodCatch.php
// Bueno: Capture Throwable o Error para capturar fallos del motor
try {
    $value = 1 / 0;
} catch (Throwable $e) {
    echo "Error capturado: " . $e->getMessage();
}
```

---

<a id="limitations"></a>
## Limitaciones

* **Declaraciones de tipo escalar**: No pueden ser nullables por defecto. Definir `int $x` y pasar `null` lanzará un TypeError (los tipos nullables llegan en PHP 7.1).
* **Declaraciones de tipo de retorno**: No pueden marcarse como retorno `void` (añadido en PHP 7.1) o múltiples tipos (tipos unión añadidos en PHP 8.0).

---

<a id="backward-incompatible"></a>
## Cambios incompatibles con versiones anteriores

### Cambios en el núcleo

* **Las etiquetas ASP (`<% %>`) y las etiquetas script (`<script language="php">`)** se eliminan por completo.
* **`$HTTP_RAW_POST_DATA`** se elimina; use `php://input` en su lugar.
* **Múltiples bloques predeterminados en un `switch`** lanzarán un ParseError.
* **Las variables globales y las llamadas dinámicas** se evalúan estrictamente de izquierda a derecha (por ejemplo, `$$foo['bar']` tiene un nuevo orden de evaluación).

---

<a id="interactive-quiz"></a>
## Quiz interactivo

Ponga a prueba sus conocimientos sobre PHP 7.0:

1. **¿Qué afirmación es verdadera con respecto a los tipos estrictos en PHP 7.0?**
   * A) Los tipos estrictos se habilitan globalmente a través de php.ini.
   * B) Los tipos estrictos deben declararse al principio de cada archivo en el que se deseen usar.
   * C) PHP 7.0 solo se ejecuta en modo estricto y no tiene modo coercitivo.
   * D) Los tipos estrictos solo se aplican a los tipos de retorno, no a los parámetros.

   <details>
   <summary>Haga clic para ver la respuesta</summary>
   
   **Respuesta correcta: B**  
   Los tipos estrictos se declaran por archivo usando `declare(strict_types=1);`.
   </details>

2. **¿Qué clase NO extiende de Exception pero implementa Throwable en PHP 7.0?**
   * A) RuntimeException
   * B) Error
   * C) BadMethodCallException
   * D) InvalidArgumentException

   <details>
   <summary>Haga clic para ver la respuesta</summary>
   
   **Respuesta correcta: B**  
   La nueva clase `Error` y sus subclases (como `TypeError` o `ParseError`) implementan `Throwable` pero no heredan de `Exception`.
   </details>

3. **¿Cuál es el tipo de retorno del operador spaceship (`<=>`)?**
   * A) Booleano
   * B) Float
   * C) Entero (`-1`, `0` o `1`)
   * D) Cadena de texto

   <details>
   <summary>Haga clic para ver la respuesta</summary>
   
   **Respuesta correcta: C**  
   El operador spaceship compara dos valores y devuelve `-1` si el izquierdo es menor, `0` si son iguales y `1` si el izquierdo es mayor.
   </details>

---

<a id="closing-thoughts"></a>
## Reflexiones finales

PHP 7.0 es un **hito revolucionario** en el desarrollo web. Asegúrese de que su servidor esté ejecutando Zend Engine 3, actualice su código heredado eliminando etiquetas ASP, convierta funciones aleatorias inseguras en sus equivalentes CSPRNG y reescriba las capturas de Exception a Throwable.