Comment définir et utiliser des variables globales? Ou pourquoi ne pas les utiliser du tout

Bien queje déconseillefortement cela,et que cela n'accélérerapas les choses,votre utilisationestincorrecte.

WordPressmet déjà ces élémentsen cache dans le cache d'objets,vousn'avezpasbesoin de stocker le résultatet de le réutiliser,WP lefait déjà .

Ilesttrèsprobable que votre code s'exécuteplus lentementen raison de cettemicro-optimisation,pasplus vite!

Comment utiliser Globals

Lorsque vousessayez d'utiliser unglobal,vous devez d'abord spécifier lemot-clé global. Vous l'avez spécifiéici lors de la définition de sa valeur,maisen dehors de cetteportée,il doit être redéclaréen tant que variable deportéeglobale.

parexemple dans functions.php:

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

Dans single.php,celane fonctionnerapas:

     echo $hello;
 

Parce que $hellon'estpas défini. Cependant,cela fonctionnera :

     global $hello;
    echo $hello;
 

Bien sûr,vousne devriezfaireni l'unni l'autre. WordPresstente déjà demettre ces élémentsen cache dans le cache d'objets .

Inconvénientset dangers des variablesglobales

Vousne verrez aucune augmentation de vitesseen faisant cela (vouspouvez voir unepetite diminution de vitesse),tout ce que vous obtiendrez,c'est une complexité supplémentaireet lanécessité detaperbeaucoup de déclarationsglobales quine sontpasnécessaires.

Vous rencontrerez également d'autresproblèmes:

• codepour lequelilestimpossible d'écrire destests
• code qui se comporte différemment à chaqueexécution
• conflits dans lesnoms de variables àpartir d'unespace denompartagé
• bogues accidentels dus à l'oubli de déclarer global
• unmanquetotal de structure dans le stockage des données de vos codes
• et bien d'autres

Que devriez-vous utiliser à laplace?

Vousferiezmieux d'utiliser des données structurées,telles que des objets ou l'injection de dépendances,ou dans votre cas,unensemble defonctions.

Variables statiques

Les variables statiquesne sontpasbonnes,mais considérez-les comme le cousin légèrementmoinsmauvais des variablesglobales. Les variables statiques sont aux variablesglobales,ce que lepain couvert deboueest au cyanure.

Parexemple,voici unmoyen defaire quelque chose de similaire via des variables statiques,parexemple

     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

Les singletons sont comme des variables statiques,sauf que la classe contient une variable statique avec uneinstance de cette classe. Elles sonttout aussimauvaises que les variablesglobales,mais avec une syntaxe différente. Évitez-les.

WP_Cache,ce que vous avezessayé defairemais que WP lefait déjà

Si vous voulez vraimentgagner dutempsen stockant les données quelquepartpour les réutiliser,pensez à utiliser le système WP_Cache avec wp_cache_getetc.parexemple

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

Maintenant,la valeur seramiseen cachepour la durée de vie de la requêtepar WordPress,apparaîtra dans les outils de débogage,et si vous avez un cache d'objets,ellepersistera àtravers les requêtes

Note 1: Je voudraisnoter que certainespersonnesessaient de conserver les données dans des variablesglobales àtravers les requêtes,sans savoir que cen'estpas ainsi que PHPfonctionne. Contrairement à une application Node,chaque requête charge unenouvelle copie de l'application,quimeurtensuite lorsque la requêteestterminée. Pour cette raison,les variablesglobales définies sur une requêtene surviventpas à la requête suivante

Note 2: àen jugerpar la questionmise àjour,vos variablesglobalesne vous donnent aucungain deperformance. Vous devriez simplementgénérer le HTML aufuret àmesure que vousen avezbesoinet ilfonctionneraittout aussi vite,peut-êtremême unpeuplus vite. C'est de lamicro-optimisation.

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.

N'utilisezpas de variablesglobales ,aussi simple que cela.

Pourquoine pas utiliser lesglobaux

Parce que l'utilisation deglobals rendplus difficile lamaintenance du logiciel sur le longterme.

