25 WordPress-Snippets plus 5 Bonus-Einstellungen für wp-config.php

WordPress-Snippets ergänzen gezielt Funktionen, ohne dass Du dafür ein eigenes Plugin entwickeln musst. In dieser Sammlung findest Du 25 PHP-Snippets für Frontend und Backend. Als Bonus folgen fünf getrennte Einstellungen für die Datei wp-config.php. Jeder Codeschnipsel nennt den richtigen Einbauort, seinen konkreten Zweck und wichtige Grenzen.

Du musst die Liste nicht von oben nach unten abarbeiten. Springe direkt zu der Funktion, die Du benötigst. Mir ist dabei wichtiger, dass Du Einbauort, Wirkung und Grenzen kennst, als dass Du möglichst viele Snippets gleichzeitig aktivierst. Erstelle vorher ein aktuelles WordPress-Backup und teste umfangreichere Änderungen zuerst in einer lokalen Installation oder Staging-Umgebung.

Wo fügst Du WordPress-Snippets ein?

Art des Codes	Geeigneter Einbauort	Wichtiger Hinweis
PHP mit add_action(), add_filter() oder add_shortcode()	Code Snippets, Mini-Plugin oder Child-Theme	Im Plugin Code Snippets kein führendes <?php einfügen
Themeabhängiger PHP-Code	Child-Theme oder Code Snippets	Nach einem Themewechsel Funktion und Hook erneut prüfen
Konstanten wie WP_POST_REVISIONS	wp-config.php	Vor der Zeile mit dem Bearbeitungsstopp einfügen
Serverregeln, HSTS, CSP oder IP-Sperren	Hosting, Webserver, Firewall oder Sicherheitsplugin	Keine pauschalen PHP-Kopiervorlagen verwenden

Das kostenlose Plugin Code Snippets ermöglicht das getrennte Aktivieren und Deaktivieren der Beispiele. In der functions.php bleibt fehlerhafter Code dagegen aktiv, bis Du die Datei korrigierst. Bei einem Themewechsel geht eine Änderung im Parent-Theme außerdem verloren.

So gehst Du zurück: Ein PHP-Snippet deaktivierst Du im Snippet-Plugin oder entfernst es aus Deinem Child-Theme. Bei einer Einstellung in wp-config.php stellst Du den vorherigen Wert wieder her oder entfernst die neu eingefügte Zeile. Manche Beispiele erzeugen gespeicherte Zählerstände oder zusätzliche Bilddateien. Solche verbleibenden Daten nenne ich direkt beim jeweiligen Snippet.

Wenn Du ohne Risiko experimentieren möchtest, kannst Du WordPress lokal unter Windows installieren. Weitere Funktionen, die WordPress bereits mitbringt, findest Du in meinem Leitfaden zu oft übersehenen WordPress-Funktionen.

WordPress-Snippets für Frontend und Inhalte

Beginne hier, wenn Du sichtbare Ausgaben, Textinformationen oder die Auswahl von Beiträgen verändern möchtest. Die ersten Beispiele greifen überwiegend über dokumentierte Filter und Shortcodes ein.

1. Länge automatischer Textauszüge ändern

Der Filter excerpt_length steuert die maximale Wortzahl automatisch erzeugter Auszüge. Manuell gepflegte Auszüge werden dadurch nicht gekürzt. Das Beispiel setzt die Länge im Frontend auf 30 Wörter.

function dwf25_excerpt_length( $length ) {
    if ( is_admin() ) {
        return $length;
    }

    return 30;
}
add_filter( 'excerpt_length', 'dwf25_excerpt_length', 999 );

Nach dem Deaktivieren verwendet WordPress wieder die vom Core oder Theme vorgegebene Länge. Grundlage ist der offizielle Filter excerpt_length.

2. Zeichen am Ende automatischer Auszüge ändern

Dieses Beispiel ersetzt die WordPress-Standardausgabe am Ende eines automatisch gekürzten Textauszugs durch ein Auslassungszeichen. Es erzeugt keinen Weiterlesen-Button.

function dwf25_excerpt_more( $more ) {
    return ' …';
}
add_filter( 'excerpt_more', 'dwf25_excerpt_more' );

Der Filter greift nur bei automatisch erzeugten Auszügen. Die Funktionsweise beschreibt die WordPress-Dokumentation zum Filter excerpt_more.

3. Aktuelle Beiträge mit einem Shortcode ausgeben

Der Shortcode [aktuelle_beitraege] erzeugt eine Liste der fünf neuesten veröffentlichten Beiträge. Mit [aktuelle_beitraege anzahl="8"] kannst Du zwischen einem und zehn Einträgen ausgeben.

function dwf25_recent_posts_shortcode( $atts ) {
    $atts = shortcode_atts(
        array(
            'anzahl' => 5,
        ),
        $atts,
        'aktuelle_beitraege'
    );

    $anzahl = min( 10, max( 1, absint( $atts['anzahl'] ) ) );
    $query  = new WP_Query(
        array(
            'post_type'           => 'post',
            'post_status'         => 'publish',
            'posts_per_page'      => $anzahl,
            'ignore_sticky_posts' => true,
            'no_found_rows'       => true,
        )
    );

    if ( ! $query->have_posts() ) {
        return '<p>Keine Beiträge gefunden.</p>';
    }

    $html = '<ul class="dwf-aktuelle-beitraege">';

    while ( $query->have_posts() ) {
        $query->the_post();
        $html .= sprintf(
            '<li><a href="%1$s">%2$s</a></li>',
            esc_url( get_permalink() ),
            esc_html( get_the_title() )
        );
    }

    wp_reset_postdata();

    return $html . '</ul>';
}
add_shortcode( 'aktuelle_beitraege', 'dwf25_recent_posts_shortcode' );

