Cómo configurar y usar variables globales en PHP o por qué evitarlas

No utilices variables globales, así de simple.

Por qué no usar globales

Porque el uso de globales hace que sea más difícil mantener el software a largo plazo.

• Una global puede ser declarada en cualquier parte del código, o en ninguna, por lo tanto no hay un lugar específico donde puedas buscar instintivamente algún comentario sobre para qué se usa la global
• Mientras lees código, usualmente asumes que las variables son locales a la función y no entiendes que cambiar su valor en una función podría tener un cambio a nivel de todo el sistema.
• Si no manejan entrada, las funciones deberían devolver el mismo valor/salida cuando son llamadas con los mismos parámetros. El uso de globales en una función introduce parámetros adicionales que no están documentados en la declaración de la función.
• Las globales no tienen ningún constructor de inicialización específico y por lo tanto nunca puedes estar seguro de cuándo puedes acceder al valor de la global, y no recibes ningún error al intentar acceder a la global antes de su inicialización.
• Alguien más (un plugin quizás) podría usar globales con el mismo nombre, arruinando tu código, o tú arruinando el suyo dependiendo del orden de inicialización.

El núcleo de WordPress usa muchísimas globales. Mientras intentas entender cómo funcionan funciones y hooks básicos como the_content, de repente te das cuenta de que la variable $more no es local sino global y necesitas buscar en todos los archivos del núcleo para entender cuándo se establece en verdadero.

Entonces, ¿qué se puede hacer cuando intentas dejar de copiar-pegar varias líneas de código en lugar de almacenar el resultado de la primera ejecución en una global? Hay varios enfoques, funcionales y POO.

La función edulcorante. Es simplemente un envoltorio/macro para ahorrar el copiar/pegar

// entrada: $id - el id de la categoría
// retorna: el valor foo2 de la categoría
function notaglobal($id) {
  $a = foo1($id);
  $b = foo2($a);
  return $b;
}

Los beneficios son que ahora hay documentación sobre lo que hacía la antigua global, y tienes un punto obvio para depuración cuando el valor devuelto no es el que esperas.

Una vez que tienes un edulcorante, es fácil cachear el resultado si es necesario (hazlo solo si descubres que esta función tarda mucho en ejecutarse)

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

Esto te da el mismo comportamiento de una global pero con la ventaja de tener una inicialización asegurada cada vez que accedes a ella.

Puedes tener patrones similares con POO. Encuentro que POO usualmente no añade ningún valor en plugins y temas, pero eso es una discusión diferente

class notaglobal {
   var $latestfoo2;

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

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

Este es un código más torpe, pero si tienes varios valores que te gustaría precalcular porque siempre se usan, esta puede ser una manera de hacerlo. Básicamente es un objeto que contiene todas tus globales de manera organizada. Para evitar hacer una instancia de este objeto una global (quieres solo una instancia, de lo contrario recalculas los valores) podrías querer usar un patrón singleton (algunos argumentan que es una mala idea, depende de ti)

No me gusta acceder a un atributo de objeto directamente, así que en mi código lo envolvería un poco más

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);

Tu pregunta está relacionada con cómo funciona PHP.

Tomemos $wpdb como ejemplo.

$wpdb es una variable global muy conocida.

¿Sabes cuándo se declarará y se le asignarán valores?

Cada página cargada, sí, cada vez que visitas tu sitio WordPress.

De manera similar, debes asegurarte de que aquellas variables que quieras globalizar se declaren y se les asignen los valores correspondientes en cada carga de página.

Aunque no soy diseñador de temas, puedo decir que after_setup_theme es un hook de una sola vez. Solo se activará cuando el tema se active.

Si fuera tú, usaría init u otros hooks. No, si fuera tú, no usaría variables globales en absoluto...

Realmente no soy bueno explicando cosas. Por lo tanto, deberías tomar un libro si quieres profundizar en PHP.

Siempre puedes utilizar el patrón singleton a través de métodos estáticos de obtención.

<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' => 'Propuesta', 'text' => 'Propuesta' ),
        'calvinball' => array( 'title' => 'Calvinball', 'text' => 'Calvinball' ),
      );
    }

    public function get_nav_prop ( $term, $prop = false )
    {
      $o = self::instance();
      if ( ! isset( $o->props[$term] ) ) {  return false; }
      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