Obtenga un mensaje personalizado para una página de archivo

¿Cómo descubro el slug de tipo de publicación personalizado cuando estoy en una página de archivo?

Por ejemplo, si /products/dispara la archive-products.phpplantilla, ¿cómo (pragmáticamente) obtengo el mensaje tipo slug?

Gracias

Para obtener el tipo de publicación actual, use get_post_type(). Luego solicite get_post_type_object()todos los datos que necesita, por ejemplo, la babosa:

$post_type = get_post_type();
if ( $post_type )
{
    $post_type_data = get_post_type_object( $post_type );
    $post_type_slug = $post_type_data->rewrite['slug'];
    echo $post_type_slug;
}

Estoy usando esto fuera del bucle en la plantilla archive.php para obtener en qué archivo de publicación personalizada estoy.

Es una combinación de los métodos que tanto @toscho como @Rarst recomiendan:

$post_type = get_queried_object();
echo $post_type->rewrite['slug'];

Actualización: @majick señaló que esto solo funciona si ha configurado la babosa de reescritura para su CPT. Reescribir slug es opcional cuando se registra un CPT y el valor predeterminado es post_type si no está configurado.

Las respuestas se vuelven confusas. Y tal vez yo también, pero la pregunta principal es:

Obtener tipo personalizado posterior babosa para una página de archivo

Si se refiere a la página de destino del archivo de tipo de publicación , y cuando is_post_type_archive()regrese true, desea la babosa que responde al archivo de visualización actual :

/* returns /products/ */

$responding_name = str_replace(get_home_url(), '', get_post_type_archive_link(get_query_var('post_type')));

/* continue to get 'products' without slug slashes */
$responding_name = str_replace('/', '', $responding_name);

- FIN DE RESPONDER LA PREGUNTA -

Explicación:

No puede confiar en la babosa registrada . Wordpress tampoco lo es. Por ejemplo, cuando se llama a get_post_type_archive_link()Wordpress, se comprueban las reglas de reescritura actuales para su instalación .

Donde quiera que esté, dentro o fuera del bucle, archivo actual o publicación individual, invierta el get_post_type_archive_link()mecanismo. (Permalinks habilitados).

Consideraciones:

Como se mencionó aquí, los tipos de publicación en la consulta actual pueden ser un array. Puede seguir adelante con sus intensiones con el filtro del tipo de publicación que busca, por ejemplo:

$post_type = get_query_var('post_type'); 
if(is_array($post_type)) $post_type = reset($post_type);

o

if(isset($post_types[0])) $post_type = $post_types[0];

Otro punto de vista:

El ejemplo de Woocommerce está registrado con el objeto de tipo de publicación 'productos' pero en realidad usa el nombre de la regla reescrita (tienda):

/* returns shop */
$responding_name = str_replace('/', '', str_replace(get_home_url(), '', get_post_type_archive_link('product')));

Mark, estoy usando $responding_name, porque los objetivos pueden variar. No existe un archivo de publicación, es solo una url.

Debe tenerse en cuenta que si has_archivese establece en verdadero al registrar el Tipo de publicación personalizada, el archivo de tipo de publicación /cptslug/se reescribirá internamente ?post_type=cptslug. Entonces esto también significaría is_post_type_archive()que volverá a ser cierto.

Desafortunadamente, cuando el slug de reescritura registrado es diferente al tipo de publicación, en realidad no está obteniendo el post_type. p.ej. si su tipo de publicación fue myplugin_carsy su slug de reescritura fue carsy necesita obtenerlo myplugin_cars, incluso esto (para evitar errores si el objeto consultado actual no es un tipo de publicación personalizado) aún fallará:

$queryobject = get_queried_object();
if (has_property('rewrite',$queryobject)) {
    if (isset($queryobject->rewrite['slug'])) {
         $posttype = $queryobject->rewrite['slug'];
     }
 }

Pero como is_post_type_archivees cierto, esto es más confiable:

if (is_post_type_archive()) {
    $posttype = get_query_var('post_type');
    // which is basically the same as:
    // global $wp_query;
    // $posttype = $wp_query->query_vars['post_type'];
} 
else ($posttype = 'post';}

Pero espera, hay más ... resulta que con un poco de prueba tampoco es tan simple ... ¿y si estás en una página de archivo de taxonomía con múltiples tipos de publicaciones en la taxonomía ...? ¿O asignar etiquetas de publicación a un tipo de publicación personalizado que no sea la publicación? ¿O estás en una página de archivo de autor? Fecha de archivo de la página? ... o incluso tener un complejo tax_queryo meta_querypara WP_Query?