Die Callback-Funktion gibt das HTML mit return zurück. Direktes echo kann Shortcode-Inhalte an einer falschen Stelle ausgeben. Diese Vorgabe findest Du in der offiziellen Dokumentation zu add_shortcode().

4. Geschätzte Lesezeit mit Unicode-Wortzählung anzeigen

Der Shortcode [lesezeit] zählt Buchstaben und Zahlen mit einem Unicode-fähigen regulären Ausdruck. Dadurch werden deutschsprachige Wörter mit Umlauten zuverlässiger erfasst als mit str_word_count(). Das Beispiel rechnet mit 200 Wörtern pro Minute.

function dwf25_reading_time_shortcode() {
    if ( ! is_singular() ) {
        return '';
    }

    $post = get_post();

    if ( ! $post instanceof WP_Post ) {
        return '';
    }

    $text  = wp_strip_all_tags( strip_shortcodes( $post->post_content ) );
    $count = preg_match_all(
        '/[\p{L}\p{N}]+(?:[’\'\-][\p{L}\p{N}]+)*/u',
        $text,
        $matches
    );

    if ( false === $count ) {
        return '';
    }

    $minutes = max( 1, (int) ceil( $count / 200 ) );

    if ( 1 === $minutes ) {
        return '1 Minute Lesezeit';
    }

    return number_format_i18n( $minutes ) . ' Minuten Lesezeit';
}
add_shortcode( 'lesezeit', 'dwf25_reading_time_shortcode' );

Die Berechnung bleibt eine Schätzung. Bilder, Tabellen, Videos und die individuelle Lesegeschwindigkeit werden nicht berücksichtigt. Eine umfangreichere Umsetzung findest Du in meiner Anleitung zur Lesezeit-Anzeige in WordPress.

5. Letztes Aktualisierungsdatum per Shortcode ausgeben

Mit [letzte_aenderung] gibst Du das WordPress-Änderungsdatum des aktuellen Beitrags als semantisches time-Element aus.

function dwf25_last_modified_shortcode() {
    if ( ! is_singular() ) {
        return '';
    }

    $date_display = get_the_modified_date( get_option( 'date_format' ) );
    $date_machine = get_the_modified_date( DATE_W3C );

    if ( ! $date_display || ! $date_machine ) {
        return '';
    }

    return sprintf(
        '<time datetime="%1$s">Zuletzt aktualisiert: %2$s</time>',
        esc_attr( $date_machine ),
        esc_html( $date_display )
    );
}
add_shortcode( 'letzte_aenderung', 'dwf25_last_modified_shortcode' );

Das sichtbare Datum sollte mit der tatsächlichen redaktionellen Aktualisierung übereinstimmen. Speichere einen Beitrag nicht allein deshalb neu, um ein aktuelleres Datum anzuzeigen.

6. Aktuelles Jahr mit einem Shortcode einfügen

Der Shortcode [aktuelles_jahr] verwendet die in WordPress konfigurierte Zeitzone. Er eignet sich für einfache Jahresangaben in wiederverwendbaren Inhalten.

function dwf25_current_year_shortcode() {
    return esc_html( wp_date( 'Y' ) );
}
add_shortcode( 'aktuelles_jahr', 'dwf25_current_year_shortcode' );

Für rechtliche Angaben solltest Du trotzdem kontrollieren, ob die vollständige Formulierung zu Deiner Website passt.

7. Copyright-Text in GeneratePress ändern

GeneratePress stellt für den Copyright-Bereich den Filter generate_copyright bereit. Das Beispiel gibt das aktuelle Jahr und den unter Einstellungen > Allgemein hinterlegten Websitenamen aus.

function dwf25_generatepress_copyright() {
    return sprintf(
        '© %1$s %2$s',
        esc_html( wp_date( 'Y' ) ),
        esc_html( get_bloginfo( 'name' ) )
    );
}
add_filter( 'generate_copyright', 'dwf25_generatepress_copyright' );

Dieses Snippet ist nur für GeneratePress bestimmt. Der Filter ist in der GeneratePress-Dokumentation beschrieben. Wenn Du GeneratePress Premium verwendest, kannst Du den Text auch über die Theme-Einstellungen pflegen. Weitere Varianten findest Du in meiner Anleitung zum Copyright-Text in GeneratePress.

8. CSS-Klasse für angemeldete und abgemeldete Besucher ergänzen

Mit einer zusätzlichen Klasse am body-Element kannst Du Inhalte abhängig vom Anmeldestatus gestalten. Das Snippet speichert keine personenbezogenen Daten.

function dwf25_login_status_body_class( $classes ) {
    $classes[] = is_user_logged_in() ? 'dwf-angemeldet' : 'dwf-abgemeldet';

    return $classes;
}
add_filter( 'body_class', 'dwf25_login_status_body_class' );

Die Klasse allein blendet nichts ein oder aus. Dafür benötigst Du zusätzlich eigenes CSS. Verstecke damit keine vertraulichen Informationen, denn CSS ist keine Zugriffskontrolle.

9. Bestimmte Inhalte aus der WordPress-Suche ausschließen

Das Beispiel entfernt ausgewählte Beiträge oder Seiten aus der internen WordPress-Suche. Ersetze die IDs 123 und 456 durch die gewünschten WordPress-IDs.

