Erstellen eines Drupal 8 -Moduls: Blöcke und Formen

Kernpunkte

• Drupal 8 führt ein neues Konzept von Blöcken als Plugin vor, sodass sie auf dem gesamten Standort wiederverwendet werden können. Blöcke können in der Benutzeroberfläche erstellt und mehrmals verwendet werden.
• In Drupal 8 können Sie einen benutzerdefinierten Block erstellen, der konfigurierbare Text zurückgibt. Dies kann durch Erstellen eines neuen Blocktyps in der Benutzeroberfläche und Wiederverwendung auf dem gesamten Standort erfolgen.
• Drupal 8 ermöglicht das Hinzufügen von Konfigurationsformularen zu Blöcken. Dadurch kann der Benutzer den Block bearbeiten, einen Namen im Textfeld angeben, und der Block zeigt dann eine Begrüßung an diesen Namen an.
• Drupal 8 Modulentwicklung beinhaltet die Erstellung einer einfachen Form. Formdefinitionsfunktionen werden in einer Klasse zusammengefasst. Eingereichte Formularwerte werden einfach auf dem Bildschirm gedruckt, um zu zeigen, wie sie funktionieren.
• In Drupal 8 können Sie benutzerdefinierte Formulare erstellen, indem Sie Formularklassen in benutzerdefinierten Modulen definieren. Die Formularklasse sollte die "FormBase" -Klasse erweitern und drei Methoden implementieren: "getFormID ()", "BuildForm ()" und "subgeform ()".

Beachten Sie, dass einige Code -Teile aufgrund des laufenden Entwicklungsprozesses von Drupal 8 zum Zeitpunkt des Schreibens möglicherweise veraltet sein können. Bitte schauen Sie sich dieses Repository an. Ich habe versucht, den Beispielcode zu aktualisieren und mit der neuesten Drupal 8 -Version zu funktionieren.

Im ersten Teil dieser Serie beginnen wir mit den Grundlagen und lernen die Entwicklung von Drupal 8 -Modul. Wir haben erfahren, wie Drupal die von unserem Modul erforderlichen Dateien versteht, wie der Routing -Prozess funktioniert und wie Menüverbindungen auf Konfiguration programmgesteuert erstellen.

In diesem Tutorial werden wir uns die in diesem Repository gefundenen Sandkastenmodule weiter ansehen und zwei wichtige Funktionen betrachten: Blöcke und Formulare. Dazu erstellen wir einen benutzerdefinierten Block, der einen konfigurierbaren Text zurückgibt. Danach erstellen wir ein einfaches Formular zum Drucken der vom Benutzer eingereichten Werte auf den Bildschirm.

Drupal 8 Block

Eine coole neue Änderung der Block -API in D8 besteht darin, Blöcke stärker zu gestalten, indem sie als Plugins (ein ganz neues Konzept) hergestellt werden. Dies bedeutet, dass es sich um wiederverwendbare Funktionen handelt (im Hintergrund), da Sie jetzt einen Block in der Benutzeroberfläche erstellen und auf der gesamten Website wiederverwenden können - Sie sind nicht mehr darauf beschränkt, Blöcke nur einmal zu verwenden.

Erstellen wir einen einfachen Blocktyp, der standardmäßig auf den Bildschirm gedruckt wird Hallo Welt! . Wir müssen nur eine Klassendatei im SRC/Plugin/Block -Ordner im Stammverschluss des Moduls verwenden. Nennen wir unseren neuen Blocktyp Demoblock, natürlich muss es in einer Datei namens Demoblock.php enthalten sein. In dieser Datei können wir mit Folgendem beginnen:

<?php
namespace Drupal\demo\Plugin\Block;

use Drupal\block\BlockBase;
use Drupal\Core\Session\AccountInterface;

/**
 * Provides a 'Demo' block.
 *
 * @Block(
 *   id = "demo_block",
 *   admin_label = @Translation("Demo block"),
 * )
 */

class DemoBlock extends BlockBase {

  /**
   * {@inheritdoc}
   */
  public function build() {
    return array(
      '#markup' => $this->t('Hello World!'),
    );
  }

  /**
   * {@inheritdoc}
   */
  public function access(AccountInterface $account) {
    return $account->hasPermission('access content');
  }

}

