# WP Code Generator — Beispiele

> Konkrete Durchläufe mit dem WP Code Generator: Plugin-Header, ein Custom Hook, ein Gutenberg-Block, ein Theme-Snippet und mehr — Schritt für Schritt.

Source: https://www.jpkc.com/db/tools/wp/examples/

Zurück zur Übersicht: [WP Code Generator](https://www.jpkc.com/db/tools/wp/) · Tool live öffnen: [www.jpkc.com/tools/wp/](https://www.jpkc.com/tools/wp/)

Das [Manual](https://www.jpkc.com/db/tools/wp/manual/) beschreibt jeden Generator und seine Felder. Diese Seite ergänzt das um **konkrete Arbeitsabläufe**: typische Aufgaben, Schritt für Schritt durchgespielt, mit Blick darauf, welche Felder welchen Code erzeugen und was du danach damit machst. Die Oberfläche des Tools ist auf Englisch — die Generator- und Feld-Namen stehen deshalb in ihrer englischen Original-Schreibweise, bei Bedarf mit deutscher Erläuterung.

## Beispiel 1: Einen Plugin-Header erzeugen

Du startest ein neues Plugin und brauchst den korrekten Header plus eine Haupt-Klasse.

1. Öffne den [WP Code Generator](https://www.jpkc.com/tools/wp/) — der **Plugin**-Generator ist standardmäßig aktiv.
2. Tippe in *Plugin Name* etwa `My Awesome Plugin`. Beobachte, wie *Text Domain* automatisch zu `my-awesome-plugin` und *Namespace / Main Class* zu `MyAwesomePlugin` wird. Beide kannst du überschreiben.
3. Ergänze *Author*, *Plugin URI* und eine *Description*. Belasse *Requires WP* bei `6.8` und *Requires PHP* bei `8.3`, wähle eine *License* (z. B. GPL-2.0-or-later). Für ein reines Multisite-Plugin aktivierst du *Network*.
4. Der Code aktualisiert sich live im `plugin.php`-Editor. Er enthält den vollständigen Doc-Header, `declare(strict_types=1)` und einen `defined('ABSPATH') || exit`-Schutz — etwa in dieser Form:

```php
<?php
/**
 * Plugin Name: My Awesome Plugin
 * Description: A custom WordPress plugin.
 * Version:     1.0.0
 * Author:      John Doe
 * License:     GPL-2.0-or-later
 * Text Domain: my-awesome-plugin
 * Requires at least: 6.8
 * Requires PHP: 8.3
 */

declare( strict_types=1 );

defined( 'ABSPATH' ) || exit;
```

5. Klick auf **Download**, um die Datei als `plugin.php` zu speichern, oder auf **Copy** und füge sie in dein Projekt ein. Die Text-Domain muss dem Plugin-Verzeichnisnamen entsprechen.

## Beispiel 2: Einen Filter-Hook anlegen

Du willst den Beitrags-Excerpt programmatisch verändern und brauchst das korrekte Hook-Gerüst.

1. Wähle in der Seitenleiste unter *Hooks & Assets* den Generator **Hook (Action / Filter)**.
2. Stelle *Type* auf **Filter (add_filter)** — denn ein Filter verändert und **gibt einen Wert zurück**, anders als eine Action.
3. Tippe in *Hook Name* `the_content` (das Feld schlägt gängige Hooks vor). Setze *Priority* auf `10`, *Accepted Args* auf `1` und *Callback Function Name* auf `my_filter_content`.
4. Der Editor zeigt ein Gerüst in dieser Form:

```php
add_filter( 'the_content', 'my_filter_content', 10, 1 );

function my_filter_content( $content ) {

	// Modify $content here.

	return $content;
}
```

5. Achte auf den Unterschied zur Action: Eine Filter-Funktion **muss** den (geänderten) Wert zurückgeben, sonst verschwindet der Inhalt. *Accepted Args* muss zur Zahl der Parameter passen, die der Hook tatsächlich übergibt.

## Beispiel 3: Einen dynamischen Gutenberg-Block registrieren

Du baust einen Block, dessen Ausgabe serverseitig gerendert werden soll (z. B. eine Liste aktueller Beiträge).

1. Wähle unter *Plugin & Theme* den Generator **Gutenberg Block**.
2. Trage *Namespace* (dein Plugin-Slug, z. B. `my-plugin`), *Block Name* (`latest-posts`), *Title* und eine *Description* ein. Wähle eine *Category* (z. B. `widgets`) und einen *Icon*-Dashicon.
3. Aktiviere **Dynamic Block (server-side render)**. Jetzt erscheint das Feld *Render Callback Function Name* — trage z. B. `my_plugin_render_latest_posts` ein.
4. Im `block.json`-Reiter steht die Block-Definition (mit `"render"` bzw. der Callback-Anbindung), im `register.php`-Reiter die PHP-Registrierung über `register_block_type()`. Bei dynamischen Blocks gibt die JS-`save()`-Funktion `null` zurück und der PHP-Callback erzeugt das Markup.
5. **Copy/Download** bezieht sich immer auf den aktiven Datei-Reiter — hol dir also beide Dateien einzeln (`block.json` und `register.php`).

## Beispiel 4: Einen Custom Post Type erzeugen

Du brauchst einen eigenen Inhaltstyp „Projekte".

1. Wähle unter *Data Types* den Generator **Custom Post Type**.
2. Trage den Slug (`project`) und die Labels (Singular/Plural) ein, wähle die *Supports* (Titel, Editor, Thumbnail …), die REST-Anbindung (für den Block-Editor und die REST-API) und ein *menu_icon* — den Dashicon-Slug findest du über den **Dashicons**-Browser unter *Reference*.
3. Der Editor zeigt einen vollständigen `register_post_type()`-Aufruf mit ausgefülltem Labels-Array, an die `init`-Action gehängt. Du kopierst ihn in dein Plugin oder die `functions.php` deines Themes.
4. Brauchst du dazu eine Taxonomie („Projekt-Kategorien"), wechselst du anschließend auf den Generator **Taxonomy** und verknüpfst sie mit dem Post-Type `project`.

## Beispiel 5: Ein fertiges Theme-Snippet holen

Du willst eine schnelle, sichere Optimierung in deine `functions.php` einbauen, ohne sie selbst zu schreiben.

1. Wähle unter *Snippets* den Reiter **Theme Snippets**.
2. Öffne das Dropdown *Snippet* und wähle in der Kategorie *Security & Cleanup* den Eintrag **Remove Generator Meta Tag**. Darunter erscheint eine Kurzbeschreibung, warum das Snippet sinnvoll ist.
3. Der Editor zeigt sofort den fertigen Code:

```php
<?php
/**
 * Remove the WordPress generator meta tag.
 */
remove_action( 'wp_head', 'wp_generator' );
```

4. Brauchst du einen eigenen Funktions-Präfix (etwa um Namenskollisionen zu vermeiden), trägst du ihn ins Feld **Text Domain / Prefix** ein — der Code wird dann mit präfixierten Funktionsnamen neu erzeugt. Manche Snippets (z. B. *Remove Emoji Support*) blenden zusätzlich ein kleines Optionen-Panel ein.
5. **Copy** oder **Download** (als `remove-generator.php`) — und ab in die `functions.php`.

## Beispiel 6: Eine Datenbank-Abfrage zusammenklicken

Du brauchst eine `WP_Query`, die nach einem Meta-Feld sortiert.

1. Wähle unter *Config & Queries* den **Query Builder**.
2. Belasse *Query Type* auf **WP_Query (posts)**. Das Formular zeigt die passenden Felder.
3. Setze *Post Type* (`product`), *Post Status* (`publish`), *Posts per Page* (`12`) und *Order By* auf `meta_value_num`.
4. Der Editor baut den vollständigen `WP_Query`-Aufruf inklusive Argument-Array und der korrekten Schleife (`have_posts()` / `the_post()` / `wp_reset_postdata()`) auf. Brauchst du stattdessen Benutzer, Begriffe oder Kommentare, wechselst du *Query Type* auf `get_users()`, `get_terms()` oder `get_comments()` — das Formular passt sich an, und ein Info-Kasten erklärt den gewählten Typ.

---

Noch tiefer: das [Manual](https://www.jpkc.com/db/tools/wp/manual/) für jeden Generator und jedes Feld im Detail, die [Tipps & Tricks](https://www.jpkc.com/db/tools/wp/tips/) für Strategie und Stolperfallen. Ausprobieren kannst du alles direkt im [Tool](https://www.jpkc.com/tools/wp/).