Usuń ślimak z niestandardowych adresów URL postów

Wygląda na to, że wszystkie zasoby internetowe oparte na temacie usuwania niestandardowego ślimaka typu post, tj

yourdomain.com/CPT-SLUG/post-name 

są obecnie bardzo nieaktualnymi rozwiązaniami, często odwołującymi się do instalacji przed wersją 3.5 WP. Powszechnym jest:

'rewrite'   => array( 'slug' => false, 'with_front' => false ),  

w ramach funkcji register_post_type. To już nie działa i wprowadza w błąd. Pytam więc społeczność w trzecim kwartale 2018 r. U progu WordPress 5 ...

Jakie są nowoczesne i wydajne sposoby usuwania informacji o typie posta z adresu URL postu o niestandardowym typie postu z argumentu o przepisaniu lub gdziekolwiek indziej?

AKTUALIZACJA: Wydaje się, że istnieje kilka sposobów zmuszenia tego do pracy z wyrażeniem regularnym. W szczególności odpowiedź od Jana Becka, jeśli konsekwentnie chcesz monitorować tworzenie treści, aby upewnić się, że nie powstają sprzeczne nazwy stron / postów ... Jestem jednak przekonany, że jest to poważna słabość rdzenia WP, w przypadku której należy sobie z nią poradzić. . Zarówno jako opcja / zaczep podczas tworzenia CPT lub zaawansowany zestaw opcji dla permalinków. Wesprzyj bilet na tor.

Przypis: Proszę wesprzeć ten bilet trac, oglądając / promując go: https://core.trac.wordpress.org/ticket/34136#ticket

Poniższy kod będzie działał, ale należy pamiętać, że konflikty mogą się łatwo zdarzyć, jeśli informacje o niestandardowym typie postu są takie same jak informacje o stronie lub postie ...

Najpierw usuniemy ślimak z bezpośredniego łącza:

function na_remove_slug( $post_link, $post, $leavename ) {

    if ( 'events' != $post->post_type || 'publish' != $post->post_status ) {
        return $post_link;
    }

    $post_link = str_replace( '/' . $post->post_type . '/', '/', $post_link );

    return $post_link;
}
add_filter( 'post_type_link', 'na_remove_slug', 10, 3 );

Samo usunięcie ślimaka nie wystarczy. W tej chwili otrzymasz stronę 404, ponieważ WordPress oczekuje tylko, że posty i strony będą się tak zachowywać. Musisz także dodać następujące elementy:

function na_parse_request( $query ) {

    if ( ! $query->is_main_query() || 2 != count( $query->query ) || ! isset( $query->query['page'] ) ) {
        return;
    }

    if ( ! empty( $query->query['name'] ) ) {
        $query->set( 'post_type', array( 'post', 'events', 'page' ) );
    }
}
add_action( 'pre_get_posts', 'na_parse_request' );

Po prostu zmień „zdarzenia” na niestandardowy typ wpisu i możesz zacząć. Może być konieczne odświeżenie łączy bezpośrednich.

Wpisz następujący kod do rejestracji taksonomii.

'rewrite' => [
  'slug' => '/',
  'with_front' => false
]

Najważniejsze, co musisz zrobić po zmianie kodu

Po zmodyfikowaniu niestandardowego dokumentu taksonomii typu posta przejdź do Ustawienia> Odnośniki bezpośrednie i ponownie zapisz ustawienia , w przeciwnym razie strona 404 nie zostanie znaleziona.

Sprawdź tutaj najlepsze rozwiązanie: http://www.krazzycodes.com/how-to-remove-custom-post-type-taxonomy-base-from-url-in-wordpress/

Próbowałem to rozgryźć niedawno, a krótka odpowiedź z tego, co wiem, brzmi „ nie” . Przynajmniej nie z argumentu przepisz.

Długie wyjaśnienie staje się oczywiste, jeśli spojrzysz na rzeczywisty kod register_post_typew linii wp-include / post.php 1454 :

add_permastruct( $post_type, "{$args->rewrite['slug']}/%$post_type%", $permastruct_args );