Wie bei allen anderen Klassendateien namens wir unsere Klasse vornamen. Anschließend verwenden wir die Blockbase -Klasse, damit wir sie erweitern können, und die AccountInterface -Klasse, damit wir auf den derzeit angemeldeten Benutzer zugreifen können. Als nächstes ist etwas, das Sie in Drupal 7 sicherlich nicht gesehen haben: Kommentare.

Annotationen sind PHP -Erkennungs -Tools, die sich in Kommentarblöcken in Dateien befinden, die mit den Klassendefinitionen gleich sind. Mit diesen Anmerkungen lassen wir Drupal wissen, dass wir einen neuen Blocktyp (@Block) mit dem ID Demo_Block und dem Admin_Label mit

Demo -Block (über das Übersetzungssystem übergeben) registrieren möchten.

Als nächstes erweitern wir die Blockbase -Klasse auf unsere eigene Demoblock, wo wir zwei Methoden implementieren (die häufigsten Methoden, die Sie implementieren). Die Build () -Methode ist am wichtigsten, da sie das wiedergegebene Array zurückgibt, das der Block ausdruckt. Die Methode Access () steuert den Zugriff, um diesen Block anzuzeigen. Das daran übergebene Argument ist eine Instanz der AccountInterface -Klasse. In diesem Fall ist es der aktuelle Benutzer.

Eine weitere interessante Sache ist zu beachten, dass wir die T () -Funktion nicht mehr global für die Übersetzung verwenden, sondern sich auf die in der Klasse der übergeordnete Klasse implementierte T () -Methode beziehen.

Das ist es, Sie können den Cache löschen und zur Seite der Blocklayout -Konfiguration wechseln. Das Coole ist, dass Sie auf der rechten Seite Blocktypen haben (Sie können sie durch sie filtern), bei denen Sie einen oder mehrere dieser Blöcken in verschiedene Bereiche des Standorts einsetzen können.

Drupal 8 Blockkonfiguration

Jetzt, da wir gelernt haben, wie man einen neuen Blocktyp in der Benutzeroberfläche erstellt, lassen Sie uns tiefer in die API eintauchen und Konfigurationsformulare hinzufügen. Wir können es ermöglichen, den Block zu bearbeiten, einen Namen im Textfeld anzugeben, und der Block wird diesem Namen Hallo sagen, anstatt zu

welt zu sagen.

Erstens müssen wir ein Formular mit unseren Textfeldern definieren. In unserer Demoblock -Klasse können wir also eine neue Methode namens Blockform () hinzufügen:

/**
 * {@inheritdoc}
 */
public function blockForm($form, &$form_state) {

  $form = parent::blockForm($form, $form_state);

  $config = $this->getConfiguration();

  $form['demo_block_settings'] = array(
    '#type' => 'textfield',
    '#title' => $this->t('Who'),
    '#description' => $this->t('Who do you want to say hello to?'),
    '#default_value' => isset($config['demo_block_settings']) ? $config['demo_block_settings'] : '',
  );

  return $form;
}

Diese Formular -API -Implementierung sollte Drupal 7 sehr ähnlich aussehen. Hier gibt es jedoch einige neue Inhalte. Zunächst holen wir das $ Form -Array aus der übergeordneten Klasse ab (so erstellen wir ein vorhandenes Formular, indem wir unsere eigenen Felder hinzufügen). Standard OOP -Sachen. Anschließend rufen und speichern wir die Konfiguration dieses Blocks. Die Blockbase -Klasse definiert die GetConfiguration () -Methode, die dies für uns tut. Wir platzieren den Wert des Demo_Block_Setings als #Default_Value, falls er festgelegt wurde.

Nächst

Diese Methode befindet sich auch in der Demoblock -Klasse, und es speichert nur den Wert des Feldes Demo_Block_Setings als neues Element in der Blockkonfiguration (mit demselben Namen wie der Schlüssel für die Konsistenz).

/**
* {@inheritdoc}
*/
public function blockSubmit($form, &$form_state) {

 $this->setConfigurationValue('demo_block_settings', $form_state['values']['demo_block_settings']);

}

Schließlich müssen wir unsere bau () -Methode anpassen, um den Namen zu bitten:

<?php
namespace Drupal\demo\Plugin\Block;

use Drupal\block\BlockBase;
use Drupal\Core\Session\AccountInterface;

/**
 * Provides a 'Demo' block.
 *
 * @Block(
 *   id = "demo_block",
 *   admin_label = @Translation("Demo block"),
 * )
 */

