Clean Code e Object Calisthenics - Aplicados no PHP

Clean Code e
Object Calisthenics
Aplicados no PHP

<?php
echo ‘Rafael Neris’;
Apaixonado por refactoring
Total Express
Github: @rafaelneris
Linkedin: https://www.linkedin.com/in/rafael-neris-
548402110/
2

Motivação:
▸ Legibilidade
▸ Manutenabilidade
▸ Reusabilidade
▸ Testabilidade
3

Como medir a
qualidade de
seu código?
Método infálivel!

Singleton
Tight Coupling
Untestability
Premature Optimization
Indescriptive Naming
Duplication
S T U P I D
7

Single Responsibility
Open/Closed Principle
Liskov Substitution
Interface Segregation
Dependency Inversion
S O L I D
8

Single Responsibility Principle
“Uma classe deve ter um, e somente um, motivo para
ser modificada”
9

class Report {
public function getTitle() {
return 'Report Title';
}
public function getDate() {
return '2018-01-22';
}
pulic function getContents() {
return [ 'title' => $this->getTitle(), 'date' => $this->getDate(), ];
}
public function formatJson() {
return json_encode($this->getContents());
}
}

class Report {
public function getTitle() {
return 'Report Title';
}
public function getDate() {
return '2018-01-22';
}
public function getContents() {
return [ 'title' => $this->getTitle(), 'date' => $this->getDate(), ];
}
}
class JsonReportFormatter {
public function format(Report $report) {
return json_encode($report->getContents());
}

Open Closed Principle
“Entidades de Software devem estar aberta para
expansão, mas fechada para modificação.”
12

class Logger {
public function writeTxt($message)
{
//lógica
}
}

class Logger {
public function writeTxt($message)
{
//lógica
}
public function writeCsv($message)
{
//lógica
}
}

class Logger {
private $writer;
public function __construct(Writer $writer) {
$this->writer = $writer;
}
public function write($message) {
$this->writer->write($message);
}
}
interface Writer {
public function write($message);
}
class Txt implements Writer {
public function write($message) { //lógica }
}
class Csv implements Writer {
public function write($message) { //lógica }
}

“
“Se q(x) é uma propriedade
demonstrável dos objetos x de tipo
T. Então q(y) deve ser verdadeiro
para objetos y de tipo S onde S é um
subtipo de T.”
Barbara Liskov
17

“
“Funções que usam ponteiros ou
referências a classes-base devem ser
capazes de usar objetos de classes
derivadas sem o saber.”
Robert C. Martin (Uncle Bob)
18

class T { … }
class S extends T { … }
$o1 = new T();
$o2 = new S();
function write(T $message) {
return “Ok”;
}
write($o1); // “Ok”
write($o2); // “Ok”

Clean Code
Vamos nos aprofundar mais!
21

Alguns conceitos importantes
▸ Nomes significativos
▸ Funções pequenas
▸ Comentários
22

Nomes significativos
Use nomes que revelam seu propósito
23

class Diretorio {
private $qtd;
public function retornarQtd() {
return $qtd;
}
}

class Diretorio {
private $quantidadeArquivos;
public function getQuantidadeArquivos() {
return $this->quantidadeArquivos;
}
}

Nomes devem ser distintos
26

class Aluno {
private $data1; // Data de Nascimento
private $data2; // Data de Matricula
}

class Aluno {
private $nascimentoData;
private $matriculaData;
}

Evite mapeamento mental!
29

class File {
private $f;
public function write(array $k) {
foreach ($k as $j) {
fwrite($f, $j);
}
}
}

class File {
private $fileResource;
public function write(array $content) {
foreach ($content as $lineOfContent){
fwrite(
$fileResource,
$lineOfContent
);
}
}
}

Nomes de classes e
Objetos
▸ Devem ter nomes com substantivos
▸ Não deve ser um verbo!
▸ Devem ser buscaveis
32

Nomes de métodos
▸ Devem possuir verbos
▸ Devem ser buscaveis.
33

if ($saqueLimite == 1000) {
// Do Something
}

const SAQUE_TETO = 1000;
if ($saqueLimite == self::SAQUE_TETO) {
// Do Something
}

Métodos pequenos
▸ Devem ser pequenos e concisos
▸ “Fazer UMA e APENAS UMA coisa. Eles devem
fazer isso bem e apenas isso.”
▸ “Menor do que pequeno”
37

Comentários no código é
bom?
39

Comentários
▸ Envelhecem e mentem
▸ Não comentem código. Deixe que o GIT resolva para você!
▸ O único comentário bom é aquele que você não precisa escrever.
41

// Verifica se o funcionário tem direito a todos
benefícios
if (
($employee->getFlag() && self::HOURLY_FLAG)
&& ($employee->getAge() > 65)
)

if ($employee->isElegibleForFullBenefits())

//$token = token($this->email);
//if (self::where('confirmation_token', $token)->first()) {
// return $this->getUniqueConfirmationToken();
//}
$row = Testimonial::find($id);
$row->list_order = $listOrder;
$row->save();
return $row;

Casos de comentários:
▸ Comentários informativos
▸ Explicar-se no código
▸ Comentários TODO
▸ Comentários Ruidosos
▸ Comentários redundantes
45

Outros conceitos:
▸ Formatação
▸ Objetos e Estrutura de dados
▸ Tratamento de erros
▸ Limites
▸ Testes unitários
▸ Classes
▸ Sistemas
▸ Concorrência
▸ Refinamento sucessivo
46

Outros conceitos:
▸ Formatação
▸ Objetos e Estrutura de dados
▸ Tratamento de erros
▸ Limites
▸ Testes unitários
▸ Classes
▸ Sistemas
▸ Concorrência
▸ Refinamento sucessivo
47

Object Calisthenics
9 regras para manter seu código limpo!
48
CONSELHOS
Termo grego, significa
“Exercício”

Somente um nível de
indentação por método
Use Extract Method Pattern
51

public function getPromoCode(string $promoName)
{
if ($this->promoCode) {
if (false === $this->promoCodeExpired()) {
if ($this->promoName == $promoname) {
return $this->promoCode;
} else {
throw new Exception('Promoção não existe mais');
}
} else {
throw new Exception('Promoção Expirada');
}
} else {
throw new Exception('Cliente sem código de promoção');
}
}

{
// 1
} else {
}
} else {
}
} else {
}
}