function dwf25_exclude_content_from_search( $query ) {
    if ( is_admin() || ! $query->is_main_query() || ! $query->is_search() ) {
        return;
    }

    $excluded_ids = array( 123, 456 );
    $existing_ids = (array) $query->get( 'post__not_in' );
    $all_ids      = array_merge( $existing_ids, $excluded_ids );
    $all_ids      = array_values( array_unique( array_map( 'absint', $all_ids ) ) );

    $query->set( 'post__not_in', $all_ids );
}
add_action( 'pre_get_posts', 'dwf25_exclude_content_from_search' );

Das Snippet wirkt nur auf die interne Suchergebnisseite. Es setzt kein noindex und entfernt die URLs nicht aus Google.

10. Verwandte Beiträge nach Kategorien und Schlagwörtern ausgeben

Der Shortcode [verwandte_beitraege] sucht bis zu drei Beiträge, die mindestens eine Kategorie oder ein Schlagwort mit dem aktuellen Beitrag teilen. Der aktuelle Beitrag wird ausgeschlossen.

function dwf25_related_posts_shortcode() {
    if ( ! is_singular( 'post' ) ) {
        return '';
    }

    $post_id      = get_queried_object_id();
    $category_ids = wp_get_post_categories( $post_id );
    $tag_ids      = wp_get_post_tags( $post_id, array( 'fields' => 'ids' ) );
    $tax_query    = array( 'relation' => 'OR' );

    if ( $category_ids ) {
        $tax_query[] = array(
            'taxonomy' => 'category',
            'field'    => 'term_id',
            'terms'    => array_map( 'absint', $category_ids ),
        );
    }

    if ( $tag_ids ) {
        $tax_query[] = array(
            'taxonomy' => 'post_tag',
            'field'    => 'term_id',
            'terms'    => array_map( 'absint', $tag_ids ),
        );
    }

    if ( 1 === count( $tax_query ) ) {
        return '';
    }

    $query = new WP_Query(
        array(
            'post_type'              => 'post',
            'post_status'            => 'publish',
            'posts_per_page'         => 3,
            'post__not_in'           => array( $post_id ),
            'ignore_sticky_posts'    => true,
            'no_found_rows'          => true,
            'update_post_meta_cache' => false,
            'update_post_term_cache' => false,
            'tax_query'              => $tax_query,
        )
    );

    if ( ! $query->have_posts() ) {
        return '';
    }

    $html = '<ul class="dwf-verwandte-beitraege">';

    while ( $query->have_posts() ) {
        $query->the_post();
        $html .= sprintf(
            '<li><a href="%1$s">%2$s</a></li>',
            esc_url( get_permalink() ),
            esc_html( get_the_title() )
        );
    }

    wp_reset_postdata();

    return $html . '</ul>';
}
add_shortcode( 'verwandte_beitraege', 'dwf25_related_posts_shortcode' );

Bei umfangreichen Websites benötigst Du eventuell eine feinere Relevanzlogik oder Caching. Eine ausführliche Variante mit Anpassungsmöglichkeiten findest Du in meiner Anleitung zu Related Posts ohne Plugin.

WordPress-Snippets für Adminbereich und Verwaltung

Die nächsten Beispiele verändern Arbeitsabläufe im Backend. Prüfe deshalb immer auch ein Konto ohne Administratorrechte, wenn ein Snippet Rollen, Spalten oder Dashboard-Bereiche betrifft.

11. Self-Pingbacks der eigenen Domain verhindern

WordPress kann beim internen Verlinken einen Pingback an die eigene Website senden. Das Snippet entfernt vor dem Versand alle Links, deren Hostname mit dem Hostnamen Deiner WordPress-Startseite übereinstimmt. Externe Pingbacks bleiben unberührt.

function dwf25_disable_self_pingbacks( &$links ) {
    $home_host = wp_parse_url( home_url(), PHP_URL_HOST );

    if ( ! $home_host ) {
        return;
    }

    foreach ( $links as $key => $link ) {
        $link_host = wp_parse_url( $link, PHP_URL_HOST );

        if ( $home_host === $link_host ) {
            unset( $links[ $key ] );
        }
    }
}
add_action( 'pre_ping', 'dwf25_disable_self_pingbacks' );

Nach dem Deaktivieren kann WordPress wieder Self-Pingbacks versenden. Bereits vorhandene Pingbacks werden dadurch nicht gelöscht.

12. Klassischen Widget-Editor wieder aktivieren

Bei einem klassischen Theme mit Widget-Bereichen schaltet dieser Filter den blockbasierten Widget-Editor ab. Die bisherige Widget-Oberfläche wird wieder verwendet.

function dwf25_disable_widgets_block_editor() {
    return false;
}
add_filter( 'use_widgets_block_editor', 'dwf25_disable_widgets_block_editor' );

Das Snippet ersetzt den Website-Editor eines Block-Themes nicht. Deaktiviere es, sobald Du wieder den blockbasierten Widget-Editor verwenden möchtest.

13. Systeminformationen nur Administratoren anzeigen

Das Dashboard-Widget zeigt WordPress-Version, PHP-Version und aktives Theme. Die Ausgabe ist auf Benutzer mit der Berechtigung manage_options begrenzt.

function dwf25_add_system_info_widget() {
    if ( ! current_user_can( 'manage_options' ) ) {
        return;
    }

    wp_add_dashboard_widget(
        'dwf-system-info',
        'Systeminformationen',
        'dwf25_render_system_info_widget'
    );
}
add_action( 'wp_dashboard_setup', 'dwf25_add_system_info_widget' );