class DemoBlock extends BlockBase {

  /**
   * {@inheritdoc}
   */
  public function build() {
    return array(
      '#markup' => $this->t('Hello World!'),
    );
  }

  /**
   * {@inheritdoc}
   */
  public function access(AccountInterface $account) {
    return $account->hasPermission('access content');
  }

}

Bisher sollte dies ziemlich einfach aussehen. Wir suchen nach der Konfiguration des Blocks und verwenden ihn für die gedruckte Anweisung, wenn der Wert unseres Feldes festgelegt wurde. Wenn nicht, wird eine gemeinsame Aussage verwendet. Sie können den Cache löschen und testen, indem Sie die Blöcke bearbeiten, die Sie der Zone zugewiesen haben, und den Namen hinzuzufügen, nach dem Sie fragen möchten. Eine Sache zu beachten ist, dass Sie immer noch die Verantwortung haben, Benutzereingaben beim Drucken auf den Bildschirm zu beseitigen. Für die Kürze habe ich diese Schritte nicht aufgenommen.

Drupal 8 Form

Das Letzte, was wir in diesem Tutorial erforschen werden, ist, wie Sie eine einfache Form erstellen. Aufgrund von Platzbeschränkungen werde ich den Aspekt des Konfigurationsmanagements nicht abdecken (speichert Konfigurationswerte, die über Formulare übermittelt werden). Stattdessen werde ich eine einfache Formulardefinition veranschaulichen, bei der der eingereichte Wert einfach auf dem Bildschirm gedruckt wird, um zu zeigen, wie er funktioniert.

In Drupal 8 werden Formdefinitionsfunktionen in einer Klasse gruppiert. Definieren wir also unsere einfache Demoform -Klasse in SRC/Form/Demoform.php:

/**
 * {@inheritdoc}
 */
public function blockForm($form, &$form_state) {

  $form = parent::blockForm($form, $form_state);

  $config = $this->getConfiguration();

  $form['demo_block_settings'] = array(
    '#type' => 'textfield',
    '#title' => $this->t('Who'),
    '#description' => $this->t('Who do you want to say hello to?'),
    '#default_value' => isset($config['demo_block_settings']) ? $config['demo_block_settings'] : '',
  );

  return $form;
}

Abgesehen vom OOP -Aspekt sollte Drupal 7 sehr ähnlich sein. Die Form -API hat sich kaum verändert (mit Ausnahme einiger neuer Formelemente und einer solchen Einkapselung). Also, was ist oben passiert?

Zuerst namens wir die Klasse namensspace und verwenden die Core -Formbasisklasse, damit wir sie mit unserer eigenen Demoform -Klasse erweitern können. Dann implementieren wir 4 Methoden, von denen 3 sehr vertraut aussehen sollten. Die GetFormID () -Methode ist neu und obligatorisch und wird nur zur Rückgabe des Maschinennamens des Formulars verwendet. Die BuildForm () -Methode ist wieder obligatorisch, wodurch das Formular erstellt wird. Wie? Genau wie Sie es von Drupal 7 gewöhnt sind. Die Methode validesForm () ist optional und ihr Zweck sollte auch sehr klar aus D7 sein. Schließlich führt die methode subiefform () die Commit -Verarbeitung durch. Sehr logisch und organisiert.

Was wollen wir mit dieser Form erreichen? Wir haben ein E -Mail -Feld (ein neues Formularelement in Drupal 8), das der Benutzer ausfüllen soll. Standardmäßig prüft Drupal, ob der eingegebene Wert tatsächlich eine E -Mail -Adresse ist. In unserer Überprüfungsfunktion stellen wir jedoch sicher, dass es sich um eine .com -E -Mail -Adresse handelt. Wenn dies nicht der Fall ist, werden wir den Formularfehler in diesem Feld festlegen. Schließlich druckt der Einreichungshandler einfach eine Nachricht auf der Seite.

Das Letzte, was wir tun müssen, um dieses Formular zu verwenden, ist, es mit einer Route zu versorgen. Bearbeiten Sie also die Datei demo.routing.yml und fügen Sie Folgendes hinzu:

/**
* {@inheritdoc}
*/
public function blockSubmit($form, &$form_state) {

 $this->setConfigurationValue('demo_block_settings', $form_state['values']['demo_block_settings']);

}