{
// 1
// 2
} else {
}
} else {
}
} else {
}
}

{
// 1
// 2
// 3
} else {
}
} else {
}
} else {
}
}

{
// 1
// 2
$this->getPromoExists($promoName);
} else {
}
} else {
}
}
protected function getPromoExists(string $promoName)
{
if ($this->promoName == $promoName) {
} else {
}
}

public function getPromoCode(string $promoName) {
// 1
$this->getValidPromoCode($promoName)
} else {
}
}
protected function getValidPromoCode(string $promoName) {
return $this->getPromoExists($promoName);
} else {
}
}
protected function getPromoExists(string $promoName) {
} else {
}
}

Benefícios:
▸ S de Single Responsibility Principle
▸ Favorece reusabilidade
60

Não use a palavra “else”
Use early returns!
61

$this->getValidPromoCode($promoName)
} else {
}
}
} else {
}
}
} else {
}
}

if (!$this->promoCode) {
}
return $this->getValidPromoCode($promoName);
}
if ($this->promoCodeExpired()) {
}
}
if ($this->promoName != $promoName) {
}
}

Benefícios:
▸ Evita duplicidade de códigos
▸ Aumenta legibilidade
▸ Reduz a complexidade ciclomatica
66

Encapsule TODOS os
tipos primitivos e strings
TODOS que possuem comportamento.
67

