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

Anche se lo sconsiglio vivamentee non velocizzerà le cose,iltuo utilizzonon è corretto.

WordPressmemorizzagià questielementinella cache degli oggetti,non ènecessariomemorizzareil risultatoe riutilizzarlo,WP lofagià .

Èmoltoprobabile cheiltuo codicefunzionipiù lentamente come risultato di questamicroottimizzazione,nonpiù velocemente!

Come utilizzarei globali

Quando sitenta di utilizzare unglobale,ènecessarioprima specificare laparola chiave global. L'hai specificato qui durante la definizione del suo valore,ma al difuori ditale ambito deveesserenuovamente dichiarato come variabile di ambitoglobale.

ades.in functions.php:

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

In single.php,questononfunzionerà:

     echo $hello;
 

Perché $hellonon è definito. Tuttavia,funzionerà :

     global $hello;
    echo $hello;
 

Ovviamentenon dovrestifarenessuno dei due. WordPresstentagià dimemorizzare questielementinella cache degli oggetti .

Svantaggie pericoli delle variabiliglobali

Non vedrai alcun aumento di velocitàfacendo questo (potresti vedere unapiccola diminuzione della velocità),tutto ciò che otterrai sarà una complessità aggiuntivae lanecessità di digitaremolte dichiarazioniglobali chenon sononecessarie.

Incontrerai anche altriproblemi:

• codiceper cui èimpossibile scriveretest
• codice che si comportain modo diverso ogni volta che vieneeseguito
• conflittinei nomi delle variabili da uno spazio deinomi condiviso
• bug accidentali dovuti alla dimenticanza di dichiarare global
• unatotalemancanza di strutturaper l'archiviazione dei dati dei codici
• e molti altri

Cosa dovresti usareinvece?

Farestimeglio a utilizzare dati strutturati,come oggetti oinserimento di dipendenze o,neltuo caso,uninsieme difunzioni.

Variabili statiche

Le variabili statichenon sonobuone,ma considerale come le cugine leggermentemenomalvagie delle variabiliglobali. Le variabili statiche stanno alle variabiliglobali,ciò cheilpane ricoperto difango sta al cianuro.

Adesempio,ecco unmodoperfare qualcosa di similetramite variabili statiche,adesempio

     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
 

Singletons

I singleton sono come le variabili statiche,tranneperilfatto che la classe contiene una variabile statica con un'istanza di quella classe. Sono dannose quanto le variabiliglobali,solo con una sintassi diversa. Evitali.

WP_Cache,la cosa che haiprovato afarema WP lofagià

Se vuoi davvero risparmiaretempo archiviandoi dati da qualcheparte da riutilizzare,considera l'utilizzo del sistema WP_Cache con wp_cache_getecc.,adesempio

 $value = wp_cache_get( 'hello' );
if ( false === $value ) {
    // not found, set the default value
    wp_cache_set( 'hello', 'world' );
}
 

Orail valore verràmemorizzatonella cachepertutta la durata della richiesta da WordPress,verrà visualizzatonegli strumenti di debuge,se si dispone di una cache degli oggetti,persisteràtra le richieste

Nota amargine 1: Vorreinotare che alcunepersone cercano dipersisterei datinelle variabiliglobali attraverso le richieste,ignari delfatto chenon è così chefunziona PHP. A differenza di un'applicazione Node,ogni richiesta carica unanuova copia dell'applicazione,chepoimuore quando la richiesta è completata. Per questomotivo le variabiliglobaliimpostate su una richiestanon sopravvivono alla richiesta successiva

Nota amargine 2: agiudicare dalla domanda aggiornata,letue variabiliglobalinonti danno alcunmiglioramento delleprestazioni. Dovresti semplicementegenerare l'HTML comee quandone haibisognoe funzionerebbe altrettanto velocemente,forse anche unpo 'più velocemente. Questa è lamicroottimizzazione.

While I strongly advise against this, and it will not speed things up, your usage is incorrect.

WordPress already caches these things in the object cache, you don't need to store the result and reuse, WP does that already.

It's very likely your code is running slower as a result of this micro-optimisation, not faster!

How To Use Globals

When you try to use a global you must specify the global keyword first. You have specified it here when defining its value, but outside of that scope it needs to be redeclared as a global scope variable.

e.g. in functions.php :

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

In single.php, this will not work:

    echo $hello;

