Por exemplo, imagine que você está implementando a classe ShoppingCart, que deve manipular uma lista de Product. Se você usar um array, ele será transportado apenas como um array em qualquer lugar do código, sem restrições sobre o que pode ser adicionado. Além disso, arrays no PHP são passados por cópia, e não por referência, o que pode impactar a performance e dificultar o controle de estado.

Aqui está um exemplo básico da classe Product:

<?php

class Product
{
    public function __construct(
    	public readonly string $name,
        public readonly float $price
    ) {}
}

Agora, veja como poderia ser a classe ShoppingCart:

<?php

class ShoppingCart
{
    private array $products = [];
    
    public function __construct(array $products = [])
    {
        $this->products = $products;
    }
    
    public function add(Product $product): void
    {
    	$this->products[] = $product;
    }
    
    public function all(): array
    {
    	return $this->products;
    }
}

Embora o método add() garanta que apenas instâncias de Product sejam adicionadas, o mesmo não acontece no construtor ou no método all(). Esse problema pode ser parcialmente resolvido com validações adicionais, mas isso leva a redundância de código e ainda não resolve o problema da ausência de referência.

Criando coleções

O PHP fornece interfaces que permitem criar classes que atuam como coleções com comportamento mais robusto, como Iterator e ArrayAccess. Vamos explorar como elas podem ser utilizadas para resolver os problemas mencionados.

Interface Iterator

A interface Iterator é útil quando você deseja que um objeto seja percorrido com um foreach. Ela exige a implementação de cinco métodos:

• current(): Retorna o elemento atual.
• key(): Retorna a chave (índice) atual.
• next(): Move para o próximo elemento.
• rewind(): Reinicia a iteração.
• valid(): Verifica se a posição atual é válida.

Veja como implementar a interface Iterator para criar uma coleção de Product:

<?php

class ProductCollection implements \Iterator
{
    private array $items = [];
    private int $position = 0;

    public function add(Product $item): void
    {
    	$this->items[] = $item;
    }

    public function current(): mixed
    {
        return $this->items[$this->position];
    }

    public function key(): int
    {
        return $this->position;
    }

    public function next(): void
    {
        $this->position++;
    }

    public function rewind(): void
    {
        $this->position = 0;
    }

    public function valid(): bool
    {
        return isset($this->items[$this->position]);
    }
}

Agora, ProductCollection pode ser usada de forma segura e iterável:

<?php

$collection = new ProductCollection();
$collection->add(new Product('Item 1'));
$collection->add(new Product('Item 2'));
$collection->add(new Product('Item 3'));

foreach ($collection as $product) {
    echo $product->name . PHP_EOL;
}

Interface ArrayAccess

A interface ArrayAccess permite que um objeto seja tratado como um array. Isso é útil se você prefere a sintaxe de colchetes ([]) para manipular os dados da coleção. Os métodos obrigatórios são:

• offsetExists($offset): Verifica se índice existe.
• offsetGet($offset): Retorna de um índice.
• offsetSet($offset, $value): Define um valor para um índice.
• offsetUnset($offset): Remove um índice.

Agora vamos implementar a interface ArrayAccess na nossa classe ProductCollection:

<?php

class ProductCollection implements \Iterator, \ArrayAccess
{
    private array $products = [];
    private int $position = 0;

    public function current(): mixed
    {
        return $this->products[$this->position];
    }

    public function key(): int
    {
        return $this->position;
    }

    public function next(): void
    {
        $this->position++;
    }

    public function rewind(): void
    {
        $this->position = 0;
    }

    public function valid(): bool
    {
        return isset($this->products[$this->position]);
    }

    public function offsetExists($offset): bool
    {
        return isset($this->products[$offset]);
    }

    public function offsetGet($offset): mixed
    {
        return $this->products[$offset] ?? null;
    }

    public function offsetSet($offset, $value): void
    {
        if (! $value instanceof Product) {
            throw new \InvalidArgumentException('Only instances of Product are allowed.');
        }

        if ($offset === null) {
            $this->products[] = $value;
        } else {
            $this->products[$offset] = $value;
        }
    }

    public function offsetUnset($offset): void
    {
        unset($this->products[$offset]);
    }
}

A nossa classe ProductCollection agora pode ter tratada como um array, mas ela tem restrição de permitir somente Product. Veja como fica a utilização dela:

<?php

$collection = new ProductCollection();

$collection[] = new Product("Produto 1");
$collection[] = new Product("Produto 2");

