ARTIGOS

Código limpo em PHP

Vamos conhecer exemplos de boas práticas para código limpo em PHP

# Código limpo

[Fonte](https://github.com/jupeter/clean-code-php)

As dicas deste tutorial não são regras regras de como produzir código-fonte, são apenas boas práticas. Elas apontam a direção para produzir softwares em `PHP`, que sejam legíveis, reusáveis e refatoráveis. Você não precisa seguir a risca todas as dicas que serão demonstradas, elas são apenas diretrizes nada mais.

A maioria dos exemplos  nesse tutorial funcionam com apenas com `PHP 7.1` ou superior.

## Variáveis

Os nomes das variáveis devem ter significado, e que possam ser pronunciados.

**Evitar**

```php
$ymdstr = $momento->format('y-m-d');
```

**Ideal**
```php
$dataAtual = $momento->format('y-m-d');
```

## Usar o mesmo vocabulário para o mesmo tipo de variável

**Evitar**

```php
getUserInfo();
getUserData();
getUserRecord();
getUserProfile();
```

**Ideal**
```php
getUser();
```

## Usar nomes procuráveis
  
Desenvolvedores de software vão ler mais código-fonte do que jamais irão escrever.  Por isso é importante escrever o código de maneira que, seja legível e pesquisável.  Ao não dar nomes não significativos para variáveis, os leitores do código-fonte são prejudicados.

De nomes pesquisáveis para suas variáveis.

**Evitar**

```php
// Para que serve o 448?
$resultado = $serializer->serialize($data, 448);
```

**Ideal**

```php
$json = $serializer->serialize($data, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
```
---

**Evitar**

```php
// Para que serve esse 4?
if ($user->access & 4)
{
	// code...
}
```

**Ideal**
```php
class User
{
	const ACCESS_READ   = 1;
	const ACCESS_CREATE = 2;
	const ACCESS_UPDATE = 4;
	const ACCESS_DELETE = 8;
}

if ($user->access & User::ACCESS_UPDATE)
{
	// code...
}
```

## Retorne cedo, evite aninhamentos

Muitas estruturas de controle (ex: if-else) tornam o código-fonte difícil de ler. Explícito é melhor que implícito.

**Evitar**
```php
function lojaAberta($dia): bool
{
	if ($dia)
	{
		if (is_string($dia))
		{
			$dia = strtolower($dia);
			
			if ($dia === 'sexta')
			{
				return true;
			}
			elseif ($dia === 'sábado')
			{
				return true;
			}
			elseif ($dia === 'domingo')
			{
				return true;
			}
			else
			{
				return false;
			}
		}
		else
		{
			return false;
		}
	}
	else
	{
		return false;
	}
}
```

**Ideal**
```php
function lojaAberta($dia): bool
{
    if (empty($dia))
    {
        return false;
    }

$openingDays         = ['friday', 'saturday', 'sunday'];
    $testarTipoVariavel  = true;

return in_array(strtolower($dia), $openingDays, $testarTipoVariabel);
}
```

## Evite mapeamento mental

Não force o leitor a traduzir o significado das variáveis do seu código, sempre use nomes explícitos.

**Evitar**

```php
$l = ['Porto Alegre', 'São Paulo', 'Los Angeles'];

for ($i = 0; $i < count($l); $i++)
{
    $li = $l[$i];
    minhaFuncao();
    minhaOutraFuncao();
    // ...
    // ...
    // ...
    // O que $li significa mesmo?
    despachar($li);
}
```

**Ideal**

```php
$locais = ['Porto Alegre', 'São Paulo', 'Los Angeles'];

foreach ($locais as $local)
{
    minhaFuncao();
    minhaOutraFuncao();
    // ...
    // ...
    // ...
    despachar($local);
}
```

## Não adicione contexto desnecessário

Se o nome da sua classe/objeto diz algo, não repita isso no nome das variáveis.

**Evitar**

```php
class Carro
{
    public $fabricanteCarro;
    public $modeloCarro;
    public $corCarro;
}
```

**Ideal**

```php
class Carro
{
    public $fabricante;
    public $modelo;
    public $cor;
}
```

## Use argumentos padrão em vez de condicionais

**Evitar**

Este código está ruim, pois o `$nomeCervejaria` pode ser `NULL`.

```php
function criarCervejaria($nomeCervejaria = 'Cervejaria Hipster Co.'): void
{
    // ...
}
```

**Meio termo**

Este código é mais legível que o anterior, mas ainda assim, é melhor controlar o valor da variável.

```php
function criarCervejaria($nome = null): void
{
    $nomeCervejaria = $nome ?: 'Cervejaria Hipster Co.';
    // ...
}
```

**Ideal**

Você pode usar [declarações de tipos](http://php.net/manual/pt_BR/functions.arguments.php) e ter certeza que `$nomeCervejaria` não será `NULL`.

```php
function criarCervejaria(string $nomeCervejaria = 'Hipster Brew Co.'): void
{
    // ...
}
```

## Use poucos argumentos de função

Limitar a quantidade de parâmetros de função é muito importante, porque isso torna o teste de função mais fácil. Ter mais de três leva a uma explosão combinatória onde você precisa testar toneladas de casos diferentes com cada argumento separado.

Não ter argumentos é o caso ideal, um ou dois é aceitável, e 3 deve ser evitado. Normalmente, se você tem mais de dois argumentos, então sua função está tentando fazer coisas demais. Quando não é o caso, um objeto de nível superior será suficiente como argumento.

**Evitar**

```php
function criarmenu(string $titulo, string $corpo, string $textoBotao, bool $botaoCancelar): void
{
    // ...
}
```

**Ideal**

```php
class MenuConfig
{
    public $titulo;
    public $corpo;
    public $textoBotao;
    public $botaoCancelar = false;
}

$config                = new MenuConfig();
$config->titulo        = 'Foo';
$config->corpo         = 'Bar';
$config->textoBotao    = 'Baz';
$config->botaoCancelar = true;

function criarMenu(MenuConfig $config): void
{
    // ...
}
```

## Funções devem fazer apenas uma coisa

Esta é a regra mais importante na Engenharia de Software. Quando funções fazem mais de uma coisa, elas começam a ficar difíceis entender e testar. Sempre que possível isole as funções, de maneira que, elas executem apenas uma ação.

**Evitar**

```php
function emailClients(array $clients): void
{
    foreach ($clients as $client)
    {
        $clientRecord = $db->find($client);
        
        if ($clientRecord->isActive())
        {
            email($client);
        }
    }
}
```

**Ideal**

```php
function emailClients(array $clients): void
{
	$activeClients = activeClients($clients);
	array_walk($activeClients, 'email');
}

function activeClients(array $clients): array
{
	return array_filter($clients, 'isClientActive');
}

function isClientActive(int $client): bool
{
	$clientRecord = $db->find($client);
	return $clientRecord->isActive();
}
```

## Os nomes das funções deve indicar o que elas fazem

**Evitar**

```php
class Email
{
    //...

public function handle(): void
    {
        mail($this->to, $this->subject, $this->body);
    }
}

$mensagem = new Email(...);
// O que  é isso? Um manipulador para a mensagem? Estamos escrevendo um arquivo?
$mensagem->handle();
```

**Ideal**

```php
class Email 
{
    //...

public function enviar(): void
    {
        mail($this->to, $this->subject, $this->body);
    }
}

$mensagem = new Email(...);
// Claro e objetivo
$mensagem->enviar();
```

## Não use flags como parâmetros de função

Flags indicam que a sua função faz mais do que uma coisa. **Funções devem fazer apenas uma coisa**. Divida as suas funções se elas seguem dois caminhos baseados em uma flag.

**Evitar**

```php
function criarArquivo(string $nome, bool $temporario = false): void
{
    if ($temporario)
    {
        touch('./temp/'.$nome);
    }
    else
    {
        touch($nome);
    }
}
```

**Ideal**

```php
function criarArquivo(string $nome): void
{
    touch($nome);
}

function criarArquivoTemporario(string $nome): void
{
    touch('./temp/'.$nome);
}
```

ARTIGOS

Código limpo em PHP

Vamos conhecer exemplos de boas práticas para código limpo em PHP

COMENTE SOBRE