Snippets

Todas las categorías

Actualizar datos en una tabla

Actualiza un registro existente en una tabla
Actualizar datos en una tabla
              

/**
* Updates data in a custom table.
*/
function my_module_update_data() {
    \Drupal::database()->update('custom_table')
        ->fields([
            'status' => 0,
        ])
        ->condition('id', 5, '=')
        ->execute();
}
 


Actualizar traducciones con Drupal

Actualiza (importa) las traducciones disponibles.
Actualizar traducciones con Drupal
              

/**
* Updates the translations installed on the system.
*/
drush locale:update;


Adjuntar contextos de caché mediante CacheableMetadata en un servicio

Cómo adjuntar contextos de caché a una array renderizado utilizando CacheableMetadata en un servicio personalizado.
Adjuntar contextos de caché mediante CacheableMetadata en un servicio
              

namespace Drupal\my_module\Service;
use Drupal\Core\Cache\CacheableMetadata;

class MyDataService {
   public function buildData(): array {
      $build = [
         '#markup' => 'Dynamic data output.',
      ];
      $cache_metadata = new CacheableMetadata();
      $cache_metadata->setCacheContexts(['route', 'user.roles']);
      $cache_metadata->applyTo($build);
      return $build;
   }
}
 


Alteración de títulos y atributos básicos de formularios

Modifica el título del formulario y añada atributos personalizados al formulario.
Alteración de títulos y atributos básicos de formularios
              

/**
* Implements hook_form_alter().
*/
function my_module_form_alter(&$form, FormStateInterface $form_state, $form_id) {
    // Check if the form ID matches.
    if ($form_id == 'user_register_form') {
        // Change form title.
        $form['#title'] = t('Custom User Registration');

        // Modify form attributes.
        $form['#attributes']['class'][] = 'custom-form-class';
        $form['#attributes']['id'] = 'custom_form_id';
    }
}
 


Alteración de una vista para añadir contextos de caché

Define hook_entity_view_alter() para añadir un contexto de caché adicional (permisos de usuario).
Alteración de una vista para añadir contextos de caché
              

/**
* Implements hook_entity_view_alter() to add cache contexts.
*/
function my_module_entity_view_alter(array &$build, \Drupal\Core\Entity\EntityInterface $entity, \Drupal\Core\Entity\Display\EntityViewDisplayInterface $display, $view_mode) {
   $build['#cache']['contexts'][] = 'user.permissions';
}
 


Añadir un botón de submit personalizado

Añade un botón de envío personalizado con atributos específicos y un gestor de envío personalizado.
Añadir un botón de submit personalizado
              

/**
* Implements hook_form_alter() to add a custom submit button.
*/
function my_module_form_alter(&$form, FormStateInterface $form_state, $form_id) {
    if ($form_id == 'user_register_form') {
        // Add a custom submit button.
        $form['actions']['custom_submit'] = [
            '#type' => 'submit',
            '#value' => t('Custom Register'),
            '#attributes' => [
                'class' => ['custom-submit-button'],
            ],
            '#submit' => ['my_module_custom_submit_handler'],
        ];
    }
}

function my_module_custom_submit_handler(&$form, $form_state, $form_id) { 

// Custom submit code.

}


Añadir un campo personalizado

Añadir nuevos campos personalizados a un formulario existente.
Añadir un campo personalizado
              

/**
* Implements hook_form_alter().
*/
function my_module_form_alter(&$form, FormStateInterface $form_state, $form_id) {

    // Lets modify the registration form.
    if ($form_id == 'user_register_form') {
        // Add a new custom text field.
        $form['new_text_field'] = [
            '#type' => 'textfield',
            '#title' => t('Custom Field'),
            '#description' => t('This is a custom field added via form alter.'),
        ];
    }
}
 


Añadir validación personalizada de formularios

Añadir validación personalizada de formularios
Añadir validación personalizada de formularios
              

/**
* Implements hook_form_alter() to add custom validation.
*/
function my_module_form_alter(&$form, FormStateInterface $form_state, $form_id) {
    if ($form_id == 'user_register_form') {
        // Add custom validation callback.
        $form['#validate'][] = 'my_module_custom_validate';
    }
}