foreach ($collection as $product) {
    echo $product->name . PHP_EOL;
}

echo $collection[0]->name . PHP_EOL;

unset($collection[1]);
var_dump(isset($collection[1]));

try {
    $collection[] = "Texto inválido";
} catch (InvalidArgumentException $e) {
    echo $e->getMessage();
}

Refatorando ShoppingCart

Com a ProductCollection, a classe ShoppingCart pode ser reescrita para ser mais robusta e confiável:

<?php 

class ShoppingCart
{
    private ProductCollection $productCollection;
    
    public function __construct(
        ?ProductCollection $productCollection = null
    ) {
        $this->productCollection = $productCollection ?? new ProductCollection();
    }
    
    public function add(Product $product): void
    {
    	$this->productCollection[] = $product;
    }
    
    public function all(): ProductCollection
    {
    	return $this->productCollection;
    }
}

Agora, o ShoppingCart utiliza ProductCollection, garantindo a integridade da lista de produtos. Sua aplicação se torna mais confiável, legível e compatível com IDEs para autocompletar e análise de código.

Conclusão

O uso de coleções no PHP, com o suporte de interfaces como Iterator e ArrayAccess, permite criar estruturas de dados mais seguras e flexíveis. Essas práticas ajudam a evitar erros comuns, aumentam a legibilidade do código e garantem a integridade dos dados, especialmente em projetos complexos. Considere usar essas abordagens sempre que possível para melhorar a qualidade do seu código.

A forma que eu utilizo para criar enums é simples, eu crio uma classe com constantes, como no exemplo abaixo:

<?php

abstract class UserStatus
{
    const BLOQUED = 0;
    const ACTIVE = 1;
}

Então, para utilizar o "enum", também é simples:

<?php

if ($user->status === UserStatus::ACTIVE) {
    //
}

Já que o PHP não tem enum de verdade, então por que utilizar uma classe ao invés de usar o explícito? Porque não diretamente if ($user->status)? Porque utilizar dessa forma que demonstrei, deixa o código mais claro, diminui a chance de erro e facilita a manutenção.

Imagine que você está implementando um sistema que possui pagamento com diversos status, como:

<?php

abstract class PaymentStatus
{
    const PENDING = 0;
    const PROCESSING = 1;
    const PAID = 2;
    const CANCELED = 3;
    const RETURNED = 4;
}

Agora fica bem mais claro usar if ($payment->status === PaymentStatus::PAID) ao invés de if ($payment->status === 2). Mas você deve estar pensando "por que não usar string?", tipo if ($payment->status === 'paid'). O problema de utilizar string é que pode conter erro de digitação, há um diferença entre letras maiúsculas e minúsculas, caso queira trocar o valor, tem que fazer manutenção em todo o código.

Para solucionar esse problema, tem uma ferramenta online chamada Carbon, onde você cola o código, informa a linguagem e escolhe o tema. É tudo configurável, padding, tamanho da fonte, cor de fundo... e ao final você pode gerar um PNG ou SVG.

Também é possível exportar as configurações para importar posteriormente, quando for gerar uma nova imagem.

Caso queira, é possível instalar o Carbon como extensão para seu editor de código favorito, como Visual Studio Code, Sublime Text 3, IntelliJ, Atom, Xcode e VIM.

Esse ano, 2020, conheci o AdonisJS, um framework Javascript muito, muito, muito mesmo, parecido com o Laravel. De cara já virou meu framework node favorito. então resolvi fazer essa publicação para apresentá-lo à vocês.

Atualmente o AdonisJS está na versão 4 e se você já conhece o Laravel, ficará bem a vontade em programar nesse framework.

Veja por exemplo como é uma migration:

const Schema = use('Schema')

class ClientSchema extends Schema {
  up () {
    this.create('clients', (table) => {
      table.increments()
      table.string('name', 128).notNullable()
      table.string('cpf', 16).nullable().unique()
      table.string('phone', 32).nullable()
      table.timestamps()
    })
  }

  down () {
    this.drop('clients')
  }
}

Agora repare como é um controller:

const { validate } = use('Validator')
const Client = use('App/Models/Client')

class ClientController {
  async index ({ request }) {
    const { page } = request.get('page')
    const clients = await Client.query()
      .orderBy('name')
      .paginate(page, 10)
    return clients
  }
  async store ({ request, response }) {
    // 
  }
  async show ({ params }) {
    // 
  }
  async update ({ params, auth, request, response }) {
    //
  }
  async destroy ({ params, auth, response }) {
    //
  }
}

