Come posso recuperare lo slug della pagina corrente?

Come indicato in altre risposte, lo slug è memorizzato nella proprietà post_name. Anche se potrebbe essere accessibile direttamente, preferisco utilizzare la funzione (poco utilizzata) get_post_field() per accedere alle proprietà dei post che non hanno una propria API dedicata.

Richiede che il post sia fornito esplicitamente e non utilizza quello corrente come predefinito, quindi per il post corrente il codice completo sarebbe:

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

EDIT 5 APRILE 2016

Dopo aver cercato una soluzione più affidabile, sono arrivato a questa risposta al seguente post che porta a questa modifica: (Assicurati di controllarlo)

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

Il metodo più affidabile fino ad oggi che sono riuscito a trovare è il seguente:

// Ottieni l'oggetto interrogato e sanitizzalo
$current_page = sanitize_post( $GLOBALS['wp_the_query']->get_queried_object() );
// Ottieni lo slug della pagina
$slug = $current_page->post_name;

In questo modo, sei sicuro al 99.9999% di ottenere i dati corretti ogni volta.

RISPOSTA ORIGINALE

Un'altra alternativa più sicura a questo problema è l'utilizzo di get_queried_object() che contiene l'oggetto attualmente interrogato per ottenere lo slug della pagina che è contenuto nella proprietà post_name. Questo può essere utilizzato ovunque nel tuo template.

$post può essere utilizzato, ma può essere inaffidabile poiché qualsiasi query personalizzata o codice personalizzato può modificare il valore di $post, quindi dovrebbe essere evitato al di fuori del loop.

L'utilizzo di get_queried_object() per ottenere l'oggetto della pagina corrente è molto più affidabile ed è meno probabile che venga modificato, a meno che non si stia utilizzando il malvagio query_posts che interrompe l'oggetto della query principale, ma questo dipende tutto da te.

Puoi utilizzare quanto sopra come segue

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

Il modo semplice per ottenere lo slug è con:

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

Dato l'esempio di codice, sembra che ciò di cui hai realmente bisogno sia un link. In questo caso, puoi utilizzare get_permalink(), che può essere utilizzato anche al di fuori del loop. Questo dovrebbe fare ciò di cui hai bisogno in modo più affidabile rispetto all'utilizzo dello slug del post.

Potrebbe essere una domanda vecchia, ma ho creato le funzioni get_the_slug() e the_slug() basate sulle vostre risposte.

if ( !function_exists("get_the_slug") ) {
    /**
    * Restituisce lo slug della pagina o dell'articolo.
    *
    * @param int|WP_Post|null $id (Opzionale) ID del post o oggetto post. Predefinito alla variabile globale $post.
    * @return string
    */
    function get_the_slug( $id = null ){
        $post = get_post($id);
        if( !empty($post) ) return $post->post_name;
        return ''; // Nessuna variabile globale $post o ID corrispondente disponibile.
    }
    /**
    * Visualizza lo slug della pagina o dell'articolo
    *
    * Utilizza get_the_slug() e applica il filtro 'the_slug'.
    *
    * @param int|WP_Post|null $id (Opzionale) ID del post o oggetto post. Predefinito alla variabile globale $post.
    */
    function the_slug( $id=null ){
        echo apply_filters( 'the_slug', get_the_slug($id) );
    }
}

Puoi semplicemente dividere lo slug dalla richiesta utilizzando explode.

global $wp;
// Poiché gli slug non possono contenere slash,
// dividiamo la stringa sugli slash e prendiamo solo l'ultima parte.
$request_args = explode('/', $wp->request);
$current_slug = end($request_args);

// Data l'URL https://example.com/foo/bar/foo-bar
if ($current_slug === 'foo-bar') {
  // la condizione corrisponderà.
}

Questo funziona per tutti i post, le pagine e le route personalizzate.

Questa è la funzione da utilizzare quando si desidera recuperare lo slug al di fuori del loop.

get_post_field( 'post_name');

Risposta trovata qui: Come recuperare lo Slug della pagina corrente in WordPress?

Se desideri una risposta più approfondita, puoi utilizzare la seguente query SQL per recuperare tutti i post che sono post, pagine o tassonomie personalizzate in qualsiasi momento, anche se nessun hook è stato ancora eseguito.

