Prática recomendada: $ this-> t () versus t ()

Estou procurando uma prática recomendada: os módulos contribuídos devem usar $this->t()ou t()?

A melhor prática depende de onde o código é colocado.

Código OOP

Use $this->t().

Se você estender uma classe base drupal como um controlador ou um plug-in, a função t () é fornecida como método de classe imediatamente $this->t()e você deve usá-la. Isso torna seu código testável.

Para a maioria das tarefas, você encontrará uma classe drupal adequada para estender a partir da qual foi $this->t()definida, mas se precisar criar sua própria classe a partir do zero, a melhor prática seria usar o recurso de conversão de string e injetar isso como serviço se você usar essa classe em um contexto de serviço:

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

Código processual

Use t().

Se você tiver um código de procedimento, por exemplo, um gancho, use t(), que é uma função global.

A melhor prática não seria usar o procedimento t()no Código OOP.

A melhor prática é usar $ this-> t (), em vez de t (). O uso do módulo não será alterado, no entanto, com o advento do Drupal 8, agora temos o teste do PHPUnit incorporado ao núcleo. O teste do PHPUnit permite que testes sejam gravados para confirmar que tudo funciona, para que, a qualquer momento que o código seja alterado, os testes possam ser executados para garantir que nada tenha sido quebrado. A relevância disso é que o teste do PHPUnit testa apenas uma classe (unidade), o que significa que o núcleo não é inicializado para esses testes. Portanto, funções globais como t () não existem e geram um erro, impedindo a execução dos testes.

Se você nunca criar testes de unidade, nunca verá a diferença entre usar t () e $ this-> t (); no entanto, criar testes também é uma prática recomendada e, portanto, se você realmente deseja fazer as coisas corretamente, você deve usar $ this-> t () e criar testes de unidade para cada uma de suas classes.

* Editar *

Atualizando depois de ler a postagem de 4k4.

Meus comentários acima referem-se apenas ao código OOP, não ao código processual. O código de procedimento não é testado por unidade, nem possui o construtor $ this. No código processual, t () está correto.