DEV Community: Matheus Mendonça Sesso

A Importância dos Metas Keys no Desenvolvimento de Plugins no WordPress

Matheus Mendonça Sesso — Sun, 16 Nov 2025 05:35:17 +0000

No WordPress, metas keys surgem como um mecanismo invisível que nos proporciona uma verdadeira flexibilidade de customização. Eles transformam dados estáticos em camadas dinâmicas, permitindo que plugins evoluam de meras extensões para ecossistemas completos e adaptáveis. Neste guia direto e prático, iremos falar um pouco sobre os fundamentos de post_meta, user_meta e similares, com exemplos que elevam o desenvolvimento de plugins a um patamar mais profissional.

Caso tenha interesse, veja o último artigo que publiquei: Desvendando o Sistema de Plugins do WordPress: Um Guia Prático para Desenvolvedores, ele complementa o que iremos abordar neste aqui.

O que vamos cobrir?

Vamos construir exemplos simples para um plugin, cobrindo:

Tipos de metas: post_meta, user_meta, term_meta e options.
Operações básicas: adicionar, recuperar, atualizar e deletar.
Integração com hooks e API REST: para automação e exposição de dados.
Boas práticas: segurança, performance e organização.

Ao final, você entenderá por que metas são essenciais para plugins que precisam de customização, como perfis avançados, campos extras em posts ou configurações por usuário.

Por que metas são tão importantes?

O WordPress é construído em torno de flexibilidade. Metas permitem estender entidades (posts, usuários, termos) com dados arbitrários, sem alterar o core ou criar tabelas customizadas. Isso é crucial para plugins: imagine adicionar campos como "data de expiração" a um post ou "preferências de tema" a um usuário. Sem metas, você ficaria preso a soluções rígidas. Eles tornam o WP headless-friendly, facilitam migrações e evitam inchaço no banco. Em resumo: metas = poder de customização sem dor de cabeça.

Anatomia dos Metas: Como Funcionam?

Metas são pares de chave-valor (meta_keys) armazenados na tabela wp_postmeta (para posts), wp_usermeta (para usuários) ou similares. Cada entidade tem um ID único, e as chaves podem ser múltiplas (um valor por chave ou arrays serializados).

Operações Básicas

Use funções nativas para CRUD. Sempre prefixe chaves (ex: meu_plugin_campo) para evitar conflitos.

// ADICIONAR meta (cria se não existir)
update_post_meta($post_id, 'meu_plugin_cor_favorita', 'azul');  // Para posts
update_user_meta($user_id, 'meu_plugin_nivel_acesso', 'premium');  // Para usuários

// RECUPERAR meta
$cor = get_post_meta($post_id, 'meu_plugin_cor_favorita', true);  // true = single value
$nivel = get_user_meta($user_id, 'meu_plugin_nivel_acesso', true);

// ATUALIZAR (sobrescreve)
update_post_meta($post_id, 'meu_plugin_cor_favorita', 'vermelho');

// DELETAR
delete_post_meta($post_id, 'meu_plugin_cor_favorita');

Dica: O terceiro parâmetro em get_*_meta é chave: true para valor único, false para array de valores (útil para múltiplas entradas).

Tipos de Metas e Exemplos

post_meta: Dados extras em posts/páginas/custom posts.

// Exemplo: Adicionar meta ao salvar post
add_action('save_post', 'salvar_meta_post');
function salvar_meta_post($post_id) {
    if (isset($_POST['cor_favorita'])) {
        update_post_meta($post_id, 'meu_plugin_cor_favorita', sanitize_text_field($_POST['cor_favorita']));
    }
}

// Recuperar no front-end
$cor = get_post_meta(get_the_ID(), 'meu_plugin_cor_favorita', true);
if ($cor) echo '<div style="color: ' . esc_attr($cor) . ';">Conteúdo colorido!</div>';

user_meta: Perfis personalizados.

// Adicionar ao registrar usuário
add_action('user_register', 'adicionar_meta_usuario');
function adicionar_meta_usuario($user_id) {
    update_user_meta($user_id, 'meu_plugin_bio_curta', 'Usuário novo!');
}

// Exibir em perfil admin
add_action('show_user_profile', 'exibir_meta_perfil');
function exibir_meta_perfil($user) {
    $bio = get_user_meta($user->ID, 'meu_plugin_bio_curta', true);
    echo '<h3>Bio Personalizada</h3><input type="text" name="bio_curta" value="' . esc_attr($bio) . '" />';
}

term_meta: Metas em taxonomias (categorias, tags).

// Para WP 4.4+
update_term_meta($term_id, 'meu_plugin_descricao_extra', 'Descrição custom');
$desc = get_term_meta($term_id, 'meu_plugin_descricao_extra', true);

get_option/set_option: Metas globais (tabela wp_options).

update_option('meu_plugin_config_ativa', true);
$ativa = get_option('meu_plugin_config_ativa', false);  // Default false

Integração com Hooks e API REST

Metas são ótimas quando combinados com hooks para automação.

// Hook para popular meta em novos posts
add_action('wp_insert_post_data', 'preencher_meta_automatico', 10, 2);
function preencher_meta_automatico($data, $postarr) {
    if ($data['post_type'] === 'post') {
        $data['ID'] ? update_post_meta($data['ID'], 'meu_plugin_data_criacao_extra', current_time('mysql')) : null;
    }
    return $data;
}

Para API REST, registre campos customizados:

// Expor post_meta na API
add_action('rest_api_init', 'registrar_campos_meta_api');
function registrar_campos_meta_api() {
    register_rest_field('post', 'cor_favorita', array(
        'get_callback' => function($post) {
            return get_post_meta($post['id'], 'meu_plugin_cor_favorita', true);
        },
        'update_callback' => function($value, $post) {
            update_post_meta($post->ID, 'meu_plugin_cor_favorita', sanitize_text_field($value));
        }
    ));
}
// Agora acessível em /wp-json/wp/v2/posts?_fields=title,cor_favorita

Boas Práticas para Metas em Plugins

Segurança: Sempre sanitize (sanitize_text_field, wp_kses_post) e escape (esc_attr, esc_html) ao salvar/exibir.

update_post_meta($id, $key, sanitize_textarea_field($_POST['texto']));
echo esc_html(get_post_meta($id, $key, true));

Performance: Evite queries desnecessárias. Use meta_query em WP_Query com cuidado:

$posts = new WP_Query(array(
    'post_type' => 'post',
    'meta_query' => array(
        array('key' => 'meu_plugin_cor_favorita', 'value' => 'azul')
    )
));

Organização: Armazene arrays serializados para dados complexos:

$config = array('opcao1' => 'valor1', 'opcao2' => 'valor2');
update_post_meta($id, 'meu_plugin_config', maybe_serialize($config));
$config = maybe_unserialize(get_post_meta($id, 'meu_plugin_config', true));

Limpeza: Delete metas órfãs na desativação:

register_deactivation_hook(__FILE__, 'limpar_metas_plugin');
function limpar_metas_plugin() {
    global $wpdb;
    $wpdb->query("DELETE FROM {$wpdb->postmeta} WHERE meta_key LIKE 'meu_plugin_%'");
}

Teste: Verifique metas em diferentes contextos (admin, front-end, API) e com usuários variados.

Em resumo, metas keys são peças essenciais no quesito customização no WordPress, proporcionando flexibilidade e dinamismo em plugins que vão além do básico. Eles não só facilitam a escalabilidade e a manipulação inteligente dos dados, mas transformam conceitos simples em ecossistemas robustos, possibilitando revoluções no seu sistema.

Para aprofundar

WP Developer Documentation - Documentação oficial do WordPress.
Metadata in Plugins - Visão geral de como usar metadados em plugins, incluindo posts, usuários, comentários e termos.
Metadata API Handbook - Guia oficial completo da API de metadados para posts, usuários e mais.
WP_Meta_Query Class - Otimização avançada de consultas com metadados em WP_Query e similares.

#wordpress #php #webdev #tutorial #metas #plugins #postmeta #usermeta #cms

Desvendando o Sistema de Plugins do WordPress: Um Guia Prático para Desenvolvedores

Matheus Mendonça Sesso — Sun, 05 Oct 2025 09:13:04 +0000

Após anos desenvolvendo para WordPress, afirmo: entender profundamente o sistema de plugins é o diferencial entre um iniciante e um profissional neste sistema. Neste artigo, você vamos aprender na prática como funciona esse ecossistema essencial e poderoso, explorando recursos que elevam o nível dos seus projetos.

O que vamos construir?

Para tornar este guia 100% prático, vamos desenvolver um simples plugin de demonstração, este plugin vai cobrir alguns dos aspectos fundamentais no desenvolvimento de plugins para WordPress, sendo eles:

Estrutura básica com cabeçalho e organização de arquivos;
Hooks nativos (actions e filters) em situações reais;
Página administrativa com estatísticas e informações;
Shortcodes personalizados para exibir dados no front-end;
Integração com a API REST nativa do WordPress;
Criação de endpoints personalizados da API REST;
Boas práticas de segurança e organização.

Ao final, você terá um plugin funcional que serve como base para qualquer projeto WordPress mais complexo, mas é importante dizer que este conhecimento é apenas um ponta pé inicial, que pode e deve ser aprofundado com diversos outros conceitos importantes e fundamentais que não abordaremos neste artigo.

Por que plugins são tão importantes?

O sistema de plugins é o que torna o WordPress verdadeiramente flexível e poderoso. Ele permite que qualquer site evolua de um blog simples para uma loja virtual, portal de notícias, plataforma de cursos ou qualquer outra solução personalizada. Para desenvolvedores, dominar plugins é indispensável: é através deles que você expande funcionalidades, integra serviços e adapta o WordPress a qualquer necessidade do projeto.

Anatomia de um Plugin WordPress

Vamos começar pelo básico, os plugins ficam localizados na pasta /wp-content/plugins, neste local você deve criar uma pasta que basicamente será o seu plugin, nela deve conter estrutura e os códigos do seu plugin.

E todo plugin WordPress precisa de um arquivo principal que orquestrará o plugin, ele ficará na raiz da pasta de seu plugin. com um cabeçalho específico. Olha só como é simples:

<?php
/*
Plugin Name: Meu Primeiro Plugin
Description: Um plugin de exemplo para aprender desenvolvimento WordPress
Version: 1.0.0
Author: Seu Nome
License: GPL v2 or later
*/

// Evita acesso direto ao arquivo
if (!defined('ABSPATH')) {
    exit;
}

// Código a partir daqui...

Dica: Sempre, SEMPRE inclua a verificação ABSPATH. Isso impede que alguém acesse seu arquivo diretamente via browser, o que pode expor informações sensíveis.

O coração do WordPress: Hooks

Aqui está o segredo do WordPress: tudo funciona através de hooks. São basicamente pontos de entrada que permitem que você "pendure" seu código em momentos específicos da execução. Sem hooks, o WordPress seria apenas um CMS "estático". Com eles, é uma plataforma infinitamente extensível e flexivel.

Actions vs Filters: A diferença crucial

// ACTION: Execute algo em um momento específico
add_action('wp_loaded', 'minha_funcao');

