Mit folgenden Zeilen in deiner functions.php, deines Child-Themes, kannst die diese HTML-Säuberung deaktivieren und so alle HTML-Tags innerhalb der Biografische Angaben nutzen.

//disable WordPress sanitization to allow more than just $allowedtags from /wp-includes/kses.php
remove_filter('pre_user_description', 'wp_filter_kses');
//add sanitization for WordPress posts
add_filter( 'pre_user_description', 'wp_filter_post_kses');

Doch vorsicht, sobald du es aktiviert hast, werden alle HTML-Eingaben nicht mehr gefiltert und es könnte schadhafter Code darüber eingetragen werden. Achte also bitte darauf, dass alle Autoren und Nutzer deiner WordPress Website entsprechend sorgsdam damit umgehen.

Und nun viel Freude mit den neuen Möglichkeiten.

Der Beitrag HTML-Tags in den Autorendaten (Biografie) erlauben erschien zuerst auf deinWP.de.

• Zähl-Logik: Code in die functions.php kopieren, der bei jedem Aufruf ein Custom Field (wp_post_views_count) hochzählt.
• Trigger setzen: Die Funktion in der single.php innerhalb des Loops aufrufen.
• Ausgabe: Eine WP_Query nutzen, um die Beiträge absteigend nach dem Meta-Wert zu sortieren und anzuzeigen.
• Vorteil: Volle Kontrolle, maximale Geschwindigkeit und DSGVO-konform.

Die von uns gezeigte Variante ist einfach und für Anfänger gedacht. Eine Profi-Variante findest du beim Kollegen Stephan.

Warum auf Plugins verzichten?

Plugins wie „WP-PostViews“ ermöglichen dir die benötigte Funktion, bringen aber oft zusätzlichen Ballast mit. Für ein einfaches Ranking reicht es völlig aus, die WordPress-eigene Datenbank-Struktur der Custom Fields (Metadaten) zu nutzen. Das spart nicht nur Datenbank-Abfragen beim Laden der Seite, sondern hält dein Backend sauber.

/************************************
    Post-Views
************************************/
function dwp_track_post_views($postID) {
    $count_key = 'wp_post_views_count';
    $count = get_post_meta($postID, $count_key, true);
    if($count == ''){
        $count = 0;
        delete_post_meta($postID, $count_key);
        add_post_meta($postID, $count_key, '0');
    } else {
        $count++;
        update_post_meta($postID, $count_key, $count);
    }
}

dwp_track_post_views(get_the_ID());

$args = array(
    'posts_per_page' => 5,
    'meta_key' => 'wp_post_views_count',
    'orderby' => 'meta_value_num',
    'order' => 'DESC'
);
$popular_posts = new WP_Query($args);
// Hier folgt der Loop für die Anzeige...

// Spalte "Aufrufe" im Backend registrieren
function dwp_add_views_column($columns) {
    $columns['post_views'] = 'Aufrufe';
    return $columns;
}
add_filter('manage_posts_columns', 'dwp_add_views_column');

// Den Wert (Views) in die Spalte ausgeben
function dwp_display_views_column($column, $post_id) {
    if ($column === 'post_views') {
        $views = get_post_meta($post_id, 'wp_post_views_count', true);
        echo ($views != '') ? $views : '0';
    }
}
add_action('manage_posts_custom_column', 'dwp_display_views_column', 10, 2);

// Spalte sortierbar machen
function dwp_make_views_column_sortable($columns) {
    $columns['post_views'] = 'post_views';
    return $columns;
}
add_filter('manage_edit-post_sortable_columns', 'dwp_make_views_column_sortable');

// Zählt nur, wenn der User NICHT eingeloggt ist oder KEINE Admin-Rechte hat
if ( !current_user_can('edit_posts') ) {
    dwp_track_post_views(get_the_ID());
}

Erfolgreiche Artikel auswerten ohne Plugin

Wer wissen möchte, welche Inhalte bei seiner Zielgruppe wirklich ankommen, muss nicht zwangsläufig auf datenhungrige Plugins oder komplexe Analyse-Tools setzen. Wie du siehst, reichen ein paar gezielte Zeilen Code aus, um ein schlankes, performantes und DSGVO-konformes Tracking direkt in WordPress zu integrieren.

Der Beitrag Meistgelesene Artikel anzeigen ohne Plugin erschien zuerst auf deinWP.de.

Lesezeit im Beitrag ausgeben

