PHP Espírito Santo

Grupo de desenvolvedores PHP do Espírito Santo. Notícias, ferramentas e novidades do ecossistema PHP.

· por Rogério Lino

FrankenPHP 1.14 com suporte ao PHP 8.6

Dois dias após o lançamento do PHP 8.6, o FrankenPHP 1.14 chegou tornando o PHP 8.6 a versão padrão.

Para quem ainda não conhece, FrankenPHP é um servidor de aplicação PHP construído em cima do servidor web Caddy, e desde 2025 faz parte da organização oficial do PHP no GitHub.

PHP 8.6 por padrão

  • Docker: as tags latest e as tags só com versão (1.14, 1) agora apontam para imagens com PHP 8.6. Versões anteriores continuam disponíveis pelas tags php8.x, por exemplo dunglas/frankenphp:1.14-php8.5.
  • Binários estáticos: compilados com PHP 8.6. Algumas extensões ainda não têm versão compatível (amqp, apcu, igbinary, imagick, lz4, memcached, msgpack, redis, xlswriter), então são compiladas a partir de branches de desenvolvimento ou pull requests.
  • Windows: binários do PHP 8.6 compilados com Visual Studio 2026.

Atenção ao atualizar

As imagens Docker com PHP 8.6 não incluem mais o mbstring nem o PECL. Instale as extensões necessárias com install-php-extensions:

FROM dunglas/frankenphp:1.14

RUN install-php-extensions mbstring

Quem quiser continuar no PHP 8.5 pode usar as tags php8.5.

file_server configurável no php_server

A diretiva php_server agora aceita um bloco file_server com qualquer opção do file_server do Caddy, exceto root:

php_server {
	file_server {
		precompressed zstd br gzip
	}
}

Notas da versão: https://github.com/php/frankenphp/releases/tag/v1.14.0

· por Rogério Lino

PHP 8.6 lançado

O PHP 8.6 foi lançado em 19 de novembro de 2026. Não é uma versão tão grande quanto o PHP 8.0 ou 8.1, mas traz várias novidades úteis no dia a dia.

Principais novidades:

  • Partial Function Application: chamar uma função com ? no lugar de alguns argumentos retorna uma closure que recebe o restante.
  • Classe \Time\Duration: representa um intervalo de tempo com precisão de nanossegundos, independente de fuso horário.
  • Função clamp(): mantém um valor dentro de um intervalo.
  • Enum SortDirection: substitui constantes inteiras para indicar a direção de ordenação.
  • Valores padrão em propriedades readonly.
  • Polling API (Io\Poll): monitora vários streams ao mesmo tempo usando epoll, kqueue, event ports ou WSAPoll, conforme a plataforma.
  • Tratamento de erros em streams com exceções.
  • DocComments em parâmetros de funções e métodos, acessíveis via ReflectionParameter::getDocComment().

Partial Function Application

$versions = ['8.4', '8.5', '8.6', '8.7', '9.0'];

$supportsPfa = array_filter(
    $versions,
    version_compare(?, '8.6', '>='),
);

\Time\Duration e clamp()

use Time\Duration;

function backoff(
    Duration $baseDelay,
    Duration $step,
    int $attempt,
): void {
    $delay = $baseDelay->add($step->multiplyBy(2 ** $attempt));

    // Durations são comparáveis, então min() funciona diretamente.
    $delay = min($delay, Duration::fromSeconds(30));

    time_nanosleep($delay->seconds, $delay->nanoseconds);
}

// Pré-configura os atrasos usando Partial Function Application.
$waitBeforeRetry = backoff(
    Duration::fromSeconds(1),
    Duration::fromMilliseconds(100),
    attempt: ?,
);
$waitBeforeRetry($attempt);
var_dump(clamp(-10, 0, 100));
// int(0)

var_dump(clamp(110, 0, 100));
// int(100)

Enum SortDirection

public function orderBy(
    string $column,
    SortDirection $direction = SortDirection::Ascending,
): static {
    $this->orderBy[] = $column . ' ' . match ($direction) {
        SortDirection::Ascending => 'ASC',
        SortDirection::Descending => 'DESC',
    };

    return $this;
}

Valores padrão em propriedades readonly

final readonly class SlugRule implements Rule
{
    public string $parser = SlugParser::class;
}

Erros de stream como exceções

$context = stream_context_create([
    'stream' => [
        'error_mode' => StreamErrorMode::Exception,
    ],
]);

try {
    $config = file_get_contents('/etc/app/config.json', context: $context);
} catch (StreamException $e) {
    foreach ($e->getErrors() as $error) {
        // $error->code é um caso do enum StreamErrorCode
        log_error($error->code->name, $error->message);
    }
}

Depreciações e quebras de compatibilidade

Algumas mudanças que merecem atenção na hora de atualizar:

  • return dentro de finally foi depreciado.
  • is_double(), is_long(), is_integer() e doubleval() foram depreciadas.
  • Funções de regex do mbstring (mb_ereg, mb_split etc.) foram depreciadas.
  • spl_object_hash() foi depreciada.
  • let e is como nomes de classes, funções ou constantes foram depreciados.
  • Sessões agora têm session.use_strict_mode e session.cookie_httponly ativados e session.cookie_samesite=Lax por padrão.
  • trim(), ltrim() e rtrim() passam a remover \f por padrão.

Anúncio oficial:

Português: https://www.php.net/releases/8.6/pt_BR.php Inglês: https://www.php.net/releases/8.6/en.php

Guia de migração: https://www.php.net/manual/en/migration86.php

· por Rogério Lino

Marko: o framework PHP modular

Marko é um framework PHP modular, criado por Mark Shust, que se propõe a combinar a extensibilidade do Magento com a experiência de desenvolvimento do Laravel. Requer PHP 8.5+ e ainda está em estágio inicial, com código aberto.

Principais conceitos:

  • Tudo é um módulo: cada funcionalidade (rotas, cache, autenticação, a própria aplicação) é um pacote Composer. Os módulos são carregados de app/, modules/ e vendor/, nessa ordem de prioridade.
  • Interface separada da implementação: por exemplo, marko/cache define a interface e marko/cache-file ou marko/cache-redis a implementam.
  • Injeção de dependência configurada em PHP puro (module.php), sem XML nem YAML.
  • Extensibilidade por atributos: #[Preference] para substituir uma classe, #[Plugin] com #[Before]/#[After] para interceptar métodos, e #[Observer] para eventos.
  • Erros explícitos: cada erro informa o que aconteceu, o contexto e uma sugestão de correção.

Instalação

composer create-project marko/skeleton my-app
cd my-app

Exemplo

As rotas são declaradas com atributos nos métodos do controller, e os parâmetros da URL são injetados pelo nome:

<?php

declare(strict_types=1);

use Marko\Routing\Attributes\Get;
use Marko\Routing\Http\Response;

class PostController
{
    #[Get('/posts/{id}')]
    public function show(int $id): Response
    {
        return Response::json(data: ['id' => $id]);
    }
}

O module.php de um módulo liga interfaces às implementações:

<?php

declare(strict_types=1);

use App\Blog\Repository\PostRepository;
use App\Blog\Repository\PostRepositoryInterface;

return [
    'bindings' => [
        PostRepositoryInterface::class => PostRepository::class,
    ],
    'singletons' => [
        PostRepository::class,
    ],
];

E para trocar a implementação de uma classe de outro módulo, basta um atributo:

#[Preference(replaces: FlatRate::class)]
class ZoneShipping extends FlatRate
{
    // ...
}

Mais detalhes na documentação oficial: https://marko.build/docs

Código-fonte: https://github.com/markshust/marko