Because $hello is undefined. This however will work:

    global $hello;
    echo $hello;

Of course you should do neither. WordPress already attempts to cache these things in the object cache.

Disadvantages and Dangers of Global Variables

You will see no speed increase from doing this ( you may see a tiny speed decrease ), all you will get is additional complexity and the need to type out a lot of global declarations that aren't necessary.

You'll also encounter other issues:

• code that's impossible to write tests for
• code that behaves differently every time it runs
• clashes in variable names from a shared name space
• accidental bugs from forgetting to declare global
• a complete lack of structure to your codes data storage
• and many more

What Should You Use Instead?

You would be better off using structured data, such as objects or dependency injection, or in your case, a set of function.

Static Variables

Static variables aren't good, but think of them as the slightly less evil cousin of global variables. Static variables are to global variables, what mud covered bread is to cyanide.

For example, here is a means of doing something similar via static variables e.g.

    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

Singletons

Singletons are like static variables, except the class contains a static variable with an instance of that class. They're just as bad as global variables, just with different syntax. Avoid them.

WP_Cache, The Thing You Tried to Do But WP Already Does It

If you really want to save time by storing data somewhere to re-use, consider using the WP_Cache system with wp_cache_get etc e.g.

$value = wp_cache_get( 'hello' );
if ( false === $value ) {
    // not found, set the default value
    wp_cache_set( 'hello', 'world' );
}

Now the value will get cached for the life of the request by WordPress, show up in debugging tools, and if you have an object cache it'll persist across requests

Sidenote 1: I would note, that some people try to persist data in global variables across requests, unaware that this is not how PHP works. Unlike a Node application, each request loads a fresh copy of the application, which then dies when the request is completed. For this reason global variables set on one request do not survive to the next request

Sidenote 2: Judging from the updated question, your global variables give you no performance gain at all. You should just generate the HTML as and when you need it and it would run just as fast, perhaps even a tiny bit faster. This is micro-optimisation.

Non utilizzare variabiliglobali ,così semplice.

Perchénon utilizzare leglobali

Perché l'uso diglobali rendepiù difficile lamanutenzione del software a lungotermine.

• Unglobalepuòessere dichiarato ovunquenel codice,o danessunaparte,quindinon c'èpostoin cuipuoiistintivamenteguardarepertrovare qualche commento su ciòper cui viene utilizzatoilglobale
• Durante la lettura del codice di solitopresumi che le variabili siano locali rispetto allafunzionee non capisci che lamodifica del loro valorein unafunzionepotrebbe avere un cambiamento a livello di sistema.
• Senongestiscono l'input,lefunzioni dovrebbero restituire lo stesso valore/output quando vengono chiamate congli stessiparametri. L'uso di variabiliglobaliin unafunzioneintroduceparametri aggiuntivi chenon sono documentinella dichiarazione dellafunzione.
• leglobalinon hanno alcun costrutto diinizializzazione specificoe quindinonpuoimaiessere sicuro dipoter accedere al valore dellaglobalee non ricevi alcunerrore quando cerchi di accedere allaglobaleprima dell'inizializzazione.
• Qualcun altro (forse unplugin)potrebbe usare le variabiliglobali con lo stessonome,rovinandoiltuo codice otu rovinandoneil contenuto a seconda dell'ordine diinizializzazione.

Il core di WordPress hamolto a chefare con l'uso diglobali. Mentre cerchi di capire comefunzionano lefunzioni dibase come the_content,ti rendiimprovvisamente conto che la variabile $morenon è localemaglobalee devi cercarein tuttii file coreper capire quando èimpostato sutrue.

Quindi cosa sipuòfare quando siprova a smettere di copiaree incollare diverse righe di codiceinvece dimemorizzareil risultato dellaprimaesecuzionein unglobale? Esistono diversi approcci,funzionalie OOP.

Lafunzione dolcificante. È semplicemente un wrapper/macroper salvareil copia/incolla

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

I vantaggi sono che ora c'è una documentazione su ciò chefailprimoglobale,e hai un ovviopuntoperil debug quandoil valore restituitonon è quello cheti aspetti.