// FILTER: Modifica dados que passam por ele
add_filter('the_title', 'modificar_titulo');

Actions fazem coisas. Filters modificam coisas. Simples assim.

Veja a diferença na prática:

// ACTION - Adiciona funcionalidade
add_action('wp_footer', 'adicionar_codigo_tracking');
function adicionar_codigo_tracking() {
    echo '<script>console.log("Plugin funcionando!");</script>';
}

// FILTER - Modifica conteúdo existente
add_filter('the_title', 'customizar_titulo');
function customizar_titulo($titulo) {
    return '[NOVO] ' . $titulo;
}

A diferença é sutil, mas crucial: actions não retornam nada, filters sempre retornam o valor (modificado ou não).

Algumas actions essenciais

init - Registrar post types, taxonomias, shortcodes
wp_enqueue_scripts - Carregar CSS/JS no front-end
admin_enqueue_scripts - Carregar CSS/JS no admin
wp_loaded - WordPress totalmente carregado
rest_api_init - Registrar endpoints da API REST
admin_menu - Adicionar páginas administrativas

// Exemplo prático do nosso plugin
add_action('admin_menu', array($this, 'add_admin_menu'));

Alguns filters poderosos

the_content - Modificar conteúdo dos posts
the_title - Modificar títulos
body_class - Adicionar classes CSS dinâmicas
document_title_parts - SEO personalizado
login_redirect - Redirecionamento após login

// Exemplo: adicionar assinatura em posts
add_filter('the_content', function($content) {
    if (is_single()) {
        $content .= '<p><em>Por ' . get_the_author() . '</em></p>';
    }
    return $content;
});

Prioridades e boas práticas

// Sintaxe completa
add_action('hook_name', 'function_name', $priority, $accepted_args);

// Controlar ordem de execução
add_action('init', 'funcao_prioritaria', 5);     // Executa cedo
add_action('init', 'funcao_normal', 10);         // Padrão
add_action('init', 'funcao_tardia', 20);         // Executa depois

Dicas importantes:

Use prioridades para controlar ordem de execução
Remova hooks quando necessário: remove_action(), remove_filter()
Sempre valide se está no contexto certo (is_admin(), is_single(), etc.)

Dominar os hooks é fundamental para cada funcionalidade ser conectada ao hook apropriado, garantindo que seu código execute exatamente no momento certo dentro do fluxo do WordPress.

Estruturando seu plugin com classes

O código em classes é fundamental para manter plugins organizados, escaláveis e livres de conflitos de nomes. Utilizar classes facilita a manutenção, permite reaproveitamento de código e torna a lógica mais clara.

Veja abaixo como a parte administrativa do plugin pode ser organizada usando uma abordagem orientada a objetos:

class MeuPluginAdmin {

    public function __construct() {
        add_action('admin_menu', array($this, 'criar_menu'));
    }

    public function criar_menu() {
        add_menu_page(
            'Configurações do Plugin',      // Título da página
            'Meu Plugin',                   // Nome no menu
            'manage_options',               // Quem pode acessar
            'meu-plugin',                   // Slug único
            array( $this, 'pagina_admin' ), // Função que renderiza
            'dashicons-admin-settings',     // Ícone
            30                              // Posição no menu
        );
    }

    public function pagina_admin() {
        echo '<div class="wrap">';
        echo '<h1>Configurações do Meu Plugin</h1>';
        echo '<p>Aqui ficam as configurações!</p>';
        echo '</div>';
    }
}

// Inicializar a classe
new MeuPluginAdmin();

Por que usar classes?

Evita conflitos de nomes de funções
Organiza melhor o código
Facilita a manutenção
Permite usar recursos de POO como encapsulamento

Criando páginas de administração

É interessante criarmos uma interface administrativa para o nosso plugin. O WordPress facilita muito isso com a função add_menu_page(). No meu exemplo:

public function pagina_admin() {
    ?>
    <div class="wrap">
        <h1>Painel do Meu Plugin</h1>

        <div class="card">
            <h2>Status do Plugin</h2>
            <p>Plugin ativo e funcionando!</p>

            <h3>Shortcode disponível:</h3>
            <code>[meu_shortcode]</code>
        </div>

        <div class="card">
            <h2>Estatísticas</h2>
            <p><strong>Posts:</strong> <?php echo wp_count_posts()->publish; ?></p>
            <p><strong>Usuários:</strong> <?php echo count_users()['total_users']; ?></p>
        </div>
    </div>
    <?php
}

Dica: Tente usar as classes CSS do WordPress (wrap, card, etc.) para manter consistência visual com o admin.

Shortcodes: Trazendo funcionalidade para o front-end

Shortcodes são uma das funcionalidades mais legais do WordPress. Permitem que usuários "não-técnicos" adicionem funcionalidades complexas apenas digitando tags, por exemplo: [alguma_coisa].

// Registrar o shortcode
add_shortcode('meu_shortcode', 'processar_meu_shortcode');

function processar_meu_shortcode($atts) {
    // Definir valores padrão
    $atts = shortcode_atts(array(
        'quantidade' => 5,
        'tipo' => 'posts'
    ), $atts );

    // Processar e retornar conteúdo
    $output = '<div class="meu-shortcode">';
    $output .= '<h3>Últimos ' . $atts['quantidade'] . ' ' . $atts['tipo'] . '</h3>';

    // Buscar dados...
    $posts = get_posts(array('numberposts' => $atts['quantidade']));

    foreach($posts as $post) {
        $output .= '<p><a href="' . get_permalink($post) . '">' . $post->post_title . '</a></p>';
    }

    $output .= '</div>';

    return $output; // SEMPRE retornar, nunca echo!
}

Regra de ouro dos shortcodes: Sempre retorne o conteúdo, nunca faça echo diretamente. O WordPress precisa controlar quando e onde o conteúdo aparece.

Utilizando a API REST do WordPress

Aqui é onde as coisas ficam interessantes. O WordPress tem uma API REST nativa super poderosa. Em vez de fazer consultas diretas no banco, você pode usar essa API:

// Função para buscar posts via API REST interna
function buscar_posts_via_api($quantidade = 5) {
    $request = new WP_REST_Request('GET', '/wp/v2/posts');
    $request->set_param('per_page', $quantidade);
    $request->set_param('context', 'view');

    $response = rest_do_request($request);

    if ($response->is_error()) {
        return array();
    }

    return $response->get_data();
}

// Usar em qualquer lugar do plugin
$posts = buscar_posts_via_api(10);
foreach($posts as $post) {
    echo $post['title']['rendered'];
}

Por que usar a API REST em vez de funções nativas?

Dados padronizados e sanitizados;
Formato JSON consistente;
Fácil de cachear;
Mesma interface para frontend e backend.

Criando sua própria API REST

Mas nós podemos ir além! Você pode criar seus próprios endpoints:

// Registrar rota personalizada
add_action('rest_api_init', 'registrar_minha_api');

function registrar_minha_api() {
    register_rest_route('meu-plugin/v1', '/estatisticas', array(
        'methods' => 'GET',
        'callback' => 'obter_estatisticas_site',
        'permission_callback' => '__return_true', // Público
    ) );
}

function obter_estatisticas_site($request) {
    return array(
        'nome_site' => get_bloginfo('name'),
        'total_posts' => wp_count_posts()->publish,
        'total_usuarios' => count_users()['total_users'],
        'versao_wp' => get_bloginfo('version'),
        'status' => 'funcionando'
    );
}

// Acesse: /wp-json/meu-plugin/v1/estatisticas

Agora você tem um endpoint personalizado em /wp-json/myplugin/v1/estatisticas. Muito útil para integrações ou aplicações headless.

Estrutura de arquivos

Um erro comum é jogar tudo no arquivo principal. Não faça isso!

Tente sempre fazer uma estrutura persistente e que condiz com o seu projeto, neste nosso caso podemos fazer algo semelhante a isso:

meu-plugin/
├── meu-plugin.php      (arquivo principal)
├── assets/
│   ├── css/
│   └── js/
└── includes/
    ├── admin.php       (painel administrativo)
    ├── shortcodes.php  (shortcodes)
    ├── api.php         (endpoints customizados)
    └── functions.php   (funções auxiliares)

No arquivo principal, organize assim:

<?php
// Cabeçalho do plugin...

// Evitar acesso direto
if (!defined('ABSPATH')) exit;

// Definir constantes úteis
define('MEU_PLUGIN_PATH', plugin_dir_path(__FILE__));
define('MEU_PLUGIN_URL', plugin_dir_url(__FILE__));

// Incluir arquivos necessários
require_once MEU_PLUGIN_PATH . 'includes/functions.php';
require_once MEU_PLUGIN_PATH . 'includes/shortcodes.php';
require_once MEU_PLUGIN_PATH . 'includes/api.php';

// Só carregar admin se estivermos no admin
if (is_admin()) {
    require_once MEU_PLUGIN_PATH . 'includes/admin.php';
}

Algumas boas práticas

1. Sempre valide permissões

'permission_callback' => '__return_true', // Público
// ou
'permission_callback' => 'manage_options', // Apenas administradores

2. Sanitize e escape tudo

esc_html($user['name']);
esc_url($user['link']);

3. Trate erros adequadamente

if ($response->is_error()) {
    return array();
}

4. Use nomes únicos

Sempre prefixe suas funções e classes para evitar conflitos:

class MyPluginAdmin // ✅ Bom
class Admin // ❌ Pode conflitar

5. Teste seu plugin

Durante o desenvolvimento, sempre teste:

Ativação/Desativação: Seu plugin deve funcionar sem erros;
Endpoints da API: Use os links na página administrativa;
Shortcodes: Teste em posts e páginas;
Permissões: Teste com diferentes níveis de usuário.

Dominar o sistema de plugins do WordPress é essencial para escalar um projeto. O segredo está em compreender profundamente os hooks (actions e filters), estruturar o código em classes, aproveitar a API REST sempre que possível, seguir as boas práticas e padrões da plataforma, e priorizar a segurança em cada etapa.

É importante salientar novamente que este artigo é uma base e o WordPress possui inúmeras funções e facilidades próprias que devem ser aprofundadas.

Abaixo listarei alguns links úteis para que você aprofunde seus conhecimentos:

WordPress Developer Handbook - A documentação oficial mais completa. Essencial para qualquer desenvolvedor.
Plugin Handbook - Guia oficial específico para desenvolvimento de plugins. Cobre desde o básico até tópicos avançados.
REST API Handbook - Documentação completa da API REST do WordPress. Fundamental para integrações modernas.
WordPress Coding Standards - Padrões de código oficiais.
GenerateWP - Ferramenta online que gera códigos do WordPress automaticamente. Excelente para acelerar o desenvolvimento e aprender sintaxes.

#wordpress #php #webdev #tutorial #plugins #rest-api #hooks #cms

Criando API RESTful simples com PHP e CodeIgniter

Matheus Mendonça Sesso — Sat, 20 Sep 2025 03:56:03 +0000

Olá pessoal! Através desse simples artigo eu vou ensinar como criamos API RESTful básica, utilizando o nosso bom e velho PHP e a ajuda do maravilhoso framework CodeIgniter 4.