// Now the validation function should be implemented.
function my_module_custom_validate(&$form, FormStateInterface $form_state, $form_id) {
 // Validation code. 
}


Anular la caché mediante inyección de dependencias

Cómo anular los metadatos de caché por defecto para una respuesta JSON utilizando la inyección de dependencia.
Anular la caché mediante inyección de dependencias
              

namespace Drupal\my_module\Controller;
use Drupal\Core\Controller\ControllerBase;
use Drupal\Core\Ajax\CacheableJsonResponse;
use Drupal\Core\Cache\CacheableMetadata;
use Symfony\Component\DependencyInjection\ContainerInterface;
 

/**
* Returns a JSON response with overridden cache metadata.
*/
class OverrideCacheController extends ControllerBase {
   /**
    * {@inheritdoc}
    */
   public static function create(ContainerInterface $container) {
      return new static();
   }

   public function overrideCache(): CacheableJsonResponse {
      $data = [
         'content' => $this->t('Response with overridden cache metadata.'),
      ];
      $response = new CacheableJsonResponse($data);
      $cache_metadata = new CacheableMetadata();
      $cache_metadata->setCacheTags(['override_tag']);
      $cache_metadata->setCacheContexts(['user.uid']);
      $cache_metadata->setCacheMaxAge(0); // Non-cacheable
      $response->addCacheableDependency($cache_metadata);
      return $response;
   }
}
 


Array renderizable con metadatos de caché

Cómo añadir contextos de caché, etiquetas y max-age a un array de renderizable.
Array renderizable con metadatos de caché
              

/**
* Render array with Cache API metadata.
*/
$form = [];
$form['content'] = [
   '#markup' => 'Hello World',
   '#cache' => [
      'contexts' => ['user.permissions'],
      'tags' => ['node_list'],
      'max-age' => 3600,
   ],
];
return $form;
 


Array renderizado con contextos de caché

Cómo añadir contextos de caché a un array de renderizado para que varíe según los roles de usuario.
Array renderizado con contextos de caché
              

$build = [
   '#markup' => 'Hello, world!',
   '#cache' => [
      'contexts' => ['user.roles'],
   ],
];
return $build;
 


Asignar un valor de configuración con Drush

Asigna y guarda directamente un valor de configuración usando Drush.
Asignar un valor de configuración con Drush
              

/**
* Saves a configuration value directly.
*/
drush config:set system.site name "New Site Name";
 


Bloque básico personalizado

Crea un bloque simple «Hola Mundo».
Bloque básico personalizado
              

namespace Drupal\my_module\Plugin\Block;
use Drupal\Core\Block\BlockBase;

/**
* Provides a 'Hello World' block.

* @Block(
* id = "hello_world_block",
* admin_label = @Translation("Hello World Block")
* )
*/
class HelloWorldBlock extends BlockBase {
   public function build(): array {
      return [
         '#markup' => $this->t('Hello, world!'),
      ];
   }
}
 


Bloque configurable

Crea un bloque que tiene un formulario de configuración en los ajustes del bloque.
Bloque configurable
              

namespace Drupal\my_module\Plugin\Block;
use Drupal\Core\Block\BlockBase;
use Drupal\Core\Form\FormStateInterface;

/**
* Provides a configurable block.
*
* @Block(
* id = "configurable_block",
* admin_label = @Translation("Configurable Block")
* )
*/

class ConfigurableBlock extends BlockBase {
   /**
    * {@inheritdoc}
    */
   public function build(): array {
      $config = $this->getConfiguration();
      return [
         '#markup' => $this->t('Configurable value: @value', ['@value' => $config['block_value'] ?? 'Default']),
      ];
   }

   /**
    * {@inheritdoc}
    */
   public function blockForm(array $form, FormStateInterface $form_state): array {
      $form = parent::blockForm($form, $form_state);
      $config = $this->getConfiguration();
      $form['block_value'] = [
         '#type' => 'textfield',
         '#title' => $this->t('Block Value'),
         '#default_value' => $config['block_value'] ?? '',
      ];
      return $form;
   }

