Prototypage rapide : présentation du chargement automatique

Last updated Nov 9, 2022

Teneur

Au cours des derniers articles, j’ai parcouru le processus consistant à faire passer une idée du concept au prototype.

Certes, il y a certaines choses que vous pourriez changer (et il y a certaines choses que je changerais concernant l’organisation des cours). Mais le but de la série n’est pas de passer en revue toutes les différentes techniques orientées objet qui peuvent être utilisées pour créer une solution.

Au lieu de cela, il s’agit de prendre un prototype et de le convertir en quelque chose d’un peu plus professionnel. Il y a encore une chose que nous devons faire, cependant.

À l’heure actuelle, nous incluons tous nos fichiers par le biais d’instructions require. Et cela fonctionne bien pour les petits fichiers, mais l’introduction du chargement automatique en conjonction avec les espaces de noms peut rendre l’application encore plus propre.

Et c’est ce que nous allons faire.

Présentation du chargement automatique

Rappelez-vous d’un article précédent (si vous l’avez lu), que le chargement automatique est une idée simple :

Ça sonne bien, non ? Mais il y a une mise en garde: vous devez écrire le chargeur automatique. PHP ne peut pas le comprendre tout seul.

Et c’est pourquoi je suis partisan de m’assurer que nos espaces de noms suivent également une structure de répertoires cohérente : si vous analysez l’espace de noms et le nom du fichier, il est relativement facile de créer le chemin d’accès au fichier et de le charger automatiquement.

Cela vous semble déroutant ? Tout d’abord, regardons où nous placerons l’autoloader concernant notre structure de répertoires :

Ensuite, mettez à jour le fichier d’amorçage de votre plug-in afin qu’il ne nécessite que le fichier de chargement automatique.

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

Bien sûr, nous avons besoin du chargeur automatique pour charger nos fichiers. Essentiellement, la façon dont cela fonctionne est la suivante:

séparer les composants du nom du fichier entrant (comme le chemin du répertoire et le nom du fichier),
remplacez tous les traits de soulignement par des traits d’union pour vous assurer que le fichier suit la structure du nom de fichier de la classe,
commencer à construire le nom de chemin complet (qui est le répertoire, le nom du fichier, etc.),
parcourir l’espace de noms jusqu’au nom de la classe et créer un nom complet pour le fichier,
l’inclure dans le projet.

C’est simple, n’est-ce pas? Si vous suivez un espace de noms, un répertoire, un nom de classe et un schéma de dénomination de fichier cohérents, vous pouvez réutiliser le même chargeur automatique dans n’importe quel projet.

Voici une copie d’un chargeur automatique que j’utilise et déposez-le dans presque tous les projets que j’utilise. Vous verrez qu’il suit exactement ce qui est couvert ci-dessus :

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

Et avec cela, le plugin est bouclé jusqu’à la version 1.0.0. Vous pouvez le vérifier sur GitHub (à la fois littéralement et juste pour examen). Et j’espère que cela a aidé à parcourir le processus de passage du prototypage rapide au concept dans le concept de WordPress.

Messages de la série

Source d’enregistrement: tommcfarlin.com