Was ist das Grundkonzept hinter Haken?

Ich bin mittelschwer in PHP. Um meine Fähigkeiten zu verbessern, beginne ich mit dem Erlernen von Drupal 7. Beim Erlernen von Drupal-Architekturkonzepten haben mich die Begriffe Hooks und Bootstrapping sehr verwirrt. Ich habe das Buch "Pro Drupal-Entwicklung" und einige Dokumentationen auf drupal.org gelesen, aber es ist für mich so fortgeschritten, zu lernen, wie Hooks in Drupal funktionieren, um die Webseite anzuzeigen.

Kann mir jemand sagen, was Haken in einfachen Worten sind?

Die anderen Antworten sind großartig, genau und detailliert, aber ich bin mir nicht sicher, ob sie die "einfachen Worte" sind, die die nackten Knochen des Konzepts erklären, nach dem der Fragesteller gesucht hat.

Ich stelle mir Hooks als einen Punkt vor, an dem der Code pausiert und " Hat noch jemand hier etwas hinzuzufügen? " Jedes Modul kann eine Funktion haben, die darauf antwortet und mit den entsprechenden Daten ausgelöst wird, die an dieser Stelle im Code an das Modul übergeben werden.

Ein schönes einfaches Beispiel ist hook_node_delete () . Jedes Modul kann es verwenden, um Dinge jedes Mal zu ermöglichen, wenn ein Knoten gelöscht wird. Die Dokumentation teilt Ihnen mit, dass dieser Hook dem Modul das Objekt des gelöschten Knotens übergibt, mit dem es arbeiten soll, und enthält weitere nützliche Informationen, z. B. über den genauen Zeitpunkt des Aufrufs (z. B. bevor die Knotendaten tatsächlich aus der Datenbank gelöscht werden). , und wo in Drupals Code der Hook aufgerufen wird (das kann mehr als eine Stelle sein).

Sie können untersuchen, welche Hooks vorhanden sind, und herausfinden, welche Daten an sie übergeben werden, indem Sie in der Drupal-API Dinge untersuchen, die mit "hook_" beginnen .

Hooks funktionieren nach Namenskonventionen: In hook_node_deleteunserem Beispiel, wenn der Knotenlöschprozess den Punkt erreicht, an dem der Hook aufgerufen wird, wird für jedes Modul mit einer Funktion wie dieser [modulename]_node_delete()das Wort hook im Hook-Namen durch den Namen des Moduls ersetzt (z. B. my_amazing_module_node_delete()) werden diese Funktionen aufgerufen.

Warum? Jedes Modul kann also an diesen wichtigen Punkten alles tun: Beispielsweise können Sie den gelöschten Knoten anzeigen und Aktionen ausführen, wenn eine bestimmte Bedingung erfüllt ist (z. B. E-Mail an einen Administrator senden oder einen längeren Prozess starten).

Mit einigen Hooks können Sie Dinge ändern, die unmittelbar vor ihrer Verarbeitung generiert wurden. Beispiel: hook_menu_alter () übergibt Ihnen die aktuellen Menüelemente , die das System generiert hat. Jedes Modul kann eine Funktion some_modulename_menu_alter () definieren und diese anzeigen, optional ändern (einige löschen, einige hinzufügen, sortieren ...) und das neu geänderte Menü zurückgeben.

Es ist einfach, sehr leistungsstark und bildet den Kern der Funktionsweise von Drupal als modulares System. Die Implementierung von Hooks ist das Herzstück der meisten Drupal-Module.

Wenn Sie den Code eines Drupal-Moduls durchsehen, können Sie feststellen, welche Funktionen von Hooks stammen (im Gegensatz zu Funktionen, die einfach aus dem Modulcode selbst aufgerufen werden), da die Drupal-Community eine Konvention erzwingt, bei der jede Implementierung eines Hooks eine hat Kommentar davor wie folgt (beachte das Bit "Implements hook _..."):

/**
 * Implements hook_some_hook().
 *
 * Some descriptive summary of what this does
 */
