Contents
Introducción
En este tutorial completo explico distintas formas de prepopular metadatos al crear un post en WordPress usando PHP (y, cuando corresponde, algo de JavaScript para el editor de bloques). Cubre: creación programática de posts con metadatos, filtros para valores por defecto, cómo prellenar metaboxes en el administrador, estrategias específicas para Gutenberg y buenas prácticas de seguridad y guardado.
Cuándo y por qué prepopular metadatos
- Automatización: crear borradores programáticamente con valores por defecto.
- UX: cuando el editor debe partir con ciertos valores (categoría, campos personalizados, flags).
- Integración: datos procedentes de formularios externos, APIs o plantillas.
Métodos principales
- Crear el post con wp_insert_post() y pasar metadatos desde PHP.
- Usar filtros de WordPress para devolver valores por defecto (default_post_metadata, default_title, default_content).
- Prellenar metaboxes en la pantalla de edición leyendo parámetros de la URL (post-new.php?mi_meta=valor) o comprobando estado auto-draft.
- Para Gutenberg: usar scripts en el editor para establecer valores iniciales en la store de editor o registrar meta con default/show_in_rest.
1) Crear un post programáticamente y añadir metadatos
Si quieres insertar un post desde código y asignar metadatos desde el principio, la forma más directa es wp_insert_post() con el parámetro meta_input o usando update_post_meta() justo después.
// Ejemplo: crear un borrador con metadatos usando meta_input
post_id = wp_insert_post( array(
post_title => Título desde PHP,
post_content => Contenido inicial...,
post_status => draft,
post_type => post,
meta_input => array(
mi_meta_clave => valor por defecto,
otro_meta => 123,
),
) )
// Alternativa: crear y luego update_post_meta
if ( ! is_wp_error( post_id ) ) {
update_post_meta( post_id, mi_meta_clave, valor por defecto )
}
Ventaja: el valor ya existe en la base de datos. Ideal para importaciones o APIs que generan contenido.
2) Usar filtros para valores por defecto (perfecto para UI de creación)
WordPress ofrece filtros como default_title, default_content y el filtro específico para metadatos default_post_metadata. Estos permiten mostrar valores iniciales en la pantalla de edición cuando el post aún no tiene metadatos.
// Ejemplo: devolver un valor por defecto para un meta llamado mi_meta_clave
add_filter( default_post_metadata, mi_default_post_meta, 10, 4 )
function mi_default_post_meta( default, object_id, meta_key, single ) {
if ( meta_key === mi_meta_clave ) {
// Solo devolver cuando no exista valor (WP llama este filtro si no hay meta)
return valor por defecto desde filtro
}
return default
}
// Títulos y contenido por defecto
add_filter( default_title, function( title, post ) {
// El post puede ser null en algunas llamadas comprobar
if ( is_null( title ) title === ) {
return Título sugerido
}
return title
}, 10, 2 )
Este método es útil para que el editor vea valores por defecto sin que estos estén guardados en DB hasta que el usuario guarde el post.
3) Prellenar metaboxes en el administrador con parámetros en la URL
Una técnica simple y portátil es abrir la página de creación con query args, por ejemplo: post-new.php?mi_meta=valor, y en la callback del metabox leer _GET si el post está en auto-draft o no tiene meta definido.
// Añadir metabox que muestra valor por defecto según _GET o meta almacenado
add_action( add_meta_boxes, function() {
add_meta_box( mi_metabox, Mi Metabox, mi_metabox_callback, post )
} )
function mi_metabox_callback( post ) {
// Autocarga de nonce para seguridad al guardar
wp_nonce_field( mi_metabox_nonce_action, mi_metabox_nonce )
// Si existe meta en DB, usarla si no, mirar la query string
value = get_post_meta( post->ID, mi_meta_clave, true )
if ( === value ) {
// Verificar si se creó como auto-draft o no existe
if ( isset( _GET[mi_meta] ) ) {
value = sanitize_text_field( wp_unslash( _GET[mi_meta] ) )
} else {
value = valor por defecto local
}
}
echo
echo
}
// Guardado
add_action( save_post, function( post_id ) {
if ( ! isset( _POST[mi_metabox_nonce] ) ) return
if ( ! wp_verify_nonce( _POST[mi_metabox_nonce], mi_metabox_nonce_action ) ) return
if ( defined( DOING_AUTOSAVE ) DOING_AUTOSAVE ) return
if ( ! current_user_can( edit_post, post_id ) ) return
if ( isset( _POST[mi_meta_input] ) ) {
update_post_meta( post_id, mi_meta_clave, sanitize_text_field( _POST[mi_meta_input] ) )
}
} )
Para usarlo: enviar a tus editores a /wp-admin/post-new.php?mi_meta=Holaampotro=1 y el metabox mostrará Hola si el meta aún no existe.
4) Gutenberg (editor de bloques): inicializar meta desde JS o registrar meta con default
Gutenberg administra el estado del post con JavaScript. Para prellenar metadatos en el editor de bloques hay dos enfoques comunes:
- Registrar la meta en PHP con show_in_rest = true y un valor default (si tu WP/REST lo soporta).
- Encolar un script para el editor que, si detecta una acción de nuevo post, establezca meta inicial usando la store de editor: wp.data.dispatch(core/editor).editPost({ meta: { … } })
Ejemplo: registrar meta y establecer default (comprobar compatibilidad de WP con el argumento default):
// Registrar meta para REST y, si tu WP lo soporta, indicar default
register_post_meta( post, mi_meta_clave, array(
show_in_rest => true,
single => true,
type => string,
// default => valor por defecto, // Opcional según versión de WP
) )
Si prefieres el enfoque JS para asegurar compatibilidad, encola un script que corra en el editor:
// Encolar un script para editor (functions.php o plugin)
add_action( enqueue_block_editor_assets, function() {
wp_enqueue_script(
mi-editor-init,
plugin_dir_url( __FILE__ ) . js/mi-editor-init.js,
array( wp-data, wp-edit-post ),
filemtime( plugin_dir_path( __FILE__ ) . js/mi-editor-init.js ),
true
)
} )
// js/mi-editor-init.js
( function( wp ) {
const { select, dispatch } = wp.data
// Ejecutar cuando el editor esté listo
wp.domReady( function() {
// Solo en la pantalla de nuevo post (sin ID o auto-draft)
const isNew = ! select( core/editor ).getCurrentPostId() select( core/editor ).getCurrentPost().status === auto-draft
if ( isNew ) {
dispatch( core/editor ).editPost( { meta: { mi_meta_clave: valor por JS } } )
}
})
} )( window.wp )
Con esto el campo meta aparece con el valor en el editor de bloques y se guardará al publicar o actualizar.
5) Usar get_post_metadata o filtros get_post_metadata para casos avanzados
Si necesitas lógica dinámica (por ejemplo, devolver una cadena que depende de otros campos) puedes interceptar la obtención del meta con filtros como get_post_metadata o default_post_metadata. Ten cuidado de no causar loops infinitos.
add_filter( get_post_metadata, mi_get_post_meta_default, 10, 4 )
function mi_get_post_meta_default( value, object_id, meta_key, single ) {
// Si ya existe meta, dejar que WP lo devuelva
if ( metadata_exists( post, object_id, meta_key ) ) {
return value
}
if ( meta_key === mi_meta_clave ) {
// devolver valor condicional sin escribir a BD
return array( valor calculado )
}
return value
}
Buenas prácticas: seguridad, sanitización y UX
- Sanitiza siempre datos que vengan de _GET/_POST antes de mostrarlos o guardarlos: sanitize_text_field, intval, esc_url_raw, etc.
- Nonce en metaboxes: wp_nonce_field() y comprobar con wp_verify_nonce() en save_post.
- Capacidades: comprobar current_user_can( edit_post, post_id ).
- No sobrescribir datos del usuario: solo prellenar si no existe meta o si es explícitamente requerido.
- Compatibilidad con Gutenberg: registrar meta con show_in_rest si quieres que el editor de bloques lo manipule nativamente.
Ejemplo completo: flujo típico
Resumen en pasos:
- Registrar la meta (opcional, si la usará REST/Gutenberg).
- Agregar metabox o encolar script editor para prellenar valores en la UI.
- Usar filtros default_post_metadata si quieres un valor visible sin guardarlo en DB.
- Guardar con save_post validando nonce y capacidades y sanitizando datos.
Ejemplo mínimo y completo (registro meta, metabox, guardado)
// 1) Registrar meta (opcional pero recomendado)
add_action( init, function() {
register_post_meta( post, mi_meta_clave, array(
show_in_rest => true,
single => true,
type => string,
) )
} )
// 2) Añadir metabox (mostrará valor existente o query param)
add_action( add_meta_boxes, function() {
add_meta_box( mi_metabox, Mi Metabox, mi_metabox_callback, post )
} )
function mi_metabox_callback( post ) {
wp_nonce_field( mi_metabox_nonce_action, mi_metabox_nonce )
value = get_post_meta( post->ID, mi_meta_clave, true )
if ( === value isset( _GET[mi_meta] ) ) {
value = sanitize_text_field( wp_unslash( _GET[mi_meta] ) )
}
echo
}
// 3) Guardado seguro
add_action( save_post, function( post_id ) {
if ( ! isset( _POST[mi_metabox_nonce] ) ) return
if ( ! wp_verify_nonce( _POST[mi_metabox_nonce], mi_metabox_nonce_action ) ) return
if ( defined( DOING_AUTOSAVE ) DOING_AUTOSAVE ) return
if ( ! current_user_can( edit_post, post_id ) ) return
if ( isset( _POST[mi_meta_input] ) ) {
update_post_meta( post_id, mi_meta_clave, sanitize_text_field( _POST[mi_meta_input] ) )
} else {
// opcional: delete_post_meta( post_id, mi_meta_clave )
}
} )
Consideraciones finales
Existen múltiples técnicas y la elección depende del caso de uso:
- Si necesitas que los valores existan inmediatamente en BD (importaciones/APIs): wp_insert_post() meta_input.
- Si quieres ofrecer valores por defecto solo en la UI sin escribir aún en DB: default_post_metadata o default_title/default_content.
- Si trabajas con Gutenberg y quieres máxima compatibilidad: registrar meta con show_in_rest y usar la store de editor para setear valores iniciales vía JS.
Aplicando las técnicas de este artículo podrás controlar cómo aparecen y se guardan los metadatos al crear un post, manteniendo seguridad y buena experiencia para los editores.
|
|
Acepto donaciones de BAT's mediante el navegador Brave 🙂 |