function dwf25_render_system_info_widget() {
    if ( ! current_user_can( 'manage_options' ) ) {
        return;
    }

    $theme = wp_get_theme();

    echo '<ul>';
    echo '<li><strong>WordPress:</strong> ' . esc_html( get_bloginfo( 'version' ) ) . '</li>';
    echo '<li><strong>PHP:</strong> ' . esc_html( PHP_VERSION ) . '</li>';
    echo '<li><strong>Theme:</strong> ' . esc_html( $theme->get( 'Name' ) ) . ' ' . esc_html( $theme->get( 'Version' ) ) . '</li>';
    echo '</ul>';
}

Das Widget zeigt bewusst keine IP-Adresse, Serverkennung oder Datenbankzugangsdaten. Solche Informationen gehören nicht in eine allgemeine Dashboard-Ausgabe.

14. Erlaubte Dateiendungen und MIME-Typen anzeigen

Das Snippet ergänzt unter Werkzeuge > Erlaubte Dateitypen eine read-only Übersicht. WordPress verwaltet Dateiendungen teilweise als reguläre Ausdrücke, zum Beispiel mehrere JPEG-Endungen in einem gemeinsamen Schlüssel.

function dwf25_register_mime_types_page() {
    add_management_page(
        'Erlaubte Dateitypen',
        'Erlaubte Dateitypen',
        'manage_options',
        'dwf-mime-types',
        'dwf25_render_mime_types_page'
    );
}
add_action( 'admin_menu', 'dwf25_register_mime_types_page' );

function dwf25_render_mime_types_page() {
    if ( ! current_user_can( 'manage_options' ) ) {
        wp_die( esc_html__( 'Keine Berechtigung.', 'dwf-snippets' ) );
    }

    $mime_types = get_allowed_mime_types();
    ksort( $mime_types );

    echo '<div class="wrap">';
    echo '<h1>Erlaubte Dateitypen</h1>';
    echo '<table class="widefat striped">';
    echo '<thead><tr><th>Dateiendung oder Muster</th><th>MIME-Typ</th></tr></thead><tbody>';

    foreach ( $mime_types as $extension => $mime_type ) {
        echo '<tr><td>' . esc_html( $extension ) . '</td><td>' . esc_html( $mime_type ) . '</td></tr>';
    }

    echo '</tbody></table></div>';
}

Die Seite verändert keine Upload-Regeln. WordPress beschreibt das Format des MIME-Arrays in der Dokumentation zum Filter upload_mimes.

15. Beiträge und Seiten mit Nonce- und Rechteprüfung duplizieren

Das Snippet ergänzt in den Übersichten für Beiträge und Seiten den Link Duplizieren. Die Aktion prüft eine Nonce und die Berechtigung zum Bearbeiten des Originals. Kopiert werden Inhalt, Auszug, Beitragsbild, Seitentemplate und zugeordnete Taxonomien. Andere Plugin-Metadaten werden bewusst nicht pauschal übernommen.

function dwf25_add_duplicate_post_link( $actions, $post ) {
    $allowed_types = array( 'post', 'page' );

    if ( ! in_array( $post->post_type, $allowed_types, true ) ) {
        return $actions;
    }

    if ( ! current_user_can( 'edit_post', $post->ID ) ) {
        return $actions;
    }

    $url = add_query_arg(
        array(
            'action' => 'dwf25_duplicate_post',
            'post'   => $post->ID,
        ),
        admin_url( 'admin-post.php' )
    );

    $url = wp_nonce_url( $url, 'dwf25_duplicate_post_' . $post->ID );

    $actions['dwf25_duplicate'] = sprintf(
        '<a href="%1$s">%2$s</a>',
        esc_url( $url ),
        esc_html__( 'Duplizieren', 'dwf-snippets' )
    );

    return $actions;
}
add_filter( 'post_row_actions', 'dwf25_add_duplicate_post_link', 10, 2 );
add_filter( 'page_row_actions', 'dwf25_add_duplicate_post_link', 10, 2 );

function dwf25_handle_duplicate_post() {
    $post_id = isset( $_GET['post'] ) ? absint( wp_unslash( $_GET['post'] ) ) : 0;

    if ( ! $post_id ) {
        wp_die( esc_html__( 'Ungültige Beitrags-ID.', 'dwf-snippets' ) );
    }

    check_admin_referer( 'dwf25_duplicate_post_' . $post_id );

    if ( ! current_user_can( 'edit_post', $post_id ) ) {
        wp_die( esc_html__( 'Du darfst diesen Inhalt nicht duplizieren.', 'dwf-snippets' ) );
    }

    $post          = get_post( $post_id );
    $allowed_types = array( 'post', 'page' );

    if ( ! $post instanceof WP_Post || ! in_array( $post->post_type, $allowed_types, true ) ) {
        wp_die( esc_html__( 'Beitrag oder Seite nicht gefunden.', 'dwf-snippets' ) );
    }

    $new_post_id = wp_insert_post(
        array(
            'post_type'      => $post->post_type,
            'post_status'    => 'draft',
            'post_title'     => $post->post_title . ' (Kopie)',
            'post_content'   => $post->post_content,
            'post_excerpt'   => $post->post_excerpt,
            'post_author'    => get_current_user_id(),
            'post_parent'    => $post->post_parent,
            'menu_order'     => $post->menu_order,
            'comment_status' => $post->comment_status,
            'ping_status'    => $post->ping_status,
        ),
        true
    );

    if ( is_wp_error( $new_post_id ) ) {
        wp_die( esc_html( $new_post_id->get_error_message() ) );
    }

    $taxonomies = get_object_taxonomies( $post->post_type );

    foreach ( $taxonomies as $taxonomy ) {
        $term_ids = wp_get_object_terms(
            $post_id,
            $taxonomy,
            array( 'fields' => 'ids' )
        );

        if ( ! is_wp_error( $term_ids ) ) {
            wp_set_object_terms( $new_post_id, $term_ids, $taxonomy, false );
        }
    }

    $meta_keys = array( '_thumbnail_id', '_wp_page_template' );

    foreach ( $meta_keys as $meta_key ) {
        $values = get_post_meta( $post_id, $meta_key, false );

        foreach ( $values as $value ) {
            add_post_meta( $new_post_id, $meta_key, maybe_unserialize( $value ) );
        }
    }

    $edit_url = get_edit_post_link( $new_post_id, 'raw' );

    wp_safe_redirect( $edit_url ? $edit_url : admin_url( 'edit.php' ) );
    exit;
}
add_action( 'admin_post_dwf25_duplicate_post', 'dwf25_handle_duplicate_post' );