SQL puro:

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`;

Questo funziona anche alla prima riga del tuo file functions, anche prima degli hook mu_plugins_loaded o init.

@nota

Questo presuppone che tu abbia un prefisso database standard wp_posts. Se devi gestire prefissi variabili, puoi ottenere facilmente la tabella dei post corretta attraverso PHP facendo quanto segue:

<?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`;"

Poi esegui con $wpdb, mysqli, o un'istanza PDO. Poiché non c'è input utente in questa query, è sicuro eseguirla senza una prepared statement finché non inserisci variabili al suo interno.

Suggerirei di memorizzare questo come valore statico privato di una classe, in modo che possa essere accessibile senza dover eseguire nuovamente la query più di una volta per pagina per ottenere le migliori prestazioni, qualcosa del genere:

class Post_Cache
{
    private static $post_cache;

    public function __construct()
    {
        //In questo modo salta l'operazione se è già impostata
        $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 ) )
        {
            //restituisce il valore della colonna specifica per l'id
            return self::$post_cache[$id][$type];
        }
        //restituisce l'intera riga
        return self::$post_cache[$id];
    }

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

            $query = "...";
            $result = some_query_method($query); //Inserisci qui la tua logica di query
            self::$post_cache = $result;
        {
    }
}

Utilizzo

$cache = new \Post_Cache();

//Ottieni lo slug della pagina
$slug = $cache->get( get_the_ID(), 'slug');

if ($cache->get( get_the_ID() ))
{
    //il post esiste
} else {
    //no, errore 404
}
if ( $cache->get( get_the_ID(), 'status') === 'publish' )
{
    //è pubblico
} else {
    //verifica current_user_can('whatever_permission') o restituisci 404,
    //a seconda se vuoi che sia visibile all'utente corrente o no
}
if ( $cache->get( get_the_ID(), 'type') === 'post' )
{
    //È un post
}
if ( $cache->get( get_the_ID(), 'type') === 'page' )
{
    //È una pagina
}

Hai capito l'idea. Se hai bisogno di ulteriori dettagli, puoi recuperarli normalmente con new \WP_Post( get_the_ID() );

Questo ti permetterà di controllare i post in qualsiasi momento, anche se il loop di WordPress non ha ancora raggiunto un punto in cui trova la tua richiesta accettabile. Questa è una versione leggermente più ottimizzata della stessa query eseguita dal core di WordPress. Questa filtra tutto il contenuto inutile che non vorresti fosse restituito e ti fornisce un elenco ben organizzato con l'ID dell'autore, il tipo di post, lo slug e la visibilità. Se hai bisogno di ulteriori dettagli, puoi recuperarli normalmente con new \WP_Post($id);, o utilizzare qualsiasi altra funzione nativa di WordPress con qualsiasi riga della tabella pertinente, anche al di fuori del loop.

Utilizzo una configurazione simile in alcuni dei miei temi e plugin personalizzati e funziona molto bene. È anche sicuro e non lascia dati interni fluttuanti nello scope globale dove possono essere sovrascritti come fa la maggior parte delle cose in WordPress.

Se ti trovi all'interno del loop allora le altre risposte ti saranno d'aiuto. In caso contrario (per esempio se stai agganciando su init o plugins_loaded) puoi ricorrere a una funzione PHP nativa come parse_url().

Ecco una funzione che funziona in entrambi i casi:

function get_the_slug() {
    global $post;
    $slug = $post->post_name ?? '';

    if ( ! $slug ) {
        $slug = basename( parse_url( $_SERVER['REQUEST_URI'] ?? '', PHP_URL_PATH ) );
    }

    return $slug;
}

Nota bene che questo approccio funziona solo su articoli/pagine al primo livello, a causa di come funziona basename().

A integrazione della risposta di @Matthew Boynes, se sei interessato a ottenere anche lo slug del genitore (se presente), ho trovato utile questa funzione:

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;
}

Ad esempio, per aggiungere gli slug alla classe del body:

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

Richiamo di pagine dinamiche in WordPress.

<?php
    // Ottiene una parte del template dalla cartella specificata usando il nome della pagina corrente
    get_template_part('foldername/'.basename(get_permalink()),'name');
    ?>