Então inspirado na Chuck Norris API, no péssimo humorista brasileiro Leo Lins, a fim de praticar e de brincadeira… 🤣

Resolvi criar uma API com piadas e humor negro brasileiro que está disponibilizada neste repositório no GitHub e pode ser utilizada através deste link:

https://darkhumor-api.ddns.net/

Sendo assim, vou explicar de forma simples e tentar ser o mais prático possível, como foi feito este esse projeto.

O que vamos construir?

API RESTful com 5 endpoints que funcionam de verdade
Arquitetura MVC bem organizada (sem gambiarras!)
Base de dados JSON com mais de 1000 piadas
Validações e tratamento de erros
Código limpo que você vai conseguir manter

O que você precisa saber antes

PHP básico (orientação a objetos ajuda)
Conceitos de API REST (GET, POST, JSON...)
CodeIgniter 4 (vou explicar tudo, mas é bom ter uma noção)
Um servidor local (Docker, XAMPP ou WAMP)

Como vamos organizar tudo

Olha, o CodeIgniter 4 já vem com uma estrutura bem definida. Vamos usar só o que precisamos:

darkhumor-api/
├── app/
│   ├── Controllers/
│   │   └── JokesController.php      # Aqui fica toda lógica da API
│   ├── Models/
│   │   └── JokesModel.php           # Aqui gerenciamos os dados
│   ├── Config/
│   │   ├── Routes.php               # Definimos as URLs da API
│   │   └── App.php                  # Configurações básicas
│   └── Libraries/
│       └── jokes.json               # Nossa "base de dados"
├── public/
│   └── index.php                    # Ponto de entrada da aplicação
└── .htaccess                        # Para URLs bonitas

Por que essa estrutura?

Controllers: Recebem as requisições HTTP e devolvem respostas
Models: Fazem toda a manipulação dos dados
Config: Configurações da aplicação
Libraries: Arquivos auxiliares (nosso JSON fica aqui)

Planejamento da API

Ela vai possuir ter 5 endpoints principais:

Método	Endpoint	O que faz
`GET`	`/jokes/random`	Pega uma piada aleatória
`GET`	`/jokes/random?category=obesidade`	Piada aleatória de uma categoria
`GET`	`/jokes/categories`	Lista todas as categorias
`GET`	`/jokes/search?query=gordo`	Busca piadas por palavra
`GET`	`/jokes/42`	Pega uma piada específica pelo ID

Como vai ser a resposta?

Todas as piadas vão retornar nesse formato JSON:

{
    "id": 1043,
    "url": "http://localhost/jokes/1043",
    "value": "Texto da piada aqui...",
    "theme": "categoria da piada"
}

Por que esse formato?

id: Para identificar unicamente cada piada
url: Para acessar diretamente a piada
value: O texto da piada em si
theme: A categoria/tema da piada

1- Configuração Básica

Antes de mais nada, precisamos configurar o CodeIgniter. Abra o arquivo app/Config/App.php e ajuste essas configurações:

<?php
// app/Config/App.php

namespace Config;

use CodeIgniter\Config\BaseConfig;

class App extends BaseConfig
{
    // Sua URL local (ajuste conforme seu ambiente)
    public string $baseURL = 'http://localhost/';

    // Remove o index.php das URLs (deixa mais bonito)
    public string $indexPage = '';

    // Protocolo de URI
    public string $uriProtocol = 'REQUEST_URI';

    // Idioma padrão
    public string $defaultLocale = 'pt-BR';

    // Não negociar idioma automaticamente
    public bool $negotiateLocale = false;

    // Idiomas suportados
    public array $supportedLocales = ['pt-BR'];
}

Por que essas configurações?

$baseURL: É a URL base da sua aplicação.
$indexPage = '': Remove o index.php das URLs. Ao invés de /index.php/jokes/random, fica só /jokes/random
$defaultLocale: Define português brasileiro como padrão

2 - Configurando as Rotas

Agora vamos definir as URLs da nossa API. Abra o arquivo app/Config/Routes.php:

<?php
// app/Config/Routes.php

use CodeIgniter\Router\RouteCollection;

/**
 * @var RouteCollection $routes
 */

// Rota principal (opcional, para uma página inicial)
$routes->get('/', 'JokesController::index');

// Agrupamos todas as rotas de piadas com o prefixo 'jokes'
$routes->group('jokes', function($routes) {
    $routes->get('random', 'JokesController::random');        // /jokes/random
    $routes->get('categories', 'JokesController::categories'); // /jokes/categories
    $routes->get('search', 'JokesController::search');        // /jokes/search
    $routes->get('(:num)', 'JokesController::show/$1');       // /jokes/42
});

Vamos entender cada linha:

$routes->get('/', 'JokesController::index'):
- Quando alguém acessar a raiz do site, chama o método index do JokesController
$routes->group('jokes', function($routes) { ... }):
- Agrupa todas as rotas com o prefixo jokes
- Assim não precisamos repetir /jokes em cada rota
$routes->get('random', 'JokesController::random'):
- URL: /jokes/random
- Chama o método random do controller
$routes->get('(:num)', 'JokesController::show/$1'):
- (:num) captura apenas números
- $1 passa esse número como parâmetro para o método show
- Exemplo: /jokes/42 → chama show(42)

3 - Criando o Model

O Model é onde fica toda a lógica de manipulação dos dados. É ele que vai ler o JSON, buscar piadas, filtrar por categoria, etc.

Crie o arquivo app/Models/JokesModel.php:

<?php
// app/Models/JokesModel.php

namespace App\Models;

use CodeIgniter\Model;

class JokesModel extends Model
{
    // Aqui vamos guardar todas as piadas carregadas do JSON
    protected $jokesData;

    // E aqui as categorias extraídas
    protected $categories;

    public function __construct()
    {
        parent::__construct();
        // Assim que o model é criado, já carrega os dados
        $this->loadJokesData();
    }

    /**
     * Carrega os dados das piadas do arquivo JSON
     * Essa função roda uma vez quando o model é instanciado
     */
    private function loadJokesData()
    {
        // APPPATH é uma constante do CodeIgniter que aponta para a pasta app/
        $jsonPath = APPPATH . 'Libraries/jokes.json';

        // Sempre verificar se o arquivo existe antes de tentar ler
        if (!file_exists($jsonPath)) {
            throw new \Exception('Arquivo de piadas não encontrado em: ' . $jsonPath);
        }

        // Lê todo o conteúdo do arquivo JSON
        $jsonContent = file_get_contents($jsonPath);

        // Converte o JSON em array PHP
        $this->jokesData = json_decode($jsonContent, true);

        // Verifica se deu erro na conversão do JSON
        if (json_last_error() !== JSON_ERROR_NONE) {
            throw new \Exception('Erro ao decodificar JSON: ' . json_last_error_msg());
        }

        // Extrai as categorias únicas das piadas
        $this->categories = $this->extractCategories();
    }

    /**
     * Pega uma piada aleatória
     * Método mais simples da nossa API
     */
    public function getRandomJoke()
    {
        $jokes = $this->jokesData['jokes'];

        // array_rand() pega um índice aleatório do array
        // Depois usamos esse índice para pegar a piada
        return $jokes[array_rand($jokes)];
    }

    /**
     * Busca uma piada específica pelo ID
     */
    public function getJokeById($id)
    {
        $jokes = $this->jokesData['jokes'];

        // Percorre todas as piadas procurando pelo ID
        foreach ($jokes as $joke) {
            if ($joke['id'] == $id) {
                return $joke; // Achou! Retorna a piada
            }
        }

        // Não achou nada? Retorna null
        return null;
    }

    /**
     * Pega piadas de uma categoria específica
     * Exemplo: getJokesByCategory('obesidade')
     */
    public function getJokesByCategory($category)
    {
        $jokes = $this->jokesData['jokes'];
        $categoryJokes = [];

        foreach ($jokes as $joke) {
            // stripos() faz busca case-insensitive
            // Procura se a categoria está no tema da piada
            if (stripos($joke['theme'], $category) !== false) {
                $categoryJokes[] = $joke;
            }
        }

        return $categoryJokes;
    }

    /**
     * Busca piadas por qualquer texto
     * Procura tanto no texto da piada quanto no tema
     */
    public function searchJokes($query)
    {
        $jokes = $this->jokesData['jokes'];
        $results = [];

        foreach ($jokes as $joke) {
            // Busca no texto da piada OU no tema
            $foundInJoke = stripos($joke['joke'], $query) !== false;
            $foundInTheme = stripos($joke['theme'], $query) !== false;

            if ($foundInJoke || $foundInTheme) {
                $results[] = $joke;
            }
        }

        return $results;
    }

    /**
     * Retorna todas as categorias disponíveis
     */
    public function getCategories()
    {
        return $this->categories;
    }

    /**
     * Extrai categorias únicas dos temas das piadas
     * Esse método é mais complexo porque alguns temas são compostos
     * Exemplo: "Obesidade e AIDS" vira duas categorias: "obesidade" e "aids"
     */
    private function extractCategories()
    {
        // array_column pega só a coluna 'theme' de todas as piadas
        $themes = array_column($this->jokesData['jokes'], 'theme');
        $categories = [];

        foreach ($themes as $theme) {
            // Alguns temas são compostos: "Obesidade e AIDS", "Deficiência e regionalismo"
            // Vamos separar por "e" ou vírgula
            $parts = preg_split('/\s+e\s+|,\s*/', $theme);

            foreach ($parts as $part) {
                // Limpa espaços e converte para minúsculo
                $category = trim(strtolower($part));

                // Só adiciona se não estiver vazio e não existir ainda
                if (!empty($category) && !in_array($category, $categories)) {
                    $categories[] = $category;
                }
            }
        }

        // Ordena alfabeticamente para ficar organizado
        sort($categories);
        return $categories;
    }

    /**
     * Método auxiliar para pegar estatísticas (opcional)
     */
    public function getStats()
    {
        return [
            'total_jokes' => count($this->jokesData['jokes']),
            'total_categories' => count($this->categories),
            'description' => $this->jokesData['description'] ?? 'API de Humor Negro'
        ];
    }
}

Por que fazer assim?

Carregamento único: Os dados são carregados uma vez no __construct() e ficam na memória
Tratamento de erros: Sempre verificamos se o arquivo existe e se o JSON é válido
Busca inteligente: Usamos stripos() para busca case-insensitive
Categorias dinâmicas: Extraímos automaticamente as categorias dos temas

4 - Criando o Controller - O Maestro da API

Agora vem a parte mais importante: o Controller! É ele que recebe as requisições HTTP, chama o Model e retorna as respostas em JSON.

Crie o arquivo app/Controllers/JokesController.php:

<?php
// app/Controllers/JokesController.php

namespace App\Controllers;

use CodeIgniter\RESTful\ResourceController;
use CodeIgniter\API\ResponseTrait;
use App\Models\JokesModel;

class JokesController extends ResourceController
{
    // Esse trait nos dá métodos prontos para responder JSON
    use ResponseTrait;

    protected $jokesModel;

    public function __construct()
    {
        // Instancia o model assim que o controller é criado
        $this->jokesModel = new JokesModel();
    }