class Customer
{
protected $name;
protected $birthday;
public function __construct(string $name, string $birthday)
{
// Validar aqui???
$this->name = $name;
$this->birthday = $birthday;
}
}

// Programador que conhece a classe
$customer = new Customer('John Doe', '1983-02-10');
// Programador que não conhece a classe
// pode gerar um 0000-00-00 no Database
$customer = new Customer('John Doe', '10/02/1983');

class Customer
{
protected $name;
protected $birthday;
public function __construct(
CustomerName $name,
CustomerBirthday $birthday
){
$this->name = $name;
$this->birthday = $birthday;
}
}

// Programador que conhece a classe
$customer = new Customer(
new CustomerName('John Doe'),
new CustomerBirthday('1983-02-10')
);
// A data será formatada internamente
$customer = new Customer(
new CustomerName('John Doe'),
new CustomerBirthday('10/02/1983')
);

Benefícios:
▸ Type hinting
▸ Encapsulamento do código
▸ Auxilia na prevenção de código duplicado
▸ Implementação de Values Object do DDD
72

Envolva suas collections
em Classes
73

class Bucket {
protected $products = [];
// many other things...
}

class Bucket {
/** @var ProductCollection */
protected $products;
// many other things...
}
class ProductCollection implements Iterator { // ... }

Benefícios:
▸ Single Responsible Principle
▸ Usar classes SPL
▸ Facilita agrupar em coleções sem se preocupar com o comportamento
delas
▸ Filtragem, ordenação, mapeamento são exemplos de métodos.
76

Um único operador de
método por linha
Com excessão de interfaces fluentes.
77

$customer->manager->getById(55988)->getPurchase(18376)->getProducts()->filterById(234);

Propriedades são dificeís de
mockar

Propriedades são dificeís de
mockar
E se retornar null?

Benefícios:
▸ Lei de Demeter
▸ Legibilidade
▸ Aumenta testabilidade (Mais fácil para mockar)
▸ Facilidade para debugar
81

Não quebre a lei de Demeter
83

Não abrevie!
Com excessão de interfaces fluentes.
84

Benefícios:
▸ Legibilidade
▸ Manutenibilidade
87

Mantenha suas classes
pequenas
▸ Métodos devem possuir até 20 linhas
▸ Não crie namespaces com mais de 15 arquivos
▸ Não crie classe com mais de 200 linhas
88

Benefícios:
▸ Legibilidade
▸ Manutenibilidade
89

Não tenha classes com mais
de duas variáveis de instância
A comunidade PHP adota à CINCO variáveis de
instância por adaptabilidade da linguagem.
90

Benefícios:
▸ Alta coesão
▸ Baixo acoplamento
▸ Encapsulamento
▸ Lista de dependências mais curtas
▸ Manutenabilidade
91

Não use GETTERS/SETTERS
▸ Regra parcialmente relacionada ao DDD
▸ Não aplicável ao PHP devido a natureza da linguagem
92

class ImmutableBankAccount
{
public $currency = 'USD';
private $amount;
public function setAmount(int $amount)
{
$this->amount = $amount;
}
}

class ImmutableBankAccount
{
private $currency = 'USD';
private $amount;
public function withdrawAmount(int $withdrawnAmount)
{
$this->amount -= $withdrawAmount;
}
}

Benefícios:
▸ Open/Close Principle
95

Valide Object Calisthenics no
seu código
https://github.com/object-calisthenics/phpcs-calisthenics-rules
96

97
“Qualquer um pode escrever um código que o
computador entenda.
Bons programadores escrevem códigos que os
humanos entendem”
Perguntas??
▸ @rafaelneris
▸ rafael.neris@totalexpress.com.br

Clean Code e Object Calisthenics - Aplicados no PHP

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Clean Code e Object Calisthenics - Aplicados no PHP

Semelhante a Clean Code e Object Calisthenics - Aplicados no PHP (20)

Clean Code e Object Calisthenics - Aplicados no PHP