Archivo
WordPress: Shortcodes API
Los shortcodes son códigos que se utilizan en las entradas/páginas para realizar tareas que sólo se podrían hacer mediante programación y dárselas al usuario como herramienta para construir las entradas/páginas. Para crear nuevos shortcodes se puede hacer desde functions.php o desde un plugin , ya sea mediante código o incluyendo algún archivo. Existen 2 tipos los que no encierran contenido y los que si. Para ambos tipo es común la forma de crearlos:
add_shortcode( $tag , $func ) |
- tag, el nombre del shortcode [tag saludo = “hola”]
- func, función que llama para realizar el tratamiento. Ésta función recibe 3 parámetros:
- atts, los parámetros del propio shortcode (saludo) en forma de array asociativo:
- array (‘saludo’ => ‘hola’)
- las claves del array serán convertidas siempre a lower
- content, el contenido del shortcode si éste encierra contenido.(ver cerrar shortcodes más adelante)
- tag, el nombre del shortcode
Dentro de func se usará la función shortcode_atts,
shortcode_atts( $pairs , $atts ) |
- pairs, array con los valores por defecto de los parámetros que va a recibir
- atts, array parámetros enviados por el shortcode
Esta función combina ambos arrays para obtener uno solo con todos los parámetros y llenos de datos. Se combina con la función php extract:
extract( $array_asociativo ) |
Esta función extrae las claves del array asociativo y las convierte en variables con sus correspondientes valores.
Unos ejemplos de shortcodes:
// [bartag foo=”foo-value”] function bartag_func( $atts ) { extract( shortcode_atts( array( ‘foo’ => ‘something’, ‘bar’ => ‘something else’, ), $atts ) ); return “foo = “.$foo; } add_shortcode( ‘bartag’, ‘bartag_func’ ); //El resultado será foo = foo-value |
Para hacer shortcodes que encierran contenido se deberá definir la función con el parámetro content = ‘’
//[callout align=”center” width=”400″] Texto dentro de la caja [/callout] function st_callout( $atts, $content = null ) { extract(shortcode_atts(array( ‘width’ => ”, ‘align’ => ” ), $atts)); $style; if ($width || $align) { $style .= ‘style=”‘; if ($width) $style .= ‘width:’.$width.’px;’; if ($align == ‘left’ || ‘right’) $style .= ‘float:’.$align.’;’; if ($align == ‘center’) $style .= ‘margin:0px auto;’; $style .= ‘”‘; } return ‘ ‘ . do_shortcode($content) . ‘
‘; |
do_shortcode ($string) acepta cualquier tipo de texto. Si la cadena contiene un shortcode procesará ese código.
WordPress: Admin API
Para insertar un nuevo item en el menú de administrador se utiliza la función, unida al hook admin_menu:
hookname <= add_menu_page( $page_title, $menu_title, $capability, $menu_slug, $function, [$icon_url], [$position] ) |
- page_title, es el título que tendrá la página a la que se accede con este menu
- menu_title, será el título que tenga el menu en sí
- capability, es el permiso necesario para que se vea el menu , normalmente ‘manage_options’. (http://codex.wordpress.org/Roles_and_Capabilities)
- menu_slug, nombre único por el cual es referenciado este item.
- function, es el nombre de la función que renderiza la página de opciones. (Si la función está dentro de un objeto se llamara mediante: array ($obj, $function_name) que represetnará a $obj::function_name)
- icon_url, url donde está el icono para el item.
- position, entero que define la posición dentro del menú
- 2 Dashboard
- 4 Separator
- 5 Posts
- 10 Media
- 15 Links
- 20 Pages
- 25 Comments
- 59 Separator
- 60 Appearance
- 65 Plugins
- 70 Users
- 75 Tools
- 80 Settings
- 99 Separator
La función devuelve un hookname usado internamente para seguir las llamadas a la página a la que apunta el menú, por ejemplo para asignarle un css particular.
Para añadir un submenú a éste menu item, unido al mismo hook que la anterior, se utilizará la función:
1
|
hook_sufix <= add_submenu_page( $parent_slug, $page_title, $menu_title, $capability, $menu_slug, $function ); |
- parent_slug, es una cadena que debe de coincidir con el menu_slug definido en la función anterior. Hay que tener en cuenta que con esta función se pueden crear submenús a menús ya existentes conociendo su parent_slug, aunque también con una función propia de cada menú:
Éstas funciones tienen los mismos parámetros que add_submenu_page, salvo el parent_slug:
hook_suffix <= add_XX_page( $page_title, $menu_title, $capability, $menu_slug, $function ) |
Devuelven un hook_suffix usado internamente para seguir las llamadas a la página a la que apunta el menú, por ejemplo para asignarle un css particular, la ayuda contextual, que se unen a los hook:
admin_head-hook_suffix ó load-hook_suffix, repectivamente.
Otra opción interesante es añadir la ayuda contextual del menú mediante:
add_contextual_help (hook_sufix, $texto) |
WordPress: Settings API
Para entender los plugins se debe estudiar antes la settings API, ésta hace que no tengamos que preocuparnos del tratamiento del formularios enviados e incluso de la renderización de los mismos.
Para que un formulario se actualice automáticamente, sin necesidad de estarnos preocupando por el control de las variables del formulario deberemos registrar el conjunto de variables que representa el formulario para ello usaremos la función:
register_setting( $option_group, $option_name, [$sanitize_callback] ) |
- option_group, es el nombre virtual de una variable o conjunto de variables option_name, es el nombre de la variable en la tabla wp_options (tipo diccionario)
- sanitize_callback, es una función que recibe como argumento el valor de la opción para validarla o tratarla
Esta función relaciona el nombre virtual con la/s variable/s de wp_options. Para no llenar de variables independientes las filas de la tabla wp_options se intenta agrupar las variables en arrays asociativos para guardar los datos. Dicho esto, para una sola variable se podrá guardar como tal o en un array con una sola variable previendo futuras modificaciones.
Con la función anterior le decimos a WordPress que existen las variables, pero ¿cómo hacemos para usarlas?. Simplemente cuando se defina el formulario de configuración del plugin (ver más adelante), justo después de la etiqueta form usaremos la función:
settings_fields( $option_group ) |
- option_group, es el mismo que el definido en la función anterior register_settings.
Esta función hace que las actualizaciones de los datos del formulario se hagan sin preparar el fichero de tratamiento de las variables $_POST. Pero aún existe un problema, y es que cuando el plugin se acaba de instalar, y no está activo aún, no existe ese par en la tabla wp_options. Esto se resuelve con hook especial que ejecuta una función cuando se activa el plugin, que además inicializa los valores por defecto en la base de datos:
register_activation_hook($fichero , $funcion) |
- fichero, es el fichero donde se encuentra $funcion
- función, es la función que se ejecutará y que probablemente contenga la función que cree el registro en la tabla wp_options de la base de datos:
add_option ($nombre, $valor, $no_se_usa, [$autoload])
- nombre, es el nombre del registro de la base de datos al cual se asociarán los datos
- valor, son los datos a guardar, normalmente arrays para no llenar la tabla de variables independientes
- no se usa, es un parámetro que se usa para mantener la compatibilidad y es un espacio en blanco (‘ ‘).
- autoload, indica si se cargará automáticamente cuando se ejecute la función wp_load_alloptions(). Su valor será true o false.
Existe además un hook que se ejecuta cuando se desactiva el plugin, para deshacer los cambios:
register_deactivation_hook($fichero, $funcion)
delete_option( $option )
update_option( $option, $newvalue )
(delete_option y update_options realizan operaciones sobre la tabla wp_options)Hasta aquí la actualización automática de los formularios. Ahora se verá cómo construir los formularios.
Construcción de los formularios
La función que construye la página de las opciones de un plugin ha de mantener esta estructura:Your Plugin Name
” />
” />
” />
Los elementos obligatorios son:
- div.wrap
- form method post, action options.php
- p.submit
- input type submit.button-primary
El formulario se ha construido a mano mediante el input y la función get_option. Observar que el parámetro name del input es el mismo que el de get_option, NO ES CASUALIDAD. Hay que tener en cuenta que si la variable de get_option es un array se deberá obtener primero el valor:<?php
$options = get_option(‘array’);
$option = $options[‘key’];
?>Your Plugin Name
” />
.
.Una vez más el parámetro name tiene un nombre singular que coincide con el dato que solicitamos a get_option. Para la construcción automática de los formularios, se usarán las funciones:
add_settings_section( $id, $title, $callback, $page );
add_settings_field( $id, $title, $callback, $page,$section,[$args] );- id, es un identificador único.
- title, el título de la sección/campo.
- callback, es la función que renderizará la sección/el campo y relacionará los datos con los del register settings
- page, puede ser cualquier texto pero ha de coincidir en ambas funciones y en do_settings_section (ver más adelante). También puede usarse __FILE__ si es el mismo archivo el que contiene las opciones. Si se va a insertar campos en páginas de ajustes se usará: general, reading, writing, discussion, media, privacy o permalink.
- section, en la función add_settings_field debe de coincidir con el id de add_settings_sections.
- args, en la función add_settings_field son para pasarle parámetros a la función $callback para renderizar el campo.
Estas funciones construyen las secciones en las que se dividen las páginas de opciones de los plugins:do_settings_sections( $page )
do_settings_fields( $page, $section )- page, deben de coincidir con las definidas en las funciones add_settings_field y add_settings_sections.
- section, en la función do_settings_fields debe de coincidir con el id de add_settings_sections.
Estas funciones se deberán usar dentro de la etiqueta HTML y renderizan el formulario asociado a la sección o una parte de una sección particular, respectivamente.Un ejemplo de todo junto, en la función del hook admin_init:
Your Plugin Name
” />
“/>
add_action(‘admin_init’, ‘register_personalizar_texto_opciones’ );
function plugin_init() {
register_setting( ‘plugin_options’, ‘plugin_options’ );
add_settings_section(‘formulario’, ‘Formulario’, ‘form_section_fn’, __FILE__);
add_settings_field(‘campo_1’, ‘Campo 1’, ‘campo_1_fn’, __FILE__, ‘formulario’);
}
function form_section_fn(){
echo ‘<h2>Formulario</h2>’;
}
function campo_1_fn(){
$options = get_option(‘plugin_options’);
echo “<input id=’plugin_text_string’ name=’plugin_options[text_string]’ type=’text’ value='{$options[‘text_string’]}’ />”;
}Se observa en la última línea una serie de curiosidades como el uso de comillas dobles para interpretar el php dentro de ellas y otras como el empleo de {} para imprimir el valor del array[‘key’]
WordPress: Storage API
Cuando empezamos a desarrollar un proyecto necesitamos guardar ciertos datos, ya sean parte de las entradas u opciones de configuración. WordPress tiene una forma para cada cosa:
POSTMETAS, son datos que forman parte de las entradas y podemos crearlos y administrarlos desde el administrador (si no puedes cambiar las opciones de visualización) y se almacenan en la tabla wp_postmeta en forma de clave-valor, sólo que una clave puede tener más de un valor, en cuyo caso devolvería un array numérico (unique=false).
Para añadir datos al postmeta usaremos:
add_post_meta($post_id, $meta_key, $meta_value, [$unique]) |
- post_id, es el id del post donde queremos meter los metadatos
- meta_key, es la clave de del valor que queremos insertar
- meta_value, es el valor que asociamos a meta_key
- unique, (false) puede ser true o false e indica si la clave tendrá más de un valor o no. Si el valor es true y se intenta insertar una clave que ya existe devuelve false y no hace nada, si no existe la crea como única.
Para actualizar los metadatos:
update_post_meta($post_id, $meta_key, $meta_value, [$prev_value]) |
- prev_value, el valor anterior de la clave que quieres cambiar. Se usa para diferenciar los valores cuando la clave es la misma.
Para eliminar los metadatos:
delete_post_meta($post_id, $meta_key, [$meta_value]) |
Para rescatar los metadatos, existen varios métodos:
$meta_values = get_post_meta($post_id, $meta_key, [$single]) |
- single, (false) establece si recuperará un valor como string o un array numérico.
$meta_values = get_post_custom_values($key, $post_id)
(Cuando $key contiene más de un valor, devuelve array)OPTIONS, son datos independientes no están ligados a nada. Se almacenan en la tabla wp_options en forma de clave-valor, y una clave puede contener más de un valor, pero esta vez puede ser en forma de array asociativo.
Para añadir datos se usará la función:
add_option ($option_name, $valor, $no_se_usa, [$autoload]) - option_name, es el nombre del registro de la base de datos al cual se asociarán los datos
- valor, son los datos a guardar, normalmente arrays para no llenar la tabla de variables independientes
- no se usa, es un parámetro que se usa para mantener la compatibilidad y es un espacio en blanco (‘ ‘).
- autoload, indica si se cargará automáticamente cuando se ejecute la funciónwp_load_alloptions(). Su valor será true o false.
Para actualizar los datos:update_option( $option_name, $nuevovalor ) Para eliminar los datos:
delete_option( $option_name ) Para obtener los datos:
string <= get_option( $option, [$default_value] ) TABLAS. Por supuesto se puede crear una tabla para uso personal, mediante el uso de $wpdb
global $wpdb;
$sql = “CREATE TABLE $table_name (
id mediumint(9) NOT NULL AUTO_INCREMENT,
time datetime DEFAULT ‘0000-00-00 00:00:00’ NOT NULL,
name tinytext NOT NULL,
text text NOT NULL,
url VARCHAR(55) DEFAULT ” NOT NULL,
UNIQUE KEY id (id)
);”;
require_once(ABSPATH . ‘wp-admin/includes/upgrade.php’);
dbDelta($sql);
WordPress: El Loop
El loop es es componente activo básico de wordpress, el que muestra los post o páginas que se solicitan. Funciona mediante un bucle sobre una consulta predefinida que muestra los post o las páginas. El Loop usa el objeto WP_Query para cumplir su objetivo:
WP_Query ($args), devuelve los posts según la consulta generada mediante $args. (ver en Codex). Los componentes básicos del loop son:
- have_post(), comprueba si hay post que mostrar
- the_post(), actualiza el objeto $post con los valores del post actual y pasa al siguiente registro.
- propiedades $post ( $post->propiedad)
- ID,
- post_author,
- post_date,
- post_date_gmt,
- post_content,
- post_title,
- post_excerpt,
- post_status,
- post_comment_status,
- post_ping_status,
- post_password,
- post_name,
- post_to_ping,
- post_pinged,
- post_modified,
- post_modified_gmt,
- post_content_filtered,
- post_parent,
- post_guid,
- post_menu_order,
- post_type,
- post_mime_type,
- post_comment_count,
- post_filter
Estos son los parámetros que acepta WP_Query para modificar la consulta, organizados por su cometido. Están expuestos como tienen que escribirse p.e:
$query = new WP_Query ($args) |
NOTA: * puede usarse el signo – para excluir las IDs
- AUTOR*
- ‘author = 25[,N1,N2,Nn…]’ {ID}
- ‘author_name = slug_name’
- CATEGORIA*
- ‘cat = 25[,N1,N2,Nn…]’ {ID}
- ‘category_name = cat_slug1[,cat_slugN…]‘
- TAG
- ‘tag_id = tagid1[,tag_idN…]‘
- ‘tag = tag_slug1[,tag_slugN…]’ ó tag_slug1[+tag_slugN…]’
- (+ significa AND)
- TAX
- array (‘taxonomy_name’ => ’taxonomy_value’)
- array (tax_query’ => array (
- array (
- ‘taxonomy’ = > ‘gente’,
- ‘campos’ = > ‘slug’,
- ‘terms’ => ‘bob’
- )
- )
- array (
- );
- POST & PAGE
- ‘p = 25′ {ID}
- ‘name = post_slug’
- ‘page_id = 25′ {ID}
- ‘pagename = page_slug’ ó ‘pagename = parent_slug/page_slug’
- ‘post_parent = page_id’ {ID, Devuelve las páginas hijas}
- ‘post__in => array(id). {Devuelve los post del array}
- ‘post__not => array(id)’ {Excluye los post del array}
- TIPO & STATUS
- ‘post_type=(string / array varios strings)’
- ‘post’
- ‘page’
- ‘revision’
- ‘attachment’ (post_status=inherit)
- ‘any’ (salvo revisions y ‘exclude_from_search’=true)
- Custom Post Types (p.e. ‘movies’)
- ‘post_type=(string / array varios strings)’
- ‘post_status (string / array)’
- ’publish’
- ’pending’
- ’draft’
- ’auto-draft’
- ’future’ – se publicará en el futuro
- ’private’
- ’inherit’
- ’trash’
- ’any’ – salvo exclude_from_search= true.
- PAGINATION
- ‘posts_per_page=nº post por pag’ (-1= todos)
- ‘posts_per_archive_page=nº post en archive’
- ‘nopaging=(bool)’ – no paginacion?false
- ‘paged=pag’ – ir a la pag pag
- (get_query_var(‘page’))
- ORDER
- ‘order=(string)’
- ’ASC’
- ’DESC’
- ‘order=(string)’
- ‘orderby=(string)’ valores separados space
- ’none’ – No order .
- ’ID’ – Order by post id.
- ’author’ – Order by author.
- ’title’ – Order by title.
- ’date’ – Order by date.
- ’modified’ – Order by last modified date.
- ’parent’ – Order by post/page parent id.
- ’rand’ – Random order.
- ’comment_count’ – nº de comentarios
- ’menu_order’ – Order by Page Order.
- ’meta_value’
- ’meta_value_num’
Un ejemplo de utilización:
$query = new WP_Query( array( ‘post_type’ => ‘page’, ‘post__in’ => array( 2, 20 ))); |
Ejemplo básico de loop:
<?php if ( have_posts() ) : while ( have_posts() ) : the_post(); ?> //Código para el loop <?php endwhile; else _e(‘Sorry, no posts matched your criteria.’); endif; ?> |
Modificando la consulta:
$myquery = new WP_Query(‘category_name=cat_1’); while ( $myquery->have_posts() ) : $myquery->the_post();?> <?php echo the_content(); // Los campos personalizados de una entrada, no se muestran en the_content() echo ‘Habitaciones:’.get_post_meta($post->ID, ‘habitaciones’, true). ‘<br/>’; echo ‘Superficie:’.get_post_meta($post->ID, ‘superficie’, true). ‘<br/>’; echo $post->post_author; endwhile; ?> |
Una vez WP_Query hace la consulta y the_post() actualiza el objeto $post se puede extraer los datos del post solicitado fácilmente con las siguientes templates tags:
- the_title(), muestra el título del post actual
- the_content(), muestra el contenido del post actual
- the_author(), muestra el autor del post actual
- the_category(), muestra la categoría del post actual
- the_permalink(), muestra el enlace permanente del post actual
- the_time( l, j de F de Y ver) {Viernes, 27 de Abril de 1978 para mes en número (m)}
- the_tags(), muestra los tags del post actual
- the_meta(), muestra los campos personalizados del post actual
- the excerpt(), muestra el resumen del post actual
Lo mismo pero sin echo:
- get_title(), idem a the_title() pero no escribe el valor, solo devuelve.
- get_content(), idem a the_content() pero no escribe el valor, solo devuelve.
- get_author(), idem a the_author() pero no escribe el valor, solo devuelve.
- get_category(), idem a the_category() pero no escribe el valor, solo devuelve.
- get_permalink(), idem a the_permalink() pero no escribe el valor, solo devuelve.
- get_time(ver), idem a the_time() pero no escribe el valor, solo devuelve.
- get_tags(), idem a get_tags() pero no escribe el valor, solo devuelve.
- get_meta(), idem a get_meta() pero no escribe el valor, solo devuelve.
- get excerpt(), idem a get_excerpt() pero no escribe el valor, solo devuelve.
Además existen otras template tags útiles que nos ayudarán a construir contenido:
- wp_get_attachment_image, devuleve una <img>
- wp_get_attachment_image_src, devuelve array (url, ancho y alto de la imagen)
Existe otra manera de hacer una consulta más libre de lo que permite WP_Query, se trata del objeto global $wpdb
- $wpdb->prefix – Devuelve el prefijo de las tablas de la BBDD
- $wpdb->prepare (‘query’) – Asegura la query | como sprintf (%d=int; %s=string)
- $wpdb->escape(‘string’) – Escapa string
- $wpdb->query(‘query’) – Ejecuta query y devuleve nº filas afectadas. (para comandos como INSERT,UPDATE,DELETE)
- $wpdb->get_results(‘query’,tipo_salida) -Devuelve el resultado de query como tipo_salida
- tipo_salida: ej: $prueba=$wpdb->get_result(‘SELECT * from <tabla> WHERE …’);
- OBJECT: array de objetos de fila
- *OBJECT_K: foreach ($prueba as $p) $p->post_title
- ARRAY_A: array de arrays asociativos (nombre columnas=keys)
- ARRAY_N: array de arrays numérico
- $wpdb->insert($tabla, $data[], $format[] )
- $wpdb->insert_id – Accede al valor del auto incremento.
- $wpdb->update($tabla, $data[], $where, $format[], $where_format[] )
Ejemplo para $wpdb->insert o update:
$wpdb->insert( ‘tabla’, array(‘column1’=>’value1,’column2’=>123), array(‘%s’,’%d’) ); |
Ejemplo de consulta con $wpdb
<?php global $wpdb; $tabla = $wpdb->prefix.’posts’; echo “SELECT guid FROM “.$tabla.” WHERE post_name LIKE ‘%slider%'”; $sliders = $wpdb->get_results(“SELECT guid FROM “.$tabla.” WHERE post_name LIKE ‘%slider%'”); foreach ($sliders as $slide) echo ‘<img src=”‘.$slide->guid.'” />’; ?> |
WordPress: Principios básicos
Funcionamiento básico
Una vez que el usuario hace una petición, wordpress carga su core, desgrana la petición y recaba el contenido deseado mediante una petición a la base de datos para luego renderizar los datos mediante un tema elegido por nosotros.
Permisos
Los permisos que funcionan bien para actualizar y funcionar son propietario www-data y grupo ftpgroup. Todos los permisos han de ser 755 salvo .htaccess y /admin/index.php que serán 644, de todas formas con el plugin WSD security detectará rápidamente los permisos necesarios
Estructura básica
Los temas están basados en un style.css, como mínimo, que es donde se definen todos los datos del tema en forma de comentario; y compuestos de plantillas que a su vez se componen de template tags y bloques de éstas. Lo primero que hace wordpress es cargar el fichero functions.php que contiene todas las funciones que necesita el tema y no se encuentran en el core, luego llamará a una de las plantillas básicas que existen en todos los temas, configuradas en ajustes-lectura:
- index.php, para iniciar con los posts del blog
- page.php, para iniciar con una página
Luego cuando se solicite una página puede renderizarse con una plantilla personalizada. Para hacer una plantilla personalizada crearemos un fichero nuevo dentro del tema por ejemplo miplantilla.php y se pondrá esto al inicio:
/** * Template Name: Nombre de la plantilla */
Los template tags que forman las plantillas provienen de funciones del core o de functions.php, lógicamente sólo se tratarán los del core puesto que los otros son independientes de cada tema. Las partes de las templates básicas son header, sidebar, y footer, además del loop (del que se hablará más adelante).
Header, muestra la cabecera html (<head>), y la cabecera del blog/página
Sidebar, muestra la barra lateral, normalmente compuesta de widgets (ver más adelante), aunque los widgets también pueden existir en otros bloques.
Footer, muestra el footer del blog/página
get_XXX($slug); |
Donde XXX pueder ser:
- header, esta función se utiliza para llamar a header.php
- sidebar, esta función se utiliza para llamar a sidebar.php
- footer esta función se utiliza para llamar a footer.php
Si se usa el parámetro slug llamará al fichero XXX-slug.php
Si se necesita incluir en la plantilla algún otro bloque que no sea alguno de los anteriores, como el loop por ejemplo, se usará:
get_template_part($nombre,[$slug]) |
- nombre, es el nombre del fichero.php que se quiere cargar
- slug, es el modificador del fichero.php (fichero-slug.php) si se deja en blanco wordpress buscará nombre.php, nombre-index.php
El formulario de búsqueda se podrá llamar desde la función:
get_search_form($echo) |
- echo, permite mostrar el formulario o sólo devolverlo como cadena
Otras funciones interesantes son:
__($string,$contexto) //Devuelve la traducción _e($string,$contexto) //Escribe la traduccion (echo) |
Se utilizan para traducir los textos del contexto donde se encuentren (tema, plugin,etc) mediante archivos .po, o .mo que funcionan como un diccionario.
Dentro de los bloques, existen necesidades que surgen como por ejemplo la ubicación de nuevos archivos css, javascript o imágenes estáticas, etc para esto está la función:
bloginfo($show) |
- name = nombre del blog
- description = descripción del blog
- admin_email = admin@example
- url = url raiz del sitio http://example/home [usar home_url(‘/’) ]
- wpurl = url donde se encuentra el wp instalado [usar site_url(‘/’) ]
- stylesheet_directory = http://example/home/wp/wp-content/themes/child-theme
- stylesheet_url = http://example/home/wp/wp-content/themes/child-theme/style.css
- template_directory = http://example/home/wp/wp-content/themes/parent-theme
- template_url = http://example/home/wp/wp-content/themes/parent-theme
- atom_url = http://example/home/feed/atom
- rss2_url = http://example/home/feed
- rss_url = http://example/home/feed/rss
- pingback_url = http://example/home/wp/xmlrpc.php
- rdf_url = http://example/home/feed/rdf
- comments_atom_url = http://example/home/comments/feed/atom
- comments_rss2_url = http://example/home/comments/feed
- charset = UTF-8
- html_type = text/html
- language = en-US
- text_direction = ltr
- version = 3.1
Aunque existen una serie de funciones que nos ayudan mejor a obtener las URLs:
home_url() | raiz del sitio | http://www.example.com |
site_url() | Sitio donde está WP | http://www.example.com/wordpress |
admin_url() | Directorio Admin | http://www.example.com/wp-admin |
includes_url() | Directorio Includes | http://www.example.com/wp-includes |
content_url() | Directorio Content | http://www.example.com/wp-content |
plugins_url() | Directorio Plugins | http://www.example.com/wp-content/plugins |
wp_upload_dir() | Upload directory URL | http://www.example.com/wp-content/uploads |
En el caso de wp_upload_dir() devuelve un array que contiene:
Para cargar nuevos ficheros javascript o css se emplearán las siguientes funciones. Es importante llamar estas funciones antes de wp_head():
Para javascript
En la parte del usuario
wp_enqueue_script ( $handle, [$src], [$deps], [$ver], [$in_footer] ); |
En la parte del Administrador
admin_enqueue_script( $handle,[$src],[$deps], [$ver], [$in_footer] ); |
Para CSS:
Si se quiere usar sólo el handle, se deberá de registrar, auqnue no es obligatorio:
wp_register_style( $handle, [$src], [$deps], [$ver], [$media] ) |
Luego para llamar las hojas de estilo, se usará la siguiente función con el handle. Atención que se puede usar esta función para cargar el estilo, pero no se registrará, debiendo escribir siempre el src del fichero en cuestión:
wp_enqueue_style ( $handle, [$src], [$deps], [$ver], [$media] ); |
- handle, identificador del fichero para ser utilizado por otras funciones. Lista de handles definidos por wordpress
- src, ubicación del fichero físico. Se puede concatenar los strings devueltos por las funciones anteriores para conocer dicha ubicación.
- deps, dependencia de otros ficheros utilizando handles de ficheros ya registrados
- ver, versión del fichero
- in_footer (false), Indica si el script se cargará en la cabecera o en el footer. Para que se ejecute en footer (true) la plantilla ha de ejecutar wp_footer()
- media, especifica el tipo para el que se dirige la hoja de estilo (all, screen, handhelld, print)