Una volta che hai un dolcificante èfacilememorizzareil risultatonella cache senecessario (fallo solo se scopri che questafunzioneimpiegamoltotempoperessereeseguita)

 function notaglobal($id) {
  static $cache;

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

Questoti dà lo stesso comportamento di unglobalema conil vantaggio di avere un'inizializzazione sicura ogni volta che vi accedete.

Puoi averemodelli simili con OOP. Trovo che l'OOP di solitonon aggiunga alcun valore aplugine 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 codicepiùgoffo,ma se hai diversi valori che vorrestiprecalcolareperché vengono sempre utilizzati,questopuòessere unmodoper andare. Fondamentalmente questo è un oggetto che contienetutte letueglobaliin modo organizzato. Perevitare di rendereglobale un'istanza di questo oggetto (vuoi una solaistanza altrimenti ricalcolii valori)potresti voler usare un pattern singleton (alcunepersone sostengono che sia una cattivaidea,YMMV)

Nonmi piace accedere direttamente all'attributo di un oggetto,quindinelmio codice si deformerà ancora unpo '

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

Don't use global variables, as simple as that.

Why not to use globals

Because the use of globals makes it harder to maintain the software in the long term.

• A global can be declared anywhere in the code, or nowhere at all, therefor there is no place in which you can instinctivly look at to find some comment about what the global is used for
• While reading code you usually assume that variables are local to the function and don't understand that changing their value in a function might have a system wide change.
• If they don't handle input, functions should return the same value/output when they are called with the same parameters. The use of globals in a function introduce additional parameters which are not document in the function declaration.
• globals don't have any specific initialization construct and therefor you can never be sure when you can access the value of the global, and you don't get any error when trying to access the global before initialization.
• Someone else (a plugin maybe) might use globals with the same name, ruining your code, or you ruining its depending on initialization order.

WordPress core has way way way much to much use of globals. While trying to understand how basic functions like the_content work, you suddenly realize that the $more variable is not local but global and need to search whole of the core files to understand when is it set to true.

So what can be done when trying to stop copy&pasting several lines of code instead of storing the first run result in a global? There are several approaches, functional and OOP.

The sweetener function. It is simply a wrapper/macro for saving the copy/paste

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

The benefits are that now there is a documentation to what the former global does, and you have an obvious point for debugging when the value being returned is not the one you expect.

Once you have a sweetener it is easy to cache the result if needed (do it only if you discover that this function takes a long time to execute)

function notaglobal($id) {
  static $cache;

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

This gives you the same behavior of a global but with the advantage of having an assured initialization every time you access it.

You can have similar patterns with OOP. I find that OOP usually doesn't add any value in plugins and themes, but this is a different discussion

class notaglobal {
   var latestfoo2;

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

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

This is a clumsier code, but if you have several values that you would like to precompute because they are always being used, this can be a way to go. Basically this is an object that contain all of your globals in an organized way. To avoid making an instance of this object a global (you want ont one instance otherwise you recompute the values) you might want to use a singleton pattern (some people argue it is a bad idea, YMMV)

I don't like to access an object attribute directly, so in my code it will warpe some more

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

Latua domanda riguardailfunzionamento diphp.

Prendi $ wpdb comeesempio

$ wpdb è unanota variabileglobale.

Sai quando verrà dichiaratoe assegnato con valori?

Ognipagina viene caricata ,sì,ogni volta che visitiiltuo sito wordpress.

Allo stessomodo,devi assicurarti che le variabili che desideriglobalizzare vengano dichiaratee assegnate con valori corrispondenti a ognipagina caricata.

Anche senon sono un designer ditemi,posso dire che after_setup_theme è un hook occasionale.verrà attivato solo quandoiltema è attivato.

Sefossiin te,useròinit o altri hook.No,sefossiin te,non userò affatto le variabiliglobali ...

Non sono davverobravo a spiegare le cose.Quindi,dovrestiprendere un libro se vuoi approfondire PHP.

Your question is involved with how php works.

Take $wpdb as example

$wpdb is a well-known global variable.

Do you know when it'll be declared and assigned with values ?

Every page loaded, yep, every time you visit your wordpress site.

Similarly, you need to make sure those variables that you want to be globalized will be declared and assigned with corresponding values every page loaded.

Although I'm not a theme designer, I can tell the after_setup_theme is one time hook. it'll only be triggered when theme activated.

If I were you, I'll use init or other hooks. No, if I were you, I won't use global variables at all...

I'm really not good at explaining things. So, you should pick up a book if you want to delve into PHP.

Puoi sempre utilizzare unpattern singletontramitegetter 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' => '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
 

You can always use a singleton pattern via static getters.

<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