Como recupero a lesma da página atual?

Estou tentando recuperar a lesma da página atual do WordPress fora do loop. O título da página retorna com wp_title (), mas como posso obter a lesma?

<li>
  <a href="/slug-of-current-page/">
    <?php wp_title('', true); ?>
  </a>
</li>

Use a variável global $post:

<?php 
    global $post;
    $post_slug = $post->post_name;
?>

Conforme outras respostas, slug é armazenado na post_namepropriedade Embora possa ser acessado diretamente, prefiro a get_post_field()função (subutilizada) para acessar as propriedades da postagem que não possuem API adequada para elas.

Requer postagem fornecida explicitamente e não é padrão para a atual, portanto, na íntegra, para a postagem atual, seria:

$slug = get_post_field( 'post_name', get_post() );

EDIT 5 DE ABRIL DE 2016

Depois de procurar mais confiabilidade, acabei respondendo à seguinte postagem que leva a esta edição: ( Não deixe de conferir )

• $ GLOBALS ['wp_the_query'] vs global $ wp_query

O método mais confiável até a data que eu pude apresentar é o seguinte:

// Get the queried object and sanitize it
$current_page = sanitize_post( $GLOBALS['wp_the_query']->get_queried_object() );
// Get the page slug
$slug = $current_page->post_name;

Dessa forma, você tem 99,9999% de certeza de obter os dados corretos sempre.

RESPOSTA ORIGINAL

Outra alternativa mais segura para esse problema é usar o get_queried_object()que mantém o objeto consultado atual para obter o slug de página mantido pela post_namepropriedade. Isso pode ser usado em qualquer lugar do seu modelo.

$postpode ser usado, mas pode não ser confiável, pois qualquer consulta ou código personalizado pode alterar o valor de $post, portanto, deve ser evitado fora do loop.

Usar get_queried_object()para obter o objeto de página atual é muito mais confiável e tem menor probabilidade de ser modificado, a menos que você esteja usando o mal query_postsque interrompe o objeto de consulta principal, mas isso depende de você.

Você pode usar o acima descrito a seguir

if ( is_page() )
    $slug = get_queried_object()->post_name;

A maneira simples de obter a lesma é com:

<?php echo basename(get_permalink()); ?>

Dado o exemplo de código, parece que você realmente precisa de um link. Nesse caso, você pode usar get_permalink () , que pode ser usado fora do loop. Isso deve fazer o que você precisa com mais confiabilidade do que usar a publicação slug.

Pode ser uma pergunta antiga, mas criei as funções get_the_slug () e the_slug () com base nas suas respostas.

if ( !function_exists("get_the_slug") ) {
    /**
    * Returns the page or post slug.
    *
    * @param int|WP_Post|null $id (Optional) Post ID or post object. Defaults to global $post.
    * @return string
    */
    function get_the_slug( $id = null ){
        $post = get_post($id);
        if( !empty($post) ) return $post->post_name;
        return ''; // No global $post var or matching ID available.
    }
    /**
    * Display the page or post slug
    *
    * Uses get_the_slug() and applies 'the_slug' filter.
    *
    * @param int|WP_Post|null $id (Optional) Post ID or post object. Defaults to global $post.
    */
    function the_slug( $id=null ){
        echo apply_filters( 'the_slug', get_the_slug($id) );
    }
}

Esta é a função a ser usada quando se deseja recuperar a lesma fora do loop.

get_post_field( 'post_name');

Resposta encontrada aqui: Como recuperar a lesma da página atual no WordPress?

Mais adiante, na resposta de Matthew Boynes, se você estiver interessado em obter a lesma dos pais (se houver), também achei esta função útil:

function mytheme_get_slugs() {
    if ( $link = get_permalink() ) {
        $link = str_replace( home_url( '/' ), '', $link );
        if ( ( $len = strlen( $link ) ) > 0 && $link[$len - 1] == '/' ) {
            $link = substr( $link, 0, -1 );
        }
        return explode( '/', $link );
    }
    return false;
}

Por exemplo, para adicionar a lesma à classe do corpo:

function mytheme_body_class( $classes ) {
    if ( $slugs = mytheme_get_slugs() ) {
        $classes = array_merge( $classes, $slugs );
    }
    return $classes;
}
add_filter( 'body_class', 'mytheme_body_class' );

Se você deseja uma resposta mais detalhada, pode usar a seguinte consulta SQL para buscar todas as postagens que são postagens, páginas ou taxonomias personalizadas a qualquer momento, mesmo que nenhum gancho tenha sido acionado até o momento.