Można zobaczyć je prefiksów $args->rewrite['slug']do %$post_type%tagu przepisywania. Można by pomyśleć „ustawmy ślimak na nullwtedy”, dopóki nie spojrzysz na kilka linijek w górę:

if ( empty( $args->rewrite['slug'] ) )
    $args->rewrite['slug'] = $post_type;

Widać, że funkcja zawsze oczekuje wartości ślimaka, która nie jest pusta, a poza tym używa typu postu.

W odpowiedzi na moją poprzednią odpowiedź : możesz oczywiście ustawić rewriteparametr na falsepodczas rejestrowania nowego typu posta i samodzielnie obsługiwać reguły przepisywania

<?php
function wpsx203951_custom_init() {

    $post_type = 'event';
    $args = (object) array(
        'public'      => true,
        'label'       => 'Events',
        'rewrite'     => false, // always set this to false
        'has_archive' => true
    );
    register_post_type( $post_type, $args );

    // these are your actual rewrite arguments
    $args->rewrite = array(
        'slug' => 'calendar'
    );

    // everything what follows is from the register_post_type function
    if ( is_admin() || '' != get_option( 'permalink_structure' ) ) {

        if ( ! is_array( $args->rewrite ) )
            $args->rewrite = array();
        if ( empty( $args->rewrite['slug'] ) )
            $args->rewrite['slug'] = $post_type;
        if ( ! isset( $args->rewrite['with_front'] ) )
            $args->rewrite['with_front'] = true;
        if ( ! isset( $args->rewrite['pages'] ) )
            $args->rewrite['pages'] = true;
        if ( ! isset( $args->rewrite['feeds'] ) || ! $args->has_archive )
            $args->rewrite['feeds'] = (bool) $args->has_archive;
        if ( ! isset( $args->rewrite['ep_mask'] ) ) {
            if ( isset( $args->permalink_epmask ) )
                $args->rewrite['ep_mask'] = $args->permalink_epmask;
            else
                $args->rewrite['ep_mask'] = EP_PERMALINK;
        }

        if ( $args->hierarchical )
            add_rewrite_tag( "%$post_type%", '(.+?)', $args->query_var ? "{$args->query_var}=" : "post_type=$post_type&pagename=" );
        else
            add_rewrite_tag( "%$post_type%", '([^/]+)', $args->query_var ? "{$args->query_var}=" : "post_type=$post_type&name=" );

        if ( $args->has_archive ) {
            $archive_slug = $args->has_archive === true ? $args->rewrite['slug'] : $args->has_archive;
            if ( $args->rewrite['with_front'] )
                $archive_slug = substr( $wp_rewrite->front, 1 ) . $archive_slug;
            else
                $archive_slug = $wp_rewrite->root . $archive_slug;

            add_rewrite_rule( "{$archive_slug}/?$", "index.php?post_type=$post_type", 'top' );
            if ( $args->rewrite['feeds'] && $wp_rewrite->feeds ) {
                $feeds = '(' . trim( implode( '|', $wp_rewrite->feeds ) ) . ')';
                add_rewrite_rule( "{$archive_slug}/feed/$feeds/?$", "index.php?post_type=$post_type" . '&feed=$matches[1]', 'top' );
                add_rewrite_rule( "{$archive_slug}/$feeds/?$", "index.php?post_type=$post_type" . '&feed=$matches[1]', 'top' );
            }
            if ( $args->rewrite['pages'] )
                add_rewrite_rule( "{$archive_slug}/{$wp_rewrite->pagination_base}/([0-9]{1,})/?$", "index.php?post_type=$post_type" . '&paged=$matches[1]', 'top' );
        }

        $permastruct_args = $args->rewrite;
        $permastruct_args['feed'] = $permastruct_args['feeds'];
        add_permastruct( $post_type, "%$post_type%", $permastruct_args );
    }
}
add_action( 'init', 'wpsx203951_custom_init' );

Widzisz, że add_permastructpołączenie nie obejmuje już ślimaka. Testowałem dwa scenariusze:

