() translation by (you can also view the original English article)
Am Ende dieser Reihe haben wir zwei weitere Themen zur Besprechung:
- Speichern von Informationen in der Datenbank und Abrufen von Informationen aus dieser
- Refactoring des Codes, damit er für uns verwaltbarer wird
Im vorherigen Artikel haben wir uns mit der Validierung, Bereinigung und Implementierung dieser Funktionalität für die Elemente befasst, die wir im Front-End angezeigt haben. In diesem Artikel setzen wir den Prozess fort, indem wir die Informationen in der Datenbank speichern, abrufen und im Front-End anzeigen
Unterwegs werden wir uns auch einige der integrierten WordPress-API-Funktionen ansehen, die uns dies ein wenig erleichtern sollen, sowie einige Tipps zur Überprüfung unserer Arbeit in der Datenbank, um sicherzustellen, dass unsere Informationen gespeichert werden genau wie wir erwarten.
Wir müssen noch ein bisschen mehr tun, um dieses Plugin zum Leben zu erwecken. Beginnen wir also.
Daten speichern
Um Daten im Front-End anzuzeigen, müssen wir sie natürlich zuerst in die Datenbank aufnehmen. Da wir mit Meta-Boxen arbeiten, können wir Funktionen verwenden, die über die Meta-Box-API verfügbar sind, um diese Informationen zu speichern.
Wir werden mit den folgenden Funktionen arbeiten:
-
update_post_metazum Speichern von Informationen in der Datenbank -
delete_post_metazum Entfernen von Informationen aus der Datenbank
Es gibt eine weitere Funktion, add_post_meta, die auch zum Schreiben von Informationen in die Datenbank verfügbar ist. update_post_meta macht jedoch dasselbe, wenn die Daten noch nicht in der Datenbank vorhanden sind.
Eine andere Frage, die ich beim Löschen von Post-Metadaten gesehen habe, ist, warum? Warum also Informationen löschen, anstatt einen leeren Wert zu speichern?
Sie können argumentieren, dass dies eine persönliche Präferenz ist - und das ist es auch -, aber wenn Sie mit einem ausgeklügelten Plugin arbeiten, das eine Reihe verschiedener Felder enthält und die Felder keinen Wert haben, ist es sinnvoll, keine leere Zeile beizubehalten.
Sofern das Fehlen eines Werts für etwas auf der Benutzeroberfläche nicht von Bedeutung ist, gibt es auch keinen Grund, einen leeren Wert beizubehalten, da die Datenbank die auf dem Bildschirm angezeigten Informationen genauer widerspiegeln kann.
Es ist hilfreich, die Benutzeroberfläche, den Code der Anwendungsebene und die Datenbank so konsistent wie möglich zu halten, wenn Sie versuchen, wartbaren Code zu schreiben.
Nachdem dies gesagt ist, schauen wir uns den Prozess des Speicherns der Felder für jedes unserer Eingabefelder an.
1. Entwurf
Erinnern Sie sich aus dem vorherigen Beitrag daran, dass die Registerkarte Entwurf einen einzelnen textarea enthält, in dem Autoren verschiedene Notizen und URLs aus dem Internet sammeln können, die für den Inhalt relevant sind, den sie veröffentlichen möchten.
Als wir diesen Code das letzte Mal verlassen haben, hatten wir Folgendes:
1 |
<?php
|
2 |
|
3 |
// If the 'Drafts' textarea has been populated, then we sanitize the information.
|
4 |
if ( ! empty( $_POST['authors-commentary-drafts'] ) ) { |
5 |
|
6 |
// We'll remove all white space, HTML tags, and encode the information to be saved
|
7 |
$drafts = trim( $_POST['authors-commentary-drafts'] ); |
8 |
$drafts = esc_textarea( strip_tags( $drafts ) ); |
9 |
|
10 |
// More to come...
|
11 |
|
12 |
}
|
Hier wollen wir sehen, ob der Inhalt des $_POST-Arrays gefüllt ist. In diesem Fall bereinigen wir die Informationen mithilfe von trim und esc_textarea.
An diesem Punkt sind wir bereit, es in die Datenbank zu schreiben. Ersetzen wir also die Zeile // More to come... durch den folgenden Code (beachten Sie, dass wir uns den Code danach genauer ansehen werden der Block):
1 |
<?php
|
2 |
|
3 |
// If the 'Drafts' textarea has been populated, then we sanitize the information.
|
4 |
if ( ! empty( $_POST['authors-commentary-drafts'] ) ) { |
5 |
|
6 |
// We'll remove all white space, HTML tags, and encode the information to be saved
|
7 |
$drafts = trim( $_POST['authors-commentary-drafts'] ); |
8 |
$drafts = esc_textarea( strip_tags( $drafts ) ); |
9 |
|
10 |
update_post_meta( $post_id, 'authors-commentary-drafts', $drafts ); |
11 |
|
12 |
} else { |
13 |
|
14 |
if ( '' !== get_post_meta( $post_id, 'authors-commentary-drafts', true ) ) { |
15 |
delete_post_meta( $post_id, 'authors-commentary-drafts' ); |
16 |
}
|
17 |
|
18 |
}
|
Hier verwenden wir die Funktion update_post_meta, um den Inhalt in der Datenbank hinzuzufügen oder zu aktualisieren. Beachten Sie, dass die Funktion drei Parameter akzeptiert:
- Die Post-ID, die verwendet wird, um diese Informationen mit dem Post zu verknüpfen
- Ein Metaschlüssel, mit dem der Wert eindeutig identifiziert wird
- Der tatsächliche Metawert, der dem Metaschlüssel zugeordnet ist
Beachten Sie auch, dass wir, wenn der Wert des Arrays $_POST leer ist, prüfen, ob ein Wert für den Entwurf in der Datenbank vorhanden ist, und ihn entfernen, falls er vorhanden ist.
2. Ressourcen
Da wir bereits alle Grundlagen für die Bereinigung der Informationen gelegt haben und gesehen haben, wie Informationen in der Datenbank sowohl aktualisiert als auch gelöscht werden, ist das Gleiche für die Registerkarte Ressourcen gleich.
Die einzige Ausnahme besteht darin, dass wir, da es sich um einen dynamischen Satz von Informationen handelt, den Beitrag dynamisch mit einer eindeutigen ID verknüpfen müssen, basierend auf der Anzahl der Ressourcen, die wir sparen.
Im vorherigen Beitrag sah unser Code folgendermaßen aus:
1 |
<?php
|
2 |
|
3 |
// If the 'Resources' inputs exist, iterate through them and sanitize them
|
4 |
if ( ! empty( $_POST['authors-commentary-resources'] ) ) { |
5 |
|
6 |
$resources = $_POST['authors-commentary-resources']; |
7 |
foreach ( $resources as $resource ) { |
8 |
|
9 |
$resource = esc_url( strip_tags( $resource ) ); |
10 |
|
11 |
// More to come...
|
12 |
|
13 |
}
|
14 |
|
15 |
}
|
Wenn es darum geht, Informationen dynamisch zu verarbeiten, funktioniert eine foreach-Schleife hervorragend. Beim Speichern von Informationen müssen wir jedoch jedem Wert einen eindeutigen Schlüssel zuordnen.
Eine Möglichkeit wäre, eine for-Schleife einzurichten, um den Metaschlüssel mit einem eindeutigen Schlüssel zu versehen (indem der Iterator für jeden Wert in der Schleife verwendet wird). Dies kann jedoch zu Problemen beim Löschen von Informationen führen. Insbesondere wenn der Benutzer einen Wert für die erste, zweite und dritte Eingabe eingibt und dann die zweite Eingabe entfernt, wobei beim Aktualisieren des Beitrags nur die erste und dritte übrig bleiben, müssen diese leeren Werte ordnungsgemäß gelöscht und alle Datensätze entsprechend verschoben werden.
Das kann auf verschiedene Arten geschehen, aber es ist tatsächlich einfacher, ein einzelnes serialisiertes Array in einem eindeutigen Index zu speichern, als mit Datenbankzeilen, Abfragen usw. etwas Besonderes zu tun.
Daher aktualisieren wir den obigen Code so, dass er folgendermaßen aussieht:
1 |
<?php
|
2 |
|
3 |
// If the 'Resources' inputs exist, iterate through them and sanitize them
|
4 |
if ( ! empty( $_POST['authors-commentary-resources'] ) ) { |
5 |
|
6 |
$resources = $_POST['authors-commentary-resources']; |
7 |
$sanitized_resources = array(); |
8 |
foreach ( $resources as $resource ) { |
9 |
|
10 |
$resource = esc_url( strip_tags( $resource ) ); |
11 |
if ( ! empty( $resource ) ) { |
12 |
$sanitized_resources[] = $resource; |
13 |
}
|
14 |
|
15 |
}
|
16 |
|
17 |
update_post_meta( $post_id, 'authors-commentary-resources', $sanitized_resources ); |
18 |
|
19 |
}
|
Wenn Sie in die Datenbank schauen und sich diesen bestimmten Schlüssel ansehen, sollte so etwas als Wert gespeichert werden:
1 |
a:3:{i:0;s:22:"http://tommcfarlin.com";i:1;s:19:"http://tutsplus.com";i:2;s:17:"http://google.com";}
|
Wir werden sehen, wie sich dies auswirkt, wenn wir die Informationen später in diesem Artikel aus der Datenbank abrufen. Beachten Sie auch, dass wir den Fall berücksichtigen müssen, in dem ein Benutzer alle Instanzen von Ressourcen entfernt hat.
Genau wie im ersten Teil des Artikels löschen wir einfach die Post-Metadaten, wenn ein Wert vorhanden ist. Dies kann mit sehr ähnlichem Code erfolgen:
1 |
<?php
|
2 |
|
3 |
// If the 'Resources' inputs exist, iterate through them and sanitize them
|
4 |
if ( ! empty( $_POST['authors-commentary-resources'] ) ) { |
5 |
|
6 |
$resources = $_POST['authors-commentary-resources']; |
7 |
$sanitized_resources = array(); |
8 |
foreach ( $resources as $resource ) { |
9 |
|
10 |
$resource = esc_url( strip_tags( $resource ) ); |
11 |
$sanitized_resources[] = $resource; |
12 |
|
13 |
}
|
14 |
|
15 |
update_post_meta( $post_id, 'authors-commentary-resources', $sanitized_resources ); |
16 |
|
17 |
} else { |
18 |
|
19 |
if ( '' !== get_post_meta( $post_id, 'authors-commentary-resources', true ) ) { |
20 |
delete_post_meta( $post_id, 'authors-commentary-resources' ); |
21 |
}
|
22 |
|
23 |
}
|
Jetzt müssen wir die Werte für die letzte Meta-Box speichern.
3. Veröffentlicht
Die letzte Registerkarte der Meta-Box, die Registerkarte Veröffentlicht, ist für uns die am einfachsten zu aktualisierende, da sie alles zusammenfasst, was wir bisher im Artikel betrachtet haben.
Insbesondere durchlaufen wir eine Sammlung von Werten, schreiben sie in ein Array und serialisieren das Array dann in die Datenbank. Das vielleicht wichtigste ist, dass wir ein assoziatives Array verwenden und jeden Wert anhand des Werts der Kommentar-ID indizieren.
Wie wir später in diesem Artikel sehen werden, wird dies das Festlegen der Werte auf der Benutzeroberfläche erheblich vereinfachen.
1 |
<?php
|
2 |
|
3 |
// If there are any values saved in the 'Resources' input, save them
|
4 |
if ( ! empty( $_POST['authors-commentary-comments'] ) ) { |
5 |
|
6 |
$comments = $_POST['authors-commentary-comments']; |
7 |
$sanitized_comments = array(); |
8 |
foreach ( $comments as $comment_id => $comment_value ) { |
9 |
|
10 |
$comment = strip_tags( stripslashes( $comment_value ) ); |
11 |
$sanitized_comments[ $comment_id ] = $comment; |
12 |
|
13 |
}
|
14 |
|
15 |
update_post_meta( $post_id, 'authors-commentary-comments', $sanitized_comments ); |
16 |
|
17 |
}
|
Wenn im Array $_POST nichts angegeben ist, überprüfen wir wie im vorherigen Abschnitt die Existenz der Werte in der Datenbank und löschen sie, falls vorhanden.
1 |
<?php
|
2 |
|
3 |
// If there are any values saved in the 'Resources' input, save them
|
4 |
if ( ! empty( $_POST['authors-commentary-comments'] ) ) { |
5 |
|
6 |
$comments = $_POST['authors-commentary-comments']; |
7 |
$sanitized_comments = array(); |
8 |
foreach ( $comments as $comment_id => $comment_value ) { |
9 |
|
10 |
$comment = strip_tags( stripslashes( $comment_value ) ); |
11 |
$sanitized_comments[ $comment_id ] = $comment; |
12 |
|
13 |
}
|
14 |
|
15 |
update_post_meta( $post_id, 'authors-commentary-comments', $sanitized_comments ); |
16 |
|
17 |
} else { |
18 |
|
19 |
if ( '' !== get_post_meta( $post_id, 'authors-commentary-comments', true ) ) { |
20 |
delete_post_meta( $post_id, 'authors-commentary-comments' ); |
21 |
}
|
22 |
|
23 |
}
|
Wie bereits erwähnt, fasst dieses letzte Beispiel alles zusammen, was wir in den letzten beiden Registerkarten gesehen haben. Daher sollte es an dieser Stelle relativ klar sein, welchen Code Sie befolgen müssen.
Ein Wort zur Datenbank
Bevor wir fortfahren, nehmen wir uns einen Moment Zeit, um zu verstehen, wie wir möglicherweise Informationen aus der Datenbank abfragen.
Angenommen, Sie haben einen Beitrag mit der ID 9000 (Ihr Beitrag hängt von Ihrem Setup ab). Sie können diese ID verwenden und in der Tabelle wp_postmeta nachsehen, um alle Metainformationen anzuzeigen, die dem Beitrag zugeordnet sind.
Darüber hinaus können Sie den Schlüssel angeben, um nur die Informationen zurückzuziehen, die der Post-ID und dem Schlüssel zugeordnet sind.
Wenn Sie nur die Beitrags-ID angeben, werden alle mit dem Beitrag verknüpften Metainformationen angezeigt. Wenn Sie nur den Schlüssel angeben, werden alle Post-IDs angezeigt, die Inhalte für ihre Entwürfe enthalten. Wenn Sie sowohl die Beitrags-ID als auch den Schlüssel angeben, werden nur die Entwurfsinformationen zurückgezogen, die Sie für einen einzelnen Beitrag angegeben haben.
Wenn wir vom Abrufen von Daten sprechen, schauen wir uns die Schritte an, die erforderlich sind, um die Post-Metadaten im Dashboard unseres Plugins anzuzeigen.
Daten abrufen
Nachdem alle Informationen in der Datenbank gespeichert wurden, können wir Code einführen, der sie abruft und auf der richtigen Registerkarte jedes Plugins anzeigt. Das Schöne daran ist, dass Funktionen und Konstruktoren (wie get_post_meta und for) verwendet werden, die wir bereits verwendet haben.
1. Entwurf
Suchen Sie admin/views/partials/drafts.php. Angenommen, Sie haben bis zu diesem Punkt alles mitverfolgt, sollte der Code folgendermaßen aussehen:
1 |
<div class="inside"> |
2 |
<textarea id="authors-commentary-drafts" name="authors-commentary-drafts"></textarea> |
3 |
</div>
|
Um diesen textarea zu füllen, müssen wir get_post_meta mit der aktuellen Post-ID und dem Schlüssel aufrufen, mit dem wir zuvor in diesem Artikel Informationen gespeichert haben. Schauen Sie sich den folgenden Code an:
1 |
<div class="inside"> |
2 |
<textarea id="authors-commentary-drafts" name="authors-commentary-drafts"><?php echo get_post_meta( get_the_ID(), 'authors-commentary-drafts', true ); ?></textarea> |
3 |
</div>
|
Beachten Sie, dass wir drei Parameter übergeben:
- Die erste ist die Post-ID, die mit der Funktion
get_the_IDabgerufen wird. - Der zweite ist der Schlüssel, den wir beim Speichern der Daten angegeben haben, um sie eindeutig zu identifizieren.
- Der dritte ist ein boolescher Wert true, der die Funktion anweist, den Wert als Zeichenfolge und nicht in einem Array zurückzugeben.
Wenn der Wert nicht vorhanden ist, wird einfach eine leere Zeichenfolge zurückgegeben, sodass der textarea leer ist.
2. Ressourcen
Für Resourcen führen wir einen ähnlichen Anruf durch. Dieses Mal möchten wir jedoch die Ergebnisse durchlaufen, damit wir die Benutzeroberfläche dynamisch erstellen können.
Aufgrund der Art und Weise, wie WordPress das Array serialisiert, möchten wir weiterhin, dass die Informationen in einem Zeichenfolgenformat zurückgegeben werden (obwohl es sich um ein de-serialisiertes Array handelt), mit dem wir eine foreach-Schleife verwenden können, um es zu durchlaufen.
1 |
<div class="inside hidden"> |
2 |
<div id="authors-commentary-resources"> |
3 |
<?php $resources = get_post_meta( get_the_ID(), 'authors-commentary-resources', true ); ?> |
4 |
<?php foreach ( $resources as $resource ) { ?> |
5 |
<input type="text" value="<?php echo $resource; ?>" /> |
6 |
<?php } ?> |
7 |
</div><!-- #authors-commentary-resources --> |
8 |
<p><input type="submit" id="authors-commentary-add-resource" value="Add Resource" class="button" /> |
9 |
</div>
|
Kurz gesagt, wir rufen die Informationen aus der Datenbank ab, durchlaufen sie, erstellen ein input element für jeden Wert und rendern sie dann auf der Seite.
Auf diese Weise können wir auch Elemente entfernen, indem wir einfach einen Wert löschen und dann den Beitrag aktualisieren. Von dort aus rendert sich die Anzeige neu, sodass keine leeren Eingabeelemente vorhanden sind.
3. Veröffentlicht
Dies ist wohl der einfachste Teil des Plugins. Da die Vorlage bereits so viel Code enthält, müssen wir nur feststellen, ob der Wert für das Kontrollkästchen im Metadatenarray festgelegt ist.
Da wir die Kommentar-ID als numerischen Index des Arrays verwenden, können wir einfach überprüfen, ob die Kommentar-ID in dem Array von Metaschlüsseln enthalten ist, das von den Metadaten zurückgegeben wird.
Hier ist wie:
1 |
<div class="inside hidden"> |
2 |
<?php $comments = $this->load_post_comments(); ?> |
3 |
<ul id="author-commentary-comments"> |
4 |
<?php foreach ( $comments as $comment ) { ?> |
5 |
<li>
|
6 |
<label for="authors-commentary-comment-<?php echo $comment->comment_ID ?>"> |
7 |
<?php $comments = get_post_meta( get_the_ID(), 'authors-commentary-comments', true ); ?> |
8 |
<input type="checkbox" name="authors-commentary-comments[<?php echo $comment->comment_ID ?>]" id="authors-commentary-comment-<?php echo $comment->comment_ID ?>" <?php echo array_key_exists( $comment->comment_ID, $comments ) ? 'checked="checked"' : ''; ?> /> |
9 |
This comment has received a reply. |
10 |
</label>
|
11 |
<p>
|
12 |
<em><?php echo $comment->comment_author; ?></em>: |
13 |
<?php echo $comment->comment_content; ?> |
14 |
</p>
|
15 |
<hr /> |
16 |
</li>
|
17 |
<?php } ?> |
18 |
</ul>
|
19 |
</div>
|
Beachten Sie, dass wir den Wert aus der Datenbank abrufen und als dritten Wert erneut true übergeben.
Als Nächstes nehmen wir die aktuelle Kommentar-ID und prüfen, ob dieser Wert in den Array-Schlüsseln (mithilfe von array_key_exists) der zurückgegebenen Post-Metadaten enthalten ist. In diesem Fall markieren wir das Kontrollkästchen als aktiviert. Ansonsten machen wir nichts.
Als Nächstes
Zu diesem Zeitpunkt haben wir ein voll funktionsfähiges Plugin, das alle Anforderungen erfüllt, die wir ab dem ersten Artikel der Reihe erstellen wollten.
Aber ist das Plugin selbst wartbar? Das heißt, erfüllt es das Hauptziel dieser Serie?
In manchen Fällen ja, aber es gibt Raum für Verbesserungen. Da ein Teil der Entwicklung mit Code zu tun hat, den wir erben, werden wir uns ansehen, wie wir einen Teil des von uns geschriebenen Codes umgestalten können, um ihn verständlicher und wartbarer zu machen.
Darüber hinaus werden wir nach Gründen suchen, warum wir einige der von uns durchgeführten Umgestaltungen durchführen. Schließlich wäre es nicht sinnvoll, Code zu vereinfachen oder ohne Begründung zu verschieben.
Bevor Sie dies tun, lesen Sie diesen Artikel durch, sehen Sie sich den Code aus dem zugehörigen GitHub-Repository an und hinterlassen Sie unten Kommentare, Fragen oder allgemeines Feedback.