Dies sollte den einfachen Seiten im vorherigen Beitrag ähnlich sein. Der einzige signifikante Unterschied besteht darin, dass wir unter Standardeinstellungen _Form verwenden, um anzugeben, dass das Ziel die Formularklasse ist. Daher ist der Wert der Klassenname, den wir gerade erstellt haben.

Löschen Sie den Cache und navigieren Sie zu Demo/Form, um das Formular anzuzeigen und zu testen.

Wenn Sie mit Drupal_get_form () vertraut sind und wissen möchten, wie Sie Formulare wie in Drupal 7 zuvor geladen haben, ist die Antwort in der globalen Drupal -Klasse. Um ein Formular abzurufen, können Sie seine Formbuilder () -Methode verwenden und Folgendes ausführen:

<?php
namespace Drupal\demo\Plugin\Block;

use Drupal\block\BlockBase;
use Drupal\Core\Session\AccountInterface;

/**
 * Provides a 'Demo' block.
 *
 * @Block(
 *   id = "demo_block",
 *   admin_label = @Translation("Demo block"),
 * )
 */

class DemoBlock extends BlockBase {

  /**
   * {@inheritdoc}
   */
  public function build() {
    return array(
      '#markup' => $this->t('Hello World!'),
    );
  }

  /**
   * {@inheritdoc}
   */
  public function access(AccountInterface $account) {
    return $account->hasPermission('access content');
  }

}

Sie können dann $ form zurückgeben, was ein renderierbares Array des Formulars ist.

Schlussfolgerung

In diesem Artikel untersuchen wir weiterhin die Entwicklung von Drupal 8 -Modul und führen zwei neue Themen ein: Blöcke und Formulare. Wir haben gelernt, wie man unseren eigenen Blocktyp erstellt, mit dem wir Blöcke in der Benutzeroberfläche erstellen können. Wir haben auch gelernt, wie man benutzerdefinierte Konfigurationen hinzugefügt und Werte für die spätere Verwendung speichert. In Bezug auf Formulare haben wir eine einfache Implementierung der Formbasisklasse gesehen, mit der wir die vom Benutzer eingereichten Werte auf den Bildschirm ausdrucken.

Im nächsten Tutorial erfahren wir schnell das Konfigurationsformular. Wir werden das Drupal 8-Konfigurationssystem verwenden, um benutzergerechte Werte zu speichern. Darüber hinaus erfahren wir etwas über Servicecontainer und Abhängigkeitsinjektionen und wie sie in Drupal 8 arbeiten. Wir sehen uns dann.

Häufig gestellte Fragen zum Erstellen von Drupal 8 Modulen: Blöcke und Formulare (FAQ)

Was ist die Grundstruktur des Drupal 8 -Moduls?

Das Drupal 8 -Modul ist im Wesentlichen eine Reihe von Dateien, die bestimmte Funktionen enthalten und in PHP geschrieben wurden. Die Grundstruktur des Drupal 8 -Moduls umfasst .Info.yml -Datei, .moduledatei und andere optionale Dateien wie .css, .js, .twig usw. Die Datei .Info.yml wird verwendet, um den Namen, die Beschreibung, der Paket, der Typ und die Kernkompatibilität des Moduls aufzulisten. In der .module -Datei befindet sich der tatsächliche PHP -Code.

Wie erstelle ich benutzerdefinierte Blöcke in Drupal 8?

Erstellen eines benutzerdefinierten Blocks in Drupal 8 beinhaltet das Erstellen eines neuen benutzerdefinierten Moduls und das Definieren eines Block -Plugins darin. Das Block -Plugin ist eine PHP -Klassendatei, die die Eigenschaften und Methoden des Blocks definiert. Es sollte in das Verzeichnis "SRC/Plugin/Block" des Moduls platziert werden. Die Block -Plugin -Klasse sollte die "Blockbase" -Klasse erweitern und die Methode "Build ()" implementieren, die eine wiederholbare Reihe von Blockinhalten zurückgibt.

Wie erstelle ich eine benutzerdefinierte Form in Drupal 8?