function my_amazing_module_some_hook() {

Einige Module, die als APIs fungieren, definieren ihre eigenen Hooks. Beispielsweise definiert Views viele Hooks, mit denen Sie Daten an verschiedenen Stellen beim Erstellen oder Anzeigen einer View hinzufügen, lesen und bearbeiten können. Informationen zu Hooks, die in benutzerdefinierten Modulen erstellt wurden, finden Sie an zwei Stellen (vorausgesetzt, das Modul folgt Konventionen usw.):

• Der Code und die Kommentare in der modulename.api.phpDatei im Modulordner
• drupalcontrib.org - hier ist zum Beispiel die Liste der D7-Module, zu denen sie Informationen haben, und hier ist die Seite der Views-Hooks

Bootstrapping ist, wie andere erklärt haben, im Grunde genommen ein Hochfahren - ich werde die anderen guten, klaren Erklärungen nicht wiederholen.

Hooks sind hauptsächlich Implementierungen der Visitor- und Observer- Muster.

Eine der häufigsten Hook- Implementierungen ist hook_menu , mit dem Module neue Pfade in einem Drupal-System registrieren können.

function my_module_menu() {
  return array('myawesomefrontpage' => array(
    'page callback' => 'function_that_will_render_frontpage'
  ));
}

Ein sehr häufiges Muster in Drupal ist, einen [DATATYPE]_infoHaken und einen [DATATYPE]_info_alterHaken zu haben. Wenn Sie einen neuen Feldtyp erstellen möchten, implementieren Sie den entsprechenden field_info -hook und wenn Sie einen vorhandenen bearbeiten möchten, implementieren Sie den entsprechenden field_info_alter -hook.

Edit: Wie Chx die in den Kommentaren weisen darauf hin, das Beobachter - Muster ist Gegenstand orientiert, die Drupal 7 ist immer noch, vor allem, nicht. Es gibt jedoch eine Wiki-Seite, Drupal-Programmierung aus einer objektorientierten Perspektive (Erstellt von JonBob am 4. April 2005), die erklärt, wie Drupal trotzdem objektorientierte Codemuster verwendet. Es ist interessant zu bemerken, dass es Beobachter, aber keine Besucher erwähnt.

Anmerkung zu Drupal 8 Dies ist noch relativ früh und kann sich ändern. Ich möchte jedoch hinzufügen, dass Hooks zwar seit geraumer Zeit der De-facto-Standard für das Hinzufügen von Funktionen zu Drupal sind, das Konzept der Plugins jedoch viel sichtbarer wird in Drupal 8, und wird uns neue Möglichkeiten der Interaktion mit Core geben. Relevantes Problem und Dokumentation .

Für Laien sind Hooks eine Art Brücke, über die Module miteinander interagieren, die Struktur und Daten des anderen ändern, neue Daten bereitstellen usw.

In den meisten Fällen wird das Wort hook_in Funktionsnamen durch den Namen Ihres Moduls ersetzt. Auf diese Weise kann Ihr Modul den Betrieb eines anderen Moduls nutzen. Zum Beispiel ruft ein Drupal-Kernmodul namens "node" verschiedene Hooks auf. Eine davon wird hook_node_updatejedes Mal aufgerufen, wenn ein vorhandener Knoten aktualisiert wird. Wenn dieser Hook aufgerufen wird, wird die mymoduleImplementierung Ihres Moduls (sagen wir, wir nennen es ) hook_node_updateaufgerufen. In diesem Fall handelt es sich um eine Funktion in der .module-Datei mymodule_node_updateIhres Moduls es ist auch in der .module-Datei enthalten). Diesem Hook werden auch die notwendigen Parameter (Variablen) übergeben, die er verwenden, ändern und / oder zu der Funktion zurückkehren kann, die den Hook aufgerufen hat.

Als ich anfing, Drupal zu lernen, saß ich im selben Boot wie Sie, es ist anfangs etwas schwierig zu verstehen, aber sobald Sie es verstanden haben, ist es so einfach und intuitiv. Viel Glück.

Einer der Kernentwickler hat vor einiger Zeit einen Artikel mit dem Titel "Drupal-Programmierung aus einer objektorientierten Perspektive" verfasst . Es ist gut zu erklären, wie Hooks als Implementierung vieler gängiger Entwurfsmuster angesehen werden können . Die beste Erklärung für Haken stammt aus dem Artikel:

Das Hook-System von Drupal ist die Basis für seine Schnittstellenabstraktion. Hooks definieren die Operationen, die an oder von einem Modul ausgeführt werden können. Wenn ein Modul einen Hook implementiert, schließt es einen Vertrag ab, um eine bestimmte Aufgabe auszuführen oder einen bestimmten Informationstyp zurückzugeben, wenn der Hook aufgerufen wird. Der aufrufende Code muss nichts über das Modul oder die Art und Weise wissen, in der der Hook implementiert ist, damit durch Aufrufen des Hook nützliche Arbeit geleistet wird.