Die Nonce verhindert bestimmte missbräuchliche Aufrufe, ersetzt aber keine Rechteprüfung. WordPress verlangt beide Kontrollen. Siehe WordPress Nonces und Checking User Capabilities.

16. Staging- und Entwicklungsumgebung im Backend kennzeichnen

Wenn WP_ENVIRONMENT_TYPE auf local, development oder staging gesetzt ist, zeigt das Snippet Administratoren einen Hinweis im Backend. Bei production bleibt die Ausgabe aus.

function dwf25_environment_admin_notice() {
    if ( ! current_user_can( 'manage_options' ) ) {
        return;
    }

    $environment = wp_get_environment_type();

    if ( 'production' === $environment ) {
        return;
    }

    printf(
        '<div class="notice notice-warning"><p>%s</p></div>',
        esc_html(
            sprintf(
                'Hinweis: Diese WordPress-Installation verwendet den Umgebungstyp %s.',
                $environment
            )
        )
    );
}
add_action( 'admin_notices', 'dwf25_environment_admin_notice' );

Wenn keine Umgebung definiert ist, verwendet WordPress den Typ production. Der Hinweis allein verhindert keine Veröffentlichung und ist kein Zugriffsschutz.

17. Änderungsdatum als sortierbare Beitragsspalte anzeigen

Das Beispiel ergänzt unter Beiträge > Alle Beiträge eine Spalte mit dem letzten WordPress-Änderungszeitpunkt. Ein Klick auf die Spaltenüberschrift sortiert nach diesem Wert.

function dwf25_add_modified_column( $columns ) {
    $columns['dwf25_modified'] = 'Geändert';

    return $columns;
}
add_filter( 'manage_post_posts_columns', 'dwf25_add_modified_column' );

function dwf25_render_modified_column( $column, $post_id ) {
    if ( 'dwf25_modified' !== $column ) {
        return;
    }

    $format = get_option( 'date_format' ) . ' ' . get_option( 'time_format' );

    echo esc_html( get_post_modified_time( $format, false, $post_id, true ) );
}
add_action( 'manage_post_posts_custom_column', 'dwf25_render_modified_column', 10, 2 );

function dwf25_make_modified_column_sortable( $columns ) {
    $columns['dwf25_modified'] = 'modified';

    return $columns;
}
add_filter( 'manage_edit-post_sortable_columns', 'dwf25_make_modified_column_sortable' );

Eine umfangreichere Fassung mit Beitragsbild, Wortanzahl und Lesezeit findest Du in meiner Anleitung zum Anpassen der WordPress-Beitragsübersicht.

18. Dashboard-Widgets für Redakteure ausblenden

Das Snippet entfernt ausgewählte Standard-Widgets für Benutzer ohne manage_options. Administratoren sehen ihr vollständiges Dashboard weiterhin.

function dwf25_remove_dashboard_widgets_for_editors() {
    if ( current_user_can( 'manage_options' ) ) {
        return;
    }

    remove_meta_box( 'dashboard_quick_press', 'dashboard', 'side' );
    remove_meta_box( 'dashboard_primary', 'dashboard', 'side' );
    remove_meta_box( 'dashboard_activity', 'dashboard', 'normal' );
}
add_action( 'wp_dashboard_setup', 'dwf25_remove_dashboard_widgets_for_editors' );

Das Entfernen eines Widgets entzieht keine Berechtigung. Benutzerrollen und Capabilities müssen separat konfiguriert werden.

19. Text im WordPress-Admin-Footer anpassen

Mit dem Filter admin_footer_text ersetzt Du den linken Standardtext im WordPress-Backend. Das Beispiel verwendet automatisch den Websitenamen.

function dwf25_custom_admin_footer_text( $text ) {
    return sprintf(
        'Verwaltung von %s',
        esc_html( get_bloginfo( 'name' ) )
    );
}
add_filter( 'admin_footer_text', 'dwf25_custom_admin_footer_text' );

Nach dem Deaktivieren verwendet WordPress wieder den vorherigen Footertext.

20. Vage Fehlermeldung bei gescheiterter Anmeldung anzeigen

WordPress kann bei einer fehlgeschlagenen Anmeldung unterschiedliche Hinweise ausgeben. Dieses Snippet ersetzt sie durch eine einheitliche Meldung.

