¿Alguna vez ha querido crear sus propias plantillas de página, pero no ha tenido acceso al tema en sí? Yo, como autor de complementos de WordPress, he encontrado que este problema es particularmente molesto al desarrollar mis complementos. ¡Por suerte, la solución es bastante simple! Lo llevaré rápidamente a través de las pocas líneas de código que necesitará para crear dinámicamente Plantillas de página de WordPress de forma directa a través de PHPEl PHP es un lenguaje de scripting de código abierto, del lado del servidor, con programación HTML integrada que se usa para crear páginas web dinámicas. Las ventajas de PHP son su flexibilidad y su alta compatibilidad con otras bases de datos. Al mismo tiempo, PHP es considerado como un lenguaje fácil de aprender. Funciones de PHP Las funciones de PHP se relacionan con los scripts del lado del servidor. más.
La inspiración para este artículo y la genialidad detrás de la solución de código proviene de Tom McFarlin: Estoy usando mi versión editada de su código original, que puede encontrar en su GitHub. He guardado sus comentarios (a la vez de agregar algunos de los míos), ya que lo encuentro muy útil para explicar lo que está sucediendo. ¡Yo mismo no podría haberlo dicho mejor!
Puede encontrar el código en su totalidad y un complemento de ejemplo al final de esta publicación.
¿Deberíamos empezar?
EL CÓDIGO
Crearemos nuestra función PHP usando una clase PHP. Para aquellos de ustedes que no están bien familiarizados con las clases PHP, una clase se define como un objeto que contiene una colección de funciones y variables que trabajan juntas. Revisar la Introducción a PHP.net para obtener más detalles sobre la sintaxis y la teoría.
Nuestro contenedor solo necesitará 3 variables:
- El pluginConcepto de Plugin¿Qué es un Plugin?Un Plugin es un fragmento o componente de código hecho para ampliar las funciones de un programa o de una herramienta. En el ámbito del marketing digital, especialmente dentro del marketing de contenidos, es algo que se utiliza con mucha frecuencia dentro de entornos como WordPress, puesto que sirven al momento de contar con añadidos que hagan mucho más cómoda y completa la experiencia de más Slug: Esto simplemente se usa como un identificador únicoLos identificadores únicos o UID son números y letras que permiten la identificación de objetos dentro de un sistema informático. Indican dónde se encuentra un objeto y cómo se puede llegar a él. Los identificadores únicos permiten el control y la interacción de distintos objetos o conjuntos de datos abstractos dentro de una red informática. Si se va a enviar un paquete de datos de un PC a otro, un más para el complemento.
- Instancia de clase: Como estamos agregando una instancia de esta clase al encabezado de WordPress, será mejor que la almacenemos.
- Matriz de plantillas: Como probablemente pueda adivinar, esta es una matriz que contiene los nombres y títulos de las plantillas.
Aquí están en código:
class PageTemplater {
/**
* A Unique Identifier
*/
protected $plugin_slug;
/**
* A reference to an instance of this class.
*/
private static $instance;
/**
* The array of templates that this plugin tracks.
*/
protected $templates;Obtener instancia de clase
Como dije previamente, agregaremos una instancia de nuestra clase al encabezado de WordPress usando el Añadir filtro() función. Por lo tanto, necesitaremos un método que nos devuelva (o cree) esta instancia.
Para esto, necesitaremos un método simple, que se llamará ‘get_instance’. Compruébalo a continuación;
/**
* Returns an instance of this class.
*/
public static function get_instance() {
if( null == self::$instance ) {
self::$instance = new PageTemplater();
}
return self::$instance;
}Este será el método llamado cuando nuestra clase se agregue al encabezado de WordPress usando ‘add_action ()’.
FiltrosConcepto de Filtros¿Qué son los Filtros?Los Filtros son unos mecanismos que, sea en el campo de la informática o en el de las páginas web, se usan para establecer qué tipo de contenidos se deben visualizar o mostrar por pantalla, o cuáles no deben aparecer. Es algo que se emplea en numerosos lugares con fines muy distintos, pero que siempre tiene como objetivo perfilar la búsqueda para acertar mejor con más de WordPress
Ahora que hemos resuelto el método ‘get_instance’, tenemos que aclarar qué sucede cuando realmente se crea una instancia.
Usaremos el softwareConcepto de Software¿Qué es el Software y cuál es su función?Un Software es la parte lógica, o más bien el soporte lógico, de cualquier sistema de tipo informático. Sea un PC, un teléfono teléfono celular o inclusive una tablet, es todo aquel programa que se ejecuta en él gracias a la coordinación de la parte física, es decir, el hardware, para llevar adelante alguna tarea concretamente o un recopilatorio de más incorporado de WordPress. Añadir filtro() función para agregar una instancia de nuestra clase en puntos clave a lo largo de la línea de tiempo de inicialización de WordPress. Con este método, insertaremos los datos de nuestras plantillas de página en espacios relevantes, como decirle a WordPress qué archivo usar como plantilla cuando se llama a la página y el título para mostrar en el menú desplegable del Editor de página.
Para esto, necesitamos usar el ‘__construir’ método (esto se ejecutará cuando la clase sea instanciada).
/**
* Initializes the plugin by setting filters and administration functions.
*/
private function __construct() {
$this->templates = array();
// Add a filter to the attributes metabox to inject template into the cache.
if ( version_compare( floatval( get_bloginfo( 'version' ) ), '4.7', '<' ) ) {
// 4.6 and older
add_filter(
'page_attributes_dropdown_pages_args',
array( $this, 'register_project_templates' )
);
} else {
// Add a filter to the wp 4.7 version attributes metabox
add_filter(
'theme_page_templates', array( $this, 'add_new_template' )
);
}
// Add a filter to the save postConcepto de Post¿Qué es un Post?Un Post es todo aquel contenido, sea post, opinión, noticia u otro género, que un autor publica en un blog. Este puede ser de carácter corporativo o meramente ocioso; pero siempre tiene como meta arrojar información o reflejar una idea, al mismo tiempo de facilitar que los usuarios encuentren la web donde se recoge por medio de de buscadores y demás plataformas online.Generalmente, se han más to inject out template into the page cache
add_filter(
'wp_insert_post_data',
array( $this, 'register_project_templates' )
);
// Add a filter to the template include to determine if the page has our
// template assigned and return it's path
add_filter(
'template_include',
array( $this, 'view_project_template')
);
// Add your templates to this array.
$this->templates = array(
'goodtobebad-template.php' => 'It's Good to Be Bad',
);
}Aquí están sucediendo 4 cosas diferentes (ignorando ‘$ this-> templates = array ();’, que solo está preparando la variable para su uso);
- Líneas 9 – 13: Este filtro agrega ‘register_project_templates’ al gancho ‘page_attributes_dropdown_pages_args’. Esto está llenando el cachéUn caché es un tipo de memoria auxiliar de la que se puede recuperar a alta velocidad con una capacidad de almacenamiento relativamente pequeña. Se encuentra entre la unidad central de procesamiento (CPU) y la memoria principal. Ayuda a evitar el acceso al disco duro o los recálculos complejos almacenando temporalmente ciertos datos y haciéndolos disponibles rápidamente cuando sea necesario. El caché almacena una copia de la petición actual y más de WordPress con nuestras nuevas plantillas, ‘engañando’ a WordPress haciéndole creer que los archivos de plantilla de página existen realmente en el directorio de plantillas. Esto agrega las plantillas de página a la lista desplegable en el meta cuadro de atributos de página en el editor de páginas.
- Líneas 16 – 20: Aquí estamos haciendo esencialmente lo mismo que el bloque de código anterior, excepto que esta vez estamos agregando nuestra plantilla de página (si está seleccionada) a los datos de publicación guardados al mismo tiempo.
- Líneas 23-28: Este filtro agrega el ‘template_include’ al gancho ‘view_project_template’. Ésta es una función muy importante; esto le dice a WordPress dónde está realmente su archivo de plantilla de página. WordPress utilizará la ruta proporcionada por este para representar la página final.
- Líneas 31 – 34: Aunque esto es simple, es muy importante. Aquí es donde especifica las plantillas de página que desea agregar y el ruta relativa al archivo donde se encuentra el archivo de plantilla de página (a modo de ejemplo, ‘algo.php’). He incluido un ejemplo (que se utilizará en el complemento de ejemplo). Vea a continuación un ejemplo general:
$this->templates = array(
'FILE_PATH_AND_NAME' => 'TEMPLATE_TITLE',
'awesome-template.php' => 'Awesome',
'templates/organised-template.php' => 'Organised',
);(Comer, dormir) Codificar, repetir según sea necesario.
register_project_templates ()
He aludido a este método previamente; veamos qué hace realmente.
Básicamente, el propósito de este método es manipular el caché de WordPress, insertando los datos relevantes sobre nuestras plantillas de página en los lugares correctos. Primero eche un vistazo al código y después lo explicaré.
public function register_project_templates( $atts ) {
// Create the key used for the themes cache
$cache_key = 'page_templates-' . md5( get_theme_root() . '/' . get_stylesheet() );
// Retrieve the cache list.
// If it doesn't exist, or it's empty prepare an array
$templates = wp_get_theme()->get_page_templates();
if ( empty( $templates ) ) {
$templates = array();
}
// New cache, therefore remove the old one
wp_cache_delete( $cache_key , 'themes');
// Now add our template to the list of templates by merging our templates
// with the existing templates array from the cache.
$templates = array_merge( $templates, $this->templates );
// Add the modified cache to allow WordPress to pick it up for listing
// available templates
wp_cache_add( $cache_key, $templates, 'themes', 1800 );
return $atts;
}En ese mismo momento. La línea 4 es el primer lugar para buscar. Como habrás adivinado, estamos generando una ‘clave de caché’. Esto se utilizará como un identificador único para nuestro datos de plantilla de página. El uso de la función md5 () simplemente crea un identificador de cadena único para evitar enfrentamientos.
A continuación, en la línea 8, estamos buscando y recuperando la caché de la plantilla de página (si ya existe): esto devolverá una matriz de rutas y títulos. En las líneas 9-11, verificamos si hubo algún resultado de la consulta de caché. Si es así, genial. Si no es así, cree una matriz local para contener los datos que fusionaremos en la caché.
El siguiente paso es crucial. En la línea 14 nosotros Borrar la caché de plantilla de página existente. No se preocupe, no se pierden datos, se almacenan en la variable $ templates.
En la línea 18 fusionamos el caché de plantillas de página existente con nuestras nuevas entradas, y en la línea 22 volvemos a insertar todo el caché de plantillas de página en el sistema de WordPress.
¡Sencillo!
view_project_template ()
Ahora estamos en nuestro método final; aquí es donde le decimos a WordPress dónde está el archivo de plantilla de página real.
/**
* Checks if the template is assigned to the page
*/
public function view_project_template( $template ) {
// Get global post
global $post;
// Return template if post is empty
if ( ! $post ) {
return $template;
}
// Return default template if we don't have a custom one defined
if ( !isset( $this->templates[get_post_meta(
$post->ID, '_wp_page_template', true
)] ) ) {
return $template;
}
$file = plugin_dir_path(__FILE__). get_post_meta(
$post->ID, '_wp_page_template', true
);
// Just to be safe, we check if the file exist first
if ( file_exists( $file ) ) {
return $file;
} else {
echo $file;
}
// Return template
return $template;
}Bien, entonces, este método se comparará con la variable $ post global (línea 6). Comprueba si se ha configurado una plantilla de página (‘_wp_page_template’) para la publicación (lo que significa que debe ser una página). Si no es así, no importa: las no páginas no pueden tener plantillas de página.
La línea 16 especifica la ubicación del archivo de plantilla de página. Como he establecido previamente, verifica el archivo de plantilla de página especificado en el directorio raízUn directorio raíz (en inglés root directory), es el directorio del nivel más alto de una jerarquía. Además se conoce como documento raíz. Desde esta raíz todos los demás directorios se ramifican. En el caso de las webs, los archivos más necesarios, como las páginas HTML, se encuentran en el directorio raíz del servidor desde el que se solicitará su visualización mediante del navegador. Los directorios raíz además se usan más de su complemento. (A pesar de todo, esto se puede cambiar fácilmente; consulte a continuación).
// Just changing the page template path
// WordPress will now look for page templates in the subfolder 'templates',
// instead of the root
$file = plugin_dir_path(__FILE__). 'templates/' .get_post_meta(
$post->ID, '_wp_page_template', true
);Posteriormente de esto, en las líneas 21-24, solo tenemos un poco de validación que verifica si el archivo realmente existe. Si es así, ¡genial! Si no es así, vaya… Lo más probable es que reciba un mensaje de error de PHP si WordPress no puede encontrar el archivo de plantilla, o incluso una pantalla en blanco. Si alguno de estos síntomas le suena familiar, simplemente verifique la ruta del archivo de la plantilla imprimiendo la variable $ file en la pantalla.
Si planea usar este código comercialmente (lo cual es libre de hacer, mi versión del código viene sin licencia, de este modo, puede hacer con él lo que quiera), realmente recomiendo invertir algo de tiempo en el manejo de errores para obtener el máximo fiabilidad.
Eso es eso. Con nuestra clase completada, solo queda una cosa por hacer: agregarla al encabezado de WordPress.
add_action( 'plugins_loaded', array( 'PageTemplater', 'get_instance' ) );¡Felicidades si lo lograste! Espero que haya encontrado útil lo que tengo que decir y se beneficie de ello en el futuro.
CÓDIGO COMPLETO
A continuación se muestra el código completo del complemento para copiar y pegar fácilmente.
<?php
/*
Plugin Name: Page Template Plugin : 'Good To Be Bad'
Plugin URI: httpEl HTTP (Hyper Text Transfer Protocol) es un protocolo que se usa para transmitir datos en redes. HTTP es un estándar técnico generalmente aceptado que establece cómo un cliente web se comunica con un servidor para que los datos solicitados por el cliente puedan ser cargados y mostrados. Información general Junto con el URL y el HTML, HTTP es uno de los conceptos más importantes de Internet (www). Fue desarrollado más://www.wpexplorer.com/wordpress-page-templates-plugin/
Version: 1.1.0
Author: R Marketing Digital
Author URI: http://www.wpexplorer.com/
*/
class PageTemplater {
/**
* A reference to an instance of this class.
*/
private static $instance;
/**
* The array of templates that this plugin tracks.
*/
protected $templates;
/**
* Returns an instance of this class.
*/
public static function get_instance() {
if ( null == self::$instance ) {
self::$instance = new PageTemplater();
}
return self::$instance;
}
/**
* Initializes the plugin by setting filters and administration functions.
*/
private function __construct() {
$this->templates = array();
// Add a filter to the attributes metabox to inject template into the cache.
if ( version_compare( floatval( get_bloginfo( 'version' ) ), '4.7', '<' ) ) {
// 4.6 and older
add_filter(
'page_attributes_dropdown_pages_args',
array( $this, 'register_project_templates' )
);
} else {
// Add a filter to the wp 4.7 version attributes metabox
add_filter(
'theme_page_templates', array( $this, 'add_new_template' )
);
}
// Add a filter to the save post to inject out template into the page cache
add_filter(
'wp_insert_post_data',
array( $this, 'register_project_templates' )
);
// Add a filter to the template include to determine if the page has our
// template assigned and return it's path
add_filter(
'template_include',
array( $this, 'view_project_template')
);
// Add your templates to this array.
$this->templates = array(
'goodtobebad-template.php' => 'It's Good to Be Bad',
);
}
/**
* Adds our template to the page dropdown for v4.7+
*
*/
public function add_new_template( $posts_templates ) {
$posts_templates = array_merge( $posts_templates, $this->templates );
return $posts_templates;
}
/**
* Adds our template to the pages cache in order to trick WordPress
* into thinking the template file exists where it doens't really exist.
*/
public function register_project_templates( $atts ) {
// Create the key used for the themes cache
$cache_key = 'page_templates-' . md5( get_theme_root() . '/' . get_stylesheet() );
// Retrieve the cache list.
// If it doesn't exist, or it's empty prepare an array
$templates = wp_get_theme()->get_page_templates();
if ( empty( $templates ) ) {
$templates = array();
}
// New cache, therefore remove the old one
wp_cache_delete( $cache_key , 'themes');
// Now add our template to the list of templates by merging our templates
// with the existing templates array from the cache.
$templates = array_merge( $templates, $this->templates );
// Add the modified cache to allow WordPress to pick it up for listing
// available templates
wp_cache_add( $cache_key, $templates, 'themes', 1800 );
return $atts;
}
/**
* Checks if the template is assigned to the page
*/
public function view_project_template( $template ) {
// Get global post
global $post;
// Return template if post is empty
if ( ! $post ) {
return $template;
}
// Return default template if we don't have a custom one defined
if ( ! isset( $this->templates[get_post_meta(
$post->ID, '_wp_page_template', true
)] ) ) {
return $template;
}
$file = plugin_dir_path( __FILE__ ). get_post_meta(
$post->ID, '_wp_page_template', true
);
// Just to be safe, we check if the file exist first
if ( file_exists( $file ) ) {
return $file;
} else {
echo $file;
}
// Return template
return $template;
}
}
add_action( 'plugins_loaded', array( 'PageTemplater', 'get_instance' ) );EL PLUGIN
Al mismo tiempo puede descargar el código completo como complemento en Github.
PRIMER PLANO DEL EDITOR
Aquí hay un primer plano del complemento en acción. ¿Ve la plantilla de página agregada en Atributos de página?