    /**
     * Página inicial (opcional)
     * Você pode criar uma view aqui ou só retornar uma mensagem
     */
    public function index()
    {
        return $this->respond([
            'message' => 'Bem-vindo à Dark Humor API!',
            'endpoints' => [
                'GET /jokes/random' => 'Piada aleatória',
                'GET /jokes/categories' => 'Lista de categorias',
                'GET /jokes/search?query=termo' => 'Busca piadas',
                'GET /jokes/{id}' => 'Piada específica'
            ]
        ]);
    }

    /**
     * GET /jokes/random
     * GET /jokes/random?category=obesidade
     */
    public function random()
    {
        // Verifica se foi passada uma categoria
        $category = service('request')->getGet('category');

        if ($category) {
            // Se tem categoria, chama método específico
            return $this->getRandomByCategory($category);
        }

        // Senão, pega uma piada aleatória qualquer
        $randomJoke = $this->jokesModel->getRandomJoke();
        $response = $this->formatJokeResponse($randomJoke);

        return $this->respond($response);
    }

    /**
     * Método privado para pegar piada aleatória por categoria
     */
    private function getRandomByCategory($category)
    {
        // Busca todas as piadas da categoria
        $categoryJokes = $this->jokesModel->getJokesByCategory($category);

        // Se não achou nenhuma, retorna erro 404
        if (empty($categoryJokes)) {
            return $this->failNotFound('Categoria não encontrada: ' . $category);
        }

        // Pega uma aleatória das que achou
        $randomJoke = $categoryJokes[array_rand($categoryJokes)];
        $response = $this->formatJokeResponse($randomJoke);

        return $this->respond($response);
    }

    /**
     * GET /jokes/categories
     * Retorna todas as categorias disponíveis
     */
    public function categories()
    {
        $categories = $this->jokesModel->getCategories();
        return $this->respond($categories);
    }

    /**
     * GET /jokes/search?query=gordo
     * Busca piadas por texto
     */
    public function search()
    {
        // Pega o parâmetro 'query' da URL
        $query = service('request')->getGet('query');

        // Se não passou o parâmetro, retorna erro
        if (!$query) {
            return $this->fail('Parâmetro query é obrigatório', 400);
        }

        // Busca as piadas
        $jokes = $this->jokesModel->searchJokes($query);
        $results = [];

        // Formata cada piada encontrada
        foreach ($jokes as $joke) {
            $results[] = $this->formatJokeResponse($joke);
        }

        // Retorna com o total de resultados
        $response = [
            'total' => count($results),
            'result' => $results
        ];

        return $this->respond($response);
    }

    /**
     * GET /jokes/42
     * Retorna uma piada específica pelo ID
     */
    public function show($id = null)
    {
        // Verifica se foi passado um ID
        if (!$id) {
            return $this->fail('ID é obrigatório', 400);
        }

        // Busca a piada no model
        $joke = $this->jokesModel->getJokeById($id);

        // Se não achou, retorna 404
        if (!$joke) {
            return $this->failNotFound('Piada não encontrada com ID: ' . $id);
        }

        // Formata e retorna
        $response = $this->formatJokeResponse($joke);
        return $this->respond($response);
    }

    /**
     * Método auxiliar para formatar a resposta das piadas
     * Padroniza o formato de saída da API
     */
    private function formatJokeResponse($joke)
    {
        return [
            'id' => $joke['id'],
            'url' => base_url('jokes/' . $joke['id']),
            'value' => $joke['joke'],
            'theme' => $joke['theme']
        ];
    }
}

Vamos entender o que está acontecendo:

1. Herança e Traits

class JokesController extends ResourceController
{
    use ResponseTrait;

ResourceController: Classe base do CodeIgniter para APIs REST
ResponseTrait: Nos dá métodos como respond(), fail(), failNotFound()

2. Método `random()`

$category = service('request')->getGet('category');

service('request') pega a instância da requisição HTTP
getGet('category') busca o parâmetro category na URL
Se /jokes/random?category=obesidade, $category será "obesidade"

3. Tratamento de Erros

if (empty($categoryJokes)) {
    return $this->failNotFound('Categoria não encontrada');
}

Sempre validamos se encontramos dados
failNotFound() retorna HTTP 404 automaticamente
fail() retorna HTTP 400 (Bad Request)

4. Formatação Consistente

private function formatJokeResponse($joke)

Método privado que padroniza todas as respostas
Evita repetir código
Se precisar mudar o formato, muda só aqui

5 - Estrutura do JSON

Para este projeto, vamos usar um arquivo JSON como base de dados. É simples, rápido e funciona perfeitamente para uma API de piadas.

Crie o arquivo app/Libraries/jokes.json e a estrutura do json será semelhante a essa:

{
    "total_jokes": 1000,
    "description": "Coleção de piadas de humor negro em português",
    "jokes": [
        {
            "id": 1,
            "joke": "Sou gordo! Adoro comer e não gosto de fazer exercício. Como vou emagrecer? Pegando AIDS!",
            "theme": "Obesidade e AIDS"
        },
        {
            "id": 2,
            "joke": "Tem ser humano que não é 100% humano. O nordestino no avião? 72%.",
            "theme": "Preconceito regional"
        },
        {
            "id": 3,
            "joke": "Se você for no zoológico, os animais vão tirar fotos de você.",
            "theme": "Obesidade"
        }
        // ... continue adicionando suas piadas aqui
    ]
}

Por que essa estrutura?

total_jokes: Facilita estatísticas sem contar o array toda vez
description: Metadados sobre a coleção
jokes: Array principal com todas as piadas
id: Identificador único e sequencial (1, 2, 3...)
joke: O texto da piada em si
theme: Categoria para filtros e buscas

O arquivo .json completo com todas as piadas está disponibilizado neste repositório do GitHub.

Testando Nossa API

Agora que tudo está pronto, vamos testar se nossa API está funcionando! Vou te mostrar várias formas de testar.

Crie um arquivo test.php para testar:

<?php
// Função auxiliar para testar endpoints
function testEndpoint($url) {
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response, true);
}

// Testa piada aleatória
$randomJoke = testEndpoint('http://localhost/jokes/random');
echo "Piada aleatória: " . $randomJoke['value'] . "\n";

// Testa categorias
$categories = testEndpoint('http://localhost/jokes/categories');
echo "Total de categorias: " . count($categories) . "\n";

// Testa busca
$searchResults = testEndpoint('http://localhost/jokes/search?query=gordo');
echo "Piadas encontradas: " . $searchResults['total'] . "\n";
?>

Respostas Esperadas

Piada aleatória:

{
    "id": 1043,
    "url": "http://localhost/jokes/1043",
    "value": "Eu sou tão feio que meu espelho me deu um processo...",
    "theme": "Aparência"
}

Busca por categoria:

{
    "id": 23,
    "url": "http://localhost/jokes/23",
    "value": "Gordo no ônibus: parece um dinossauro entrando.",
    "theme": "Obesidade"
}

Lista de categorias:

[
    "aborto",
    "abuso",
    "acidente",
    "amizade",
    "animais",
    "aparência"
]

Busca por texto:

{
    "total": 74,
    "result": [
        {
            "id": 1,
            "url": "http://localhost/jokes/1",
            "value": "Sou gordo! Adoro comer...",
            "theme": "Obesidade"
        }
    ]
}

Bom, é isso ai! Se você leu até aqui, espero que tenha te ajudado!

Criamos uma API RESTful completamente funcional utilizando as facilidades que CodeIgniter proporciona com sua estrutura MVC, criando uma ótima base para podermos explorar melhorias nas próximas implementações com recursos mais avançados, como:

Cache: Implementar cache Redis para performance
Paginação: Adicionar paginação na busca
Rate Limiting: Limitar requisições por IP
Logs: Implementar logs estruturados
Validação: Validar parâmetros de entrada
Autenticação JWT: Para APIs privadas
Upload de piadas: Endpoint para adicionar piadas
Favoritos: Sistema de piadas favoritas
Estatísticas: Analytics de uso da API
Webhooks: Notificações de novas piadas

Existe um projeto 100% open-source desta API e está disponibilizada neste repositório no GitHub e para utilização através deste link: https://darkhumor-api.ddns.net/

Links Recomendados

CodeIgniter 4 Docs - Documentação oficial
REST API Best Practices - Boas práticas
JSON Validator - Validar seu JSON
Postman - Testar APIs

#PHP #CodeIgniter4 #API #REST #JSON #WebDevelopment #Backend #MVC

PHP em 2025: Por Que Ele Ainda Reina na Web?

Matheus Mendonça Sesso — Thu, 01 May 2025 04:18:11 +0000

Você com certeza já ouviu falar que o PHP é uma linguagem ultrapassada, que é uma linguagem só de "gambiarras" e que existem opções muito melhores para você que está começando na programação. Mas eu discordo!

Programo em PHP desde 2010, estou, de fato no mercado de trabalho desde 2016, utilizando na maioria das vezes como base o bom e velho PHP e desde então, venho acompanhando a sua evolução.

Apesar de algumas críticas, essa linguagem continua sendo a base de mais de 76% dos sites na web, impulsionando plataformas como WordPress, Facebook e Wikipedia. Neste artigo, eu procurei trazer alguns dados e informações cruciais que exploram o por que o PHP permanece tão relevante, destacando o poder do WordPress, os frameworks versáteis, as integrações modernas e a enorme comunidade que mantém a linguagem mais viva do que nunca.

PHP no Mercado: WordPress, Frameworks e Dominância

O PHP é um colosso no mercado. Em 2025, ele alimenta 76% dos sites do planeta, segundo a W3Techs, cobrindo mais da metade da internet. Um dos principais motores dessa força é o WordPress, que roda em PHP e domina 43% do mercado de CMS. Sites como BBC, The New York Times e TechCrunch confiam no WordPress para entregar conteúdo escalável, de blogs a portais corporativos. Sua flexibilidade, com mais de 60 mil plugins e 10 mil temas, o torna imbatível para soluções rápidas.

Mas o PHP vai além do WordPress. Frameworks como Laravel, Symfony e CodeIgniter são amplamente adotados no mercado. O Laravel, usado por 61% dos desenvolvedores PHP, segundo a JetBrains, é a escolha preferida para startups e SaaS, como plataformas de e-commerce e ferramentas de automação. O Symfony, base de projetos enterprise como Drupal e Magento, é padrão em CRMs e sistemas corporativos de grande escala. CodeIgniter, por sua leveza, é popular em startups e agências digitais que desenvolvem MVPs rápidos. Empresas como Zoom, Slack e Automattic (dona do WordPress.com) também usam PHP em infraestruturas críticas, seja via WordPress ou frameworks customizados. Meus projetos com PHP, como sistemas web e APIs, sempre aproveitaram sua simplicidade e rapidez. A combinação de WordPress para CMS e frameworks para soluções sob medida explica por quê o PHP continua reinando.

Críticas ao PHP: Verdade ou Mito?

As críticas ao PHP, como ser "bagunçado" ou "ultrapassado", muitas vezes vêm de quem parou no PHP 5, por meados de 2005. O PHP moderno, nas versões 8.x, é bem diferente: tem JIT compilation para maior performance, tipagem robusta com union types e mixed types, e é 2-3x mais rápido que versões antigas. A PHP Foundation, criada em 2021, garante atualizações constantes e segurança. Projetos legados modernizados com PHP 8 resultam em código limpo, rápido e fácil de manter, destruindo por completo todos os preconceitos.

