Boas práticas no desenvolvimento de software — parte 1
Tags: php, javascript, braziliandevs, portugues
Published: 2020-12-02 12:09:12

Já fiz muita gambiarra na vida, não que hoje em dia meu código seja aquele código bem escrito, mas sigo estudando e melhorando a cada dia. Quero compartilhar alguns erros que cometia, e alguns que ainda luto todos os dias para deixar de cometer.

### Múltiplas responsabilidades em um único arquivo

No começo eu misturava muitas responsabilidades em um mesmo arquivo, em uma mesma classe ou função etc. Um exemplo clássico é o de encaixar tudo em um mesmo arquivo: HTML, CSS, PHP, SQL… tudo!

```php
<?php
if (isset($_POST["logar"])) {
 …
 $stmt = $pdo->prepare("SELECT FROM `usuarios` WHERE email=`{$email}`");
 …
 header("Location: home.php");
}
?>
<form method="POST" style="background:red;color:yellow;">
 …
 <button>Logar</button>
</form>
```

Se por algum motivo eu precisasse mudar alguma coisa no banco ou na estilização das páginas, eu precisaria mudar em todos os arquivos. Sair verificando todos eles a fim de encontrar as definições. Se você quer ver alguns códigos legados, prepare uma pipoca e vem ver [esse meu repositório](https://medium.com/r/?url=https%3A%2F%2Fgithub.com%2Ftadeubarbosa%2Fprojetos-antigos) aonde alguns arquivos datam o ano de 2015.

Depois de estudar e aprender algumas coisas, eu comecei a pensar com uma mentalidade diferente. Comecei a estudar mais sobre Orientação a Objetos (tratando do PHP) e como é importante separar as responsabilidades. Algo que me ajuda bastante é o padrão MVC, que é mais ou menos separar as responsabilidades entre Model, View e Controller.

Basicamente o modelo MVC funciona da seguinte forma, tudo relacionado a conexões, banco de dados etc, serão responsabilidade dos Models. O que é apresentado ao cliente final será responsabilidade das Views e o que fará a ligação entre estas camadas é chamado de Controller. Fiz um modelo bem básico de como o código acima poderia ser separado.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/tckgusnuusxpe91z7ju7.jpg)

### Múltiplas responsabilidades em uma mesma classe ou função

Um outro erro que também cometia bastante, e que hoje tento me policiar, é o de designar muitas responsabilidades para uma única classe ou função. Um exemplo seria o seguinte… Imagine que preciso criar uma classe de usuários. Um usuário possui diferentes responsabilidades dentro de um sistema, juntar todas estas em uma mesma classe é um erro.

```php
class Usuarios
{
  public function logar() {}
  public function cadastrar() {}
  public function logout() {}
  public function alterarDados() {}
  public function salvarFoto() {}
  public function ehAdministrador() {}
  public function ehModerador() {}
  public function adicionarALista() {}
  public function removerDaLista() {}
  public function adicionarNota() {}
  public function editarNota() {}
  public function removerNota() {}
}
```

Na função logar:

```php
public function logar($email, $senha) {
  $database = new Database();
  $stmt = $database->prepare("SELECT (email,password) FROM usuarios WHERE email=?");
  $usuario = $stmt->fetch(PDO::FETCH_OBJ);
  if (!$usuario || $smtm->rowCount() === 0) {
    $_SESSION["erro_login"] = "Usuário não encontrado!";
    header("Location: login.php");
    die;
  }
  if (password_verify($senha, $usuario->senha) == false) {
    $_SESSION["erro_login"] = "Senha incorreta!";
    header("Location: login.php");
    die;
  }
  $_SESSION["usuario"] = $usuario->email;
  $_SESSION["login"] = true;
  header("Location: dashboard.php");
}
```

Percebe que isso pode se tornar um grande problema?! Uma simples mudança acarretaria em um trabalho enorme. Bem superficialmente poderíamos fazer o seguinte:

```php
class Banco
{
  private static $stmt;
  public static function connect() {}
  public static function prepare() {}
  public static function query() {}
}

class AlteraBanco
{
  public function find() {}
  public function findAll() {}
  public function update() {}
  public function delete() {}
  public function join() {}
}

class Autenticavel extends AlteraBanco
{
  public function login() {}
  public function cadastro() {}
  public function logout() {}
}

class UsuarioAuth extends Autenticavel
{
  public function ehAdministrador() {}
  public function ehModerador() {}
}

class UsuarioModel extends UsuarioAuth
{
  public function alterarDados() {}
  public function salvarFoto() {}
  
  public function adicionarALista() {}
  public function removerDaLista() {}
  
  public function adicionarNota() {}
  public function editarNota() {}
  public function removerNota() {}
}
```

Ah! Só coloquei todas as classes juntas pra economizar espaço haha ;)

### Nomes de classes, funções e variáveis

Uma coisa que não me preocupava no inicio por pensar ser irrelevante, e que comecei a pensar bastante sobre com o passar do tempo, é o nome que damos as coisas.

```php
function pega($valor1, $valor2, $valor3, $tipo) {
  if ($tipo === 1) {
    return $valor2 + $valor3;
  } else {
    return $valor1 + $valor2 + $valor3;
  }
}
```

Seria bem mais fácil entender a função acima se os nomes das variáveis fossem mais descritivas.

```php
function isAdmin($usuarioTipo)
{
  return $usuarioTipo === 1;
}

function getValorOperacao($dividaInterna, $dividaExterna, $novaDivida, $usuarioTipo)
{
  if (isAdmin($usuarioTipo)) {
    return $dividaExterna + $novaDivida;
  }

  return $dividaInterna + $dividaExterna + $novaDivida;
}
```

Uma frase que representa muito isso é:

Quando eu escrevi esse código, apenas Deus e eu sabíamos o que eu estava fazendo. Hoje só Deus sabe.

Haha! E é assim mesmo!

---

Bem, por enquanto é isso! Espero que esse texto possa te ajudar de alguma forma. Até a próxima!