1. Kiedy utworzyłem stronę ze ślimakiem „kalendarz”, ta strona jest zastępowana przez archiwum typu postu, które również używa ślimaka „kalendarz”.

2. Kiedy utworzyłem stronę ze ślimakiem „moje-wydarzenie” i zdarzeniem (CPT) ze ślimakiem „moje-zdarzenie”, wyświetlany jest niestandardowy typ postu.

3. Żadne inne strony też nie działają. Jeśli spojrzysz na powyższe zdjęcie, stanie się jasne, dlaczego: niestandardowa reguła typu postu zawsze będzie pasować do informacji o stronie. Ponieważ WordPress nie ma możliwości ustalenia, czy jest to strona, czy niestandardowy typ postu, który nie istnieje, zwróci 404. Dlatego potrzebujesz ślimaka, aby zidentyfikować stronę lub CPT. Możliwym rozwiązaniem byłoby przechwycenie błędu i poszukiwanie strony, która mogłaby istnieć podobnie do tej odpowiedzi .

Patrząc na odpowiedzi tutaj, myślę, że jest miejsce na lepsze rozwiązanie, które łączy niektóre rzeczy, których się nauczyłem powyżej, i dodaje automatyczne wykrywanie i zapobieganie duplikatom post ślimaków.

UWAGA: Upewnij się, że zmieniłeś „custom_post_type” dla własnej nazwy CPT w całym moim przykładzie poniżej. Istnieje wiele zdarzeń, a „znajdź / zamień” jest łatwym sposobem na złapanie ich wszystkich. Cały ten kod może przejść w pliku functions.php lub we wtyczce.

Krok 1: Wyłącz przepisywanie niestandardowego typu postu, ustawiając przepisywanie na „fałsz” po zarejestrowaniu postu:

register_post_type( 'custom_post_type',
    array(
        'rewrite' => false
    )
);

Krok 2: Ręcznie dodaj nasze niestandardowe przepisywania na dole przepisywania WordPress dla naszego niestandardowego typu postu

function custom_post_type_rewrites() {
    add_rewrite_rule( '[^/]+/attachment/([^/]+)/?$', 'index.php?attachment=$matches[1]', 'bottom');
    add_rewrite_rule( '[^/]+/attachment/([^/]+)/trackback/?$', 'index.php?attachment=$matches[1]&tb=1', 'bottom');
    add_rewrite_rule( '[^/]+/attachment/([^/]+)/feed/(feed|rdf|rss|rss2|atom)/?$', 'index.php?attachment=$matches[1]&feed=$matches[2]', 'bottom');
    add_rewrite_rule( '[^/]+/attachment/([^/]+)/(feed|rdf|rss|rss2|atom)/?$', 'index.php?attachment=$matches[1]&feed=$matches[2]', 'bottom');
    add_rewrite_rule( '[^/]+/attachment/([^/]+)/comment-page-([0-9]{1,})/?$', 'index.php?attachment=$matches[1]&cpage=$matches[2]', 'bottom');
    add_rewrite_rule( '[^/]+/attachment/([^/]+)/embed/?$', 'index.php?attachment=$matches[1]&embed=true', 'bottom');
    add_rewrite_rule( '([^/]+)/embed/?$', 'index.php?custom_post_type=$matches[1]&embed=true', 'bottom');
    add_rewrite_rule( '([^/]+)/trackback/?$', 'index.php?custom_post_type=$matches[1]&tb=1', 'bottom');
    add_rewrite_rule( '([^/]+)/page/?([0-9]{1,})/?$', 'index.php?custom_post_type=$matches[1]&paged=$matches[2]', 'bottom');
    add_rewrite_rule( '([^/]+)/comment-page-([0-9]{1,})/?$', 'index.php?custom_post_type=$matches[1]&cpage=$matches[2]', 'bottom');
    add_rewrite_rule( '([^/]+)(?:/([0-9]+))?/?$', 'index.php?custom_post_type=$matches[1]', 'bottom');
    add_rewrite_rule( '[^/]+/([^/]+)/?$', 'index.php?attachment=$matches[1]', 'bottom');
    add_rewrite_rule( '[^/]+/([^/]+)/trackback/?$', 'index.php?attachment=$matches[1]&tb=1', 'bottom');
    add_rewrite_rule( '[^/]+/([^/]+)/feed/(feed|rdf|rss|rss2|atom)/?$', 'index.php?attachment=$matches[1]&feed=$matches[2]', 'bottom');
    add_rewrite_rule( '[^/]+/([^/]+)/(feed|rdf|rss|rss2|atom)/?$', 'index.php?attachment=$matches[1]&feed=$matches[2]', 'bottom');
    add_rewrite_rule( '[^/]+/([^/]+)/comment-page-([0-9]{1,})/?$', 'index.php?attachment=$matches[1]&cpage=$matches[2]', 'bottom');
    add_rewrite_rule( '[^/]+/([^/]+)/embed/?$', 'index.php?attachment=$matches[1]&embed=true', 'bottom');
}
add_action( 'init', 'custom_post_type_rewrites' );

