Criando recursos (utilitários) para o framework - Entendendo o padrão MVC na prática – Parte 04 Artigo

Conheça os cursos gratuitos do WebDevBr! - Inscreva-se!


Este artigo foi publicado a 3 anos, 4 meses, 2 semanas atrás.

Seguindo com nossa série de artigos.

Agora que você já tem a estrutura do Framework e um autoloader configurado, está na hora de criarmos algumas funções de "utilidades" para nos ajudar posteriormente, eu vou criar uma classe de tratamento de strings (inflector) e uma para tratar as requisições.

Vamos começar pela mais curtinha, a inflector.

Gostou deste artigo?

Receba atualizações semanais com novos artigos do WebDevBr e outras dicas!

Criando uma função de tratamento de strings

Durante o processo vou precisar transformar strings para o padrão UpperCamelCase e para um formato de url amigável (slug), então vou começar a trabalhar de acordo com os padrões PSR e informar o namespace e declarar a classe:

<?php

namespace ErikUtilities;

trait Inflector
{

    ...

}

Mas pera lá, que que é um trait? Bem esse cara (inserido no PHP 5.4) cuida de organizar funções úteis que poderão ser utilizadas em vários lugares da nossa aplicação (isso chama herança múltipla), com isso você ganha em organização, e em desempenho, já que não vai ter um monte de classes extendendo e carregando outro monte de classes uma depois da outro, agora você as carrega em dois sentidos (dai o horizontal e vertical que vemos falar nos hangouts a fora).

E duas funções aonde estão os 3 pontinhos (...).

public function upperCamelCase($string=null)
{
    $string=strtolower($string);
    $string=ucwords($string);
    $string=str_replace(' ', '', $string);

    return $string;
}

public function slug($string=null,$separator='-')
{
    $string=strtolower($string);
    $string=str_replace(' ', $separator, $string);

    return $string;
}

Em ambas o primeiro parâmetro é a string em questão e na segunda funçção temos o separador que (caso não seja informado) será o hífen.

O código está simples, então não vou entrar em detalhes, apenas salve na pasta Library/Erik/Core/Utilities com o mesmo nome da classe (Inflector.php).

Cuidando das requisições

Agora precisamos de um cara que cuide de nos passar os dados da requisição (GET, POST...) e também nos informar se houve um post, por exemplo. Nossa classe também vai cuidar de informar a url base da aplicação, definir o MVC a se usar e passar parâmetros.

Vamos criar nossa classe:

<?php

namespace Erik\Utilities;

trait Request
{
    ...
}

Novamente salve o arquivo na mesma pasta (Library/Erik/Core/Utilities) com o mesmo nome da classe (Request.php).

Vamos precisar de 9 funções e a _construct(), vamos criar e já entender "meio por cima" o que cada uma vai fazer.

/**
 * Retorna todos os dados das requisições
 *
 * @return  Array, retorna um vetor com os dados da requisição atual
 *
 */
public function request()
{
    $data['post'] = $this->post();
    $data['get'] = $this->get();
    $data['parametros'] = $this->params();
    $data['path_info'] = $this->path_info();
    $data['url'] = $this->url();
    $data['base_url'] = $this->base_url();
    return $data;
}

/**
 * Checa ou retorna o tipo de requisição
 *
 * @param string $var o tipo da requisição
 *
 * @return  True/false, se $var for enviado como false no parametro $var retorna o metodo usado
 *
 */
public function requestIs($var)
{
    $request = $_SERVER['REQUEST_METHOD'];
    $request = strtolower($request);
    if ($var) {
        if ($request==$var) {
            return 'true';
        }
        return 'false';
    }
    return $request;
}

/**
 * Retorna os dados enviados via post
 *
 * @return  Retorna os dados post
 *
 */
private function post()
{
    return $_POST;
}

/**
 * Retorna os dados enviados via get
 *
 * @return  Retorna os dados get
 *
 */
private function get()
{
    return $_GET;
}

/**
 * Retorna a path_info (usada para definir o MVC a se usar)
 *
 * @return  Retorna a path_info
 *
 */
private function path_info()
{
    if (isset($_SERVER["PATH_INFO"])) {
        return $_SERVER["PATH_INFO"];
    }
}

/**
 * Retorna os parâmetros enviados (através do path_info)
 *
 * @return  Retorna os parametros enviados
 *
 */
private function params()
{
    $params=explode('/', $this->path_info());
    unset($params[0]);
    unset($params[1]);
    unset($params[2]);
    $params = array_values($params);
    return $params;
}

/**
 * Transforma a pathinfo em url e retorna
 *
 * @return  url
 *
 */
private function url()
{
    if (empty($this->path_info())) {
        return '/';
    } else {
        return $this->path_info();
    }
}

/**
 * Retorna a url base do framework (aonde ele está instalado)
 *
 * @return  url base do framework
 *
 */
private function base_url()
{
    return $_SERVER['REQUEST_URI'];
}

Prontinho, já temos um utilitário que (de grosso modo) cuida das nossas requisições, comentei o código pra ficar mais fácil de entender o que cada função faz mas o legal é que o método requestIs() aceita tanto uma string quanto um array, por exemplo, se você quiser verificar se a requisição é post:

if ($this->requestIs('post')) {
    ...
}

Agora se quiser retornar o tipo da requisição:

echo $this->requestIs(false);

Bem simples né.

Se você achar que falta algum utilitário, pode enviar pra mim nos comentários sua sugestão, vou ficar muito feliz com a contribuição de vocês.

No mais é isso, até o próximo artigo desta série.

Aqui os arquivos desta aula e o estudo completo.


Cursos relacionados


* Parcelamento apenas cartão de crédito! Pode haver uma pequena variação no parcelamento em relação a simulações apresentadas!