Du möchtest deinen Beitrag um die geschätzte Lesezeit ergänzen?^[1]GeneratePress Support-Frage
Mit dem folgenden Code für die functions.php, kannst du die Lesezeit innerhalb der Meta-Angaben deines Beitrages hinterlegen. Beim Wert von „300“ wird die Anzahl der Worte je Minute angegeben. Je nach „Verdaulichkeit“ deiner Texte kannst du diesen Wert nach deinen Bedürfnissen anpassen. Die Textbereiche bei „Minuten“ sowie „Lesezeit ca.“ kannst du ebenfalls anpassen oder übersetzen.

/* Lesezeit im Beitrag ausgeben */
function dwp_estimated_reading_time() {
    $post = get_post();
    $content = $post->post_content;
    $wpm = 300; // How many words per minute.

    $clean_content = strip_shortcodes($content);
   $clean_content = strip_tags($clean_content);
    $word_count = str_word_count($clean_content);
    $time = ceil($word_count / $wpm);

    return $time . ' Minuten';
}

add_filter('generate_post_date_output', function ($output) {
    $output .= '<div class="read-time">Lesezeit ca. ' . dwp_estimated_reading_time() . '</div>';

    return $output;
});

Du findest fortan den Hinweis der Lesezeit hinter den Datumsangaben deines Beitrages. Wenn wir uns nun die Ausgabe der neuen Zeitangabe betrachten, sehen wir, dass die zeitlichen Angaben des Beitrages mit einem (time-Tag) umfasst werden und unsere Lesezeit einen anderen Aufbau hat. Wir nutzen hier bewusst nicht das time-Tag, da dies nur ein Datum oder eine Zeit enthalten sollte. Die zeitliche Dauer ist dagegen besser in einem (div-Tag) aufgehoben. Die Gestaltung kannst du dann per CSS und der hinterlegten Klasse „.read-time“ nach deinen Wünschen gestalten.

Container komplett klickbar machen

Mittlerweile besitzt GenerateBlocks Pro diese Funktion.

Wenn du kein Pro-Nutzer bist oder noch eine alte Version nutzen musst, kannst du die Funktion wie folgt nachrüsten. Hierzu erstellst du ein Overlay per HTML-Element für Links innerhalb des Containers. Dieser wird als komplette Klickfläche dienen. Eine schöne Alternative zu schnöden Buttons und auf Mobilgeräten mit größerer Klickfläche immer eine feine Sache.

/* Container klickbar machen */
.clickable-container {
    position: relative;
}
.clickable-container a.overlay {
    position: absolute;
    height: 100%;
    width: 100%;
    top: 0;
    right: 0;
    bottom: 0;
    left: 0;
    z-index: 999;
}

@media (min-width: 769px) {
    #right-sidebar > .inside-right-sidebar {
        position: -webkit-sticky;
        position: sticky;
        top: 120px;
    }
}

add_filter( 'generate_navigation_search_output', function() {
    printf(  
        '<form method="get" class="search-form navigation-search" action="%1$s">
            <input type="search" placeholder="Produkte durchsuchen ..." class="search-field" value="" name="s" title="%3$s" />
            <input type="hidden" name="post_type" value="product" />
        </form>', 
        esc_url( home_url( '/' ) ), 
        esc_attr( get_search_query() ),   
        esc_attr_x( 'Search', 'label', 'generatepress' ) 
    ); 
} );

#site-navigation.has-active-search .navigation-search input {
    outline: none !important;
    border: 1px solid #ccc; /* optional */
}

add_filter( 'generate_smooth_scroll_elements', function( $elements ) {
    $elements[] = 'a:not([data-gpmodal-trigger="gp-search"])[href*="#"]';
    
    return $elements;
} );

add_filter('wp_nav_menu_objects', 'db_menu_item_featured_image', 10, 2);

function db_menu_item_featured_image($sorted_menu_objects, $args) {

    // Check navigagtion is primary
    if ($args->theme_location != 'primary')
        return $sorted_menu_objects;
    // edit menu items
    foreach ($sorted_menu_objects as $menu_object) {
       $menu_object->title = '<span class="menu-label">' . $menu_object->title . '</span>';
    }

    return $sorted_menu_objects;
}