Der Bootstrap ist der Prozess, den Drupal durchläuft, um eine Seite zu erstellen, die im Grunde den gesamten Kern-, Design- und Modulcode in der richtigen Reihenfolge durchläuft.
Im Grunde bootet Drupal und bereitet sich darauf vor, seine Arbeit als CMS zu erledigen.

Es ist insofern clever, als es uns ermöglicht, Hooks an einer beliebigen Stelle in unseren Modulen und Themes zu platzieren, und der Bootstrap-Prozess stellt sicher, dass sie zum richtigen Zeitpunkt ausgeführt werden.
Wenn Sie zum Beispiel 'hook_form_alter' verwenden, um einem Formular ein benutzerdefiniertes Kontrollkästchen hinzuzufügen, stellt Drupals Bootstrap sicher, dass dieser Code ausgeführt wird, kurz bevor es Ihr Formular rendert.

Ein Problem mit dem Bootstrap ist, dass der gesamte Prozess einige Zeit in Anspruch nimmt, selbst wenn Sie nur eine kleine Datenmenge zurückgeben. Wenn Sie Drupal mit dem Services-Modul als API verwenden und viele kleine XHTML- oder JSON-Antworten zurückgeben, ist die Ausführung des gesamten Bootstraps nicht sehr performant. Einige clevere Leute suchen nach Wegen, um dies für Drupal 8 zu umgehen.

Für das Rendern normaler Drupal-Seiten funktioniert der Bootstrap-Prozess jedoch hervorragend. Er verwendet das Drupals-Caching-System, um die Dinge zu beschleunigen, und gibt Ihnen die vollständige Kontrolle über jeden Teil Ihrer Website. Wenn Sie feststellen, dass Ihre Site langsam ist, können Sie immer etwas wie APC oder MemCached verwenden, um die Geschwindigkeit zu erhöhen.

Ich hoffe, meine Antwort war richtig und erklärt die Dinge einfach für Sie, ich bin kein Experte, aber ich denke, dass es so funktioniert.

Bootstrap ist der Prozess, während dessen Drupal sich selbst initialisiert. Der Prozess umfasst tatsächlich:

• Festlegen des Fehlers und der Ausnahmebehandlungsroutinen
• Initialisierung des Werts einiger spezifikationsglobaler Variablen in $_SERVER
• Einige Variablen werden mit initialisiert init_set()
• Ermitteln der zwischengespeicherten Version der zu liefernden Seite
• Initialisierung der Datenbank
• Festlegen der Handler, die Dateien laden, wenn eine Klasse oder eine Schnittstelle nicht gefunden wird
• Initialisierung der Drupal-Variablen
• Initialisierung der PHP-Sitzung
• Initialisierung der Sprachvariablen
• Laden der aktivierten Module

Einige der Operationen, die ich beschrieben habe, sind spezifisch für Drupal 7 oder höher, aber die meisten Operationen sind unabhängig von der Drupal-Version.

Ein Hook ist eine PHP-Funktion, die bei Bedarf von Drupal oder Modulen von Drittanbietern aus aufgerufen werden kann, um eine Aufgabe auszuführen. Anstatt eine vorangestellte Liste mit aufzurufenden Funktionen zu haben, werden in der Liste die aktivierten Module und die von ihnen implementierten Funktionen überprüft.
Zum Beispiel verwendet Drupal hook_node_update(); Wenn ein Knoten mit node_save () gespeichert wird , wird der folgende Code ausgeführt.

// Call the node specific callback (if any). This can be
// node_invoke($node, 'insert') or
// node_invoke($node, 'update').
node_invoke($node, $op);

Was node_invoke () macht, ist das Folgende:

• Liste aller aktivierten Module abrufen
• Prüfen, ob die aktivierten Module eine Funktion haben, deren Name auf "_node_update" endet und mit dem Kurznamen des Moduls beginnt
• Aufruf dieser Funktion, Übergabe $nodeals Parameter

Hooks können ihre eigenen Daten in einer Datenbank speichern oder den von einer Funktion zurückgegebenen Wert ändern. Der letzte Fall ist zum Beispiel, was mit hook_form_alter () passiert , was den Wert von $formübergeben als Referenz auf drupal_prepare_form () ändert .

Drupal-Hooks werden im Allgemeinen mit drei Funktionen aufgerufen:

• drupal_alter ()
• module_invoke ()
• module_invoke_all ()