   /**
    * {@inheritdoc}
    */
   public function blockSubmit(array &$form, FormStateInterface $form_state): void {
      $this->setConfigurationValue('block_value', $form_state->getValue('block_value'));
   }
}
 


Bloquear plugin con metadatos de caché

Bloque personalizado que define metadatos de caché para su salida de renderizado.
Bloquear plugin con metadatos de caché
              

/**
* Provides a 'CachedContentBlock' block.
* @Block annotation is assumed to be defined in the plugin YAML.
*/
use Drupal\Core\Block\BlockBase;

class CachedContentBlock extends BlockBase {
   /**
   * {@inheritdoc}
   */
   public function build(): array {
      $build = [
         '#markup' => $this->t('This content is cached.'),
         '#cache' => [
            'contexts' => ['url.path'],
            'tags' => ['my_module_block'],
            'max-age' => 600,
         ],
      ];
      return $build;
   }
}
 


Borrar un registro

Elimina un registro de una tabla específica
Borrar un registro
              

/**
* Deletes a record from a custom table.
*/
function my_module_delete_data() {
    \Drupal::database()->delete('custom_table')
        ->condition('id', 10, '=')
        ->execute();
}
 


Clase de formulario personalizado compatible con Ajax

Crea un formulario personalizado que utiliza Ajax para actualizar parte del formulario (un contenedor) cada vez que cambia el valor del campo de texto.
Clase de formulario personalizado compatible con Ajax
              

/**
* Provides an example AJAX form.
*/
namespace Drupal\my_module\Form;
use Drupal\Core\Form\FormBase;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Ajax\AjaxResponse;
use Drupal\Core\Ajax\HtmlCommand;

class AjaxExampleForm extends FormBase {
   /**
   * {@inheritdoc}
   */
   public function getFormId(): string {
      return 'ajax_example_form';
   }

   /**
   * {@inheritdoc}
   */
   public function buildForm(array $form, FormStateInterface $form_state): array {
      $form['example_text'] = [
         '#type' => 'textfield',
         '#title' => $this->t('Enter text'),
         '#ajax' => [
            'callback' => '::ajaxCallback',
            'wrapper' => 'result-wrapper',
            'event' => 'keyup',
         ],
      ];
      $form['result'] = [
         '#type' => 'container',
         '#attributes' => ['id' => 'result-wrapper'],
      ];
      return $form;
   }

   /**
   * Ajax callback to update the result container.
   */
   public function ajaxCallback(array &$form, FormStateInterface $form_state): AjaxResponse {
      $response = new AjaxResponse();
      $value = $form_state->getValue('example_text');
      $response->addCommand(new HtmlCommand('#result-wrapper', $this->t('You typed: @value', ['@value' => $value])));
      return $response;
   }

   /**
   * {@inheritdoc} (No submission processing required.)
   */
   public function submitForm(array &$form, FormStateInterface $form_state): void { }
}
 


Comando Post-Despliegue

Ejecuta varios comandos tras un despliegue de código.
Comando Post-Despliegue
              

/**
* Executes post-deployment commands.
*/
drush deploy;
 


Comprobar actualización de traducciones con Drush

Comprueba si existen actualizaciones en las traducciones.
Comprobar actualización de traducciones con Drush
              

/**
* Check for updates in translations.
*/
drush locale:check;


Comprobar el directorio de Drupal con Drush

Devuelve la ruta del sistema de archivos para módulos, temas, etc.
Comprobar el directorio de Drupal con Drush
              

/**
* Displays the directory path for modules, themes or other items.
*/
drush drupal:directory modules/contrib;
// Alias: dr:dir
// Output: /var/www/html/modules/contrib
 


Comprobar información de campos configurables con Drush

Lista todos los campos configurables de un tipo de entidad.
Comprobar información de campos configurables con Drush
              

/**
* Lists the configurable fields for a bundle.
*/
drush field:info node article;
 


Comprobar informe de estado con Drush

Muestra el reporte de requisitos del sistema (informe de estado).
Comprobar informe de estado con Drush
              

/**
* Displays the Drupal site requirements report.
*/
drush core:requirements
 


