# PHP 7.0: Speed and Type Declarations in the Long-Awaited Release

> PHP 7.0 was released this week. I share my first impressions on the performance gains, scalar type declarations, and return types.

- Published: 2015-12-06
- Category: Languages
- Tags: PHP
- Reading time: 3 min read
- Source: https://www.muhammetsafak.com.tr/en/blog/php-7-0-the-long-awaited-release-speed-and-type-declarations/
- Language: en-US
- Author: Muhammet Şafak

---
PHP 7.0 was officially released this week. It's the biggest version jump since PHP 5.0. It had been talked about for years — in community polls, at conferences, on developer blogs. I've spent the last few days reading about it and running tests, so I wanted to share my first impressions.

A quick caveat: this post is not a deep-dive guide to PHP 7.0. The release just dropped this week and I haven't used it in a production project yet. But the standout changes are noteworthy enough to write about.

## Performance gains

The most talked-about feature in PHP 7.0 isn't a language feature — it's the engine. **Zend Engine 3** (the core of PHP) has been rewritten. The benchmarks on PHP.net show up to **twice the speed** compared to [PHP 5.6](/en/blog/php-5-6-new-features-variadic-functions-and-exponentiation-operator) on real-world applications. Tests against popular apps like WordPress, Drupal, and Magento show significant improvement as well.

A leap that large doesn't come from a language feature alone — it comes from optimizations at the engine level. Memory usage is down too. I haven't felt the full practical impact beyond test environments yet, but the numbers are impressive.

## Scalar type declarations

In PHP 5.x, type declarations in function signatures were only possible for classes, interfaces, and `array`. Primitive (scalar) types like `int`, `float`, `string`, and `bool` were not supported.

PHP 7.0 changes that:

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

echo topla(3, 4);   // 7
echo topla(3.7, 4); // 7 — PHP coerces 3.7 to 3
```

The default behavior is **coercive mode** — PHP attempts to convert the value where possible. To enable strict mode, add this at the top of your file:

```php
declare(strict_types=1);
```

In strict mode, calling `topla(3.7, 4)` throws a `TypeError`. Which mode you use depends on your needs, but strict mode makes intent far more explicit.

## Return type declarations

It's not just parameters — return types can be declared on functions too:

```php
function bolKelimeler(string $cumle): array
{
    return explode(' ', $cumle);
}

function tamSayi(float $sayi): int
{
    return (int) $sayi;
}
```

The `void` return type isn't in PHP 7.0 yet (it's coming in 7.1), but `int`, `float`, `string`, `bool`, `array`, `callable`, and class names are all supported. This makes function contracts much more readable — you can tell what a function returns just from its signature, without reading the body.

## Combined comparison operator: <=>

Also known as the "spaceship operator." It compares two values and returns -1, 0, or 1:

```php
echo 1 <=> 2;  // -1 (left is smaller)
echo 2 <=> 2;  //  0 (equal)
echo 3 <=> 2;  //  1 (left is larger)
```

It's particularly handy when writing sort callbacks for functions like `usort()`:

```php
usort($kullanicilar, function ($a, $b) {
    return $a->yas <=> $b->yas;
});
```

Previously you'd write `if ($a > $b) return 1; elseif ($a < $b) return -1; return 0;`.

## Null coalescing operator: ??

Shorthand for an `isset()` check combined with a default value:

```php
// Old way
$isim = isset($_GET['isim']) ? $_GET['isim'] : 'Misafir';

// PHP 7.0
$isim = $_GET['isim'] ?? 'Misafir';
```

Multiple nulls can be chained:

```php
$deger = $a ?? $b ?? $c ?? 'varsayilan';
```

## Anonymous classes

PHP 7.0 introduces **anonymous class** support. Instead of defining a full class just to create a one-off object:

```php
$logger = new class {
    public function log(string $mesaj): void
    {
        echo date('H:i:s') . ' — ' . $mesaj . PHP_EOL;
    }
};

$logger->log('Bir şey oldu.');
```

Creating objects without naming a class is useful when writing tests or for short-lived usage patterns.

## What now?

PHP 7.0 just came out; it makes sense to wait a few months before moving production workloads over. You'll want to [audit your dependencies](/en/blog/switching-to-composer-stop-managing-php-dependencies-by-hand) for compatibility and confirm framework support. [Laravel 5.1](/en/blog/migrating-to-laravel-5-directory-structure-and-env) and Symfony 3.0 have been prepared for PHP 7.0 support.

But there's no reason not to set it up in a test environment and start experimenting. Scalar type declarations and the performance improvements signal that PHP is maturing into a more serious platform. These are steps the community has been waiting a long time to see.