Veja como é a estrutura de pastas, veja a semelhança:

.
├── app/
  ├── Controllers
  ├── Middleware
├── config/
  ├── app.js
  ├── auth.js
  └── ...
├── database/
  ├── migrations/
  ├── seeds/
  └── factory.js
├── public/
├── resources/
  ├── ...
  └── views/
└── storage/

O mais legal disso é reaproveitar o conhecimento. Para quem trabalha com o Laravel, poder mexer com NodeJS de forma bem confortável é bastante animador, principalmente para quem quer fazer uma aplicação desktop, com Electron.

Todos nós sabemos que os meses do ano não possuem o número fixo de dias, certo? Além disso, o mês de fevereiro varia em anos bisextos (a cada quatro anos) e tem um dia a mais. Em algumas aplicações nós precisamos saber qual é o último dia de um determinado mês e ninguém que ficar perdendo tempo fazendo cálculos. Por isso irei apresenta 2 formas de nós sabermos isso.

Utilizando PHP puro

Se você está utilizando o PHP para manipular datas, basta utilizar a classe DateTime:

<?php

$data = '2019-09-22';

$data = new \DateTime($data); 
$data->modify('last day of this month');

echo $data->format('Y-m-d');

Veja como foi simples, utilizamos o método modify() e passamos à ele o parâmetro "last day of this month" (último dia desse mês). Depois é pegar o formato que desejar.

Utilizando Carbon

Caso você utilize a biblioteca Carbo (ela já vem instalada no Laravel) basta utilizar o seguinte código:

<?php 

use Carbon\Carbon;

$data = '2019-09-22';

$carbon = new Carbon($data);
$carbon->lastOfMonth();

echo $carbon->format('Y-m-d');

Claramente podemos ver que utilizando a biblioteca Carbon o código fica mais limpo, usamos um método sem parâmetro, que diminui, inclusive, as changes de erro. No site da documentação você encontra bem mais detalhes sobre a biblioteca.

As vezes precisamos ler ou escrever um arquivo em formato CSV. O que seria uma tarefa simples pode tomar boa parte do seu dia. Para solucionar esse problema de forma simples, eu recomendo utilizar a biblioteca League\Csv.

Instalação

Sua instalação é simples, basta executar o seguinte comando para baixá-la usando o Composer:

composer require league/csv

Caso não esteja utilizando algum framework que carregue automaticamente as classes, deve importar o arquivo autoload:

<?php

require 'vendor/autoload.php';

Ler Arquivo

Como exemplo, irei usar o seguinte conteúdo de uma arquivo CSV:

Nome,Sobrenome,E-mail
van,neves,van@gmail.com
maria,souza,maria@gmail.com
paulo,silva,paulo@hotmail.com

Agora vamos ler as linhas desse arquivo que coloquei como exemplo:

<?php 

use League\Csv\Reader;

$leitor = Reader::createFromPath('/caminho/para/arquivo.csv', 'r');
$linhas = $leitor->getRecords();
foreach ($linhas as $numero => $linha) {
    echo $linha[0];
}

No exemplo acima estamos pegando todas as linhas do arquivo, percorrendo-as e imprimindo o valor da primeira coluna, que no caso é o "Nome".

Uma coisa que acho interessante, principalmente quando estamos trabalhando com muitas colunas, é definir nomes para que a programação fique mais clara. Ao invés de usar $linha[0] ou $linha[1], podemos definir um índice de texto. Para isso, bastaria substituir o código da linha 6 pelo seguinte código:

<?php

$linhas = $leitor->getRecords(['nome', 'sobrenome', 'email']);

Dessa maneira bastaria acessarmos as colunas pelos menos que definimos, como $linha['nome']. Mas com essa biblioteca podemos ir além e fazer coisas mais interessantes. Imagine um arquivo CSV com mais de 100 e você deseja filtra, ordenar ou retornar fazer uma paginação. Então vamos lá:

<?php

use League\Csv\Reader;
use League\Csv\Statement;

function filtrarPorEmail(array $linha)
{
    // verifica se a coluna é realmente um e-mail
    return (bool) filter_var($linha[2], FILTER_VALIDATE_EMAIL);
}

function ordernarPorSobrenome(array $linhaA, array $linhaB)
{
    // ordenando pela coluna 1 (sobrenome)
    return strcmp($linhaB[1], $linhaA[1]);
}