drupal_alter()ist die Funktion, die zum Aufrufen bestimmter Hooks verwendet wird, deren Zweck darin besteht, die als Referenz übergebenen Daten zu ändern, z. B. hook_form_alter () , hook_hook_info_alter () und hook_tokens_alter () .

Es gibt andere Funktionen, die zum Aufrufen von Hooks verwendet werden, wie z. B. node_invoke(), aber diese Funktionen verwenden im Wesentlichen eine der zuvor aufgeführten Funktionen.

Haken sind pointcuts und module_invoke_allist der Weber (leider sind wir in der Implementierung nicht klar und es gibt andere Webfunktionen). Nach meinem Kenntnisstand ist Drupal das einzige System, das AOP mit PHP-Funktionen implementiert .

Weitere Informationen finden Sie unter Wie funktioniert AOP in Drupal?

Wenn Sie die Hooks sehen möchten, mit denen Drupal Sie anrufen kann, gehen Sie zu api.drupal.org , gehen Sie zum Suchfeld und geben Sie 'hook_' ein. Dies gibt Ihnen eine große Liste der meisten von Drupal definierten Hooks. Tun Sie dasselbe für '_alter' und sehen Sie noch mehr.

Die Seite Node API Hooks bietet eine chronologische Liste aller Hooks, die während der Knotenoperationen aufgerufen werden. Sie können sehen, wie sich das Knotenmodul und das Entity- und das Field-System beim Aufrufen von Hooks gegenseitig drehen.

Wenn Sie zum Beispiel nach unten scrollen und den Abschnitt nachsehen node_load(): Das Node-Modul gibt Ihnen ein hook_load () und übergibt dann die Steuerung an das Entitätssystem, das einige Felder lädt. Es gibt eine ganze Reihe von Feld-Hooks, die nicht aufgelistet sind, und wenn dies vorbei ist, ruft das Entity-System auf hook_entity_load(), bevor die Kontrolle an den Node zurückgegeben wird, der sie aufruft hook_node_load().

Dies gibt Ihrem Code die Möglichkeit, beim Laden Stück für Stück auf den betreffenden Knoten zu reagieren. Das Erlernen dieser Hooks und wann und warum sie aufgerufen werden, ist Teil des Abenteuers der Drupal-Codierung. :-)

Andere Systeme haben auch Haken. Wie hook_init()und hook_boot(). Dies bringt Sie zum Bootstrap-Teil Ihrer Frage. hook_boot()wird von Drupal aufgerufen, bevor das Caching-System geladen wurde. Wenn Ihr Modul also etwas tun muss, bevor Drupal wirklich gestartet ist, und Sie möchten, dass Ihr Code unabhängig vom Caching ausgeführt wird, müssen Sie dies implementieren hook_boot(). Andernfalls würden Sie implementieren, wenn Sie sich nur für Seiten interessieren, die nicht zwischengespeichert sind hook_init().

Dies gibt Ihnen die Möglichkeit, etwas früh im Ladevorgang zu implementieren, bevor Drupal vollständig gebootet wurde, und Ihnen gleichzeitig eine gewisse Flexibilität zu geben, an welcher Stelle des Prozesses Sie abfangen möchten.

Wenn Sie sicherstellen müssen, dass Drupal zu einem bestimmten Zeitpunkt gestartet wurde, bevor Sie fortfahren, können Sie anrufen drupal_bootstrap(). Wenn Sie sich zu dieser Dokumentation durchklicken, sehen Sie die verfügbaren Bootstrap-Stufen, von nichts bis zu allem.

Schließlich können Sie im Beispielprojekt ausführlich dokumentierten Code für ein bestimmtes Subsystem sehen .

Hooks sind PHP-Funktionen, Bausteine, die auf den Namenskonventionen "yourmodulename_hookname" basieren. Sie sollen Entwicklern das Erstellen von Modulen erleichtern .

Module sind das einzig wahre, da sie sowohl CORE- als auch benutzerdefinierte Funktionen in Ihrem Drupal-System ermöglichen. Module bestehen also aus Hooks, und wenn ein Modul in Ihrer Drupal-Installation aktiviert ist, können seine Hook-Funktionen dank der module.inc-Funktion module_invoke_all ($ hook) oder module_invoke von anderen Modulen aufgerufen werden.

Um zu verstehen, was Haken sind, sollten Sie sich die Hände schmutzig machen und die Modulentwicklung ausprobieren. Beginnen Sie zu diesem Zweck mit dem Herunterladen und Testen einiger Drupal-Beispiele für Entwickler . Sie sollten sich auch mit der Modulerstellung vertraut machen .