Comprobar la información de entorno con Drush

Obtiene un resumen del estado del entorno (Drush y Drupal).
Comprobar la información de entorno con Drush
              

/**
* Displays a summary of the status of the Drupal and Drush environment.
*/
drush core:status;

 


Consulta Select simple

Consulta básica para obtener resultados de una tabla específica
Consulta Select simple
              

/**
* Fetches data from a custom table.
*/
function my_module_get_data() {
    $query = \Drupal::database()->select('custom_table', 'ct');
    $query->fields('ct', ['id', 'name', 'status']);

    $result = $query->execute()->fetchAll();

    return $result;
}
 


Creación de una clase de comando Ajax personalizada

Define una clase de comando Ajax personalizado que implementa CommandInterface de Drupal. El comando devuelve una estructura JSON con un mensaje personalizado.
Creación de una clase de comando Ajax personalizada
              

/**
* Defines a custom Ajax command.
*/
namespace Drupal\my_module\Ajax;
use Drupal\Core\Ajax\CommandInterface;

class CustomCommand implements CommandInterface {
   /**
   * The message to display.
   */
   protected string $message;

   /**
   * Constructs a CustomCommand object.
   */
   public function __construct(string $message) {
      $this->$message = $message;
   }

   /**
   * {@inheritdoc}
   */
   public function render(): array {
      return [
         'command' => 'customCommand',
         'message' => $this->$message,
      ];
   }
}
 


Crear un campo nuevo con Drush

Crea un nuevo campo (almacenamiento y instancia).
Crear un campo nuevo con Drush
              

/**
* Creates a new field for an entity bundle.
*/
drush field:create node article field_tags taxonomy_term;
 


Crear un usuario administrador con Drush

Crea un nuevo usuario con el nombre de usuario y la contraseña especificados.
Crear un usuario administrador con Drush
              

/**
* Create a new user with a password.
*/
drush user:create username --mail=user@example.com --password=password;
 


Eliminar entidades con Drush

Elimina entidades de contenido.
Eliminar entidades con Drush
              

/**
* Removes content entities from a given bundle.
*/
drush entity:delete node --bundle=article;
 


Eliminar un campo con Drush

Elimina un campo de un tipo de entidad.
Eliminar un campo con Drush
              

/**
* Removes a field from a bundle.
*/
drush field:delete node article field_tags;
 


Exportar todo un proyecto con Drush

Hace un backup del código, archivos y base de datos en un solo archivo.
Exportar todo un proyecto con Drush
              

/**
* Creates an archive dump that includes code, files and database.
*/
drush archive:dump --destination=/path/to/archive.tar.gz --overwrite --exclude-code-paths=web/sites/default/settings.php
// Alias: N/A
// Output: Archive created at /path/to/archive.tar.gz
 


Exportar traducciones conDrush

Exporta traducciones a un archivo PO (gettext).
Exportar traducciones conDrush
              

/**
* Export translations to a .po file.
*/
drush locale:export fr --file=translations.fr.po;
 


Formulario de carga dinámica de contenidos («Cargar más»)

Formulario personalizado que muestra una lista de elementos y un botón «Cargar más». Cuando se hace clic en el botón, un callback Ajax añade nuevos elementos a la lista de forma dinámica sin necesidad de recargar toda la página.
Formulario de carga dinámica de contenidos («Cargar más»)
              

/**
* Load More Form using AJAX.
*/
namespace Drupal\my_module\Form;

use Drupal\Core\Form\FormBase;
use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Ajax\AjaxResponse;
use Drupal\Core\Ajax\AppendCommand;

class LoadMoreForm extends FormBase {

   /**
   * {@inheritdoc}
   */
   public function getFormId(): string {
      return 'load_more_form';
   }

