Cómo hacer 200 a partir de dos líneas de código y por qué necesita hacer esto

Hola a todos

Yo (nosotros, como empresa) terminamos la plataforma del proveedor, la plataforma es un complemento para WordPress. Estoy familiarizado con el frontend, JS, HTML solo en la medida en que, por lo tanto, las soluciones anteriores pueden no estar alfabetizadas, pero la esencia del artículo no es eso .

La conclusión es demostrar claramente por qué a veces, en lugar de dos líneas de código, sería la decisión correcta escribir doscientas.

Desarrolladores principiantes y desarrolladores con experiencia para quienes tal pensamiento parece dudoso, pregunto bajo cat.

Introduccion

Leer el artículo sin leer los comentarios en el código no tiene sentido, porque los comentarios en el código no están duplicados en el texto del artículo y el texto del artículo implica que el lector ha leído los comentarios.

Desafío

Fue necesario realizar cambios en JS, realizo los cambios en archivos separados, de modo que lo menos posible "contamine" el código fuente del proveedor de la plataforma, por lo que en el futuro será más fácil adaptar las actualizaciones de las fuentes de la plataforma.

En consecuencia, el código de la nueva funcionalidad está en los nuevos archivos que deben cargarse en la página.

Tarea: se requiere cargar ciertos archivos al cargar la página.

El primer panqueque es grumoso

+<script src="e-cryptex.js"></script> +<script src="wp-content/themes/tol-child/js/child_realforex.js"></script> 

(las líneas con "+" son líneas nuevas en el código fuente)

La solución se probó para la página principal y funcionó allí, luego resultó que para las páginas con la dirección example.com/about, la solución no funcionó, porque el navegador estaba intentando cargar example.com/about/e-cryptex.js y el navegador recibió un error 404 , porque el archivo realmente estaba en la raíz - example.com/e-cryptex.js.

Segunda opción

Observé cómo los desarrolladores de la plataforma se aferran a la página:

 wp_register_script(FILE-ID,FILE-PATH); wp_enqueue_script(FILE-ID); 

Los archivos se adjuntan utilizando la funcionalidad de WordPress. Bien, hagamos lo mismo:

 // : -<script src="e-cryptex.js"></script> -<script src="wp-content/themes/tol-child/js/child_realforex.js"></script> //  : +<?php +const E_CRYPTEX_JS ='e-cryptex_js'; +wp_register_script(E_CRYPTEX_JS,'/e-cryptex.js',array(),null); +wp_enqueue_script(E_CRYPTEX_JS); +const CHILD_REALFOREX_JS = 'child_realforex_js'; +wp_register_script( + CHILD_REALFOREX_JS, + '/wp-content/themes/tol-child/js/child_realforex.js', + array(E_CRYPTEX_JS), + null); +wp_enqueue_script(CHILD_REALFOREX_JS); +?> 

(las líneas con "+" son líneas nuevas en el código fuente, las líneas con "-" son líneas eliminadas del código fuente).

Comprobado - obras, aprox.

Había dos líneas: se convirtió en 12, todas dentro del mismo archivo.

Refactorización

Miré este código y mi sentido de la belleza se rebeló:

• una persona que no esté familiarizada con WordPress no entenderá nada; debe ir al directorio para comprender el propósito de las funciones wp_register_script () y wp_enqueue_script ()
• obviamente lo mismo se hace dos veces seguidas, los argumentos solo son diferentes: DRY se viola

Ok, refactor.

Primero, hacemos una clase (un archivo), y segundo, conectamos y usamos la clase (cambiamos otro archivo).

