Cum să setezi și să folosești variabile globale? Sau de ce să nu le folosești deloc

Nu folosiți variabile globale, atât de simplu.

De ce să nu folosiți globale

Deoarece utilizarea variabilelor globale face mai dificilă întreținerea software-ului pe termen lung.

• O variabilă globală poate fi declarată oriunde în cod sau nicăieri, prin urmare nu există un loc în care să poți căuta în mod instinctiv comentarii despre scopul acesteia
• În timp ce citești codul, de obicei presupui că variabilele sunt locale pentru funcție și nu înțelegi că modificarea valorii lor într-o funcție poate avea un impact la nivelul întregului sistem.
• Dacă nu prelucrează input, funcțiile ar trebui să returneze aceeași valoare/ieșire atunci când sunt apelate cu aceiași parametri. Utilizarea variabilelor globale într-o funcție introduce parametri suplimentari care nu sunt documentați în declarația funcției.
• Variabilele globale nu au niciun constructor de inițializare specific și, prin urmare, nu poți fi niciodată sigur când poți accesa valoarea globală și nu primești nicio eroare când încerci să accesezi variabila globală înainte de inițializare.
• Cineva altcineva (un plugin, poate) ar putea folosi variabile globale cu același nume, stricându-ți codul sau tu stricându-i al lui, în funcție de ordinea de inițializare.

Nucleul WordPress are mult prea multe utilizări ale variabilelor globale. În timp ce încerci să înțelegi cum funcționează funcțiile și hook-urile de bază precum the_content, realizezi brusc că variabila $more nu este locală, ci globală și trebuie să cauți în toate fișierele de bază pentru a înțelege când este setată la true.

Deci, ce poți face atunci când încerci să eviți copierea și lipirea mai multor linii de cod în loc să stochezi rezultatul primei rulări într-o variabilă globală? Există mai multe abordări, funcționale și OOP.

Funcția sweetener. Este pur și simplu un wrapper/macro pentru a salva copierea/lipirea

// input: $id - ID-ul categoriei
// returnează: valoarea foo2 a categoriei
function notaglobal($id) {
  $a = foo1($id);
  $b = foo2($a);
  return $b;
}

Beneficiile sunt că acum există o documentație despre ce face fostul global și ai un punct evident pentru depanare atunci când valoarea returnată nu este cea pe care o așteptai.

Odată ce ai un sweetener, este ușor să cache-ui rezultatul dacă este necesar (fă-o doar dacă descoperi că această funcție durează mult timp pentru a executa)

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

Aceasta îți oferă același comportament ca o variabilă globală, dar cu avantajul că ai o inițializare asigurată de fiecare dată când o accesezi.

Poți avea modele similare cu OOP. Consider că OOP de obicei nu adaugă nicio valoare în plugin-uri și teme, dar aceasta este o discuție diferită

class notaglobal {
   var latestfoo2;

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

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

Acesta este un cod mai stângaci, dar dacă ai mai multe valori pe care ai vrea să le precalculezi pentru că sunt întotdeauna folosite, aceasta poate fi o cale de urmat. Practic, acesta este un obiect care conține toate variabilele tale globale într-un mod organizat. Pentru a evita să faci o instanță a acestui obiect globală (vrei doar o singură instanță, altfel recalculezi valorile), ai putea dori să folosești un model singleton (unii oameni susțin că este o idee proastă, YMMV)

Nu îmi place să accesez direct un atribut al unui obiect, așa că în codul meu va fi încapsulat mai mult

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

Întrebarea ta este legată de modul în care funcționează PHP.

Să luăm $wpdb ca exemplu.

$wpdb este o variabilă globală binecunoscută.

Știi când este declarată și inițializată cu valori?

La fiecare încărcare de pagină, da, de fiecare dată când vizitezi site-ul tău WordPress.

În mod similar, trebuie să te asiguri că acele variabile pe care dorești să le globalizezi vor fi declarate și inițializate cu valorile corespunzătoare la fiecare încărcare de pagină.

Deși nu sunt designer de teme, pot spune că after_setup_theme este un hook care se declanșează o singură dată. Acesta va fi activat doar când tema este activată.

Dacă aș fi în locul tău, aș folosi init sau alte hook-uri. Nu, dacă aș fi în locul tău, nu aș folosi deloc variabile globale...

Nu sunt foarte bun în a explica lucrurile. Așadar, ar fi bine să iei o carte dacă vrei să aprofundezi PHP.

Puteți utiliza întotdeauna un model singleton prin intermediul getter-ilor 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' => 'Propunere', 'text' => 'Propunere' ),
        '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