Como definir e usar variáveis ​​globais? Ou por que não usá-los?

ATUALIZAÇÃO: Minha pergunta original foi resolvida, mas isso está se transformando em uma discussão válida sobre por que não usar variáveis ​​globais, por isso estou atualizando a questão para refletir isso. A solução foi <?php global $category_link_prop; echo esc_url( $category_link_prop ); ?>como o @TomJNowell sugeriu.

ATUALIZAÇÃO 2: Agora eu faço exatamente o que eu queria. Mas ainda estou usando o escopo global e ficaria feliz em encontrar uma maneira melhor.

Estou tentando configurar um monte de variáveis ​​globais para os links permanentes para categorias a serem usadas em vários lugares no meu tema. A principal razão para isso é o uso na navegação principal e em uma série de sub-navegações escolhidas com base em qual categoria a postagem atual se encontra. Esse não é um tema que lançarei para uso por outras pessoas, mas é construído para um propósito muito específico.

É assim que os estou criando atualmente (colei apenas algumas das variáveis).

function set_global_nav_var()
{
    //proposal
    global $prop;
    // Get the ID of a given category
    $category_id_prop = get_cat_ID( 'proposal' );
    // Get the URL of this category
    $category_link_prop = get_category_link( $category_id_prop );
    $prop = '<a href="' .esc_url( $category_link_prop ). '" title="Proposal">Proposal</a>';

    //Calvinball
    global $cb;
    // Get the ID of a given category
    $category_id_cb = get_cat_ID( 'calvinball' );
    // Get the URL of this category
    $category_link_cb = get_category_link( $category_id_cb );
    $cb = '<a href="' .esc_url( $category_link_cb). '" title="Calvinball">Calvinball</a>';
}
add_action( 'init', 'set_global_nav_var' );

Agora eu posso fazer <?php global $prop; echo $prop; ?>int ele 4 lugares que vai e voltar todo o link para o código. Quando isso muda, só preciso mudar em um só lugar. Estou aberto a alternativas que não envolvem o escopo global.

Embora eu recomendo fortemente isso, e isso não acelera as coisas, seu uso está incorreto.

Ao tentar usar um global, você deve especificar a palavra-chave global primeiro. Você o especificou aqui ao definir seu valor, mas fora desse escopo, ele precisa ser redeclarado como uma variável de escopo global.

por exemplo, em functions.php:

function test() {
    global $hello;
    $hello = 'hello world';
}
add_action( 'after_theme_setup', 'test' );

No single.php, isso não funciona:

echo $hello;

Porque $ hello é indefinido. No entanto, isso funcionará:

global $hello;
echo $hello;

Claro que você não deve fazer nenhum. O WordPress já tenta armazenar essas coisas no cache de objetos. Você não verá nenhum aumento de velocidade fazendo isso (você pode ver uma pequena diminuição de velocidade), tudo o que obterá é complexidade adicional e a necessidade de digitar muitas declarações globais que não são necessárias.

Seria melhor usar dados estruturados, como objetos ou injeção de dependência ou, no seu caso, um conjunto de funções.

Por exemplo, aqui está um meio de fazer algo semelhante por meio de variáveis ​​estáticas (ainda ruins pelas mesmas razões, mas um pouquinho menos e mais fáceis de digitar), por exemplo

function awful_function( $new_hello='' ) {
    static $hello;
    if ( !empty( $new_hello ) ) {
        $hello = $new_hello;
    }
    return $hello;
}

awful_function( 'telephone' );
echo awful_function(); // prints telephone
awful_function( 'banana');
echo awful_function(); // prints banana

Se você realmente deseja economizar tempo armazenando dados em algum lugar para reutilização, considere usar o WP_Cachesistema com wp_cache_getetc

Não use variáveis ​​globais , tão simples quanto isso.

Por que não usar globais

Porque o uso de globais torna mais difícil a manutenção do software a longo prazo.

• Um global pode ser declarado em qualquer lugar do código, ou em nenhum lugar; portanto, não há lugar em que você possa instintivamente procurar algum comentário sobre o uso do global.
• Ao ler o código, você normalmente assume que as variáveis ​​são locais para a função e não entende que alterar seu valor em uma função pode ter uma alteração ampla no sistema.
• Se eles não manipularem entrada, as funções deverão retornar o mesmo valor / saída quando forem chamadas com os mesmos parâmetros. O uso de globais em uma função introduz parâmetros adicionais que não estão documentados na declaração da função.
• os globals não têm nenhuma construção de inicialização específica e, portanto, você nunca pode ter certeza de quando pode acessar o valor do global e não recebe nenhum erro ao tentar acessar o global antes da inicialização.
• Outra pessoa (talvez um plugin) pode usar globais com o mesmo nome, arruinando seu código ou você estragando, dependendo da ordem de inicialização.

O núcleo do WordPress tem muito a ver com o uso de globais. Ao tentar entender como as funções básicas funcionam the_content, você repentinamente percebe que a $morevariável não é local, mas global e precisa pesquisar todos os arquivos principais para entender quando é configurada como verdadeira.