   /**
   * {@inheritdoc}
   */
   public function buildForm(array $form, FormStateInterface $form_state): array {
      $items = $form_state->get('items') ?? ['Item 1', 'Item 2', 'Item 3'];
      $form_state->set('items', $items);

      $form['items_container'] = [
         '#type' => 'container',
         '#attributes' => ['id' => 'items-container'],
      ];

      foreach ($items as $item) {
         $form['items_container'][] = [
            '#markup' => '<p>' . $item . '</p>',
         ];
      }

      $form['load_more'] = [
         '#type' => 'submit',
         '#value' => $this->t('Load more'),
         '#ajax' => [
            'callback' => '::loadMoreAjaxCallback',
            'wrapper' => 'items-container',
            'effect' => 'fade',
         ],
      ];

      return $form;
   }

   /**
   * AJAX callback to append new items.
   */
   public function loadMoreAjaxCallback(array &$form, FormStateInterface $form_state): AjaxResponse {
      $response = new AjaxResponse();
      $items = $form_state->get('items') ?? [];

      $count = count($items) + 1;
      $new_items = [
         ['#markup' => '<p>Item ' . $count . '</p>'],
         ['#markup' => '<p>Item ' . ($count + 1) . '</p>'],
      ];

      $items[] = 'Item ' . $count;
      $items[] = 'Item ' . ($count + 1);
      $form_state->set('items', $items);
      $response->addCommand(new AppendCommand('#items-container', $new_items));

      return $response;
   }

   /**
   * {@inheritdoc} (No normal submit processing required.)
   */
   public function submitForm(array &$form, FormStateInterface $form_state): void {}
}
 


Generar código con Drush

Generar código base (plantilla) para módulos, plugins, etc.
Generar código con Drush
              

/**
* Generates code base for different elements (modules, plugins, etc.).
*/
drush generate;
 


Importar traducciones con Drush

Importar traducciones desde un archivo .po.
Importar traducciones con Drush
              

/**
* Import translations from a .po file.
*/
drush locale:import fr translations.fr.po;
 


Información de campos base de una entidad

Obtiene información de todos los campos base de un tipo de entidad.
Información de campos base de una entidad
              

/**
*  Lists the base fields of an entity.
*/
drush field:base-info node;
// Alias: N/A
// Example output:
// ------------------------------- ---------- ------------------ ------------- 
// Field name Required Field type Cardinality 
// ------------------------------- ---------- ------------------ ------------- 
// nid integer 1 
// uuid uuid 1 
// vid integer 1 
// langcode language 1 
// type ✔ entity_reference 1 
// revision_timestamp created 1 
// revision_uid entity_reference 1 
// revision_log string_long 1 
// status boolean 1 
// uid entity_reference 1 
// title ✔ string 1 
// created created 1 
// changed changed 1 
// promote boolean 1 
// sticky boolean 1 
// default_langcode boolean 1 
// revision_default boolean 1 
// revision_translation_affected boolean 1 
// metatag metatag_computed -1 
// path path 1 
// menu_link entity_reference 1 
// content_translation_source language 1 
// content_translation_outdated boolean 1 
// ------------------------------- ---------- ------------------ ------------- 
 


Insertar datos en una tabla

Inserta un nuevo registro en una tabla
Insertar datos en una tabla
              

/**
* Inserts a record into a custom table.
*/
function my_module_insert_data() {
    \Drupal::database()->insert('custom_table')
        ->fields([
            'name' => 'Sample Name',
            'status' => 1,
        ])
        ->execute();
}
 


Instalar y desinstalar un módulo con drush en Drupal

Instala/desinstala un módulo de Drupal. Al desinstalar, esto también elimina cualquier configuración asociada.
Instalar y desinstalar un módulo con drush en Drupal
              

/**
* Enable a specific module.
*/
drush en module_name -y;
 

/**
* Uninstall a specific module.
*/
drush pm:uninstall module_name -y;
 


Invalidación de caché basado en etiquetas

Cómo invalidar datos almacenados en caché utilizando etiquetas de caché.
Invalidación de caché basado en etiquetas
              

/**
* Invalidate cache entries tagged with 'my_module_tag'.
*/
\Drupal::cache()->invalidateTags(['my_module_tag']);
 


Limpiar el estado de actualizaciones de traducciones con Drush

Limpia las banderas de estado de actualización de traducciones.
Limpiar el estado de actualizaciones de traducciones con Drush
              

/**
* Clears the status of translation updates.
*/
drush locale:clear-status;
 


