Come impostare e utilizzare variabili globali? O perché non usarle affatto

Non utilizzare variabili globali, è semplice.

Perché non usare le globali

Perché l'uso di variabili globali rende più difficile la manutenzione del software nel lungo periodo.

• Una globale può essere dichiarata ovunque nel codice, o da nessuna parte, quindi non c'è un posto in cui puoi istintivamente cercare per trovare qualche commento su a cosa serve la globale
• Durante la lettura del codice di solito si assume che le variabili siano locali alla funzione e non si capisce che cambiarne il valore in una funzione potrebbe avere un effetto a livello di sistema.
• Se non gestiscono input, le funzioni dovrebbero restituire lo stesso valore/output quando vengono chiamate con gli stessi parametri. L'uso di globali in una funzione introduce parametri aggiuntivi che non sono documentati nella dichiarazione della funzione.
• Le globali non hanno alcun costrutto di inizializzazione specifico e quindi non puoi mai essere sicuro di quando puoi accedere al valore della globale, e non ottieni alcun errore quando tenti di accedere alla globale prima dell'inizializzazione.
• Qualcun altro (un plugin magari) potrebbe usare globali con lo stesso nome, rovinando il tuo codice, o tu rovinando il suo a seconda dell'ordine di inizializzazione.

Il core di WordPress utilizza moltissime globali, decisamente troppe. Mentre cerchi di capire come funzionano funzioni e hook di base come the_content, improvvisamente ti rendi conto che la variabile $more non è locale ma globale e devi cercare in tutti i file del core per capire quando viene impostata a true.

Quindi cosa si può fare quando si cerca di evitare di copiare-incollare diverse righe di codice invece di memorizzare il risultato del primo run in una globale? Ci sono diversi approcci, funzionali e OOP.

La funzione "sweetener". È semplicemente un wrapper/macro per evitare il copia/incolla

// input: $id - l'ID della categoria
// restituisce: il valore foo2 della categoria
function notaglobal($id) {
  $a = foo1($id);
  $b = foo2($a);
  return $b;
}

I vantaggi sono che ora c'è una documentazione su cosa faccia la precedente globale, e hai un punto ovvio per il debug quando il valore restituito non è quello che ti aspetti.

Una volta che hai una funzione "sweetener" è facile memorizzare il risultato nella cache se necessario (fallo solo se scopri che questa funzione impiega molto tempo per essere eseguita)

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

Questo ti dà lo stesso comportamento di una globale ma con il vantaggio di avere un'inizializzazione assicurata ogni volta che vi accedi.

Puoi avere pattern simili con l'OOP. Trovo che l'OOP di solito non aggiunga alcun valore in plugin e temi, ma questa è una discussione diversa

class notaglobal {
   var latestfoo2;

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

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

Questo è un codice più goffo, ma se hai diversi valori che vorresti precalcolare perché vengono sempre utilizzati, questa può essere una strada da percorrere. Fondamentalmente è un oggetto che contiene tutte le tue globali in modo organizzato. Per evitare di rendere un'istanza di questo oggetto una globale (vuoi solo un'istanza altrimenti ricalcoli i valori) potresti voler usare un pattern singleton (alcuni sostengono che sia una cattiva idea, dipende da te)

Non mi piace accedere direttamente a un attributo di un oggetto, quindi nel mio codice lo wrapperò un po' di più

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

La tua domanda riguarda il funzionamento di PHP.

Prendiamo $wpdb come esempio

$wpdb è una variabile globale ben conosciuta.

Sai quando viene dichiarata e assegnata con i valori?

Ogni pagina caricata, sì, ogni volta che visiti il tuo sito WordPress.

Allo stesso modo, devi assicurarti che quelle variabili che vuoi rendere globali vengano dichiarate e assegnate con i valori corrispondenti ad ogni caricamento di pagina.

Anche se non sono un designer di temi, posso dirti che after_setup_theme è un hook che viene eseguito una sola volta. Verrà attivato solo quando il tema viene attivato.

Se fossi in te, userei init o altri hook. No, se fossi in te, non userei affatto variabili globali...

Non sono davvero bravo a spiegare le cose. Quindi, dovresti prendere un libro se vuoi approfondire PHP.

Puoi sempre utilizzare il pattern singleton tramite getter statici.

<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' => 'Proposta', 'text' => 'Proposta' ),
        '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; // fine MyGlobals