WordPress: Um monstro do PHP

O WordPress é um dos maiores exemplos do poder do PHP. Com 43% do mercado de CMS, ele é usado por mais de 800 milhões de sites, de blogs pessoais a portais corporativos. Sua flexibilidade vem de um ecossistema rico: mais de 60 mil plugins e 10 mil temas disponíveis no WordPress.org permitem customizações infinitas. Desenvolvedores PHP podem criar plugins, temas e até custom post types para atender necessidades específicas. A REST API do WordPress facilita integrações com apps mobile e sistemas externos, enquanto o editor Gutenberg moderniza a criação de conteúdo com blocos dinâmicos. A comunidade de desenvolvedores, com eventos como WordCamps e fóruns ativos, mantém o WordPress inovador. Para quem usa PHP, o WordPress é uma porta de entrada para projetos rápidos e escaláveis, com uma base de código que aproveita as versões mais recentes da linguagem.

Frameworks: Soluções Sob Medida

Enquanto o WordPress brilha em CMS, os frameworks PHP são ideais para projetos personalizados. O ecossistema de frameworks é vasto, com opções para diferentes necessidades:

Laravel: Destaca-se pela sintaxe elegante, Eloquent ORM e Blade templating. É perfeito para aplicações full-stack e APIs RESTful.
Symfony: Ideal para projetos enterprise, é modular, escalável e usado em plataformas como Drupal e Magento. O Doctrine ORM e o Twig oferecem flexibilidade para aplicações complexas.
CodeIgniter: Leve, rápido e com curva de aprendizado suave, é ótimo para projetos menores ou MVPs.
Outros: CakePHP, com ORM embutido, Yii, focado em performance, e micro-frameworks como Lumen e Slim, ideais para APIs enxutas.

Esses frameworks garantem código organizado, desenvolvimento rápido e aderência às melhores práticas, complementando a força de plataformas como o WordPress.

Integrações: PHP Conversa com Tudo

O PHP se conecta a tecnologias modernas com facilidade. Para APIs, Laravel e Lumen são excelentes para RESTful e GraphQL. Na nuvem, o PHP roda em AWS, Azure e Google Cloud, com ferramentas como Bref para serverless no AWS Lambda. Para IoT, frameworks como Laravel e Symfony sincronizam dispositivos com scripts assíncronos. Em IA, a biblioteca PHP-ML permite tarefas como predição e reconhecimento de padrões, além de integrar com APIs de machine learning. Essas capacidades tornam o PHP versátil para uma ampla gama de projetos.

A Comunidade: O Segredo da Longevidade

A comunidade PHP certamente é um pilar essencial. Com mais de 600 mil desenvolvedores no Symfony, 45 mil no Laravel.io, além de fóruns, Slack, Reddit e eventos como PHP Conference e CakeFest, o suporte é constante. A PHP Foundation impulsiona inovações, como property hooks e lazy objects introduzidos em 2024. A documentação é vasta, com tutoriais para tudo, de PHPUnit (usado por 50% dos devs para testes) a bibliotecas como PHPMailer. A comunidade do WordPress, com WordCamps e fóruns, também contribui, oferecendo recursos para desenvolvedores PHP. Posts no Stack Overflow e vídeos no Laracasts seguem sendo aliados valiosos.

Olhando pro Futuro: O que Vem por Aí?

O PHP se mantém na vanguarda da modernidade. Em 2025, sua adoção em arquiteturas cloud-native cresce, com frameworks como Laravel e Symfony rodando em containers via Docker e orquestrados por Kubernetes, garantindo escalabilidade em aplicações distribuídas. Ferramentas como Bref permitem usar PHP em ambientes serverless, como AWS Lambda, para soluções de baixo custo e alta performance. A integração com IA é outro destaque: bibliotecas como PHP-ML suportam tarefas de machine learning, enquanto APIs de IA, como Google Cloud AI e OpenAI, são facilmente conectadas para criar chatbots avançados e interfaces inteligentes.

Ferramentas de NLP, como spaCy e TextRank, integram-se ao PHP para buscas por voz e análise de texto, atendendo à demanda por experiências conversacionais. Suporte a WebSockets, via extensões como Swoole e Ratchet, habilita aplicações em tempo real, como chats e dashboards interativos. Práticas DevOps modernas, como CI/CD com GitHub Actions, são amplamente usadas em projetos PHP, agilizando entregas.

O WordPress também evolui, com melhorias na REST API para integrações headless e no editor Gutenberg para interfaces dinâmicas, reforçando a relevância do PHP. O PHP 8.5, previsto para novembro de 2025, trará otimizações no JIT, novas funcionalidades como property hooks aprimorados e maior eficiência em memória, consolidando a linguagem como uma escolha contemporânea.

O PHP continua surpreendendo, alinhado às demandas do desenvolvimento moderno.

Conclusão

O PHP é mais do que relevante: é essencial. Com o WordPress dominando o mercado de CMS, frameworks poderosos como Laravel e Symfony, integrações modernas e uma comunidade vibrante, ele permanece uma escolha sólida. Minha experiência com PHP desde 2010 mostra que a linguagem entrega soluções rápidas e escaláveis. Para quem busca confiabilidade e versatilidade, o PHP é imbatível.

Referências

Quer se aprofundar no PHP e nas informações que citei? Aqui vão alguns links que valem a pena conferir:

W3Techs: Dados atualizados sobre a participação do PHP na web.
PHP Official Documentation: A bíblia do PHP, com tudo sobre as versões 8.x e novidades.
PHP Foundation: Saiba mais sobre quem tá mantendo o PHP vivo e evoluindo.
JetBrains PHP Developer Survey: Estatísticas sobre o uso de frameworks e ferramentas PHP.
WordPress.org - About: Informações sobre o impacto e as capacidades do WordPress.
WordPress Developer Resources: Documentação oficial para desenvolver com WordPress.
Laravel Documentation: Docs oficiais do Laravel, com guias pra APIs, Eloquent e mais.
Symfony Documentation: Documentação oficial do Symfony.
CodeIgniter Documentation: Documentação oficial do CodeIgniter.
Laracasts: Cursos e tutoriais incríveis pra dominar PHP e Laravel.
PHP Conference International: Infos sobre a maior conferência PHP do mundo.
PHP Conference Brasil: Infos sobre a maior conferência PHP do Brasil.
Bref - Serverless PHP on AWS: Como rodar PHP em serverless na AWS.
PHP-ML Documentation: Biblioteca pra brincar com machine learning em PHP.

Desafio da Mochila (Knapsack Problem) em PHP

Matheus Mendonça Sesso — Wed, 26 Feb 2025 01:12:37 +0000

Resolvi trazer neste artigo um problema relativamente simples, que aprendi a bastante tempo atrás, um dos problemas de otimização mais famosos da computação: o desafio da mochila.

É bem simples, mas há pouco tempo, desenvolvendo um sistema de LMS para meu trabalho, me deparei com um problema exatamente igual, porém envolvendo notas e questionários. Por isso, hoje vou resolver esse problema de forma bem simples e prática utilizando nosso guerreiro PHP.

O desafio é o seguinte, imagine que você está se preparando para uma aventura e tem que escolher o que levar na mochila. Só tem um problema... a mochila tem um limite de peso, e você precisa escolher o que levar para maximizar o valor total.

Você pode ser informar melhor sobre esse problema neste link: https://pt.wikipedia.org/wiki/Problema_da_mochila

O que temos aqui é um problema de escolha. Dado um número de itens, cada um com um valor e um peso, precisamos decidir quais itens colocar na mochila para maximizar o valor, sem exceder a capacidade de peso da mochila.

Dados e regras do desafio:

A capacidade da mochila (quantidade máxima de peso que podemos carregar).
Uma lista de itens, onde cada item tem um peso e um valor.

Cada item pode ser levado ou deixado, ou seja, é uma decisão binária. E não dá pra dividir o item, ou leva o item inteiro ou nada.

O objetivo é simples: encontrar o valor máximo que conseguimos carregar sem ultrapassar a capacidade.

A solução: programação dinâmica

Para resolver o problema da mochila, vamos usar a boa e velha programação dinâmica. A ideia é construir uma tabela que vai armazenando os valores máximos possíveis para cada capacidade da mochila, conforme a gente decide incluir ou não cada item.

Como faremos:

Criamos uma matriz onde as linhas representam os itens e as colunas representam as capacidades (de 0 até a capacidade máxima).
Cada célula dessa tabela vai guardar o valor máximo que conseguimos atingir até aquele momento.
Para cada item, decidimos se vamos colocá-lo na mochila ou não, comparando o valor de incluir versus deixar o item de fora.

function mochila($capacidade, $pesos, $valores, $n) {
    // Criando uma tabela para armazenar os valores máximos possíveis
    $dp = array_fill(0, $n + 1, array_fill(0, $capacidade + 1, 0));

    // Preenchendo a tabela com os valores
    for ($i = 1; $i <= $n; $i++) { // Iterando sobre os itens
        for ($w = 1; $w <= $capacidade; $w++) { // Iterando sobre as capacidades
            if ($pesos[$i - 1] <= $w) {
                // Se o item cabe na mochila, decidimos se vamos colocar ele ou não
                $dp[$i][$w] = max(
                    $valores[$i - 1] + $dp[$i - 1][$w - $pesos[$i - 1]], // Colocamos o item
                    $dp[$i - 1][$w] // Deixamos o item de fora
                );
            } else {
                // Se o item não cabe, apenas seguimos sem ele
                $dp[$i][$w] = $dp[$i - 1][$w];
            }
        }
    }

    // Retorna o valor máximo que pode ser colocado na mochila
    return $dp[$n][$capacidade];
}

// Exemplo de uso:
$valores = [60, 100, 120]; // Valores dos itens (ex: dinheiro)
$pesos = [10, 20, 30]; // Pesos dos itens (ex: kg)
$capacidade = 50; // Capacidade máxima da mochila (ex: quantos kg podemos carregar)
$n = count($valores); // Quantidade de itens

// Chamamos a função e imprimimos o valor máximo possível:
echo "Valor máximo que pode ser levado: " . mochila($capacidade, $pesos, $valores, $n);

O está acontecendo aqui?

Função mochila: Ela recebe a capacidade da mochila, os arrays de pesos e valores dos itens e o número total de itens. Cria uma tabela dp onde cada célula guarda o valor máximo possível para aquela capacidade e aquele conjunto de itens.
Preenchimento da tabela: Para cada item, verificamos se podemos colocá-lo na mochila, comparando o valor de incluir o item (se couber) com o valor de não incluí-lo. Assim, vamos atualizando a tabela com o valor máximo em cada passo.
Resultado final: No fim, a célula dp[n][capacidade] vai ter o valor máximo que conseguimos alcançar com os itens e capacidade.

Conclusão

Bom, é isso ai! Essa foi uma implementação bem simples em PHP, mas é prática e pode ser facilmente adaptada para resolver problemas semelhantes em outros cenários.