Então, o que pode ser feito ao tentar parar de copiar e colar várias linhas de código em vez de armazenar o resultado da primeira execução em um global? Existem várias abordagens, funcionais e OOP.

A função adoçante. É simplesmente um invólucro / macro para salvar a cópia / colar

// input: $id - the category id
// returns: the foo2 value of the category
function notaglobal($id) {
  $a = foo1($id);
  $b = foo2($a);
  return $b;
}

Os benefícios são que agora existe uma documentação para o que o antigo global faz, e você tem um ponto óbvio para a depuração quando o valor retornado não é o esperado.

Depois de ter um adoçante, é fácil armazenar em cache o resultado, se necessário (faça-o apenas se você descobrir que essa função leva muito tempo para ser executada)

function notaglobal($id) {
  static $cache;

  if (!isset($cache)) {
    $a = foo1($id);
    $b = foo2($a);
    $cache = $b;
  } 
  return $cache;
} 

Isso fornece o mesmo comportamento de um global, mas com a vantagem de ter uma inicialização garantida toda vez que você o acessa.

Você pode ter padrões semelhantes com OOP. Acho que o OOP geralmente não agrega valor a plugins e temas, mas essa é uma discussão diferente

class notaglobal {
   var latestfoo2;

   __constructor($id) {
     $a = foo1($id);
     $this->latestfoo2 = foo2($a)
   }
}

$v = new notaglobal($cat_id);
echo $v->latestfoo2;

Este é um código desajeitado, mas se você tiver vários valores que gostaria de pré-calcular porque eles estão sempre sendo usados, esse pode ser um caminho a percorrer. Basicamente, este é um objeto que contém todos os seus globais de maneira organizada. Para evitar que uma instância desse objeto seja global (você deseja uma instância, caso contrário você recalcula os valores), convém usar um padrão singleton (algumas pessoas argumentam que é uma má idéia, YMMV)

Não gosto de acessar diretamente um atributo de objeto, portanto, no meu código, ele distorcerá um pouco mais

class notaglobal {
   var latestfoo2;

   __constructor() {}

   foo2($id) {  
     if (!isset($this->latestfoo2)) {    
       $a = foo1($id);
       $b = foo2($a);
       $this->latestfoo2= $b;
     } 
     return $this->latestfoo2;
   }
}

$v = new notaglobal();
echo $v->foo2($cat_id);

Sua pergunta está envolvida em como o php funciona.

Tome $ wpdb como exemplo

$ wpdb é uma variável global bem conhecida.

Você sabe quando será declarado e atribuído com valores?

Toda página carregada , sim, toda vez que você visita seu site wordpress.

Da mesma forma, você precisa garantir que as variáveis ​​que deseja globalizar serão declaradas e atribuídas com os valores correspondentes a cada página carregada.

Embora eu não seja um designer de temas, posso dizer que o after_setup_theme é um gancho de uma vez. só será acionado quando o tema for ativado.

Se eu fosse você, usarei init ou outros ganchos. Não, se eu fosse você, não usarei variáveis ​​globais ...

Eu realmente não sou bom em explicar as coisas. Portanto, você deve pegar um livro se quiser se aprofundar no PHP.

Você sempre pode usar um padrão singleton através de getters estáticos.

<ul>
    <li><?php echo MyGlobals::get_nav_prop( 'proposal' )[ 'html' ]; ?></li>
    <li><?php echo MyGlobals::get_nav_prop( 'calvinball', 'html' ); ?></li>
</ul>


<?php

if ( ! class_exists('MyGlobals') ):

class MyGlobals {

    public $props;

    public function __construct(){
      $this->props = array (
        'proposal' => array( 'title' => 'Proposal', 'text' => 'Proposal' ),
        'calvinball' => array( 'title' => 'Calvinball', 'text' => 'Calvinball' ),
      );
    }

    public function get_nav_prop ( $term, $prop = false )
    {
      $o = self::instance();
      if ( ! isset( $o->props[$term] ) ) {  return falst; }
      if ( ! isset( $o->props[$term][ 'html' ] ) ) {
          $id = get_cat_ID( $term );
          $link = esc_url ( get_category_link( $id ) );
          $title = $o->props[$term]['title'];
          $text = $o->props[$term]['text'];
          $o->props[$term]['html'] = '<a href="'.$link.'" title="'.$title.'">'.$text.'</a>';
          $o->props[$term]['link'] = $link;
          $o->props[$term]['id'] = $id;
      }

      if($prop){ return isset($o->props[$term][$prop]) ? $o->props[$term][$prop] : null; }

      return $o->props[$term];
    }

    // -------------------------------------

    private static $_instance;

    public static function instance(){

      if(!isset(self::$_instance)) {
        self::$_instance = new MyGlobals();
      }
      return self::$_instance;
    }

}

endif; // end MyGlobals