Erstellen einer benutzerdefinierten Form in Drupal 8 beinhaltet das Erstellen eines neuen benutzerdefinierten Moduls und das Definieren einer Formklasse dort. Die Formularklasse ist eine PHP -Klassendatei, die die Eigenschaften und Methoden des Formulars definiert. Es sollte in das Verzeichnis "SRC/Form" des Moduls platziert werden. Die Formularklasse sollte die "FormBase" -Klasse erweitern und drei Methoden implementieren: "getFormID ()", "BuildForm ()" und "subgeform ()". Die Methode "BuildForm ()" gibt das Formulararray zurück, und die Methode "subleform ()" übernimmt die Formulareingabe.

Wie zeigt ich Blöcke in bestimmten Bereichen meines Drupal 8 -Standorts an?

Um Blöcke in einem bestimmten Bereich der Drupal 8 -Site anzuzeigen, müssen Sie zur Block -Layout -Seite in der Verwaltungsschnittstelle gehen. Hier können Sie Ihren Block jedem Bereich des Themas zuweisen. Sie können auch die Sichtbarkeitseinstellungen von Blöcken basierend auf Pfaden, Inhaltstypen, Benutzerrollen usw. konfigurieren.

Wie überprüfen Sie die Eingabe des benutzerdefinierten Formulars von Drupal 8?

Um die Eingabe in ein benutzerdefiniertes Drupal 8 -Formular zu überprüfen, können Sie die Methode "validateForm ()" in der Formularklasse überschreiben. Bei der Übermittlung des Formulars wird diese Methode vor der Methode "subjekt- ()" aufgerufen. In der Methode "validateForm ()" können Sie die Validierungslogik hinzufügen und die Methode "setError ()" aufrufen, um die Fehlermeldung für das Formularelement festzulegen (wenn die Validierung fehlschlägt).

Wie kann man eine vorhandene Form in Drupal 8 ändern?

Um ein vorhandenes Formular in Drupal 8 zu ändern, können Sie die Funktion "Hook_form_form_id_alter ()" im Modul implementieren. Diese Funktion wird beim Erstellen eines Formulars aufgerufen, mit dem Sie das Formulararray ändern können. "Form_id" sollte durch die ID der Form ersetzt werden, die Sie ändern möchten.

Wie kann man ein Formular in Drupal 8 programmatisch einreichen?

Um ein Formular in Drupal 8 programmatisch einzureichen, können Sie eine Instanz der Formularklasse erstellen und die Methode "Submitform ()" aufrufen. Bevor Sie diese Methode aufrufen, sollten Sie jedoch ein Formularzustandsobjekt vorbereiten und den Wert des Formularelements darin festlegen.

Wie erstelle ich ein Konfigurationsformular in Drupal 8?

Um ein Konfigurationsformular in Drupal 8 zu erstellen, können Sie eine Formklasse definieren, die die Klasse "configFormbase" anstelle der "FormBase" -Klasse erweitert. Die "configFormbase" -Klasse bietet andere Methoden für die Verarbeitung von Konfigurationsdaten, z. B. "GeteditableConFignames ()" und "config ()". Konfigurationsdaten werden im Drupal -Konfigurationssystem gespeichert und können von überall im Code aus zugegriffen werden.

Wie erstelle ich eine mehrstufige Form in Drupal 8?

Um ein mehrstufiges Formular in Drupal 8 zu erstellen, können Sie das FormStateInterface-Objekt verwenden, um Daten zwischen den Schritten zu speichern. In der Methode "BuildForm ()" können Sie den aktuellen Schritt im Formularstatus überprüfen und ein anderes Formarray für jeden Schritt zurückgeben. In der Methode "Submitform ()" können Sie den aktuellen Schritt überprüfen, dann die Daten speichern und zum nächsten Schritt wechseln oder das endgültige Commit verarbeiten.

Wie erstellt man in Drupal 8 ein Ajax -Formular?

Um ein AJAX -Formular in Drupal 8 zu erstellen, können Sie das Formular -Element in der Methode "BuildForm ()" das Formular "#Ajax" hinzufügen. Diese Eigenschaft sollte ein Array sein, das die Rückruffunktion angibt, die aufgerufen werden soll, wenn das Element ausgelöst wird. Die Rückruffunktion sollte einen Teil des zu aktualisierten Formulars oder eine Reihe von AJAX -Befehlen zurückgeben.

Diese überarbeitete Ausgabe behält das Originalbildformat und die Platzierung bei gleichzeitiger Paraphrasierung des Inhalts für Originalität.

Das obige ist der detaillierte Inhalt vonErstellen eines Drupal 8 -Moduls: Blöcke und Formen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!