UWAGA: W zależności od potrzeb możesz zmodyfikować powyższe przepisania (wyłączyć trackbacki? Kanały? Itp.). Reprezentują one „domyślne” typy przepisywania, które zostałyby wygenerowane, gdyby nie wyłączyć przepisywania w kroku 1

Krok 3: Ponownie dodaj permalinki do niestandardowego typu posta jako „ładna”

function custom_post_type_permalinks( $post_link, $post, $leavename ) {
    if ( isset( $post->post_type ) && 'custom_post_type' == $post->post_type ) {
        $post_link = home_url( $post->post_name );
    }

    return $post_link;
}
add_filter( 'post_type_link', 'custom_post_type_permalinks', 10, 3 );

UWAGA: Możesz zatrzymać się tutaj, jeśli nie martwisz się, że użytkownicy utworzą sprzeczny (zduplikowany) post w innym typie postu, co spowoduje sytuację, w której tylko jeden z nich będzie mógł zostać załadowany, gdy strona zostanie poproszona.

Krok 4: Zapobiegaj powielaniu ślimaków postowych

function prevent_slug_duplicates( $slug, $post_ID, $post_status, $post_type, $post_parent, $original_slug ) {
    $check_post_types = array(
        'post',
        'page',
        'custom_post_type'
    );

    if ( ! in_array( $post_type, $check_post_types ) ) {
        return $slug;
    }

    if ( 'custom_post_type' == $post_type ) {
        // Saving a custom_post_type post, check for duplicates in POST or PAGE post types
        $post_match = get_page_by_path( $slug, 'OBJECT', 'post' );
        $page_match = get_page_by_path( $slug, 'OBJECT', 'page' );

        if ( $post_match || $page_match ) {
            $slug .= '-duplicate';
        }
    } else {
        // Saving a POST or PAGE, check for duplicates in custom_post_type post type
        $custom_post_type_match = get_page_by_path( $slug, 'OBJECT', 'custom_post_type' );

        if ( $custom_post_type_match ) {
            $slug .= '-duplicate';
        }
    }

    return $slug;
}
add_filter( 'wp_unique_post_slug', 'prevent_slug_duplicates', 10, 6 );

UWAGA: Spowoduje to dołączenie ciągu „-duplikacja” na końcu każdego powielonego ślimaka. Ten kod nie może zapobiec duplikatom ślimaków, jeśli istnieją już przed wdrożeniem tego rozwiązania. Najpierw sprawdź, czy nie ma duplikatów.

Chciałbym usłyszeć od każdego, kto spróbuje to sprawdzić, czy to również dobrze dla nich zadziałało.

Nie potrzebujesz tyle twardego kodu. Wystarczy użyć lekkiej wtyczki:

• Usuń podstawowy ślimak z niestandardowego postu

Ma konfigurowalne opcje.

Miałem te same problemy tutaj i wydaje się, że nie ma ruchu na stronie wordpress. W mojej szczególnej sytuacji, gdy dla pojedynczych postów na blogu potrzebne było takie rozwiązanie, struktura / blog /% postname% /

https://kellenmace.com/remove-custom-post-type-slug-from-permalinks/

