Métodos estáticos como solución para preocupaciones transversales en WordPress

Recientemente escribí sobre programación orientada a objetos (OOP) para el desarrollo de PHP. Una de las cosas que he tratado de enfatizar es que el uso de clases no hace el código OOP y no siempre lo usa mejor. OOP implica el uso de clases para crear objetos reutilizables. Con demasiada frecuencia usamos clases como colecciones de nombres espaciadas por los nombres, perdiendo el punto OOP. Pero eso no significa que todo el código debe ser “verdadero OOP”. Nadie va a su sitio web o no carga su aplicación y dice “Maldita sea, este es un verdadero OOP”. Les importa trabajar y está funcionando. Como desarrollador, estas también son sus preocupaciones, pero agregar pruebas, reutilizables y manejables a esa lista de atributos es importante y, a menudo, nos ayuda a llegar allí.
Equilibrar los buenos principios del diseño de software, que a menudo ayuda a lograr estos objetivos, con la necesidad de hacer algo para trabajar y trabajar bien siempre es una pelea. En este artículo, quiero discutir sobre preocupaciones transversales, con algunos ejemplos prácticos. Estos ejemplos conducirán al habla sobre los métodos estáticos y las propiedades de las clases. Es posible que desee consultar una publicación reciente que escribió primero, que cubrió los métodos y propiedades estáticas en las clases, si este concepto es nuevo para usted, ¿qué es una preocupación transversal? Tendemos a considerar el código orientado al código como una jerarquía vertical. Una clase lo extiende a otra, construyendo sobre ella. Pero, algunas tareas se extienden a varias jerarquías de clase, como cortadas, horizontalmente en esas jerarquías.
Estas “preocupaciones transversales” se aplican a varias partes de una aplicación.El ejemplo clásico a este respecto es la periodización.Este es el tipo de embarazo que se utilizará en muchas clases.No queremos repetirnos cortando y pegando los mismos métodos de grabación en todas las clases, por lo que podríamos sentirnos tentados a hacer una clase abstracta básica para expandir todas las clases, que tienen métodos de registro en ella.Este es un mal uso de la extensión de la clase y se enreda rápidamente.Otro enfoque sería ingresar el registro en una función que no esté en ninguna clase.Esto podría funcionar, pero a las funciones les faltan muchas capacidades de clases: visibilidad, propiedades, etc.El uso de una función para un sistema de inicio de sesión, en lugar de una clase, conducirá a una función grande y probablemente global.
Un mejor enfoque sería usar una clase con todos los métodos estáticos que tratan con el registro. La memorización de caché es otra preocupación transversal común. Por ejemplo, el caché de los objetos de WordPress se usa en toda la aplicación. El caché de objeto se sigue en una variable global $ wp_object_cache y hay muchas funciones que funcionan con esa variable. El uso de un global no es ideal, pero funciona para realizar un seguimiento de los valores almacenados en caché en toda la aplicación. Un ejemplo: rastrear los ganchos eliminados como un ejemplo práctico, imagine que debe eliminar todas las llamadas inversas de un gancho particular. Puede hacer esto con la función remove_all_filters (). Pero, ¿qué pasa si necesitas agregarlos? Tengo que reescribir las mismas llamadas add_action/add_filter (), incluidos los de arados y temas que no escribió no está seco y será muy difícil de mantener. Una mejor manera de almacenar acciones eliminadas y luego volver a colocarlos fácilmente, es usar ese registro almacenado. Esto significa que necesitamos una variable, que me gustaría ser una propiedad de clase, no una global, que actúe como este registro. Veamos dos formas de crear tal clase. Aquí está el primero, que no utiliza métodos estáticos: remover de clase {
/**
* Ganchos retirados del camino
*
* @Var Matrix
*/
protegido $ eliminado = [];
/**
* Retire todas las llamadas inversas de un gancho con la posibilidad de agregar más tarde
*
* @param cadena $ name de gancho gancho
*/
Función pública remove_all ($ gancho) {
Global $ wp_filter;
if (isset ($ wp_filter [$ gook])) {
if (class_exists (‘wp_hook’)) {
$ all = clone $ wp_filter [$ gancho];} de lo contrario {
$ all = $ wp_filter [$ gancho];
}
If (! Vacía ($ all)) {
$ this-> eliminado [$ gancho] = $ all;
remove_all_filters ($ gancho);
}
}
}
/**
* Agregue todas las llamadas retrasadas de un gancho
*
* Debe haber usado $ this-> remove_all () para eliminar
*
* @param cadena $ name de gancho gancho
*/
Función pública re_add ($ gancho) {
if (isset ($ this-> eliminado [$ gancho])) {
$ Hooked = $ this-> eliminado [$ gancho];
If (! Vacía ($ hoced)) {
if (class_exists (‘wp_hook’)) {
$ priorities = $ Hooked-> Callbacks;
} de lo contrario {
$ prioridades = $ Hooked;
}
Foreach ($ prioridades como $ priority => $ llamadas) {
Foreach ($ devoluciones de llamada como $ llamadas) {
ADD_FILTER ($ HONCH, $ Callback [‘function’], $ priority, $ Callback [‘Acept_args’]);
}
}
}
}
}
} En este caso, debemos crear una instancia de este objeto y luego seguirla a lo largo de la aplicación. Esto es vital porque cada instancia de este objeto tendría diferentes ganchos eliminados en su propiedad.
Podría estar bien. Puede proporcionar una instancia de esta clase a cualquier clase que tuviera que eliminar los ganchos, con la opción de volver a colocarlos más tarde. Dicho esto, este enfoque no tiene una gran ventaja, lo que requeriría más tribunales de la misma clase existente a lo largo de la aplicación. De hecho, es menos útil que tener solo una instancia. Antes de llegar a un modelo de variable global o singleton, veamos esta clase reescrita utilizando métodos estáticos y una propiedad estática: <? Php
Removedor de clase {

/**
* Ganchos retirados del camino
*
* @Var Matrix
*/
estático protegido $ Elimined = [];
/**
* Retire todas las llamadas inversas de un gancho con la posibilidad de agregar más tarde*
* @param cadena $ name de gancho gancho
*/
Función pública pública remove_all ($ gancho) {
Global $ wp_filter;
if (isset ($ wp_filter [$ gook])) {
if (class_exists (‘wp_hook’)) {
$ all = clone $ wp_filter [$ gancho];
}de lo contrario{
$ all = $ wp_filter [$ gancho];
}
If (! Vacía ($ all)) {
self :: $ eliminado [$ gancho] = $ all;
remove_all_filters ($ gancho);
}
}
}
/**
* Agregue todas las llamadas retrasadas de un gancho
*
* Debe haber usado $ this-> remove_all () para eliminar
*
* @param cadena $ name de gancho gancho
*/
Función pública pública re_add ($ gancho) {
if (isset (self :: $ eliminado [$ gancho])) {
$ Hooked = self :: $ eliminado [$ gancho];
If (! Vacía ($ hoced)) {
if (class_exists (‘wp_hook’)) {
$ priorities = $ Hooked-> Callbacks;
} de lo contrario {
$ prioridades = $ Hooked;
}
Foreach ($ prioridades como $ priority => $ llamadas) {
Foreach ($ devoluciones de llamada como $ llamadas) {
ADD_FILTER ($ HONCH, $ Callback [‘function’], $ priority, $ Callback [‘Acept_args’]);
}
}
}
}
}
} Lo importante para recordar aquí sobre los métodos y propiedades estáticas es que se puede acceder sin la instancia de la clase. Esto significa que cuando usamos remover :: remove_all () que usa propiedad estática $ eliminada, no debemos preocuparnos por el enjuiciamiento de la corte y cuando volveremos a usar remover :: re_add () más tarde, se verá en la misma propiedad $ eliminado para los ganchos perseguidos.
Ahora, tengo un sistema global esencial para rastrear la eliminación de los ganchos, sin usar una variable global. No tengo que preocuparme por las colisiones con otros complementos o temas, que usan el mismo global llamado de otra manera, o el uso incorrecto de la propiedad $ eliminada, porque el acceso a ella está controlado por mi clase. Resolviendo problemas en este artículo, hemos introducido el concepto de preocupaciones transversales. También hablamos sobre clases con todos los métodos estáticos como una solución a problemas transversales que requieren algo más que una función. Solo recuerde que el propósito no es adherirse a los principios por el bien de los principios, es resolver problemas, sin crear deudas técnicas innecesarias. Espero que esto aumente su capacidad de crear un código PHP orientado en grandes proyectos. Para mí, para hacer frente a estos problemas que deben resolverse en muchos lugares diferentes en un proyecto, fue un desafío. Tratar de mantener mis cursos con respecto al principio de responsabilidad única, evitar al mismo tiempo repetirme, siempre ha sido un desafío. La conciencia del concepto de preocupaciones transversales me ayudó a comprender el problema y ver soluciones nuevas y útiles.