$leitor = Reader::createFromPath('/caminho/para/arquivo.csv', 'r');
$stmt = (new Statement())
    ->where('filtrarPorEmail') // filtro
    ->orderBy('ordernarPorSobrenome') // ordenação
    ->offset(3) // pular os 3 primeiros resultados
    ->limit(10) // retornar apenas 10 linhas
;

$linhas = $stmt->process($leitor);

No exemplo acima o código está lendo um arquivo CSV, filtrando pela coluna 2 (verifica se é um e-mail válido), orderna pelo sobrenome, pula as 3 primeiras linhas e retorna as próximas 10 linhas.

Escrever em Arquivo

Caso precise criar um arquivo em formato CSV, também é muito fácil. Veja o exemplo abaixo:

<?php

use League\Csv\Writer;

$linhas = [
    ['van','neves','van@gmail.com','+556392621234'],
    ['paulo','souza','paulo@hotmail.com','+556384082020'],
    ['fabio','maciel','fabio@gmail.com','+556399887766'],
];

$escritor = Writer::createFromPath('/caminho/para/salvar/arquivo.csv', 'w+');
$escritor->insertAll($linhas);

O código acima está pegando um array, com um array dentro, e inserindo no arquivo CSV. Você pode inserir também somente uma linha, para isso pode usar o seguinte método:

<?php 

$escritor->insertOne(['maria', 'nunes', 'maria@nunes.com.br', '+556399876543']);

O codigo recebe um array acima insere e uma linha no final do arquivo. A diferença dele para o outro é que não precisa passar um array bidimensional para inserir apenas uma linha.

A biblioteca oferece bem mais recursos, como converter o array em arquivos XML e tabelas HTML. Além disso você pode ver mais detalhes e mais métodos das funcionalidades apresentadas aqui, basta acessar o site oficial com a documentação.

Para solucionar esse problema existem os Mocks, que permitem você criar objetos com dados falsos. Para isso iremos utilizar a biblioteca para PHP chamada Faker.

Instalar a biblioteca

A instalação é simples via Composer:

composer require fzaninotto/faker

Mãos à obra

Primeiro vamos importar a biblioteca via autoload (caso não esteja usando um framework que faça isso), depois vamos criar uma instância da classe Faker:

<?php 

require_once 'vendor/autoload.php';

$faker = Faker\Factory::create('pt_BR');

Agora é só "chamar" as propriedades ou métodos que retornará os dados que desejamos. Por exemplo, para criar um nome falso, basta usar:

<?php

echo $faker->name;

Toda vez que usar a propriedade name, ele irá retornar um nome diferente. Como estamos usando o "pt_BR" na instância, irá retornar nomes brasileiros. Os nomes retornados são masculinos ou femininos, mas você especificar qual deseja retorna:

<?php

echo $faker->name('male');
echo $faker->name('female');

Você pode retornar o nome e sobrenome separadamente:

<?php

echo $faker->firstName;
echo $faker->firstNameMale;
echo $faker->firstNameFemale;

Ao usar o método firstName() irá retornar somente o primeiro nome, mas de forma aleatória (masculino ou feminino). Podemos novamente passar o parâmetro "male" ou "female". Outra forma é chamar diretamente a propriedade firstNameMale ou firstNameFemale.

Para gerar um RG, CPF ou CNPJ:

<?php

echo $faker->cpf;         // '145.343.345-76'
echo $faker->cpf(false);  // '45623467866'
echo $faker->cnpj;        // '23.663.478/0001-24'
echo $faker->cnpj(false); // '23663478000124'
echo $faker->rg;          // '84.405.736-3'
echo $faker->rg(false);   // '844057363'

Agora vamos criar um exemplo preenchendo um array com 2 mil dados de exemplo de clientes. Cada cliente vai ter uma informação diferente.

<?php

$clientes = [];
for ($i = 0; $i < 2000; $i++) {
    array_push($clientes, [
    	'nome' => $faker->name,
        'email' => $faker->email,
        'endereco' => $faker->address,
        'telefone' => $faker->phoneNumber,
        'foto' => $faker->imageUrl(100, 100),
        'cor_favorita' => $faker->hexcolor,
        'funcao' => $faker->jobTitle,
        'biografia' => $faker->text(200)
    ]);
}

Esses exemplos foi apenas uma pequena parte do que o Faker pode fazer. Para saber todas as funcionalidades ou as formas de usar as apresentadas aqui, basta acessar a documentação oficial no GitHub.