@media (min-width: 769px) {
    .main-navigation .menu>.menu-item>a>.menu-label {
        position: relative;
    }

    .main-navigation .menu>.menu-item>a>.menu-label::after {
        content: "";
        position: absolute;
        right: 0;
        left: 50%;
        bottom: -5px;
        -webkit-transform: translate3d(-50%, 0, 0);
        transform: translate3d(-50%, 0, 0);
        display: block;
        width: 0;
        height: 2px;
        background-color: currentColor;
        transition: 0.3s width ease;
    }

    .main-navigation .menu>.menu-item.current-menu-item>a>.menu-label::after,
    .main-navigation .menu>.menu-item.current-menu-ancestor>a>.menu-label::after,
    .main-navigation .menu>.menu-item:hover>a>.menu-label::after {
        width: 100%;
    }
}

Der Beitrag GeneratePress Code Snippets erschien zuerst auf deinWP.de.

Lösung auf Basis von GeneratePress

GeneratePress Version 3.1.3

add_filter( 'generate_excerpt_more_output', function( $more ) {
    if ( in_category('slug') ) {
        return sprintf( ' ... <a class="read-more" title="%1$s" href="%2$s">%3$s</a>',
            the_title_attribute( 'echo=0' ),
            esc_url( get_permalink( get_the_ID() ) ),
            __( 'Custom Text', 'generatepress' )
        );
	}
    return $more;
}, 50 );