Modificación de campos existentes

Modifique las propiedades de los campos de formulario existentes, como los títulos y los valores por defecto.
Modificación de campos existentes
              

/**
* Implements hook_form_alter() to modify existing form fields.
*/
function my_module_form_alter(&$form, FormStateInterface $form_state, $form_id) {
    if ($form_id == 'user_register_form') {
        if (isset($form['mail'])) {
            // Change the title of the 'mail' field.
            $form['mail']['#title'] = t('Custom Email Address');

            // Change the value of the 'mail' field.
            $form['mail']['#value'] = test@example.com;
        }
    }
}
 


Mostrar todos los comandos de Drush

Muestra todos los comandos disponibles en Drush.
Mostrar todos los comandos de Drush
              

/**
* Displays a complete list of Drush commands.
*/
drush list;
 


Obtención y configuración básica de la caché

Cómo obtener y establecer datos en la caché utilizando un ID de caché único.
Obtención y configuración básica de la caché
              

/**
* Basic example of using the Cache API to get and set data.
*/
namespace Drupal\my_module;

use Drupal\Core\Cache\Cache;

$cid = 'my_module:unique_cache_id';
$cache = \Drupal::cache()->get($cid);
if ($cache) {
   $data = $cache->data;
} else {
   $data = 'result of expensive processing';
   \Drupal::cache()->set($cid, $data, Cache::PERMANENT);
}
 


Obtiene el estado del modo mantenimiento.

Muestra si el modo de mantenimiento está activado o no.
Obtiene el estado del modo mantenimiento.
              

/**
* Shows whether the maintenance mode is activated or not.
*/
drush maint:get;
Alias: N/A
Output: Maintenance mode is OFF.
 


Plugin de contexto de caché personalizado

Define un plugin de contexto de caché personalizado que devuelve la hora actual. (Asegúrate de que tu objeto es serializable).
Plugin de contexto de caché personalizado
              

namespace Drupal\my_module\Cache\Context;


use Drupal\Core\Cache\Context\CacheContextInterface;
use Drupal\Core\Cache\CacheableMetadata;

/**
* Provides a custom cache context based on the current hour.
*
* @CacheContext(
* id = "my_custom_time",
* label = @Translation("Custom Time Cache Context")
* )
*/

class MyCustomTimeCacheContext implements CacheContextInterface {
   public function getContext(): string {
      return date('H');
   }

   public function getCacheableMetadata(): CacheableMetadata {
      return new CacheableMetadata();
   }
}
 


Respuesta JSON almacenable en caché desde un controlador

Devuelve una respuesta JSON almacenable en caché con metadatos de caché personalizados (etiquetas, contextos y max-age).
Respuesta JSON almacenable en caché desde un controlador
              

namespace Drupal\my_module\Controller;
use Drupal\Core\Controller\ControllerBase;
use Drupal\Core\Cache\CacheableMetadata;
use Drupal\Core\Ajax\CacheableJsonResponse;


class MyController extends ControllerBase {
   /**
    * Returns a cacheable JSON response with custom metadata.
    */
   public function jsonContent(): CacheableResponseInterface {
      $data = [
         'message' => $this->t('Hello, cacheable JSON response!'),
      ];
      $cache_metadata = new CacheableMetadata();
      $cache_metadata->setCacheTags(['my_module_tag']);
      $cache_metadata->setCacheContexts(['url.path', 'user.roles']);
      $cache_metadata->setCacheMaxAge(3600);

      $response = new \Drupal\Core\Ajax\CacheableJsonResponse($data);
      $response->addCacheableDependency($cache_metadata);

      return $response;
   }
}
 


Servicio de caché personalizado con inyección de dependencias

Cómo definir un servicio que utilice inyección de dependencias para trabajar con el servico de caché backend.
Servicio de caché personalizado con inyección de dependencias
              

/**
* Service class for caching data using dependency injection.
*/

use Drupal\Core\Cache\CacheBackendInterface;

class MyCacheService {
   /**
   * The cache backend service.
   */
   protected CacheBackendInterface $cacheBackend;

