Prototipagem Rápida: Apresentando o Autoloading

Last updated Nov 9, 2022

Contente

Nos últimos posts, passei pelo processo de levar uma ideia do conceito ao protótipo.

Concedido, há algumas coisas que você pode mudar (e há algumas coisas que eu mudaria em relação à organização de aulas). Mas o objetivo da série não é percorrer todas as várias técnicas orientadas a objetos que podem ser usadas para criar uma solução.

Em vez disso, trata-se de pegar um protótipo e convertê-lo em algo um pouco mais profissional. Ainda há uma coisa que precisamos fazer, no entanto.

No momento, incluímos todos os nossos arquivos por meio de instruções require. E isso funciona bem para arquivos pequenos, mas introduzir o carregamento automático em conjunto com namespaces pode tornar o aplicativo ainda mais limpo.

E é isso que vamos fazer.

Apresentando o carregamento automático

Lembre-se de um post anterior (se você o leu), que o carregamento automático é uma ideia simples:

Parece ótimo, certo? Mas há uma ressalva: você precisa escrever o autoloader. PHP não pode descobrir por conta própria.

E é por isso que sou fã de garantir que nossos namespaces também sigam uma estrutura de diretório consistente: se você analisar o namespace e o nome do arquivo, é relativamente fácil construir o caminho para o arquivo e carregá-lo automaticamente.

Parece confuso? Primeiro, vamos dar uma olhada em onde colocaremos o autoloader em relação à nossa estrutura de diretórios:

Em seguida, atualize o arquivo bootstrap do seu plug-in para que ele exija apenas o arquivo autoloader.

<?php
/**
 * Three Recent Posts
 *
 * @package     TRP
 * @author      Tom McFarlin
 * @copyright   2017 Tom McFarlin
 * @license     MIT
 *
 * @wordpress-plugin
 * Plugin Name: Three Recent Posts
 * Plugin URI:  https://tommcfarlin.com/three-recent-posts/
 * Description: Displays the three mot recent posts in your post editor screen.
 * Version:     1.0.0
 * Author:      Tom McFarlin
 * Author URI:  https://tommcfarlin.com
 * Text Domain: three-recent-posts
 * License:     GPL
 * License URI: http://www.gnu.org/licenses/gpl-3.0.txt
 */

namespace McFarlinTRP;
use McFarlinTRPDisplayMeta_Box;

// Import the autoloader.
include_once 'Includes/autoload.php';

add_action( 'add_meta_boxes', __NAMESPACE__. 'trp_start' );
/**
 * Starts the plugin.
 */
function trp_start() {

    $meta_box = new Meta_Box( dirname( __FILE__) );
    $meta_box->init();
}

Claro, precisamos do autoloader para carregar nossos arquivos. Essencialmente, a forma como funciona é esta:

separe os componentes do nome do arquivo de entrada (como o caminho do diretório e o nome do arquivo),
substitua quaisquer sublinhados por hífens para garantir que o arquivo esteja seguindo a estrutura do nome de arquivo da classe,
comece a criar o nome do caminho totalmente qualificado (que é o diretório, o nome do arquivo etc.),
itere pelo namespace até o nome da classe e construa um nome totalmente qualificado para o arquivo,
incluí-lo no projeto.

É direto, não é? Se você seguir um namespace, diretório, nome de classe e esquema de nomenclatura de arquivo consistentes, poderá reutilizar o mesmo carregador automático em qualquer projeto.

Aqui está uma cópia de um autoloader que eu uso e coloco em quase qualquer projeto que eu uso. Você verá que segue exatamente o que foi abordado acima:

<?php
/**
 * Automatically loads the specified file.
 *
 * @package McFarlinTFP
 */

namespace McFarlinTFP;

/**
 * Automatically loads the specified file.
 *
 * Examines the fully qualified class name, separates it into components, then creates
 * a string that represents where the file is loaded on disk.
 *
 * @package McFarlinTFP;
 */
spl_autoload_register(function( $filename) {

    // First, separate the components of the incoming file.
    $file_path = explode( '', $filename );

    // Get the last index of the array. This is the class we're loading.
    if (isset( $file_path[ count( $file_path) - 1 ])) {

        $class_file = strtolower(
            $file_path[ count( $file_path) - 1 ]
        );

        /**
         * The classname has an underscore, so we need to replace it
         * with a hyphen for the file name.
         */
        $class_file = str_ireplace( '_', '-', $class_file );
        $class_file = "class-$class_file.php";
    }

    /**
     * Find the fully qualified path to the class file by iterating through the $file_path array.
     * We ignore the first index since it's always the top-level package. The last index is always
     * the file so we append that at the end.
     */
    $fully_qualified_path = trailingslashit(
        dirname(
            dirname( __FILE__)) );

    /**
     * We start at the second index of the namespace because our directory
     * structure does not include 'McFarlin/TRP'.
     */
    for ($i = 2; $i < count( $file_path) - 1; $i++) {

        $dir = strtolower( $file_path[ $i ] );
        $fully_qualified_path .= trailingslashit( $dir );
    }
    $fully_qualified_path .= $class_file;

    // Now we include the file.
    if (file_exists( $fully_qualified_path)) {
        include_once( $fully_qualified_path );
    }
});

E com isso, o plugin é empacotado para a versão 1.0.0. Você pode conferir no GitHub (literalmente e apenas para revisão). E espero que isso tenha ajudado a percorrer o processo de passar da prototipagem rápida ao conceito dentro do conceito do WordPress.

Postagens da série

Fonte de gravação: tommcfarlin.com