Creación rápida de prototipos: Introducción a la carga automática

Last updated Nov 9, 2022

Contenido

En las últimas publicaciones, he recorrido el proceso de llevar una idea del concepto al prototipo.

Por supuesto, hay algunas cosas que podrías cambiar (y hay algunas cosas que yo cambiaría con respecto a la organización de clases). Pero el objetivo de la serie no es recorrer todas las diversas técnicas orientadas a objetos que se pueden usar para crear una solución.

En cambio, se trata de tomar un prototipo y convertirlo en algo un poco más profesional. Sin embargo, todavía hay una cosa que tenemos que hacer.

En este momento, incluimos todos nuestros archivos a través de declaraciones requeridas. Y esto funciona bien para archivos pequeños, pero la introducción de la carga automática junto con los espacios de nombres puede hacer que la aplicación sea aún más limpia.

Y eso es lo que vamos a hacer.

Introducción a la carga automática

Recuerda de una publicación anterior (si la has leído), que la carga automática es una idea simple:

Suena genial, ¿verdad? Pero hay una advertencia: debe escribir el cargador automático. PHP no puede resolverlo por sí solo.

Y es por eso que me encanta asegurarme de que nuestros espacios de nombres también sigan una estructura de directorio consistente: si analiza el espacio de nombres y el nombre del archivo, es relativamente fácil crear la ruta al archivo y cargarlo automáticamente.

¿Suena confuso? Primero, echemos un vistazo a dónde colocaremos el cargador automático con respecto a nuestra estructura de directorios:

A continuación, actualice el archivo de arranque de su complemento para que solo requiera el archivo de carga automática.

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

Por supuesto, necesitamos el cargador automático para cargar nuestros archivos. Esencialmente, la forma en que funciona es esta:

separar los componentes del nombre del archivo entrante (como la ruta del directorio y el nombre del archivo),
reemplace los guiones bajos con guiones para asegurarse de que el archivo siga la estructura del nombre de archivo de la clase,
comience a construir el nombre de la ruta completa (que es el directorio, el nombre del archivo, etc.),
iterar a través del espacio de nombres hasta el nombre de la clase y crear un nombre completo para el archivo,
incluirlo en el proyecto.

Es sencillo, ¿no? Si sigue un espacio de nombres, un directorio, un nombre de clase y un esquema de nomenclatura de archivos consistentes, puede reutilizar el mismo cargador automático en cualquier proyecto.

Aquí hay una copia de un cargador automático que uso y lo coloco en casi cualquier proyecto que uso. Verás que sigue exactamente lo que se cubre arriba:

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

Y con esto, el complemento está listo para la versión 1.0.0. Puede consultarlo en GitHub (tanto literalmente como solo para revisión). Y con suerte, esto ha ayudado a recorrer el proceso de pasar de la creación rápida de prototipos al concepto dentro del concepto de WordPress.

Publicaciones de la serie

Fuente de grabación: tommcfarlin.com