   /**
   * Constructs a MyCacheService object.
   */
   public function __construct(CacheBackendInterface $cache_backend) {
      $this->$cacheBackend = $cache_backend;
   }

   public function getData(string $cid): ?string {
      $cache = $this->$cacheBackend->get($cid);
      return $cache ? $cache->data : NULL;
   }

   public function setData(string $cid, string $data, int $expire = CacheBackendInterface::CACHE_PERMANENT): void {
      $this->$cacheBackend->set($cid, $data, $expire);
   }
}
 


Sobrescribir un campo base con Drush

Sobrescribe un campo base de un tipo de entidad.
Sobrescribir un campo base con Drush
              

/**
* Creates an overwrite of a base field for a bundle.
*/
drush field:base-override-create node article field_example;
 


Uso de #states para mostrar/ocultar elementos del formulario

Cómo utilizar la propiedad #states para mostrar u ocultar elementos de formulario en función del valor de otro elemento de formulario.
Uso de #states para mostrar/ocultar elementos del formulario
              

/**
* Implements hook_form_alter() to add conditional states.
*/
function my_module_form_alter($form, FormStateInterface $form_state, $form_id) {
    if ($form_id == 'custom_form_id') {
        // Add a checkbox to control the visibility of another field.
        $form['show_additional_info'] = [
            '#type' => 'checkbox',
            '#title' => t('Show additional information'),
        ];

        // Add a textfield that will only be shown when the checkbox is checked.
        $form['additional_info'] = [
            '#type' => 'textfield',
            '#title' => t('Additional Information'),
            '#states' => [
                'visible' => [
                    ':input[name="show_additional_info"]' => [
                        'checked' => TRUE,
                    ],
                ],
            ],
        ];
    }
}
 


Uso de AJAX en Drupal Forms

Cómo utilizar AJAX en un formulario de Drupal para actualizar dinámicamente los elementos del formulario sin recargar la página.
Uso de AJAX en Drupal Forms
              

/**
* Implements hook_form_alter() to add AJAX functionality.
*/
function my_module_form_alter($form, FormStateInterface $form_state, $form_id) {
    if ($form_id == 'custom_form_id') {
        // Add a select element with AJAX properties.
        $form['select_field'] = [
            '#type' => 'select',
            '#title' => t('Choose an option'),
            '#options' => [
                'option_1' => 'Option 1',
                'option_2' => 'Option 2',
            ],
            '#ajax' => [
                'callback' => 'my_module_ajax_callback',
                'wrapper' => 'ajax-wrapper',
            ],
        ];

        // Add a container to be updated via AJAX.
        $form['ajax_container'] = [
            '#type' => 'container',
            '#attributes' => [
                'id' => 'ajax-wrapper',
            ],
        '#markup' => t('Select an option to update this content.'),
        ];
    }
}
 

/**
* AJAX callback function.
*/
function my_module_ajax_callback(array $form, FormStateInterface $form_state) {
    // Update the content of the AJAX container based on the selected value.
    $selected_value = $form_state->getValue('select_field');
    if ($selected_value == 'option_1') {
        $form['ajax_container']['#markup'] = t('You selected Option 1.');
    } else if ($selected_value == 'option_2') {
        $form['ajax_container']['#markup'] = t('You selected Option 2.');
    }

    // Return the updated container.
    return $form['ajax_container'];
}
 


Uso personalizado de la memoria caché

Cómo utilizar una caché personalizada (por ejemplo, definida en el YAML de servicios de tu módulo como «cache.my_module_bin») para almacenar y recuperar datos.
Uso personalizado de la memoria caché
              

/**
* Retrieve data from a custom cache bin or generate and store it.
*/
$cid = 'my_module:custom_item';
$cache_bin = \Drupal::service('cache.my_module_bin');
if ($item = $cache_bin->get($cid))) {
   $data = $item->data;
} else {
   $data = 'Expensive data calculation';
   $cache_bin->set($cid, $data, Cache::PERMANENT);
}
 


Ver documentación del core

Muestra documentación detallada sobre un tema en particular.
Ver documentación del core
              

/**
* Displays documentation on a specific Drush topic.
*/
drush core:topic;