Du musst noch bei „Slug“ im Bereich if ( in_category(‚slug‚) den Namen deiner Wunsch-Kategorie angeben und den Platzhalter „Custom Text“ mit deiner eigenen Idee befüllen. Schon erstrahlt je nach Kategorie ein anderer Text auf deinem Weiterlesen-Button.

Ideen für deinen Weiterlesen-Text

• weiterlesen
• mehr
• Mehr erfahren
• Mehr lesen
• Tiefer eintauchen

Der Beitrag WordPress Weiterlesen Button – individueller Text je nach Kategorie erschien zuerst auf deinWP.de.

• Der Zugriff auf Revisionen ist erst verfügbar, nachdem die erste Revision verfügbar ist.
• Es gibt keine Revisionen von unveröffentlichten Entwürfen (Du musst einmal „Entwurf speichern“ drücken)
• Die Revisionen enthalten nur (!) die Änderungen im Inhalt (dem Contentbereich) deines Beitrages oder deiner Seite. Alle zusätzlichen Angaben (wie Kategorien, Schlagwörter, Textauszug, Beitragsbild, etc.) werden nicht einbezogen.
• Die Anzahl an Revisionen ist nicht unendlich, verlasse dich also nicht auf deren Verfügbarkeit.
• Du kannst die Anzahl deiner Revisionen einstellen und solltest dies auch nutzen, denn je höher die Anzahl ist, desto mehr Speicherplatz wird in der Datenbank verwendet.

Snippet & Plugins für Limitierung der Anzahl an Revisionen

Am einfachsten lässt sich die Anzahl an Revisionen mittels Plugin (beispielsweise WP Revisions Control) steuern. Allerdings ist die „Code-Lösung nicht kompliziert und du kannst dir ein Plugin sparen.

Innerhalb der Datei wp-config.php kannst du die Anzahl an Revisionen begrenzen. Die Datei findest du im Hauptverzeichnis deiner WordPress-Installation. Öffne diese und füge folgende Zeilen ein. Die Zahl gibt an, wie viele Versionen du abspeichern möchtest. Etwa 25 halte ich für eine passende Höchstgrenze. Die Angabe POST wird seitens WordPress in diesem Fall für Beiträge und Seiten verwendet. Du änderst somit die Anzahl für beide Beitragsarten.

// Stelle die Anzahl der Revisionen der Beiträge auf 25
define( 'WP_POST_REVISIONS', 25 );

// Es sollen gar keine Revisionen angelegt werden
define( 'WP_POST_REVISIONS', false );

Anstatt false kannst du auch 0 verwenden, der Effekt ist identisch. Mit true oder -1 legt deinWP unbegrenzt viele Revisionen.

// Es sollen unbrgtrnzt viele Revisionen angelegt werden
define( 'WP_POST_REVISIONS', true );

Zusätzlich kannst du die Zeit bestimmen, in der dein WordPress automatisch abspeichern soll. Die Angabe des AUTOSAVE_INTERVAL geschieht in Sekunden.

// Intervall der automatischen Speicherung von Post-Revisionen
define( 'AUTOSAVE_INTERVAL', 180 ); // Sekunden

Wie du die Revisionen für WooCommerce Produkte aktivierst, erfährst du hier.

Liegt deine aktuelle Revision-Anzahl allerdings bereits über der gewünschten neuen Anzahl, dann bleiben die vorhergehenden Informationen bestehen. Damit du diese ebenfalls reduzieren kannst, musst du die Datenbank reinigen.

Mythos: Viele Revisionen verlangsamen deine Website nicht. Zwar werden die Varianten in der Datenbank abgespeichert, aber im Frontend erfolgt keine Datenbank-Abfrage danach. Deine Nutzer bemerken somit keinen Geschwindigkeitsunterschied. Eine solche Abfrage geschieht lediglich, um die Anzahl beim Editieren des Inhalts auszugeben und wenn du innerhalb der verschiedenen Revisionen stöberst. An dieser Stelle kann sich eine hohe Anzahl allerdings bemerkbar machen.

Der Beitrag WordPress Revisionen nutzen und optimieren erschien zuerst auf deinWP.de.

Grundsätzlich kannst du die PHP Dateien deiner Website (header.php / footer.php) direkt bearbeiten oder in einem Child-Theme zusätzlich anlegen, wenn du eigene Codeanpassungen zu deiner Seite hinzufügen möchtest, die im HTML-Header oder Footer-Bereich erscheinen sollen. Du benötigst dazu Zugriff auf den Server via SFTP. Empfehlenswert ist es dennoch (je nach Umfang der gewünschten Funktion) kleine Anpassungen direkt in der functions.php oder als Snippet einzubinden.

Wenn es nun also darum geht, etwas eigenen Code zum Header oder Footer hinzuzufügen, kannst du die folgenden Codeschnippsel nutzen um deinen eigenen Code dazwischen zu platzieren. Die Wahl zwischen Header und Footer musst du je nach Anwendungsfall selbst entscheiden.

Quick-Tipp:
Je nach Setup deiner Seite kann es auch sein, dass dein Theme oder ein Plugin z.B. ein PageBuilder bereits eine Möglichkeit mit sich bringen, dort eigenen Code im Header oder Footer unterzubringen. Gerne kannst du auch solche Optionen nutzen. Behalte also im Hinterkopf, dass bei einem Themewechsel oder dem abschalten des genutzten Plugins, auch die eingetragenen Zeilen nicht mehr geladen werden können. Die nachfolgenden Beispiele sind dahingehend praktisch, weil die Integration unabhängig vom Parent-Theme in die functions.php vom Child-Theme eingetragen werden kann und so dein WordPress an der richtigen Stelle erweitert.

In der Zeile 5 beim markierten Text (###) kannst du deinen eigenen Code einfügen und die Ausgabe erfolgt dann jeweils im Header- und Fußbereich deiner Website.

eigenen Code im Header von WordPress hinzufügen

Im HTML-Header deiner Website finden sich verschiedene Bausteine zum Betrieb deiner Website. Manche dieser Bausteine müssen zu Beginn geladen werden, während andere aus Perfomance- und Geschwindigkeits-Gründen besser im Footer aufgehoben sind. Hier eine kleine Liste der häufigsten Elemente, welche du im Headerbereich so antriffst.

• Link zum Favicon
• Links zu Schriftarten
• Links zu Stylesheets
• Links zu Script-Dateien
• Meta-Tags

Schriften, Stylings und Scripte können ebenso auch inline eingebunden sein und statt einem zu ladenden Link direkt ausgeführt werden. Das Favicon deiner WordPress Seite bearbeitest du z.B. besser direkt mit dem Gutenberg-Editor. Wenn es nun aber darum geht Scripte oder Stylings im Header deiner Seite anzupassen, bist du hier genau richtig. Mit dem folgenden Snippet kannst du deinen eigenen Code zum HTML-Header hinzufügen. Tausche dazu den Text ab ### mit deinem eigenen Code für den Header aus. Der Rest ist lediglich der „Rahmen“, damit der Inhalt auch an der richtigen Stelle geladen wird.

HTML-Header – functions.php / Snippet

/* dwp - eigener Code im Header */
add_action('wp_head', 'dwp_custom_header_code');
function dwp_custom_header_code(){
?>
### Hier dein eigener Code für den Header ###
<?php
};

eigenen Code im Footer von WordPress hinzufügen

Der HTML-Footer einer Website wird zuletzt geladen, deshalb findest du hier oft Dinge, die nicht sofort beim öffnen der Seite geladen werden müssen. Wie auch im Header, findest du hier Script-Dateien oder Stylesheets. Diese können als Link ausgegeben oder auch direkt inline ausgeführt werden. Der Footer eignet sich daher z.B. für Scripte, die nicht sofort benötigt werden oder im Header ggf. Ladeverzögerungen mit sich bringen würden. Beliebt sind hier u.A. Trackings-Codes oder andere externe Services.

Mit dem folgenden Snippet fügst du zum Footer deiner WordPress Seite eigenen Code hinzu.

HTML-Footer functions.php / Snippet

/* dwp - eigener Code im Footer */
add_action('wp_head', 'dwp_custom_footer_code');
function dwp_custom_footer_code(){
?>
### Hier dein eigener Code für den Footer ###
<?php
};

Pluginlösung

Was wäre WordPress ohne seine zahllosen Plugins. Natürlich gibt es auch für genau diese Aufgabe ein passendes und so kannst du u.A. mit Insert Headers and Footers by WPBeginner ganz einfach auch via Plugin deinen eigenen Code in den Header oder Footer (und auch Body) deiner Seite einbinden.

Beispiele

Wenn dir das bis hierhin zu theoretisch war, helfen dir evtl. ein paar kleine Beispiele zur Anwendung, ein besseres Bild von der Nutzung zu bekommen.

JavaScript im Footer

externe Links global & automatisch in einem neuen Tab öffnen

/* dwp - externe Links in neuem Tab öffnen */
add_action('wp_footer', 'dwp_external_links_blank');
function dwp_external_links_blank(){
?>
    <script type="text/javascript">
        jQuery(document).ready( function($) {
            $('a').each(function() {
            var a = new RegExp('/' + window.location.host + '/');
            if (!a.test(this.href)) {
                $(this).addClass('external').attr('target','_blank').attr('rel','noopener');
            }
            });
        });
    </script>
<?php
};

Weitere Beispiele folgen, bleib gespannt.

Was würdest du denn gerne als nächstes in deinem Website-Header oder -Footer unterbringen?

Der Beitrag Code im (HTML-)Header oder Footer hinzufügen erschien zuerst auf deinWP.de.

Der nachfolgende Code kommt am besten in die „functions.php“ deines Child-Themes.

/*  Shortcodes in CF7 akzeptieren */
add_filter( 'wpcf7_form_elements', 'do_shortcode' );

Mit dieser kleinen Anpassung werden Shortcodes von deinem Theme oder einem anderen Plugin direkt im Contact Form 7 nutzbar gemacht.

Für welche Kombination möchtest du Shortcodes im CF7 auf deiner Website freischalten? Teile es gerne in den Kommentaren.

Der Beitrag Contact Form 7 – Shortcodes ausführen erschien zuerst auf deinWP.de.

Was nun, wenn du auch die inhaltlichen Änderungen an deinem WooCommerce Produkt festhalten möchtest? Denn derzeit kommt WooCommerce ohne jegliche Revisionen aus. Und das wird wohl noch eine Weile so bleiben, solange nicht auch weitere Produktdaten wie Varianten oder Preise ebenfalls von den Revisionen erfasst werden können. Auch für die Anwendung auf redaktioneller Ebene ist es allemal hilfreich zu sehen, wie die Beschreibung deines Produkts sich über die Zeit veränderte oder wer daran gearbeitet hat.

Wenn dir also die Revisionen der textlichen Änderungen an einem Produkt fehlen, gibt es eine einfache Möglichkeit sie zu aktivieren. Sobald diese aktiviert sind, kannst du bequem und wie gewohnt schauen, was du vor dem letzten Speichern geändert hast. Es braucht -wie so oft- nur ein paar Zeilen Code in deiner functions.php, um diese Funktion in deiner WordPress-Website zu erweitern.

Wie?

/* Revisionen für Produkte aktivieren */
add_filter( 'woocommerce_register_post_type_product', 'dwp_add_revision_support' );

function dwp_add_revision_support( $args ) {
     $args['supports'][] = 'revisions';

     return $args;
}

• getestet mit WooCommerce 6.x und 7.x

INFO: Beachte bitte, dass es sich bei der Schnippsel-Lösung nur um die Änderungen des Text-Inhalts deiner Produkte handelt. Jegliche Metadaten oder Attribute wie Varianten, Preise, Gewicht, usw. sind hiervon nicht betroffen und werden in der Versionierung deines Produkts nicht erfasst!

Der Beitrag Revisionen für WooCommerce Produkte aktivieren erschien zuerst auf deinWP.de.

Du kannst diese Einleitung gerne überspringen, wenn du weißt, was du tust und direkt zum spannenden Teil willst.

Sitemaps und ein kurzes Warum.

1. Bewerte deine vorhandenen Sitemaps und
2. bewerte enthaltene Seiten nach deren Sinnhaftigkeit

Sitemaps selbst geben Besuchern oder Suchmaschinen die komplette Übersicht über deine Website in Form von Links der einzelnen Unterseiten, welche sich durch deine Homepage ziehen.

Eingereichte URLs innerhalb der Sitemap sollen von einer Suchmaschine indexiert werden. Daher sollten hier nur sinnvolle und wichtige Seiten enthalten sein!

Im Fall von WordPress werden diese noch einmal aufgeteilt und nach z.B. Seiten, Beiträgen, Produkten, Kategorien, Taxonomien, Schlagworten, Autoren oder Anderen sogenannten Posttypen getrennt dargestellt. Für dich bietet sich an dieser Stelle ein riesiger Vorteil, denn du kannst all deine Inhalte nach Typen untersuchen. Siehst beispielsweise innerhalb der Google Search Console (ehemals Webmaster Tools) sehen, an welcher Stelle der Crawler, nicht allen Seiten folgt.

Ein einfaches Beispiel für teils unliebsame Seiten in deiner Sitemap können so beispielsweise die automatisch erstellten Autoren-Seiten von WordPress sein. In den meisten Fällen kann das sicher vernachlässigt werden. Sobald du allerdings tiefer in die Optimierung deiner Seite gelangst, solltest du zumindest wissen, auf was es zu achten gilt. Wenn du nun als Administrator deiner Website eine Seite oder einen Beitrag veröffentlichst, trägt deine Sitemap und die gesamte WordPress-Infrastruktur alle vorhandenen Links automatisch nach außen. In kurzer Zeit ist diese Autoren-Seite, befeuert durch deine Sitemap, auch im Index diverser Suchmaschinen enthalten und für jeden sichtbar. Die gut durchgestylten Archiv- oder Autoren-Seiten sind eher die Ausnahme und sollten somit nicht unbedingt das Ziel potenzieller Besucher sein. Und bis es so weit ist, hast du deine Links innerhalb der Sitemap mit wenigen Zeilen Code selbst gesteuert.

Es kann natürlich sein, dass du bestimmte Seiten nicht öffentlich aufgeführt haben möchtest. Dies kann unter Anderen eine bestimmte Landingpage sein, die nicht in deiner Navigation erscheint und nur über einen bestimmten Weg beworben werden soll, damit du deine Zielgruppe besser erreichen kannst.

In anderen Fällen ergibt es eventuell mehr Sinn diese unerwünschten Seiten zu deaktivieren, umzuleiten oder mit anderen Lösungen nicht aufrufbar zu machen. Du solltest jedoch nicht vergessen, die Existenz mit der Sitemap zu prüfen und diese Seiten ggf. dort deaktivieren.

Das Thema Sicherheit und Suchmaschinenoptimierung können weitere Punkte sein, weshalb du die Pflege deiner Sitemap nicht außer Acht lassen solltest.

Apropos Google

Google selbst sagt, dass du keine Sitemap erstellen musst, wenn du weniger als 100 URLs besitzt. Allerdings änder sich die Seitenanzahl zumeist im Laufe eines Website-Lebens. Dadurch ist es in sehr vielen Fällen lohnenswert, sich rechtzeitig mit dem Gedanken zu beschäftigen. Zudem bietet die Datei einige lohnenswerte Funktionen zur Auswertung und damit zur Steuerung der Indexierung. Bing erwähnt keine Zahl, schreibt allerdings, dass deren Webmaster Tools auch mit RSS 2.0, Atom 0.3 & 1.0 sowie einem Text-Dokument gefüttert werden können.

Einreichung: Reiche eine Sitemap ein und du kannst besser prüfen, welche Inhalte indexiert werden und ranken.

Wo finde ich meine Sitemap?

Deine Sitemap findest du in der Regel, wenn du „/sitemap.xml“ hinter deine Website-URL setzt. Seit Version 5.5 bringt WordPress eigene Sitemaps automatisch mit. Als praktische Alternativen (und natürlich vor der Zeit der WordPress eigenen Sitemap) haben Webseiten-Betreiber dedizierte Plugins, wie Yoast oder Rankmath, eingesetzt. Mit diesen praktischen Tools kannst du die Ausgabe und den Aufbau deiner Sitemaps bequem über das Backend steuern. Bei der WordPress-Sitemap gibt es diesen Komfort (noch?) nicht und du bist auf andere Mittel angewiesen, um deine Sitemap individuell zu steuern.

Wie kann ich meine Sitemap bearbeiten?

Die nachfolgend genannten Beispiele beziehen sich derzeit nur auf die WordPress-Core-Sitemap, welche seit Version 5.5 mit jedem WordPress kommt und ohne zusätzliche Plugins automatisch aktiv ist.
Beispiele zum Ausschluss einzelner Seiten von der „Rankmath-Sitemap“ (Plugin) werden noch ergänzt.

Alle folgenden Code-Beispiele gehören am besten in die „functions.php“ deines (Child-)Themes. Alternativ kannst du dafür Code Snippets nutzen. Halte bitte dennoch den Zugang per FTP bereit, damit du im Falle von Fehlern handlungsfähig bist.

Nun aber los!

WordPress Sitemap deaktivieren

• Willst du die native WordPress XML-Sitemap deaktivieren, weil du diese Funktionalität via Plugin steuern möchtest, dann bietet die Dokumentation folgende zwei Varianten an:

/* sitemap deactivated */
add_filter('wp_sitemaps_enabled', '__return_false');

• Oder den Weg über eine Action:

/* sitemap deactivated */
remove_action( 'init', 'wp_sitemaps_get_server' );

WordPress Sitemap anpassen

Sinnvoller erscheint die Möglichkeit, die Sitemap nach eigenen Wünschen anzupassen. Um die Autoren- und Benutzer-Archive für deine WordPress-Sitemap zu deaktivieren kannst du folgende Zeilen nutzen:

/* sitemap - disable user-sitemap */
function dwp_disable_sitemap_users($provider, $name) {
    return ($name == 'users') ? false : $provider;
}
add_filter('wp_sitemaps_add_provider', 'dwp_disable_sitemap_users', 10, 2);

• Nur in wenigen Fällen wird es sinnvoll sein, die einzelnen Kategorien (Taxonomies) über eine Sitemap zu senden. Daher kannst du diese über folgende Zeilen deaktivieren.

/* sitemap - disable taxonomies */
add_filter(
	'wp_sitemaps_taxonomies',
	function( $taxonomies ) {
		unset( $taxonomies['post_tag'] );
        unset( $taxonomies['product_cat'] );
		unset( $taxonomies['product_shipping_class'] );
		return $taxonomies;
	}
);

An der Stelle „post_tag“ musst du eventuell Änderungen vornehmen. Beispielsweise, wenn in einem WooCommerce die Produkt-Kategorien ausgeschlossen werden sollen. Gibt es bei dir einen Eintrag: wp-sitemap-taxonomies-product_tag.xml wird dieser via „product_tag“ deaktiviert.

• Um bestimmte Seiten von der WordPress-Sitemap auszuschließen kannst du bei diesem Beispiel die gewünschte ID (hier: 75) eintragen:

/* sitemap - disable pages */
function dwp_disable_sitemap_specific_page($args, $post_type) {
	if ('page' !== $post_type) return $args;
	$args['post__not_in'] = isset($args['post__not_in']) ? $args['post__not_in'] : array();
	$args['post__not_in'][] = 75; // exclude page with ID = 75
	return $args;
}
add_filter('wp_sitemaps_posts_query_args', 'dwp_disable_sitemap_specific_page', 10, 2);

• Um individuelle Beiträge von der WordPress-Sitemap auszuschließen, kannst du ebenfalls die gewünschte ID (hier: 1) eintragen:

/* sitemap - disable posts */
function dwp_disable_sitemap_specific_post($args, $post_type) {
	if ('post' !== $post_type) return $args;
	$args['post__not_in'] = isset($args['post__not_in']) ? $args['post__not_in'] : array();
	$args['post__not_in'][] = 1; // exclude post with ID = 1
	return $args;
}
add_filter('wp_sitemaps_posts_query_args', 'dwp_disable_sitemap_specific_post', 10, 2);

Die ID erhältst du, indem du im Backend über den Inhalt hoverst. WordPress zeigt die in dem Fall die interne ID in Form von post.php?post=400 an.

Solltest du mehr als eine Seite oder einen Beitrag deaktivieren wollen, dupliziere einfach die markierte Zeile mit der ID und trage die weitere ID ein. Beachte bitte, dass im Beispiel der Seiten „page“ genutzt wird, während für die Blogbeiträge „post“ genutzt wird.

Ausschluss einzelner Seiten/Beiträge/Produkte aus der Yoast-Sitemap?

Um einen Seite oder anderem Posttyp wie Produkte (ggf. in Yoast-Einstellungen zu aktivieren) aus der Sitemap des Yoast-SEO-Plugin auszuschließen, kannst du die Einstellungen bequem im Backend deiner Seite treffen. Wechsele dazu auf deine auszuschließende Seite (bearbeitungs-Ansicht im Backend) und gehe in den Bereich von Yoast SEO.

Das „Yoast SEO“ Element, befindet sich in der Regel direkt unter deinem Editor. Falls du dieses Element nicht siehst, kannst du ganz oben-rechts auf „Ansicht anpassen“ gehen und findest dort die Einstellungen für deine „Bildschirm-Elemente“ innerhalb deines Profils. Hier einfach bei „Yoast Seo“ den Haken setzen, fertig. Nun ist der Bereich für dich in der Bearbeitungs-Ansicht aktiviert.

Im Element von Yoast SEO findest du im Tab „SEO“ den Abschnitt „Advanced“ oder „Erweitert“ und kannst die Einstellung für die Anzeige in den Suchergebnissen treffen. Sobald hier „No“ oder „Nein“ eingestellt ist, findet sich diese Seite auch nicht mehr in deiner Yoast-Sitemap wieder. Dies am besten noch einmal gegenprüfen, um wirklich sicher zu sein.

Und das war es auch schon. Keine manuellen Codezeilen nötig, wenn du bei deiner Seite ein Yoast-SEO-Plugin aktiviert hast und die entsprechenden Einstellungen kennst.

Update 14.07.2021 – Ergänzung Yoast SEO Plugin – Ausschließen von Seiten innerhalb der Sitemap

Update 30.08.2021 – Weitere Erklärungen eingefügt

Der Beitrag Sitemaps in WordPress steuern erschien zuerst auf deinWP.de.

Hier kommt die einfache aber sichere Lösung für dich: Wir geben einfach jedem Block per CSS einen kleinen Rahmen. Sobald du dann mit der Maus darüber fährst, erscheint dieser Rahmen und so siehst du beim Bearbeiten genau wo du dich befindest und welchen Block du im Gutenberg anwählst. Keine umständliche Suche mehr, nach dem richtigen Element, durch mehr Sichtbarkeit des gewünschten Block.

Doch was ist dafür nötig? Das erfährst du nun!

Zu aller erst erstellen wir die Grundlage, damit wir unser eigenes CSS für das Backend im Gutenberg auch sehen. Dazu fügst du in deiner „functions.php“ des (Child-)Themes folgendem Code-Schnipsel hinzu.

/* Gutenberg Stylings im Backend */
function dwp_gutenberg_styles() {
	wp_enqueue_style( 'gutenberg-css', get_theme_file_uri( '/gutenberg.css' ), false );
}
add_action( 'enqueue_block_editor_assets', 'dwp_gutenberg_styles' );

Dieser Code lädt den Inhalt der Datei „gutenberg.css„, welche wir nutzen, um deinen Gutenberg-Editor um eigene Stylings zu erweitern. Nun erstellst du im Ordner deines Child-Themes eine weitere Datei und nennst diese „gutenberg.css„. Für die angesprochene Problematik fügst du nun folgenden Zeilen ein.

/* Rahmen für Gutenberg-Blöcke */
.wp-block:hover {
    box-shadow: 0 0 0 1.5px #d7d7d7;
}

Mit diesen Zeilen erhältst du beim hovern über deine Blöcke einen kleinen Rahmen, damit du besser siehst wo du dich befindest. Hier ein kleines Beispiel, wie es bei dir aussehen kann:

Von nun an kannst du mit der gutenberg.css auch weitere Anpassungen für dein Backend-Editor erstellen. Von der Breite des Editors selbst bis hin zu eigenen Klassen, die z.B. deine Schrift in der Darstellung anpassen, damit du diese schon beim bearbeiten im gleichen Stil, wie auch im Frontend siehst. Doch dazu später mehr.

Der Beitrag Gutenberg – Blöcke besser erkennen erschien zuerst auf deinWP.de.