Hacer clase

 +class Migesco { + + const SCRIPT = 'script'; + const SOURCE = 'source'; + const DEPENDENCY = 'dependency'; + //   ,      'configuration.js', //     ""   . + static function attachConfigurationJS(){ + $configurationFiles = array( + array(Migesco::SCRIPT => 'configuration.js', + Migesco::SOURCE=>'/configuration.js')); + Migesco::includeScriptFiles($configurationFiles); + } //              + static function includeScriptFiles($scriptFiles){ + foreach ($scriptFiles as $scriptFile){ + $dependency = array_key_exists(self::DEPENDENCY,$scriptFiles) + ? $scriptFile[self::DEPENDENCY] + : array(); + self::includeScript($scriptFile[self::SCRIPT],$scriptFile[self::SOURCE],$dependency); + } + } //    , //    "",     // (     ) + static function includeScript($id,$source,$dependency){ + wp_register_script($id,$source,$dependency,null); + wp_enqueue_script($id); + } +} 

Nos conectamos y usamos

 <?php //: -const E_CRYPTEX_JS ='e-cryptex_js'; -wp_register_script(E_CRYPTEX_JS,'/e-cryptex.js',array(),null); -wp_enqueue_script(E_CRYPTEX_JS); -const CHILD_REALFOREX_JS = 'child_realforex_js'; -wp_register_script( - CHILD_REALFOREX_JS, - '/wp-content/themes/tol-child/js/child_realforex.js', - array(E_CRYPTEX_JS), - null); -wp_enqueue_script(CHILD_REALFOREX_JS); // : //  +require_once(ABSPATH . 'configuration.php'); //  +const ECRYPTEX_JS = 'cryptex'; +const TRADEROOM_SCRIPT_FILES = array( + array(Migesco::SCRIPT => ECRYPTEX_JS, + Migesco::SOURCE=>'/e-cryptex.js'), + array(Migesco::SCRIPT => 'child_realforex', + Migesco::SOURCE=>'/wp-content/themes/tol-child/js/child_realforex.js', + Migesco::DEPENDENCY =>ECRYPTEX_JS) +); +Migesco::includeScriptFiles(TRADEROOM_SCRIPT_FILES); ?> 

Había 12 líneas de códigos fuente en un archivo, había 35, y en dos (más adelante, busque troncos donde más arreglar, para no olvidar nada, no perderse, no perderse).

Y refactorizando de nuevo

Miró el nuevo código:

• algunos métodos estáticos
• algunas constantes ...

se ve torpe! Recuerdo el siguiente consejo: "si el constructor no tiene argumentos, ¿se necesita esa clase?"

Vamos a rehacer, pero una clase normal, con un constructor y métodos normales.

Clase

 // : -class Migesco { - - const SCRIPT = 'script'; - const SOURCE = 'source'; - const DEPENDENCY = 'dependency'; - - static function attachConfigurationJS(){ - $configurationFiles = array( - array(Migesco::SCRIPT => 'configuration.js', - Migesco::SOURCE=>'/configuration.js')); - Migesco::includeScriptFiles($configurationFiles); - } - static function includeScriptFiles($scriptFiles){ - foreach ($scriptFiles as $scriptFile){ - $dependency = array_key_exists(self::DEPENDENCY,$scriptFiles) - ? $scriptFile[self::DEPENDENCY] - : array(); - self::includeScript($scriptFile[self::SCRIPT],$scriptFile[self::SOURCE],$dependency); - } - } - static function includeScript($id,$source,$dependency){ - wp_register_script($id,$source,$dependency,null); - wp_enqueue_script($id); - } -} //: //      : //   //   //    //       +namespace Migesco; + + //      html- +class Configurator +{ //               + static function attachConfigurationJS() + { + $configurationFiles = array( + (new WebResource('configuration.js'))->setSource('/configuration.js')); + self::attachFiles($configurationFiles); + } + //      html- + static function attachFiles($resourceList) + { + (new Registrar($resourceList))->toRegistrate(); + } +} + //      html- +class Registrar +{ //     + public $list = array(); //     private (   ) + /** @var WebResource $resource */ + public $resource = null; + + public function __construct($list) + { + $isArray = is_array($list); + if ($isArray) { + $this->list = $list; + } + } + //      WordPress + function registerScript() + { + wp_register_script( + $this->resource->getName(), + $this->resource->getSource(), + $this->resource->getDependency(), + null); + } + //     + function enqueueScript() + { + wp_enqueue_script($this->resource->getName()); + } + //      + function toRegistrate() + { + $result = false; + foreach ($this->list as $resource) { + /** @var WebResource $resource */ + $isResource = $resource instanceof WebResource; + if ($isResource) { + $this->resource = $resource; + $this->registerScript(); + $this->enqueueScript(); + + $result = true; + } + } + return $result; + } +} + //     +class WebResource +{ //    + public $source = ''; //   + public $name = ''; //   + public $dependency = array(); + + public function __construct($name) + { + $this->setName($name); + } + + /** + * @param string $source + * @return WebResource + */ + public function setSource($source) + { + $this->source = strval($source); + return $this; + } + + /** + * @param string $name + * @return WebResource + */ + public function setName($name) + { + $this->name = strval($name); + return $this; + } + + /** + * @param array $dependency + * @return WebResource + */ + public function setDependency($dependency) + { + $isArray = is_array($dependency); + if ($isArray) { + $this->dependency = $dependency; + } + return $this; + } + + /** + * @return string + */ + public function getSource() + { + return $this->source; + } + + /** + * @return string + */ + public function getName() + { + return $this->name; + } + + /** + * @return array + */ + public function getDependency() + { + return $this->dependency; + } +} 

Uso

  <?php // : -const TRADEROOM_SCRIPT_FILES = array( - array(Migesco::SCRIPT => ECRYPTEX_JS, - Migesco::SOURCE=>'/e-cryptex.js'), - array(Migesco::SCRIPT => 'child_realforex', - Migesco::SOURCE=>'/wp-content/themes/tol-child/js/child_realforex.js', - Migesco::DEPENDENCY =>ECRYPTEX_JS) -); -Migesco::includeScriptFiles(TRADEROOM_SCRIPT_FILES); // : +$traderoomScriptFiles = array( + (new Migesco\WebResource(ECRYPTEX_JS)) + ->setSource('/e-cryptex.js'), + (new Migesco\WebResource('child_realforex')) + ->setSource('/wp-content/themes/tol-child/js/child_realforex.js') + ->setDependency(array(ECRYPTEX_JS)) +); +Migesco\Configurator::attachFiles($traderoomScriptFiles); ?> 

Puede volver a realizar la refactorización (la plataforma se ejecuta en PHP 5.6; me encantaría configurar los tipos en todas partes, pero desafortunadamente no puede, puede hacer que la clase Configurador estático sea más humana, por ejemplo, inicializar desde una lista de archivos: recursos web y el método attachFiles estático), pero lo ideal para un mundo ideal es que vivimos en lo real y hace sus propias correcciones, el tiempo dedicado a la tarea, el trabajo en la tarea se detiene.

Total: había 35 líneas en la fuente en dos archivos, se convirtió en ~ 170, también en dos archivos.

Que conseguimos

1. Ahora no tiene que recurrir a la ayuda de WordPress para comprender el propósito de los parámetros de "funciones".
2. Ahora tenemos un contenedor para conectar archivos y podemos cambiar sin problemas el algoritmo para conectar archivos: no tendremos que editar todas las llamadas a wp_register_script y wp_enqueue_script
3. Ahora podemos cambiar WordPress a cualquier cosa y solo la clase tendrá que reescribir
   Registrador, no es necesario reemplazar todas las llamadas wp_register_script y wp_enqueue_script y seguir la lógica de WordPress.

¿Valió la pena?

Cada uno tiene su propio enfoque para apoyar la base del código y su propia opinión.

Mi respuesta es si.