zakończyło się w grupie 404

Ale wraz z tym cudownym podejściem, które nie wykorzystuje struktury wewnętrznej backendu dla blogu, w końcu działa jak charme. https://www.bobz.co/add-blog-prefix-permalink-structure-blog-posts/

Wielkie dzięki.

i możemy wprowadzić pewne zmiany w wyżej wspomnianej funkcji:

function na_parse_request( $query ) {

if ( ! $query->is_main_query() || 2 != count( $query->query ) || ! isset( $query->query['page'] ) ) {
    return;
}

if ( ! empty( $query->query['name'] ) ) {
    $query->set( 'post_type', array( 'post', 'events', 'page' ) );
}
}

do:

function na_parse_request( $query ) {

if ( ! $query->is_main_query() || 2 != count( $query->query ) || ! isset( $query->query['page'] ) ) {
    return;
}

if ( ! empty( $query->query['name'] ) ) {

    global $wpdb;
    $pt = $wpdb->get_var(
        "SELECT post_type FROM `{$wpdb->posts}` " .
        "WHERE post_name = '{$query->query['name']}'"
    );
    $query->set( 'post_type', $pt );
}
}

w celu ustawienia właściwej wartości typu post_type.

To działało dla mnie: 'rewrite' => array('slug' => '/')

Dla każdego, kto to czyta, który miał problem z postami podrzędnymi, tak jak ja, znalazłem najlepszy sposób, aby dodać własne reguły przepisywania.

Głównym problemem, jaki miałem, było to, że WordPress traktuje przekierowanie ze stron o głębokości 2 poziomów (posty podrzędne) nieco inaczej niż traktuje 3 poziomy głębokości (posty podrzędne).

Oznacza to, że kiedy mam / post-type / post-name / post-child / mogę użyć / post-name / post-child i przekieruję mnie do tego z post-type z przodu, ale jeśli mam post-type / post-name / post-child / post-grandchild, wtedy nie mogę używać post-name / post-child / post-grandchild.

Patrząc na zasady przepisywania, wygląda na to, że pasuje do rzeczy innych niż pagename na pierwszym i drugim poziomie (myślę, że drugi poziom pasuje do załącznika), a następnie robi coś, aby przekierować cię do właściwego postu. Na trzech poziomach głębokości to nie działa.

Pierwszą rzeczą, którą musisz zrobić, to również usunąć link typu postu z dzieci. Ta logika powinna się tutaj zdarzyć, jeśli spojrzysz na odpowiedź Nate'a Allena powyżej:

$post_link = str_replace( '/' . $post->post_type . '/', '/', $post_link );

Sam użyłem mieszanki różnych warunkowych, aby sprawdzić, czy post ma dzieci, a co nie, aby uzyskać właściwy bezpośredni link. Ta część nie jest zbyt trudna i znajdziesz przykłady ludzi, którzy robią to gdzie indziej.

Następnym krokiem jest jednak zmiana sytuacji od podanej odpowiedzi. Zamiast dodawać rzeczy do głównego zapytania (które działało dla niestandardowych postów i ich dzieci, ale nie dla dalszych dzieci) dodałem przepisanie, które poszło na dół do reguł WordPress, aby jeśli pagename nie wypisało się i miało zamiar uderzył 404, zrobiłoby to ostatnie sprawdzenie, czy strona w niestandardowym typie postu ma tę samą nazwę, w przeciwnym razie wyrzuciłaby 404.

Oto reguła przepisywania, której użyłem, zakładając, że „zdarzenie” to nazwa twojego CPT

function rewrite_rules_for_removing_post_type_slug()
{
    add_rewrite_rule(
        '(.?.+?)?(:/([0-9]+))?/?$',
        'index.php?event=$matches[1]/$matches[2]&post_type=event',
        'bottom'
    );
}

add_action('init', 'rewrite_rules_for_removing_post_type_slug', 1, 1);

Mam nadzieję, że to pomaga komuś innemu, nie mogłem znaleźć nic innego, co miałoby związek z dzieckiem postów dziecka i usunięciem ślimaka z nich.