SQL bruto:

SELECT `id`, `post_type` AS `type`, `post_author` AS `author`, `post_name` AS 
`slug`, `post_status` AS `status`
FROM wp_posts 
WHERE `post_type` NOT IN ('attachment', 'nav_menu_item', 'revision')
AND `post_status` NOT IN ('draft', 'trash')
ORDER BY `id`;

Isso funciona mesmo na primeira linha do seu arquivo de funções, mesmo antes dos ganchos mu_plugins_loadedou init.

@Nota

Isso pressupõe que você tenha um prefixo de banco de dados padrão wp_posts. Se você precisar dar conta de prefixos variáveis, poderá obter a tabela de postagem correta através do PHP facilmente, fazendo o seguinte:

<?php
global $wpdb;
$table = $wpdb->posts;
$query = "SELECT `id`, `post_type` AS `type`, `post_author` AS `author`, `post_name` AS 
`slug`, `post_status` AS `status`
FROM " . $table . "
WHERE `post_type` NOT IN ('attachment', 'nav_menu_item', 'revision')
AND `post_status` NOT IN ('draft', 'trash')
ORDER BY `id`;"

Em seguida, execute com qualquer um $wpdb, mysqliou uma PDOinstância. Como não há entrada do usuário nesta consulta, é seguro executar sem uma instrução preparada, desde que você não injete nenhuma variável nela.

Sugiro que você armazene isso como um valor estático privado de uma classe, para que possa ser acessado sem ter que disparar a consulta novamente mais de uma vez por página para obter o melhor desempenho, algo como isto:

class Post_Cache
{
    private static $post_cache;

    public function __construct()
    {
        //This way it skips the operation if it's already set.
        $this->initCache();
    }

    public function get($id, $type = null)
    {
        if ( !(is_int( $id ) && array_key_exists( $id, self::$post_cache ) ) )
            return false;
        }
        if ( !is_null( $type ) )
        {
            //returns the specific column value for the id
            return self::$post_cache[$id][$type];
        }
        //returns the whole row
        return self::$post_cache[$id];
    }

    private function initCache()
    {
        if ( is_null(self::$post_cache) )
        {

            $query = "...";
            $result = some_query_method($query); //Do your query logic here.
            self::$post_cache = $result;
        {
    }
}

Uso

$cache = new \Post_Cache();

//Get the page slug
$slug = $cache->get( get_the_ID(), 'slug');

if ($cache->get( get_the_ID() ))
{
    //post exists
} else {
    //nope, 404 'em
}
if ( $cache->get( get_the_ID(), 'status') === 'publish' )
{
    //it's public
} else {
    //either check current_user_can('whatever_permission') or just 404 it,
    //depending whether you want it visible to the current user or not.
}
if ( $cache->get( get_the_ID(), 'type') === 'post' )
{
    //It's a post
}
if ( $cache->get( get_the_ID(), 'type') === 'page' )
{
    //It's a page
}

Você entende a essência. Se precisar de mais detalhes, você pode buscá-los normalmente, comnew \WP_Post( get_the_ID() );

Isso permitirá que você verifique as postagens a qualquer momento, mesmo que o loop do wordpress não atinja um ponto em que sua solicitação seja agradável. Esta é uma versão um pouco mais otimizada da mesma consulta executada pelo próprio núcleo do Wordpress. Esse filtro filtra todo o lixo que você não gostaria que fosse devolvido e fornece apenas uma lista bem organizada com o ID do autor, tipo de postagem, slug e visibilidade relevantes. Se precisar de mais detalhes, você pode buscá-los normalmente new \WP_Post($id);, ou usar qualquer uma das outras funções nativas do Wordpress com qualquer uma das linhas relevantes da tabela, mesmo fora do loop.

Uso uma configuração semelhante em alguns dos meus próprios temas e plugins personalizados e funciona muito bem. Também é seguro e não deixa dados internos flutuando no escopo global, onde podem ser substituídos, como a maioria das coisas no Wordpress.

Sinceramente, não entendo por que nenhuma das respostas simplesmente faz:

global $wp;
$current_slug = $wp->request;

// Given the URL of https://example.com/foo-bar
if ($current_slug === 'foo-bar') {
  // the condition will match.
}

Isso funciona para todas as postagens, páginas, rotas personalizadas.

Chamada de página dinâmica no WordPress.

<?php
    get_template_part('foldername/'.basename(get_permalink()),'name');
    ?>