La única respuesta confiable (sin probar cada caso de archivo posible) es hacer un bucle de las publicaciones reales en la consulta ... Aquí está la función completa que se me ocurrió para trabajar tanto en páginas singulares como de archivo, y permitiéndole pasar opcionalmente un objeto de consulta personalizado (u objeto de publicación / ID de publicación para publicaciones singulares):

function get_current_post_types($object=null) {

    // if a numeric value passed, assume it is a post ID
    if ( ($object) && (is_numeric($object)) ) {$object = get_post($object);}
    // if an object is passed, assume to be a post object
    if ( ($object) && (is_object($object)) ) {return get_post_type($object);}

    // standard single post type checks
    if (is_404()) {return '';}
    // update: removed this check, handled by is_singular
    // if (is_single()) {return 'post';}
    if (is_page()) {return 'page';}
    if (is_attachment()) {return 'attachment';}
    if (is_singular()) {return get_post_type();}

    // if a custom query object was not passed, use $wp_query global
    if ( (!$object) || (!is_object($object)) ) {
        global $wp_query; $object = $wp_query;
    }
    if (!is_object($object)) {return '';} // should not fail

    // if the post_type query var has been explicitly set
    // (or implicitly set on the cpt via a has_archive redirect)
    // ie. this is true for is_post_type_archive at least
    // $vqueriedposttype = get_query_var('post_type'); // $wp_query only
    if (property_exists($object,'query_vars')) {
        $posttype = $object->query_vars['post_type'];
        if ($posttype) {return $posttype;}
    }

    // handle all other cases by looping posts in query object
    $posttypes = array();
    if (method_exists($object,'found_posts')) {
        if ($object->found_posts > 0) {
            $queriedposts = $object->posts;
            foreach ($queriedposts as $queriedpost) {
                $posttype = $queriedpost->post_type;
                if (!in_array($posttype,$posttypes)) {$posttypes[] = $posttype;}
            }
            if (count($posttypes == 1)) {return $posttypes[0];}
            else {return $posttypes;}
         }
     }
     return ''; // nothin to see here
}

Esto devolverá de forma confiable (¿dije eso?) Una matriz de tipos de publicación si hay más de una presente, o una cadena con el tipo de publicación única si solo hay un tipo. Todo lo que necesitas hacer es:

$posttypes = get_current_post_types();
// or pass a post ID 
$posttypes = get_current_post_types($postid);
// or pass a post object
$posttypes = get_current_post_types($post);
// or pass a custom query - that has been run
$posttypes = get_current_post_types($query);

Ejemplo de uso (solo por diversión):

add_filter('the_posts','myplugin_fading_thumbnails',10,2);
function myplugin_fading_thumbnails($posts,$query) {
    if (!is_archive()) {return $posts;}
    $cptslug = 'myplugin_slug'; $dosomethingcool = false;
    $posttypes = get_current_post_types($query);
    if ( (is_array($posttypes)) && (in_array($cptslug,$posttypes)) ) {$dosomethingcool = true;}
    elseif ($cptslug == $posttypes) {$dosomethingcool = true;}

    if ($dosomethingcool) {
        global $fadingthumbnails; $fadingthumbnails = $cptslug;
        if (!has_action('wp_footer','myplugin_cpt_script')) {
            add_action('wp_footer','myplugin_cpt_script');
        }
    }

    function myplugin_cpt_script() {
        global $fadingthumbnails;
        echo "<script>var thumbnailclass = 'img.thumbtype-".$fadingthumbnails."';
        function fadeoutthumbnails() {jQuery(thumbnailclass).fadeOut(3000,fadeinthumbnails);}
        function fadeinthumbnails() {jQuery(thumbnailclass).fadeIn(3000,fadeoutthumbnails);}
        jQuery(document).ready(function() {fadeoutthumbnails();});
        </script>";
    }

    return $posts;
 }

Para ver el efecto, cambie el tipo de publicación personalizada en el código posty agregue un thumbtype-postatributo de clase a las imágenes en miniatura de su publicación ...

Puedes usar este código:

$queried_object = get_queried_object();
$posttype_slug = $queried_object->query_var;
echo $posttype_slug;

usa $ posttype_slug var lo que necesites

Puedes usar este código y este código funciona para mí,

 $ t_slug = get_query_var ('término');

if( get_post_type( get_the_ID() ) == 'projects' )
{
  //enter code for this post type
}