function dwf25_generic_login_error_message() {
    return 'Anmeldung nicht möglich. Bitte prüfe Deine Zugangsdaten.';
}
add_filter( 'login_errors', 'dwf25_generic_login_error_message' );

Das Snippet begrenzt keine Anmeldeversuche und ersetzt keine Firewall oder Zwei-Faktor-Authentifizierung. Für den praktischen Schutz findest Du die passenden Einstellungen in meiner Anleitung zum Einrichten von Wordfence.

Weitere praktische WordPress-Snippets

Zum Abschluss der PHP-Sammlung folgen fünf Aufgaben, die häufig etwas mehr Erklärung benötigen. Beim Aufrufzähler und bei zusätzlichen Bildgrößen bleiben gespeicherte Daten beziehungsweise Dateien auch nach dem Deaktivieren erhalten.

21. Beitragsaufrufe mit post_views_count annähernd zählen

Dieses Snippet erhöht bei einem nicht angemeldeten Aufruf eines einzelnen Beitrags den Metawert post_views_count. Mit dem Shortcode [post-views] gibst Du den gespeicherten Wert aus. Das Snippet selbst setzt kein Cookie und speichert keine IP-Adresse.

function dwf25_count_post_views() {
    if (
        ! is_singular( 'post' )
        || is_preview()
        || is_feed()
        || is_embed()
        || is_user_logged_in()
    ) {
        return;
    }

    $post_id = get_queried_object_id();

    if ( ! $post_id ) {
        return;
    }

    $count = (int) get_post_meta( $post_id, 'post_views_count', true );
    update_post_meta( $post_id, 'post_views_count', $count + 1 );
}
add_action( 'template_redirect', 'dwf25_count_post_views' );

function dwf25_post_views_shortcode() {
    if ( ! is_singular( 'post' ) ) {
        return '';
    }

    $count = (int) get_post_meta(
        get_queried_object_id(),
        'post_views_count',
        true
    );

    $label = 1 === $count ? ' Aufruf' : ' Aufrufe';

    return sprintf(
        '<span class="dwf-post-views">%s</span>',
        esc_html( number_format_i18n( $count ) . $label )
    );
}
add_shortcode( 'post-views', 'dwf25_post_views_shortcode' );

Der Wert ist eine Annäherung und keine belastbare Webanalyse. Bots und wiederholtes Aktualisieren können den Zähler erhöhen. Ein Seiten- oder CDN-Cache kann dagegen verhindern, dass PHP bei jedem Aufruf ausgeführt wird. Außerdem entsteht bei jedem ungecachten Aufruf eine Schreiboperation über update_post_meta(). Verwende das Snippet deshalb nicht zusammen mit einem anderen Aufrufzähler, der denselben Metaschlüssel benutzt.

Auf einem neuen Beitrag kann der Shortcode zunächst „0 Aufrufe“ anzeigen. Möchtest Du den Hinweis erst nach dem ersten gezählten Aufruf ausgeben, ergänze vor der Ausgabe eine Prüfung auf einen Wert größer als null.

Beim Deaktivieren bleibt der gespeicherte Metawert erhalten und wird nur nicht weiter erhöht. Möchtest Du statt Seitenaufrufen eine direkte Bewertung erfassen, findest Du in meinem WordPress Like Button eine datensparsame Alternative mit Backend-Statistik.

22. Werkzeugleiste für Benutzer ohne Administratorrechte ausblenden

Der Filter show_admin_bar steuert die Werkzeugleiste im Frontend. Das Beispiel lässt sie nur für Benutzer sichtbar, die über die Capability manage_options verfügen.

function dwf25_hide_admin_bar_for_non_admins( $show_admin_bar ) {
    if ( ! is_user_logged_in() ) {
        return $show_admin_bar;
    }

    return current_user_can( 'manage_options' )
        ? $show_admin_bar
        : false;
}
add_filter( 'show_admin_bar', 'dwf25_hide_admin_bar_for_non_admins', 20 );

Das Ausblenden entzieht keine Berechtigungen und verändert das WordPress-Backend nicht. Es betrifft ausschließlich die sichtbare Werkzeugleiste im Frontend. Grundlage ist der dokumentierte Filter show_admin_bar.

23. IDs in den Übersichten für Beiträge und Seiten anzeigen

Manche Shortcodes, Ausschlusslisten und API-Aufrufe benötigen eine Beitrags- oder Seiten-ID. Dieses Snippet ergänzt dafür eine sortierbare Spalte in beiden Übersichten.

function dwf25_add_id_column( $columns ) {
    $columns['dwf25_id'] = 'ID';
    return $columns;
}
add_filter( 'manage_post_posts_columns', 'dwf25_add_id_column' );
add_filter( 'manage_pages_columns', 'dwf25_add_id_column' );

function dwf25_render_id_column( $column_name, $post_id ) {
    if ( 'dwf25_id' !== $column_name ) {
        return;
    }

    echo esc_html( (string) absint( $post_id ) );
}
add_action( 'manage_post_posts_custom_column', 'dwf25_render_id_column', 10, 2 );
add_action( 'manage_pages_custom_column', 'dwf25_render_id_column', 10, 2 );

function dwf25_make_id_column_sortable( $columns ) {
    $columns['dwf25_id'] = 'ID';
    return $columns;
}
add_filter( 'manage_edit-post_sortable_columns', 'dwf25_make_id_column_sortable' );
add_filter( 'manage_edit-page_sortable_columns', 'dwf25_make_id_column_sortable' );