Criando planilhas Excel e outros formatos com PHP

Matheus Mendonça Sesso — Sun, 29 Sep 2024 13:07:10 +0000

Olá pessoal, neste artigo iremos falar um pouco sobre o PhpSpreadsheet, uma biblioteca extremamente completa para lhe auxiliar com demandas para ler e escrever arquivos utilizando PHP.

O PhpSpreadsheet é uma biblioteca PHP que permite ler e escrever arquivos de planilhas em vários formatos, como Excel (xlsx), OpenDocument Spreadsheet (ODS), CSV, entre outros. Com ele, você pode criar, modificar e ler planilhas de forma programática em seus projetos PHP.

Ele é extremamente útil no ramo corporativo, já utilizei em diversos projetos de empresas distintas, portanto eu acho ele algo essencial para quem quer elevar um pouquinho seu nível de desenvolvimento em PHP.

Aqui eu ensinarei o básico para você utilizar a lib, porém vale ressaltar que este é um projeto open-source e bem ativo na comunidade, portanto a manutenção e documentação dele é bem completa, vale a pena dar uma estudada. Para se aprofundar, você pode acessar todas as informações da biblioteca neste link: https://phpspreadsheet.readthedocs.io/

Bom vamos ao que interessa!

Primeiramente existe alguns requisitos para que você possa utilizar o PhpSpreadsheet em seu projeto, são eles:

Versão do PHP deve ser a 7.4 ou superior;
Necessariamente possuir o Composer instalado no seu sistema.

Primeiramente você deve acessar a pasta raiz do seu projeto e executar o comando:

composer require phpoffice/phpspreadsheet

Este comando irá adicionar o PhpSpreadsheet como uma dependência em seu projeto e atualizar o arquivo composer.json.

Após a instalação da biblioteca via Composer já é possível utilizar todas as funcionalidades do PhpSpreadsheet, vamos abordar algumas dessas possibilidades:

Criando uma Nova Planilha

Para começar de fato a utilizar o PhpSpreadsheet, você precisa criar uma instância da classe Spreadsheet:

<?php
require 'vendor/autoload.php';

use PhpOffice\PhpSpreadsheet\Spreadsheet;

$spreadsheet = new Spreadsheet();

Após a criação da instância da classe Spreadsheet, você pode começar a manipular a planilha adicionando dados, criando novas folhas, formatando células, entre outras funcionalidades.

Adicionando Dados à Planilha

Para adicionar dados à sua planilha, você precisa acessar a folha ativa (ou criar uma nova) e utilizar o método setCellValue(). Veja o exemplo abaixo:

<?php
require 'vendor/autoload.php';

use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;

$spreadsheet = new Spreadsheet();

// Seleciona a primeira folha da planilha
$sheet = $spreadsheet->getActiveSheet();

// Define o valor das células
$sheet->setCellValue('A1', 'Nome');
$sheet->setCellValue('B1', 'Idade');
$sheet->setCellValue('A2', 'João');
$sheet->setCellValue('B2', 25);
$sheet->setCellValue('A3', 'Maria');
$sheet->setCellValue('B3', 30);

// Salva a planilha em um arquivo .xlsx
$writer = new Xlsx($spreadsheet);
$writer->save('planilha.xlsx');

Neste exemplo acima, criamos uma nova planilha, inserimos alguns dados e salvamos em um arquivo chamado planilha.xlsx.

Lendo uma Planilha Existente

Também é possível ler dados de uma planilha existente utilizando o PhpSpreadsheet. Para isso, utilizaremos a classe IOFactory para carregar o arquivo:

<?php
require 'vendor/autoload.php';

use PhpOffice\PhpSpreadsheet\IOFactory;

$inputFileName = 'planilha.xlsx';

// Carrega o arquivo de planilha
$spreadsheet = IOFactory::load($inputFileName);

// Seleciona a primeira folha
$sheet = $spreadsheet->getActiveSheet();

// Lê os dados das células
$nome1 = $sheet->getCell('A2')->getValue();
$idade1 = $sheet->getCell('B2')->getValue();

echo "Nome: $nome1, Idade: $idade1";

Neste exemplo acima, carregamos a planilha criada anteriormente e lemos os valores das células A2 e B2.

Estilizando a Planilha

O PhpSpreadsheet permite que você aplique estilos às células, como definir fontes, cores, alinhamentos e muito mais. Veja como aplicar alguns estilos básicos:

<?php
require 'vendor/autoload.php';

use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;

$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();

// Define os valores das células
$sheet->setCellValue('A1', 'Produto');
$sheet->setCellValue('B1', 'Preço');
$sheet->setCellValue('A2', 'Camiseta');
$sheet->setCellValue('B2', 29.99);
$sheet->setCellValue('A3', 'Calça');
$sheet->setCellValue('B3', 59.99);

// Aplica estilos ao cabeçalho
$headerStyle = [
    'font' => [
        'bold' => true,
        'color' => ['argb' => 'FFFFFFFF'],
    ],
    'fill' => [
        'fillType' => \PhpOffice\PhpSpreadsheet\Style\Fill::FILL_SOLID,
        'startColor' => ['argb' => 'FF0000FF'],
    ],
];

$sheet->getStyle('A1:B1')->applyFromArray($headerStyle);

// Ajusta a largura das colunas
$sheet->getColumnDimension('A')->setAutoSize(true);
$sheet->getColumnDimension('B')->setAutoSize(true);

// Salva a planilha estilizada
$writer = new Xlsx($spreadsheet);
$writer->save('planilha_estilizada.xlsx');

No código acima, aplicamos um estilo de cabeçalho às células A1 e B1, incluindo negrito e fundo azul com texto branco. Também ajustamos a largura das colunas automaticamente.

Trabalhando com Várias Folhas

Você também pode adicionar múltiplas folhas à sua planilha:

<?php
require 'vendor/autoload.php';

use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;

$spreadsheet = new Spreadsheet();

// Renomeia a folha ativa
$spreadsheet->getActiveSheet()->setTitle('Dados Pessoais');

// Cria uma nova folha
$sheet2 = $spreadsheet->createSheet();
$sheet2->setTitle('Dados Profissionais');

// Define valores na primeira folha
$sheet1 = $spreadsheet->setActiveSheetIndex(0);
$sheet1->setCellValue('A1', 'Nome');
$sheet1->setCellValue('A2', 'Carlos');

// Define valores na segunda folha
$sheet2 = $spreadsheet->setActiveSheetIndex(1);
$sheet2->setCellValue('A1', 'Empresa');
$sheet2->setCellValue('A2', 'Tech Solutions');

// Salva a planilha com múltiplas folhas
$writer = new Xlsx($spreadsheet);
$writer->save('planilha_multiplas_folhas.xlsx');

Neste exemplo, criamos uma planilha com duas folhas: "Dados Pessoais" e "Dados Profissionais", cada uma contendo informações distintas.

Protegendo a Planilha

Você pode proteger sua planilha ou folhas específicas com senha:

<?php
require 'vendor/autoload.php';

use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;

$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();

// Define valores
$sheet->setCellValue('A1', 'Dados Confidenciais');

// Protege a folha ativa
$protection = $sheet->getProtection();
$protection->setPassword('senha_secreta');
$protection->setSheet(true);

// Salva a planilha protegida
$writer = new Xlsx($spreadsheet);
$writer->save('planilha_protegida.xlsx');

Com esse código, a folha será protegida, impedindo alterações sem a que a senha seja definida.

Exportando para Diferentes Formatos

O PhpSpreadsheet permite que você salve sua planilha em diferentes formatos, como CSV, HTML, PDF, entre outros:

Exportando para CSV:

<?php
require 'vendor/autoload.php';

use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Csv;

$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();

// Define valores
$sheet->setCellValue('A1', 'Nome');
$sheet->setCellValue('B1', 'Email');
$sheet->setCellValue('A2', 'Ana');
$sheet->setCellValue('B2', 'ana@example.com');

// Salva a planilha em formato CSV
$writer = new Csv($spreadsheet);
$writer->save('contatos.csv');

Exportando para PDF:

Para exportar para PDF, você precisa ter as bibliotecas de renderização de PDF instaladas (mPDF, Dompdf ou TCPDF).

Vou mostrar um exemplo utilizando o Dompdf:

<?php
require 'vendor/autoload.php';

use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Pdf\Dompdf;

$spreadsheet = new Spreadsheet();
$sheet = $spreadsheet->getActiveSheet();

// Define valores
$sheet->setCellValue('A1', 'Relatório');
$sheet->setCellValue('A2', 'Dados importantes aqui.');

// Configura o writer para PDF usando Dompdf
\PhpOffice\PhpSpreadsheet\IOFactory::registerWriter('Pdf', Dompdf::class);
$writer = \PhpOffice\PhpSpreadsheet\IOFactory::createWriter($spreadsheet, 'Pdf');

// Salva a planilha em formato PDF
$writer->save('relatorio.pdf');

Obs: Certifique-se de possuir instalada a biblioteca Dompdf, caso não possua instale também via Composer:

composer require dompdf/dompdf

Basicamente é isso pessoal, como vocês puderam ver, o PhpSpreadsheet é uma ferramenta extremamente poderosa e versátil para manipulação de planilhas em PHP.

Com ele, você pode:

Criar e editar planilhas em diversos formatos.
Ler dados de planilhas existentes.
Aplicar estilos e formatações avançadas.
Trabalhar com múltiplas folhas.
Proteger planilhas com senha.
Exportar planilhas para diferentes formatos, incluindo CSV e PDF.

Este artigo abordou os conceitos básicos para você começar a utilizar o PhpSpreadsheet em seus projetos. A biblioteca oferece muito mais funcionalidades avançadas que podem ser exploradas na documentação oficial: https://phpspreadsheet.readthedocs.io/.

Espero que este artigo contribua e tenha sido útil, para que você possa aplicar esses conhecimentos em suas aplicações.

Criando um ambiente LAMP utilizando Docker Compose

Matheus Mendonça Sesso — Tue, 19 Mar 2024 01:19:40 +0000

Neste artigo explicarei um pouco sobre o Docker e demonstrarei na prática como criar um ambiente de desenvolvimento LAMP, stack web que utiliza as tecnologias Apache, PHP e MySQL como base para rodar sua aplicação.

O Docker é uma plataforma que permite automatizar o processo de criação, implantação e execução de aplicativos dentro de contêineres. Ele basicamente simplifica o desenvolvimento e a implantação de aplicativos, fornecendo uma maneira consistente de empacotar o código, bibliotecas e outras dependências necessárias em um contêiner isolado.

Portanto quando você possui um aplicativo configurado em Docker, ele irá funcionar de maneira consistente, independentemente do ambiente em que está sendo executado.

O Docker Compose é uma ferramenta complementar ao Docker que permite definir e executar aplicativos multi-contêiner em um único ambiente e neste artigo iremos utilizar essa ferramenta.

Para você criar um ambiente em Docker utilizando o docker-compose você precisará somente de uma pasta com dois arquivos dentro dela apenas, sendo eles o Dockerfile e docker-compose.yml.