Hier sind einige der nützlichen Drupal-Beispiele für die oben genannten Entwickler:

Implementierungsbeispiel für hook_block_view () im Modul block_example

/**
 * @file examples/block_example/block_example.module line 127
 *
 * Implements hook_block_view().
 *
 * This hook generates the contents of the blocks themselves.
 */
function block_example_block_view($delta = '') {
  //The $delta parameter tells us which block is being requested.
  switch ($delta) {
    case 'example_configurable_text':
      // The subject is displayed at the top of the block. Note that it
      // should be passed through t() for translation. The title configured
      // for the block using Drupal UI supercedes this one.
      $block['subject'] = t('Title of first block (example_configurable_text)');

Mit diesem Hook können Sie auf die Erstellung von Drupal-Blöcken zugreifen, um benutzerdefinierte Blöcke auf Ihrer Website anzuzeigen. Dies ist möglich, da das block.module eine _block_render_block-Funktion hat, mit der alle Module ihre hook_block-Ansicht definieren können (beachten Sie die letzte Zeile von module_invoke):

/**
 * @file modules/block/block.module, line 838
 *
 * Render the content and subject for a set of blocks.
 *
 * @param $region_blocks
 *   An array of block objects such as returned for one region by _block_load_blocks().
 *
 * @return
 *   An array of visible blocks as expected by drupal_render().
 */
function _block_render_blocks($region_blocks) {
  ...
  foreach ($region_blocks as $key => $block) {
    ...
    $array = module_invoke($block->module, 'block_view', $block->delta);

Implementierungsbeispiel für hook_menu () im Modul render_example

/**
 * @file examples/render_example/render_example.module line 22
 * 
 * Implements hook_menu().
 */
function render_example_menu() {
  ...
  $items['examples/render_example/arrays'] = array(
    'title' => 'Render array examples',
    'page callback' => 'render_example_arrays',
    'access callback' => TRUE,
  );

Dieser Hook ist mit dem URL-Routing-System von Drupal verknüpft und definiert URL-Muster mit zugehörigen Render-Rückrufen, die von Ihrem Modul verwendet werden. Es wird von system.module aufgerufen .

Grundsätzlich müssen Sie über den Bootstrap nur wissen, dass er bei jeder Seitenanforderung ausgeführt wird. Ich rate Ihnen wirklich, diese Stackoverflow-Antwort zu lesen . Sie erklärt, wie Bootstrap und Hooks zusammenhängen, aber voneinander getrennt sind.

In Bezug auf die Anzeige der Webseite wird die HTML-Anzeige der Drupal-Website hauptsächlich mit Render-Arrays und Theming erzielt .

Überall ein Modul ruft module_implements () http://api.drupal.org/api/drupal/includes%21module.inc/function/module_implements/7 Drupal werden alle korrekt genannten Funktionen in der richtigen Reihenfolge auf ihr Gewicht basierend abzufeuern. Diese werden als Hook-Funktionen bezeichnet, da in der Dokumentation für Module, die module_implements verwenden, Dinge wie hook_menu angezeigt werden (wenn das Menü alle Funktionen aufruft, die Menüelemente zurückgeben sollen). Das Wort "hook" muss nur durch den Namen des Moduls ersetzt werden, das es implementiert, und Drupal erledigt den Rest.

Es gibt auch eine drupal_alter () -Funktion, die alle korrekt benannten alter-Funktionen auslöst, mit der Absicht, Sie Dinge ändern zu lassen, die zuvor von einem anderen Hook registriert wurden.

Im Allgemeinen übergeben Änderungen Argumente als Referenz, sodass Sie das Objekt direkt bearbeiten können, wohingegen "normale" Hooks Sie normalerweise dazu bringen, neue Dinge zurückzugeben.

Die Idee ist, dass jedes Modul (einschließlich Ihres eigenen) einfach erweitert werden kann, indem Drupal aufgefordert wird, alle erforderlichen Hook-Funktionen aufzurufen und das zurückzugewinnen, was zur Verarbeitung zurückgegeben wird. Das Modul, das die Hook-Funktionen aufruft, muss nichts über die Module wissen, die die Hooks implementieren, und die Module, die den Hook implementieren, müssen nichts über das Modul wissen, das den Hook aufruft. Das einzige, was beide Module wissen müssen, ist die Struktur der zurückgegebenen oder geänderten Daten.

In der Praxis werden Haken üblicherweise verwendet, um:

• auf Ereignisse reagieren, wie hook_user_login aufgerufen wird, wenn sich ein Benutzer anmeldet
• Registrieren Sie etwas Neues, mit dem Sie das System erweitern können, wie zum Beispiel hook_menu
• Theme / HTML rendern oder Formulare erstellen / validieren / senden

Sie haben oben eine Menge Antworten, aber ich möchte eine Antwort auf viel einfachere Weise geben, um das grundlegende Konzept hinter Hooks zu verstehen. Hooks sind tatsächlich in Funktionen in Drupal Core integriert, um verschiedene Dinge zu verwalten und verschiedene Aufgaben in Core zu erledigen. Sie können Ihre eigenen Funktionen mit diesen integrierten Funktionen von Drupal Core synchronisieren, um ihre Funktionalität in Ihre eigenen Funktionen zu integrieren, indem Sie verschiedene Hooks aufrufen.

Ich hoffe, dass Sie den Punkt bekommen!

Für mich dreht sich alles um die Funktion module_implements, wenn es um Hooks und Core (D7) geht. Eine Sache, die ich für entscheidend halte, um zu verstehen, ist, dass Sie beim Schreiben eines Hakens zum Ändern von etwas keineswegs das letzte Wort darüber haben, was mit den Datenstrukturen geschieht, mit denen Sie es zu tun haben. Ihr Hook wird einfach in die Zeile (Warteschlange) von Funktionen eingereiht, die AUCH auf die gleichen Datenstrukturen einwirken, unabhängig davon, ob es sich um Menüs, menu_links, Blöcke, Knoten, Benutzer oder Entitäten oder Renderelemente handelt.

Um wirklich zu sehen, wie Ihre Haken in einer erwarteten Weise verwendet werden, müssen Sie wissen oder sich dessen bewusst sein, wo Sie (Ihr Haken) in der Schlange stehen. Dies wird durch das Gewicht Ihres Mondules bestimmt. Drupal Core ruft einfach die korrekt benannten Hooks in aufsteigender Gewichtsreihenfolge auf und was auch immer mit den Daten passiert, passiert.

Ich habe zuvor Hooks geschrieben, die keinen Effekt hatten, nur um nach stundenlangem Headbangen festzustellen, dass mein Modulgewicht zu leicht war und nachfolgende Hooks praktisch nicht das taten, was ich tat, oder alles zusammen ignorierten.

Ein gut geschriebener Hook wird sich nicht als "Mensch behandeln" oder "zwingen", der letzte zu sein, sondern wird "nett zu anderen" platziert, indem sichergestellt wird, dass sie die Datenstrukturen beibehalten, wie sie von den übrigen Hooks in der Folge erwartet werden.

Und wenn man von "The Line" der Haken spricht. Im Laufe der Jahre, in denen ich auf Google nach Drupal-Inhalten gesucht habe, scheint dieses Bild eine gute Darstellung der Vorverarbeitungs- und Prozess-Hook-Liste der Möglichkeiten zu sein.

Auf viel einfachere Weise helfen Hooks dem Entwickler, die vorhandene Funktionalität entsprechend den Anforderungen zu ändern, ohne Änderungen am vorhandenen Code vorzunehmen. Eher wie abstrakte Funktion in PHP.

Beispiel: Sie haben ein Modul zur Buchung eines Bustickets angelegt. Laut Ihrem Code kann der Abholort nicht bearbeitet werden, wenn das Ticket einmal gebucht wurde. Angenommen, Ihr Freund benötigt dasselbe Modul für ähnliche Anforderungen, mit der Ausnahme, dass der Benutzer den Abholort ändern kann. Irgendwie muss er Ihr Modul verwenden und Sie möchten nicht, dass er Codeänderungen vornimmt. Sie stellen also eine Schnittstelle (in unserem Fall Hook) zur Verfügung, über die er seine Änderungen implementieren kann, ohne Änderungen an Ihrem Modul vorzunehmen.

In Drupal bis Drupal-7 haben wir Hooks für Module sowie Themen. Um zu erfahren, wie Hooks funktionieren, klicken Sie auf drupal.org , um einen benutzerdefinierten Hook zu erstellen, und klicken Sie auf diesen Link

Haken. Ermöglichen Sie Modulen die Interaktion mit dem Drupal-Kern. Das Modulsystem von Drupal basiert auf dem Konzept der "Hooks". Ein Hook ist eine PHP-Funktion mit dem Namen foo_bar (), wobei "foo" der Name des Moduls (dessen Dateiname also foo.module lautet) und "bar" der Name des Hooks ist.