Prototipazione rapida: introduzione del caricamento automatico

Last updated Nov 9, 2022

Contenuto

Presentazione del caricamento automatico

Negli ultimi post, ho seguito il processo per portare un’idea dal concetto al prototipo.

Certo, ci sono alcune cose che potresti cambiare (e ci sono alcune cose che cambierei riguardo all’organizzazione delle classi). Ma il punto della serie non è quello di esaminare tutte le varie tecniche orientate agli oggetti che possono essere utilizzate per creare una soluzione.

Invece, si tratta di prendere un prototipo e convertirlo in qualcosa di un po’ più professionale. C’è ancora una cosa che dobbiamo fare, però.

In questo momento, includiamo tutti i nostri file tramite le istruzioni require. E questo funziona bene per file di piccole dimensioni, ma l’introduzione del caricamento automatico insieme agli spazi dei nomi può rendere l’applicazione ancora più pulita.

Ed è quello che faremo.

Presentazione del caricamento automatico

Ricorda da un post precedente (se l’hai letto), che il caricamento automatico è un’idea semplice:

Suona benissimo, vero? Ma c’è un avvertimento: devi scrivere il caricatore automatico. PHP non riesce a capirlo da solo.

Ed è per questo che sono un fan dell’assicurarmi che anche i nostri spazi dei nomi seguano una struttura di directory coerente: se si analizza lo spazio dei nomi e il nome del file, è relativamente facile creare il percorso del file e caricarlo automaticamente.

Suona confuso? Per prima cosa, diamo un’occhiata a dove collocheremo il caricatore automatico per quanto riguarda la nostra struttura di directory:

Quindi, aggiorna il file bootstrap del tuo plug-in in modo che richieda solo il file del caricatore automatico.

<?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();
}

Naturalmente, abbiamo bisogno del caricatore automatico per caricare i nostri file. In sostanza, il modo in cui funziona è questo:

separare i componenti del nome del file in entrata (come il percorso della directory e il nome del file),
sostituire eventuali caratteri di sottolineatura con trattini per assicurarsi che il file segua la struttura del nome file della classe,
inizia a costruire il nome del percorso completo (che è la directory, il nome del file, ecc.),
scorrere lo spazio dei nomi fino al nome della classe e creare un nome completo per il file,
includerlo nel progetto.

È semplice, non è vero? Se segui uno schema di nomi di file, directory, nome di classe e spazio dei nomi coerente, puoi riutilizzare lo stesso caricatore automatico in qualsiasi progetto.

Ecco una copia di un caricatore automatico che uso e lo inserisco in quasi tutti i progetti che uso. Vedrai che segue esattamente quanto descritto sopra:

<?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 con questo, il plugin è passato alla versione 1.0.0. Puoi verificarlo su GitHub (sia letteralmente che solo per la revisione). E si spera che questo abbia aiutato a camminare attraverso il processo di passaggio dalla prototipazione rapida al concetto all’interno del concetto di WordPress.

Messaggi di serie

Fonte di registrazione: tommcfarlin.com