Die WordPress-Code-Referenz beschreibt die Spaltenfilter unter manage_posts_columns und die Ausgabe eigener Werte unter manage_posts_custom_column. Eine umfangreichere Beitragsübersicht mit Wortanzahl, Lesezeit und Bildern behandelst Du besser mit der bereits verlinkten Spezialanleitung.

24. Logo der WordPress-Anmeldeseite anpassen

Ersetze im Code zuerst die Beispieladresse durch die vollständige URL Deines Logos. Das Snippet tauscht das Hintergrundbild aus und verlinkt es mit Deiner Startseite.

function dwf25_custom_login_logo() {
    $logo_url = 'https://example.com/wp-content/uploads/mein-logo.png';

    $css = sprintf(
        'body.login h1 a{background-image:url("%s");background-size:contain;background-position:center;width:100%%;height:96px;}',
        esc_url( $logo_url )
    );

    wp_add_inline_style( 'login', $css );
}
add_action( 'login_enqueue_scripts', 'dwf25_custom_login_logo' );

function dwf25_custom_login_logo_url() {
    return home_url( '/' );
}
add_filter( 'login_headerurl', 'dwf25_custom_login_logo_url' );

function dwf25_custom_login_logo_text() {
    return get_bloginfo( 'name' );
}
add_filter( 'login_headertext', 'dwf25_custom_login_logo_text' );

Teste die Anmeldeseite anschließend in einem privaten Browserfenster. Die verwendeten Hooks sind login_enqueue_scripts, login_headerurl und login_headertext. Nach dem Deaktivieren erscheint wieder die zuvor verwendete Darstellung.

25. Eigene Bildgröße für neue Uploads registrieren

Das Beispiel registriert ein zugeschnittenes Querformat mit 640 × 360 Pixeln und macht es in der Medienauswahl verfügbar. Ändere Name und Maße, bevor Du das Snippet aktivierst.

function dwf25_register_landscape_image_size() {
    add_image_size( 'dwf25-landscape', 640, 360, true );
}
add_action( 'after_setup_theme', 'dwf25_register_landscape_image_size' );

function dwf25_add_landscape_image_size_name( $sizes ) {
    $sizes['dwf25-landscape'] = 'Querformat 640 × 360';
    return $sizes;
}
add_filter(
    'image_size_names_choose',
    'dwf25_add_landscape_image_size_name'
);

add_image_size() erzeugt die zusätzliche Variante grundsätzlich erst bei später hochgeladenen Bildern. Vorhandene Medien benötigen eine gezielte Neuerzeugung der Bildgrößen. Nach dem Deaktivieren entstehen keine neuen Varianten mehr. Bereits erzeugte Dateien werden dadurch nicht automatisch gelöscht. Der Filter image_size_names_choose ergänzt den lesbaren Namen in der Medienauswahl.

Bonus: 5 Einstellungen für wp-config.php

Diese fünf Einstellungen zählen bewusst nicht zu den 25 PHP-Snippets. Sie gehören weder in Code Snippets noch in die functions.php, sondern ausschließlich in die Datei wp-config.php. Füge sie oberhalb der Zeile mit dem Hinweis ein, dass die Bearbeitung beendet werden soll. Suche vorher nach einer bestehenden Definition derselben Konstante. Jede Konstante darf nur einmal definiert werden.

Bonus 1. WordPress Revisionen begrenzen

Mit WP_POST_REVISIONS legst Du fest, wie viele Revisionen WordPress pro Beitrag oder Seite aufbewahrt. Der Wert 10 erhält zehn frühere Fassungen.

define( 'WP_POST_REVISIONS', 10 );

Die Einstellung ist kein sofortiger Datenbankbereiniger. Sie steuert, wie viele Revisionen WordPress beim weiteren Speichern behält. Mit false würdest Du Revisionen vollständig deaktivieren. Das empfehle ich nicht, weil damit eine wichtige Wiederherstellungsmöglichkeit entfällt. Die zulässigen Werte dokumentiert WordPress im Abschnitt Post Revisions.

Bonus 2. Autosave-Intervall anpassen

WordPress speichert während der Bearbeitung automatisch Zwischenstände. Das Beispiel setzt den Abstand auf 180 Sekunden.

define( 'AUTOSAVE_INTERVAL', 180 );

Ein längeres Intervall reduziert die Häufigkeit, erhöht aber den möglichen Verlust bei einem Browserabsturz oder einer unterbrochenen Verbindung. Die WordPress-Dokumentation nennt 60 Sekunden als Standard.

Bonus 3. Theme- und Plugin-Datei-Editor deaktivieren

DISALLOW_FILE_EDIT entfernt die eingebauten Editoren für Theme- und Plugin-Dateien aus dem WordPress-Backend. Administratoren können Dateien dann weiterhin per Hosting, SFTP oder Deployment bearbeiten.

define( 'DISALLOW_FILE_EDIT', true );

Die Konstante verhindert keine Installation, Aktualisierung oder Deaktivierung von Plugins. Dafür gelten andere Berechtigungen und gegebenenfalls die weitergehende Konstante DISALLOW_FILE_MODS.

Bonus 4. Aufbewahrungsdauer des Papierkorbs festlegen

Mit EMPTY_TRASH_DAYS legst Du fest, nach wie vielen Tagen WordPress Inhalte aus dem Papierkorb endgültig löschen darf. Das Beispiel verwendet 14 Tage.

define( 'EMPTY_TRASH_DAYS', 14 );