O Dockerfile ele descreve o ambiente de execução do contêiner, incluindo quaisquer dependências, configurações de ambiente e comandos necessários para configurar o ambiente do aplicativo dentro do contêiner e o docker-compose.yml é o arquivo de configuração usado pelo Docker Compose para definir, configurar e gerenciar aplicativos compostos por múltiplos contêineres.

O Docker disponibiliza um hub em nuvem que possível encontrar imagens oficiais e feitas por colaboradores dos aplicativos através desse link: https://hub.docker.com/

Vamos logo ao que interessa, vamos montar nossa stack LAMP utilizando o Docker e Docker-Compose!

Primeiramente você precisa fazer o download e a instalação do Docker em seu ambiente, portando acesse o site oficial e faça o procedimento necessário: https://www.docker.com/products/docker-desktop

Sendo assim, vamos criar uma pasta com o nome docker-lamp e dentro dela criaremos os arquivos Dockerfile e docker-compose.yml inicialmente.

É possível configurar essa stack de diversas maneiras utilizando as imagens e configurando o arquivo docker-compose.yml, mas eu particularmente gosto de de configurar dois containers distintos: sendo o primeiro o ambiente Linux já com o Apache e o PHP configurado com todas as dependências necessárias diretamente na execução do Dockerfile e o segundo é o banco de dados em MySQL através da imagem oficial configurado no docker-compose.yml.

Como bônus também irei criar um terceiro container com o phpMyAdmin utilizando sua imagem oficial que tem a função de gerenciador do banco de dados com uma interface gráfica. Mas ele é completamente desnecessário.

No arquivo Dockerfile simplesmente utilizaremos bash como linguagem, portanto vamos configura-lo da seguinte maneira:

# Utilizaremos Ubuntu como SO
FROM ubuntu:22.04

ARG DEBIAN_FRONTEND=noninteractive

# Update do linux e instalação de dependências 
RUN apt-get update && apt-get install -y
RUN apt-get install software-properties-common -y
RUN add-apt-repository ppa:ondrej/php

# Instalação do Apache, PHP, plugins do PHP e softwares necessários
RUN apt-get install -y build-essential \
    nano \
    unzip \
    curl \
    locales \
    apache2 \
    php8.1 \
    php8.1-common \
    php8.1-mysql \
    php8.1-xml \
    php8.1-xmlrpc \
    php8.1-curl \
    php8.1-gd \
    php8.1-imagick \
    php8.1-cli \
    php8.1-dev \
    php8.1-imap \
    php8.1-mbstring \
    php8.1-opcache \
    php8.1-soap \
    php8.1-zip \
    php8.1-intl \
    php8.1-bcmath \
    php8.1-pgsql \
    php8.1-pspell \
    libapache2-mod-php8.1 \
    && apt-get clean 

RUN locale-gen pt_BR.UTF-8

# Instala o Composer para o PHP
RUN cd /usr/local/lib/ && curl -sS https://getcomposer.org/installer | php && mv composer.phar /usr/local/bin/composer

# Instala o CA Certificates para futura configuração SSL
RUN apt-get install --reinstall ca-certificates -y

# Cria a pasta src, que é a pasta onde ficará sua aplicação
ADD src/ /var/www/html/src

# Seta as permissões da pasta src
RUN chown $USER:www-data -R /var/www/html/src
RUN chmod u=rwX,g=srX,o=rX -R /var/www/html/src
RUN find /var/www/html/src -type d -exec chmod g=rwxs "{}" \;
RUN find /var/www/html/src -type f -exec chmod g=rws "{}" \;

# Ativa Apache mod_rewrite
RUN a2enmod rewrite
RUN a2enmod actions

# Altera AllowOverride de None para All
RUN sed -i '170,174 s/AllowOverride None/AllowOverride All/g' /etc/apache2/apache2.conf

# Inicia o Apache
RUN service apache2 restart

# Expõe as portas necessárias
EXPOSE 80 8080 3306

# Roda o apache fulltime
ENTRYPOINT ["apache2ctl", "-D", "FOREGROUND"]

Agora vamos configurar o arquivo docker-compose.yml para rodar o Dockerfile e adicionar a imagem do banco de dados para rodar um segundo container MySQL e do phpMyAdmin para o rodar o terceiro, vamos lá:

# Em services definiremos nossos containers
services:

  # App é nosso primeiro container que contém o Apache e o PHP confiugrado no Dockerfile
  app:
    container_name: docker-lamp
    build: .
    # Porta exposta para o Apache
    ports:
      - "80:80"
    # Facilitando as configurações os volumes são os alias de pastas e arquvivos do Apache e PHP para pasta do docker-compose   
    volumes:
      - ./src:/var/www/html/src
      - ./config/php.ini:/etc/php/8.1/apache2/php.ini
      - ./config/000-default.conf:/etc/apache2/sites-available/000-default.conf
      - ./config/apache2.conf:/etc/apache2/apache2.conf
      - ./logs/apache2:/var/log/apache2
    # Configuração do uso de recursos da virtualização
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 12G 

  # mysql é nosso segundo container que contém a imagem oficial do Mysql
  mysql:
    # Imagem do MySQL do Docker Hub
    image: mysql:latest
    container_name: mysql
    # Configurações de acesso e db do mysql
    environment:
      MYSQL_ROOT_PASSWORD: 'senha-root'
      MYSQL_DATABASE: banco-de-dados
      MYSQL_USER: user
      MYSQL_PASSWORD: 'user-senha'
    restart: always
    command: --default-authentication-plugin=mysql_native_password
    # Porta exposta para o MySQL
    ports:
      - "3306:3306"
    # Facilitando as configurações os volumes são os alias de pastas e arquvivos do MySQL para pasta do docker-compose   
    volumes:
      - ./config/my.cnf:/etc/mysql/conf.d/my.cnf
      - ./database:/var/lib/mysql
      - ./logs/mysql:/var/log/mysql
    # Configuração do uso de recursos da virtualização
    deploy:
      resources:
        limits:
          cpus: '2'
          memory: 12G

  # phpmyadmin é nosso terceiro container que contém a imagem oficial do phpmyadmin
  phpmyadmin:
    # Imagem do phpMyAdmin do Docker Hub
    image: phpmyadmin:latest
    container_name: phpmyadmin
    # Configurações de link do banco de dados com o phpMyAdmin
    links:
      - mysql
    environment:
      PMA_HOST: mysql
      PMA_PORT: 3306
      PMA_ARBITRARY: 1
      UPLOAD_LIMIT: 300M
    restart: always
    # Porta exposta para o uso phpMyAdmin
    ports:
      - 8080:80

Vendo os códigos podemos observar que de acordo com as nossas configurações no Dockerfile e docker-compose-yml será necessário criar mais algumas pastas dentro da nossa docker-lamp para finalizar nossa configuração, a estrutura da pasta ficará assim:

De qualquer maneira no final desse artigo vou disponibilizar o repositório desse projeto no GitHub com todos os arquivos.

Pronto! Toda a configuração do nosso ambiente em Docker está devidamente aplicada, agora nós devemos apenas dar um build (complilar) na nossa pasta do docker-lamp e após isso dar um up (start) em nossos containers para ver nossa aplicação rodando.

Para isso basta acessar a nossa pasta docker-lamp abrir seu terminal e rodar os seguintes comandos:

docker compose build

Com isso ele irá compilar nossos nosso ambiente em docker-compose, esse processo pode demorar alguns minutos, após isso basta rodar o seguinte comando:

docker compose up -d

Esse comando irá criar os containers e dar start no ambiente colocando nossa aplicação online, a variável -d é para rodar em segundo plano.

Agora basta você colocar sua aplicação na pasta src e acessa-la via web.

Repositório no GitHub: https://github.com/matsesso/docker-lamp

É isso aí! Espero que esse artigo contribua a você.

Formulário para consulta em banco de dados e apresentação dos dados em tabela

Matheus Mendonça Sesso — Fri, 27 Oct 2023 01:14:24 +0000

Neste artigo aprenderemos de maneira prática e eficaz a realizar consultas em um banco de dados através de um formulário e retornar o resultado dessa consulta em forma de tabela em nossa página web.

Minha ideia aqui é utilizar o PHP puro, mas existem frameworks que podem te auxiliar e tornam essa execução bem simples, como por exemplo o Laravel e o Filament, porém dessa forma você precisará de um conhecimento mais avançado na linguagem.

Para executarmos nosso plano, aqui utilizaremos somente o PHP puro como base, a extensão PDO nativa do PHP para conexão com o banco de dados, os frameworks Bootstrap para nos auxiliar no front-end do formulário, DataTables para nos auxiliar com a tabela e JQuery pois é um requisito do DataTables.

Bom primeiramente, é necessário que você possua um banco de dados com uma tabela populada para que possamos realizar a consulta, neste tutorial irei utilizar uma tabela em um banco MySQL, mas o tipo de banco fica ao seu critério.

Minha tabela no banco de dados contém as seguintes colunas:

id | nome | cpf | cargo | telefone | sexo

Disponibilizei o código .sql desse DB de teste no repositório no GitHub que você pode acessar através do link disponibilizado no final desse artigo.

A minha intenção é criar um formulário com os campos de consulta “nome”, “cargo” e “sexo” para apresentar os demais dados na tabela, sendo que você pode preencher um, dois, todos ou nenhum dos campos para realizar a pesquisa.

Primeiramente, vamos criar uma página com nome consulta.php contendo apenas o escopo do HTML:5 e importação dos frameworks para nosso projeto, irei fazer isso através dos CDNs.

Bootstrap:
https://getbootstrap.com/docs/
JQuery:
https://releases.jquery.com/
DataTables:
https://datatables.net/download/

OBS: O DataTables possui várias extensões para você personalizar sua tabela, porém a mais interessante e que iremos utilizar aqui é a extensão Buttons que nos permite fazer o download da tabela em PDF e Excel.

Após adicionar os CDNs, inicialmente nossa página consulta.php irá ficar basicamente dessa maneira:

<!doctype html>
<html lang="pt-br">
  <head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Sistema de Consultas</title>

  <!-- CSS Bootstrap -->
  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">

  <!-- CSS DataTables -->
  <link href="https://cdn.datatables.net/v/bs5/jszip-3.10.1/dt-1.13.6/b-2.4.2/b-colvis-2.4.2/b-html5-2.4.2/b-print-2.4.2/datatables.min.css" rel="stylesheet">
  </head>
  <body>
<main>

</main>
  <!-- JS JQuery -->
  <script src="https://code.jquery.com/jquery-3.7.1.min.js" integrity="sha256-/JqT3SQfawRcv/BIHPThkBvs0OEvtFFmqPF/lYI/Cxo=" crossorigin="anonymous"></script>

  <!-- JS Bootstrap -->
  <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-C6RzsynM9kWDrMNeT87bh95OGNyZPhcTNXj1NW7RuBCsyN/o0jlpcV8Qyq46cDfL" crossorigin="anonymous"></script>

  <!-- JS DataTables -->
  <script src="https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.2.7/pdfmake.min.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.2.7/vfs_fonts.js"></script>
  <script src="https://cdn.datatables.net/v/bs5/jszip-3.10.1/dt-1.13.6/b-2.4.2/b-colvis-2.4.2/b-html5-2.4.2/b-print-2.4.2/datatables.min.js"></script>
