Best practice: $ this-> t () contro t ()

Sto cercando una buona pratica: i moduli con contribuzione dovrebbero usare $this->t()o t()?

Le migliori pratiche dipendono da dove si trova il codice.

Codice OOP

Usa $this->t().

Se estendi una classe base drupal come un controller o un plug-in, la funzione t () viene fornita come metodo di classe pronto $this->t()all'uso e dovresti usarla. Questo rende il tuo codice testabile.

Per la maggior parte delle attività troverai una classe drupal adatta da estendere da cui è stata $this->t()definita, ma se hai bisogno di costruire la tua classe da zero la migliore pratica sarebbe quella di usare il tratto di traduzione delle stringhe e iniettarlo come servizio se usi questa classe in un contesto di servizio:

use Drupal\Core\StringTranslation\StringTranslationTrait;
use Drupal\Core\StringTranslation\TranslationInterface;
class MyClass {
  use StringTranslationTrait;

  /**
   * Constructs a MyClass object.
   *
   * @param \Drupal\Core\StringTranslation\TranslationInterface $string_translation
   *   The string translation service.
   */
  public function __construct(TranslationInterface $string_translation) {
    // You can skip injecting this service, the trait will fall back to \Drupal::translation()
    // but it is recommended to do so, for easier testability,
    $this->stringTranslation = $string_translation;
  }

  /**
   * Does something.
   */
  public function doSth() {
    // ...
    $string = $this->t('Something');
    // ...
  }

}

Fonte: https://www.drupal.org/docs/8/api/translation-api-code-text

Codice di procedura

Usa t().

Se si dispone di codice procedurale, ad esempio un hook, utilizzare t(), che è una funzione globale.

Non è buona prassi utilizzare la procedura t()nel codice OOP.

La migliore pratica è usare $ this-> t (), piuttosto che t (). L'utilizzo del modulo non cambierà, tuttavia, con l'avvento di Drupal 8, ora abbiamo i test PHPUnit integrati nel core. Il test PHPUnit consente di scrivere i test per confermare che tutto funziona, in modo che ogni volta che il codice viene modificato, i test possono essere eseguiti per assicurarsi che nulla sia stato interrotto. La rilevanza di ciò è che i test di PHPUnit eseguono test solo su una singola classe (ovvero un'unità), il che significa che il core non viene avviato per questi test. Pertanto non esistono funzioni globali come t () e genereranno un errore, impedendo l'esecuzione dei test.

Se non crei mai alcun test unitario, non vedrai mai la differenza tra l'utilizzo di t () e $ this-> t (), tuttavia la creazione di test è anche una buona pratica e quindi se vuoi davvero fare le cose nel modo giusto, dovresti usare $ this-> t () e creare unit test per ciascuna delle tue classi.

* Modificare *

Aggiornamento dopo aver letto il post di 4k4.

I miei commenti sopra si riferiscono solo al codice OOP, non al codice procedurale. Il codice procedurale non è testato in unità, né ha il costruttore $ this. Nel codice procedurale, t () è corretto.