Der Wert 0 deaktiviert den Papierkorb. Inhalte werden dann beim Löschen unmittelbar endgültig entfernt. Verwende deshalb einen positiven Wert und halte weiterhin unabhängige Backups vor.

Bonus 5. Debug-Log in einer Testumgebung aktivieren

Diese Konfiguration ist für eine lokale Installation oder Staging-Umgebung bestimmt. Fehler werden in wp-content/debug.log geschrieben und nicht im Frontend ausgegeben.

define( 'WP_ENVIRONMENT_TYPE', 'staging' );
define( 'WP_DEBUG', true );
define( 'WP_DEBUG_LOG', true );
define( 'WP_DEBUG_DISPLAY', false );
@ini_set( 'display_errors', 0 );

Der @-Operator folgt hier dem Beispiel der offiziellen WordPress-Debugging-Anleitung. Die WordPress-Coding-Standards raten von seinem pauschalen Einsatz in Plugin- und Theme-Code ab, weil er Diagnosemeldungen unterdrückt.

In Kombination mit Snippet 16 erscheint nach dem Setzen von WP_ENVIRONMENT_TYPE auf staging automatisch der dort konfigurierte Hinweis im WordPress-Backend.

Wichtig: Lasse das Debugging nicht dauerhaft auf einer produktiven Website aktiv. Protokolle können Pfade, Abfragen und andere sensible technische Angaben enthalten. Lösche die Logdatei nach der Fehlersuche und setze WP_DEBUG wieder auf false. Den vollständigen Ablauf erklärt mein Leitfaden zum WordPress Debugging mit Debug-Modus und debug.log.

Welche Sicherheitsaufgaben gehören nicht in eine Snippet-Sammlung?

Ein kurzes PHP-Beispiel ist nicht für jede Sicherheitsaufgabe geeignet. Die folgenden Funktionen solltest Du auf Server-, Hosting- oder Firewall-Ebene konfigurieren:

• IP-Sperren für wp-login.php: Eine PHP-Lösung greift erst, nachdem der Webserver und Teile von WordPress die Anfrage verarbeitet haben. Proxys und wechselnde IP-Adressen erschweren eine zuverlässige Erkennung.
• Begrenzung von Anmeldeversuchen: Sperren allein nach REMOTE_ADDR können mehrere Personen hinter derselben öffentlichen IP-Adresse gleichzeitig treffen.
• HSTS und CSP: HSTS mit includeSubDomains gilt für alle Subdomains. Eine Content Security Policy muss zu den tatsächlich geladenen Skripten, Styles, Bildern und externen Diensten passen.
• Pauschales Freischalten von Uploadformaten: Zusätzliche Dateitypen benötigen eine fachliche Prüfung von Dateiendung, MIME-Typ, Inhalt, Auslieferung und Benutzerrechten.

Der frühere Code dieser Seite setzte unter anderem X-XSS-Protection. Dieser Header ist laut MDN veraltet. Die Folgen von includeSubDomains und preload beschreibt die MDN-Dokumentation zu HSTS.

So testest Du ein WordPress-Snippet

Wenn Du Dir aus diesem Artikel nur eine Regel merkst, dann diese: Aktiviere neue Funktionen einzeln. So weißt Du bei einem Fehler, welche Änderung Du zurücknehmen musst.

1. Erstelle ein aktuelles Backup von Dateien und Datenbank.
2. Notiere, welche Datei oder welches Snippet Du veränderst.
3. Aktiviere immer nur ein neues Beispiel gleichzeitig.
4. Prüfe Frontend, Backend, Anmeldung, Formulare und betroffene Beitragstypen.
5. Kontrolliere bei Problemen debug.log und den PHP-Fehlerbericht Deines Hostings.
6. Deaktiviere das Snippet sofort, wenn Warnungen, Fehler oder unerwartete Seiteneffekte auftreten.
7. Leere danach nur die Caches, die Deine Website tatsächlich verwendet.

Ein fehlerfreier PHP-Syntaxtest ist nur der erste Schritt. Er erkennt keine falsche Berechtigungslogik, unpassende Hooks, problematische Datenbankabfragen oder Konflikte mit Deinem Theme und Deinen Plugins.

FAQ zu WordPress-Snippets

Fazit: kleine Funktionen gezielt und kontrolliert ergänzen

Die 25 WordPress-Snippets decken klar abgegrenzte Aufgaben in Frontend und Adminbereich ab. Die fünf Bonus-Einstellungen für wp-config.php sind davon bewusst getrennt. Meine Empfehlung: Wähle nur die Funktion aus, die Du gerade benötigst, und teste sie vollständig, bevor Du das nächste Snippet aktivierst.

Für Brute-Force-Schutz, IP-Regeln, Sicherheits-Header und komplexe Zugriffskontrollen verwendest Du eine dafür vorgesehene Firewall, eine Serverkonfiguration oder eine gepflegte Speziallösung. Kurze PHP-Beispiele sind dafür keine belastbare Grundlage.

Verwendete Primärquellen

• WordPress Plugin Handbook: Hooks
• WordPress Shortcode API
• WordPress Nonces
• WordPress: Checking User Capabilities
• WordPress: Sanitizing Data
• WordPress: Escaping Data
• WordPress: Editing wp-config.php
• WordPress: update_post_meta()
• WordPress: show_admin_bar
• WordPress: manage_posts_columns
• WordPress: login_enqueue_scripts
• WordPress: add_image_size()
• GeneratePress: generate_copyright