</body>
</html>

Agora, nós iremos criar um arquivo chamado database.php para criarmos nossa classe de conexão com o banco de dados, neste arquivo deve conter o seguinte script:

<?php

class Database {
  private $connection;
  private static $_instance;
  private $dbhost = 'db_host';
  private $dbuser = 'db_login';
  private $dbpass = 'db_pass';
  private $dbname = 'db_name';

  /*
      * Pega a instancia do banco de dados
      * @return Instance
  */
  public static function getInstance()
    {
        if (! self::$_instance) {
            self::$_instance = new self();
        }
        return self::$_instance;
    }

    // Construtor
    private function __construct()
    {
        try {
            $this->connection = new PDO('mysql:host=' . $this->dbhost . ';dbname=' . $this->dbname . ';charset=utf8', $this->dbuser, $this->dbpass);
            $this->connection->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

            // Error handling
        } catch (PDOException $e) {
            die("Falha ao conectar ao banco de dados: " . $e->getMessage());
        }
    }

    // Método mágico previne conexão duplicada
    private function __clone()
    {}

    // Realiza a conexão
    public function getConnection()
    {
        return $this->connection;
    }
}

OBS: Modifique as variáveis com as informações do seu banco de dados para que a conexão seja realizada sem problemas.

Após a criação do arquivo de configuração do banco de dados, iremos adicionar esse arquivo em nossa página consulta.php, no início do código, acima de tudo, adicione esse script:

<?php
  require_once 'database.php';
?>

Adicionaremos nosso formulário em nossa página consulta.php, o formulário deve estar dentro da tag main, o código é o seguinte:

<form action="" method="post">
  <div class="row">
    <div class="col-md-12 my-1">
      <label for="nome">Nome:</label>
      <!-- Input para preencher o nome -->
      <input type="text" id="nome" name="nome" class="form-control" placeholder="Digite o nome" value="<?= $_POST["nome"] ?>"></input>
    </div>
    <div class="col-md-6 my-1">
      <label for="sexo">Sexo:</label>
      <select id="sexo" name="sexo" class="form-control">
        <option disabled selected>Selecione</option>
        <?php
          // Array de opções do select, ele irá relembrar a opção selecionada após o submit do form
          $values = array('F' => 'Feminino', 'M' => 'Masculino');
          foreach($values as $val => $value) {
            $selected = (!empty($_POST['sexo']) && $_POST['sexo'] == $val) ? 'selected' : '';
            echo "<option value='$val' $selected>$value</option>";
          }
        ?>
      </select>
    </div>
    <div class="col-md-6 my-1">
      <label for="cargo">Cargo:</label>
      <select id="cargo" name="cargo" class="form-control">
        <option disabled selected>Selecione</option>
        <?php
          // Array de opções do select, ele irá relembrar a opção selecionada após o submit do form
          $values = array('Presidente' => 'Presidente', 'Gerente' => 'Gerente', 'Funcionário' => 'Funcionário');
          foreach($values as $val => $value) {
            $selected = (!empty($_POST['cargo']) && $_POST['cargo'] == $val) ? 'selected' : '';
            echo "<option value='$val' $selected>$value</option>";
          }
        ?>
      </select>
    </div>
    <div class="col-md-12 my-2">
      <button type="submit" name="submit" class="btn btn-primary">Pesquisar</button>
    </div>
  </div>
</form>

Logo após o formulário iremos adicionar um código PHP para que o resultado da tabela seja apresentado somente após o envio do formulário, o código é o seguinte:

<?php if (isset($_POST["submit"])) { ?>

<?php } ?>

Neste momento iremos de fato adicionar as validações e o script que pegará os dados do formulário e realizará a consulta no banco de dados, o código deve ficar logo após a verificação do envio do formulário, ficando assim:

<?php if (isset($_POST["submit"])) { 

// Faz as validações dos inputs e emite as querys
// Essa validação nos permitirá que os campos do form não sejam obrigatórios
if (!empty($_POST["nome"])) {
  $nomeQuery = "nome LIKE '%{$_POST["nome"]}%' COLLATE utf8_general_ci";
} else {
  $nomeQuery = "nome IS NOT NULL";
}

if (!empty($_POST["sexo"])) {
  $sexoQuery = " AND sexo LIKE '%{$_POST["sexo"]}%'";
} else {
  $sexoQuery = " AND sexo IS NOT NULL";
}

if (!empty($_POST["cargo"])) {
  $cargoQuery = " AND cargo LIKE '%{$_POST["cargo"]}%'";
} else {
  $cargoQuery = " AND cargo IS NOT NULL";
}

// Realiza a busca das informações no banco de dados
try {
  $db = Database::getInstance();
  $con = $db->getConnection();
  // Query de busca no banco de dados
  $query = "SELECT * FROM db_teste.tb_teste WHERE " . $nomeQuery . $sexoQuery . $cargoQuery;
  $stmt = $con->prepare($query);
  $stmt->execute();
  $result = $stmt->fetchAll(PDO::FETCH_ASSOC);
} catch (PDOexception $error) {
  // echo $query . "<br>";
  die("Erro ao retornar os dados: " . $error->getMessage());
}

?>

<?php } ?>

O COLLATE utf8_general_ci adicionado na query do nome tem a função de ignorar a edição do caracteres, como por exemplo acentos ou letras maiúsculas ou minúsculas na hora da pesquisa do input.

OBS: É importante ressaltar que o tipo de COLLATE muda de acordo com o tipo de banco de dados, portanto fique atento.

Após isso, iremos fazer o código da nossa tabela que mostrará os resultados, esse código deve estar entre a tag php acima, minha tabela ficou assim:

<div class="row my-4">
  <div class="col table-responsive">
    <!-- O id da table corresponde ao id setado no código do DataTables -->
    <table id="resultado" class="table table-sm table-bordered table-striped table-hover mt-4 mb-4">
      <thead>
        <tr>
          <th scope="col">Nome</th>
          <th scope="col">CPF</th>
          <th scope="col">Cargo</th>
          <th scope="col">Sexo</th>
          <th scope="col">Telefone</th>
        </tr>
      </thead>
      <tbody>
      <?php
        // Irá buscar os resultados do banco de dados através da variável $result
        foreach ($result as $row) {
          echo "<tr>";
          echo "<td>" . $row['nome'] . "</td>";
          echo "<td>" . $row['cpf'] . "</td>";
          echo "<td>" . $row['cargo'] . "</td>";
          echo "<td>" . $row['sexo'] . "</td>";
          echo "<td>" . $row['telefone'] . "</td>";
          echo "</tr>";
        }
      ?>
      </tbody>
    </table>
  </div>  
</div>

Por fim, iremos adicionar o código do DataTables para a modificação da nossa tabela, esse código deve ser adicionado no final da nossa página antes de fechar a tag body, o código é este:

<script>
  $(document).ready(function() {
    $('#resultado').DataTable({
      // Ordenação da tabela pela coluna (0 = primeira coluna)
      order: [[0, 'asc']],
      // Quantidade de resultados a serem apresentados por página
      "iDisplayLength": 25,
      // Organização do layout da tabela
      dom: "<'row'<'col-sm-4'B><'col-sm-4 text-center'l><'col-sm-4'f>>" +
            "<'row'<'col-sm-12'tr>>" +
            "<'row'<'col-sm-6'i><'col-sm-6'p>>",
      buttons: [
        {
          // Botão para download da tabela em Excel
          extend: 'excelHtml5',
          orientation: 'landscape',
          className: 'btn btn-sm btn-success',
          messageTop: 'Resultado dos Dados da Consulta'
        },
        {
          // Botão para download da tabela em PDF
          extend: 'pdfHtml5',
          orientation: 'landscape',
          className: 'btn btn-sm btn-primary',
          messageTop: 'Resultado dos Dados da Consulta'
        }
      ]
    });
  });
</script>

Pronto, finalmente nosso código está finalizado e funcional, o resultado deve ficar assim:

É importante ressaltar que eu fiz esse código de uma maneira bem simplificada, mas você pode aprimorar essa ideia da maneira que for mais conveniente para ti. De qualquer forma estarei disponibilizando esse código completo em um repositório no GitHub que você pode acessar através do link abaixo:

https://github.com/matsesso/consulta-php-datatables

É isso, espero ter ajudado, tentei explicar de uma forma detalhada e deixei os códigos bem comentados para que todos possam entender, recomendo que visitem e estudem as documentações das tecnologias utilizadas neste artigo.

DEV Community: Matheus Mendonça Sesso

A Importância dos Metas Keys no Desenvolvimento de Plugins no WordPress

O que vamos cobrir?

Por que metas são tão importantes?

Anatomia dos Metas: Como Funcionam?

Operações Básicas

Tipos de Metas e Exemplos

Integração com Hooks e API REST

Boas Práticas para Metas em Plugins

Para aprofundar

Desvendando o Sistema de Plugins do WordPress: Um Guia Prático para Desenvolvedores

O que vamos construir?

Por que plugins são tão importantes?

Anatomia de um Plugin WordPress

O coração do WordPress: Hooks

Actions vs Filters: A diferença crucial

Algumas actions essenciais

Alguns filters poderosos

Prioridades e boas práticas

Estruturando seu plugin com classes

Criando páginas de administração

Shortcodes: Trazendo funcionalidade para o front-end

Utilizando a API REST do WordPress

Criando sua própria API REST

Estrutura de arquivos

Algumas boas práticas

1. Sempre valide permissões

2. Sanitize e escape tudo

3. Trate erros adequadamente

4. Use nomes únicos

5. Teste seu plugin

Criando API RESTful simples com PHP e CodeIgniter

O que vamos construir?

O que você precisa saber antes

Como vamos organizar tudo

Planejamento da API

1- Configuração Básica

2 - Configurando as Rotas

3 - Criando o Model

4 - Criando o Controller - O Maestro da API

1. Herança e Traits

2. Método random()

3. Tratamento de Erros

4. Formatação Consistente

5 - Estrutura do JSON

Testando Nossa API

Respostas Esperadas

Links Recomendados

PHP em 2025: Por Que Ele Ainda Reina na Web?

PHP no Mercado: WordPress, Frameworks e Dominância

Críticas ao PHP: Verdade ou Mito?

WordPress: Um monstro do PHP

Frameworks: Soluções Sob Medida

Integrações: PHP Conversa com Tudo

A Comunidade: O Segredo da Longevidade

Olhando pro Futuro: O que Vem por Aí?

Conclusão

Desafio da Mochila (Knapsack Problem) em PHP

Dados e regras do desafio:

A solução: programação dinâmica

O está acontecendo aqui?

Conclusão

Criando planilhas Excel e outros formatos com PHP

Criando uma Nova Planilha

Adicionando Dados à Planilha

Lendo uma Planilha Existente

Estilizando a Planilha

Trabalhando com Várias Folhas

Protegendo a Planilha

Exportando para Diferentes Formatos

Criando um ambiente LAMP utilizando Docker Compose

Formulário para consulta em banco de dados e apresentação dos dados em tabela

2. Método `random()`