Namespaces PHP no WordPress – um guia prático

Os namespaces PHP têm quase dez anos. Sim, uma década se passou (e sim, você está ficando velho). Apesar de uma década se passar desde que o PHP v5.3 foi lançado, muitos desenvolvedores ainda não possuem um entendimento básico de namespaces. Verdade seja dita , o WordPress não usa namespaces , então “ você não precisa saber como usar namespaces se você trabalha apenas com o WordPress ”. Você não precisa ser um ninja de namespace, mas entender o básico é simples e faz bem a você.

Quando não há suporte para namespace - use um prefixo

Por muito, muito tempo o PHP não teve suporte a namespace nativo. É por isso que o WordPress e muitas outras grandes bases de código não usam namespaces nativos. Eles não estavam por perto quando necessário, então prefixos são usados.

O namespace é importante porque garante que sua função write_to_log() ainda não tenha sido definida por outro pedaço de código. Para evitar conflito de nomes, tudo no escopo global precisa de um prefixo para que a função se torne awesome_project_write_to_log() e todas as outras funções e variáveis ​​também recebam o prefixo awesome_project_ . Simples? Isso é! Bonito? Não exatamente.

Existem algumas alternativas para essa abordagem, como o encapsulamento de métodos estáticos. Você envolve todas as suas funções em uma classe e as declara como métodos estáticos. Então, em vez de chamar my_function() , você chama My_Class::my_function() . Melhorar? Um pouco, mas ainda não é um namespace adequado.

Vamos ver como o namespace permite que várias partes de código (ou pacotes, se você quiser) usem os mesmos nomes de classe e função sem conflito. Ou como diz o manual do PHP – como eles permitem o encapsulamento de código. A analogia deles com arquivos e pastas também é clara – de várias maneiras, os namespaces se comportam como pastas, então copiarei/colarei do manual;

Declarando namespaces – lembre-se da primeira linha

A palavra-chave namespace deve ser a primeira linha de código no arquivo (sem contar comentários e qualquer conteúdo não PHP). Os namespaces afetam apenas classes, interfaces, funções e constantes. Eles não afetam as variáveis. Você pode definir o mesmo namespace em vários arquivos, permitindo dividir o código em vários arquivos. Sub-namespaces permitem definir uma hierarquia em namespaces como em pastas usando uma barra invertida – namespace myproject\level1\level2 . Essas são regras básicas e quase todas para declarar namespaces.

// file-A.php contains a function under the myCompany\PackageA namespace
namespace myCompany\PackageA;
 
function do_something() {
  // do things
}

// file-B.php contains a function with the same name
// but under a different namespace
namespace myCompany\PackageB;
 
function do_something() {
  // do things
}

Embora seja possível, eu recomendo não combinar vários namespaces em um único arquivo. Confie em mim, mais cedo ou mais tarde você esquecerá que fez isso e, em seguida, depurar um bug de 2 minutos leva duas horas. No entanto, se você precisar, aqui está a sintaxe.

// do not put multiple namespace declarations into the same file
// but if you must, here's the syntax

namespace MyFirstProject {
  const CONST = true;
  class Connection { /* ... */ }
  function connect() { /* ... */  }
}

namespace MySecondProject {
  const CONST = true;
  class Connection { /* ... */ }
  function connect() { /* ... */  }
}

// any code after this has to go in the global namespace
namespace {
  $some_var = 1;
  function_in_global_namespace();
}

Usando namespaces – lembre-se de pastas

Como eu já disse – namespaces são extremamente semelhantes a pastas. Supondo que o arquivo foo.txt esteja em sua pasta atual; você pode referenciá-lo com um simples foo.txt . Se você estiver um nível acima da pasta com o arquivo foo.txt , precisará usar um caminho relativo ../foo.txt ou um absoluto /folder1/folder2/foo.txt . Nada chique. Os namespaces usam o mesmo paradigma.

// remember after declaring a namespace
// all our code is in it; like when you're working in a folder
namespace mycompany\project;

function foo() {}
class foo {
  static function staticmethod() {}
}

// resolves to mycompany\project\foo() because of line #3
foo();

// likewise, resolves to mycompany\project\foo::staticmethod()
foo::staticmethod();

// constant are affected by namespaces too
// so we're working with mycompany\project\FOO
echo FOO;

// this is a relative path
// resolves to mycompany\project\subnamespace\foo()
subnamespace\foo();

// static methods are no different
// mycompany\project\subnamespace\foo::staticmethod()
subnamespace\foo::staticmethod();
                                 
// a full namespace path starts with a backslash
// it resolves exactly to what it says it does
\otherNamespace\Bar\foo();

// again same thing for a constant, full path nothing magical
echo \otherNamespace\Bar\FOO;

Dê uma olhada na palavra-chave use no manual do PHP – os exemplos são ótimos. Ele fornece uma maneira de importar código de outros namespaces PHP para o namespace atual ou fazer referência a um nome externo (totalmente qualificado) com um alias.

Sim, você precisa de namespaces e deve usá-los

Como é mais do que evidente olhando para a fonte do WordPress – você não precisa usar namespaces, mas você precisa usar algum método de namespace. Prefixando com wp_ no caso do WP. Então, se já estamos fazendo isso, por que não fazê-lo corretamente?

Namespaces em PHP integram-se facilmente a qualquer fluxo de trabalho de desenvolvimento. Eles facilitam o carregamento automático, a nomeação de arquivos e, em geral, tornam o código mais limpo. Refatorar código antigo nunca é uma tarefa popular (independentemente da linguagem de codificação), então não vou dizer para você ir em frente e refatorar um projeto de trabalho de 2 MB apenas para que você possa dizer que usa namespaces. No entanto, vou insistir que você use namespaces ao trabalhar em novos projetos. Você vai agradecer a si mesmo em breve.