• Unglobalpeut être déclarén'importe où dans le code,ounullepart dutout,iln'y a donc aucunendroit où vouspouvezinstinctivement regarderpourtrouver des commentaires sur l'utilisation duglobal
• Lors de la lecture du code,vous supposezgénéralement que les variables sont locales à lafonctionet ne comprenezpas que lamodification de leur valeur dans unefonctionpeut avoir un changement à l'échelle du système.
• Siellesne gèrentpas lesentrées,lesfonctions doivent renvoyer lamême valeur/sortie lorsqu'elles sont appelées avec lesmêmesparamètres. L'utilisation deglobaux dans unefonctionintroduit desparamètres supplémentaires quine sontpas documentés dans la déclaration defonction.
• lesglobauxn'ontpas de construction d'initialisation spécifiqueet vousne pouvez doncjamais être sûr quand vouspouvez accéder à la valeur duglobal,et vousn'obtenez aucuneerreuren essayant d'accéder auglobal avant l'initialisation.
• Quelqu'un d'autre (unpluginpeut-être)pourrait utiliser desglobaux avec lemêmenom,ruiner votre code ou vous ruineren fonction de l'ordre d'initialisation.

Lenoyau de WordPress abeaucoup à utiliser lesglobaux. Enessayant de comprendre commentfonctionnent lesfonctions debase comme the_content,vous vous rendez compte soudainement que la variable $moren'estpas localemaisglobaleet doit rechercher l'ensemble desfichiers debasepour comprendre quandest-il défini sur vrai.

Alors,quepeut-onfaireen essayant d'arrêter le copier-coller deplusieurs lignes de code au lieu de stocker le résultat de lapremièreexécution dans unfichierglobal? Ilexisteplusieurs approches,fonctionnelleset POO.

Lafonction édulcorant. C'est simplement un wrapper/macropourenregistrer le copier/coller

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

Les avantages sont qu'ilexistemaintenant une documentation sur ce quefait l'ancienglobal,et vous avez unpoint évidentpour le débogage lorsque la valeur renvoyéen'estpas celle que vous attendez.

Unefois que vous avez un édulcorant,ilestfacile demettreen cache le résultat sinécessaire (ne lefaites que si vous découvrez que cettefonctionprendbeaucoup detemps à s'exécuter)

 function notaglobal($id) {
  static $cache;

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

Cela vous donne lemême comportement d'unglobalmais avec l'avantage d'avoir uneinitialisation assurée à chaquefois que vous y accédez.

Vouspouvez avoir desmodèles similaires avec la POO. Jetrouve que la POOn'ajoutegénéralement aucune valeur auxpluginset auxthèmes,mais c'est une discussion différente

 class notaglobal {
   var latestfoo2;

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

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

C'est un codeplusmaladroit,mais si vous avezplusieurs valeurs que vous souhaitezprécalculer carelles sonttoujours utilisées,celapeut être une solution. Fondamentalement,c'est un objet qui contienttous vosglobals demanière organisée. Pour éviter defaire d'uneinstance de cet objet uneinstanceglobale (vous voulez uneinstance sinon vous recalculez les valeurs),vouspouvez utiliser un motif singleton (certainespersonnes soutiennent que c'est unemauvaiseidée,YMMV)

Jen'aimepas accéder directement à un attribut d'objet,donc dansmon codeil se déformeraencore

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

Votre question concerne lefonctionnement dephp.

Prenez $ wpdb commeexemple

$ wpdb est une variableglobalebien connue.

Savez-vous quandil sera déclaréet attribué avec des valeurs?

Chaquepage chargée ,oui,chaquefois que vous visitez votre site wordpress.

Demême,vous devez vous assurer que les variables que vous souhaitezglobaliser seront déclaréeset affectées avec les valeurs correspondantes à chaquepage chargée.

Bien queje ne soispas un concepteur dethèmes,je peux dire que after_setup_themeest un hookponctuel.ilne sera déclenché que lorsque lethème sera activé.

Sij'étais vous,j'utiliseraiinit ou d'autres hooks.Non,sij'étais vous,je n'utiliseraipas dutout de variablesglobales ...

Jene suis vraimentpas douépourexpliquer les choses.Donc,vous devriezprendre un livre si vous voulez vousplonger dans 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.

Vouspouveztoujours utiliser unmotif singleton via desgetters statiques.

 <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