Как установить и использовать глобальные переменные? Или почему бы их вообще не использовать

Хотя я настоятельно не рекомендую этого делать,и это не ускорит процесс,ваше использование неверно.

WordPress уже кэширует эти вещи в кеше объектов,вам не нужно сохранять результат и повторно использовать,WP это уже делает .

Весьма вероятно,что ваш код работает медленнее в результате этой микрооптимизации,а не быстрее!

Как использовать глобальные переменные

Когда вы пытаетесь использовать глобальное значение,вы должны сначала указать ключевое слово global. Вы указали его здесь при определении его значения,но за пределами этой области ее необходимо повторно объявить как глобальную переменную области действия.

например в functions.php:

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

В single.php это не сработает:

     echo $hello;
 

Потому что $hello не определен. Однако это будет работать:

     global $hello;
    echo $hello;
 

Конечно,вам не следует этого делать. WordPress уже пытается кэшировать эти вещи в кеше объектов .

Недостатки и опасности глобальных переменных

Вы не увидите увеличения скорости от этого (вы можете увидеть небольшое снижение скорости),все,что вы получите,- это дополнительная сложность и необходимость напечатать множество глобальных объявлений,которые не нужны.

Вы также столкнетесь с другими проблемами:

• код,для которого невозможно написать тесты
• код,который каждый раз ведет себя по-разному.
• конфликты в именах переменных из общего пространства имен
• случайные ошибки из-за того,что забыли объявить global
• полное отсутствие структуры в хранилище данных вашего кода.
• и многое другое

Что лучше использовать?

Лучше использовать структурированные данные,такие как объекты или внедрение зависимостей,или,в вашем случае,набор функций.

Статические переменные

Статические переменные - это нехорошо,но воспринимайте их как немного менее злых родственников глобальных переменных. Статические переменные относятся к глобальным переменным,а покрытый грязью хлеб - к цианиду.

Например,вот способ сделать что-то подобное с помощью статических переменных,например

     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
 

Синглтоны

Синглтоны похожи на статические переменные,за исключением того,что класс содержит статическую переменную с экземпляром этого класса. Они так же плохи,как и глобальные переменные,только с другим синтаксисом. Избегайте их.

WP_Cache,то,что вы пытались сделать,но WP уже это делает

Если вы действительно хотите сэкономить время,сохраняя данные где-нибудь для повторного использования,рассмотрите возможность использования системы WP_Cache с wp_cache_get и т. д.,например

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

Теперь значение будет кэшироваться на время существования запроса WordPress,отображаться в инструментах отладки,и,если у вас есть кеш объекта,оно будет сохраняться во всех запросах

Замечание 1: я хотел бы отметить,что некоторые люди пытаются сохранять данные в глобальных переменных между запросами,не зная,что PHP работает иначе. В отличие от приложения Node,каждый запрос загружает новую копию приложения,которая затем умирает,когда запрос завершен. По этой причине глобальные переменные,установленные в одном запросе,не сохраняются до следующего запроса

Замечание 2: судя по обновленному вопросу,ваши глобальные переменные вообще не дают вам прироста производительности. Вы должны просто сгенерировать HTML по мере необходимости,и он будет работать так же быстро,возможно,даже немного быстрее. Это микрооптимизация.

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.

Не используйте глобальные переменные ,вот и все.

Почему бы не использовать глобальные переменные

Поскольку использование глобальных переменных затрудняет обслуживание программного обеспечения в долгосрочной перспективе.

• Глобал может быть объявлен где угодно в коде или вообще нигде,поэтому нет места,в котором вы могли бы инстинктивно взглянуть,чтобы найти комментарий о том,для чего используется глобал
• При чтении кода вы обычно предполагаете,что переменные являются локальными по отношению к функции,и не понимаете,что изменение их значения в функции может повлечь за собой изменение всей системы.
• Если они не обрабатывают ввод,функции должны возвращать одно и то же значение/вывод,когда они вызываются с одинаковыми параметрами. Использование глобальных переменных в функции вводит дополнительные параметры,которые не задокументированы в объявлении функции.
• глобальные переменные не имеют какой-либо конкретной конструкции инициализации,и поэтому вы никогда не можете быть уверены,когда сможете получить доступ к значению глобального,и вы не получите никаких ошибок при попытке доступа к глобалу перед инициализацией.
• Кто-то другой (возможно,плагин) может использовать глобальные переменные с тем же именем,разрушая ваш код или вы его в зависимости от порядка инициализации.

Ядро WordPress имеет много возможностей для использования глобальных переменных. Пытаясь понять,как работают базовые функции,такие как the_content,вы внезапно понимаете,что переменная $more не локальная,а глобальная,и вам нужно выполнить поиск во всех основных файлах,чтобы понять,когда установлено ли значениеtrue.

Итак,что можно сделать,пытаясь остановить копирование и вставку нескольких строк кода вместо сохранения результата первого запуска в глобальном? Есть несколько подходов,функциональный и ООП.

Функция подсластителя. Это просто оболочка/макрос для сохранения копии/вставки

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

Преимущества заключаются в том,что теперь есть документация о том,что делает предыдущий глобальный,и у вас есть очевидная точка для отладки,когда возвращаемое значение не то,что вы ожидаете.

Если у вас есть подсластитель,его легко кэшировать при необходимости (делайте это,только если вы обнаружите,что эта функция требует много времени для выполнения)

 function notaglobal($id) {
  static $cache;

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

Это дает вам то же поведение,что и глобальное,но с преимуществом гарантированной инициализации при каждом доступе к нему.

Подобные шаблоны могут быть и с ООП. Я считаю,что ООП обычно не добавляет ценности плагинам и темам,но это другое обсуждение

 class notaglobal {
   var latestfoo2;

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

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

Это более неуклюжий код,но если у вас есть несколько значений,которые вы хотели бы предварительно вычислить,потому что они всегда используются,это может быть подходящим вариантом. По сути,это объект,который содержит все ваши глобальные объекты организованным образом. Чтобы не делать экземпляр этого объекта глобальным (вам нужен только один экземпляр,иначе вы повторно вычисляете значения),вы можете использовать одноэлементный шаблон (некоторые люди утверждают,что это плохая идея,YMMV)

Мне не нравится обращаться к атрибуту объекта напрямую,поэтому в моем коде он будет еще немного искажаться

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

Ваш вопрос связан с тем,как работаетphp.

Возьмем $ wpdb в качестве примера

$ wpdb - широко известная глобальная переменная.

Вы знаете,когда он будет объявлен и ему будут присвоены значения?

Загружается каждая страница ,да,каждый раз,когда вы посещаете свой сайт WordPress.

Точно так же вам нужно убедиться,что те переменные,которые вы хотите глобализировать,будут объявлены и присвоены соответствующие значения на каждой загруженной странице.

Хотя я не дизайнер тем,я могу сказать,что after_setup_theme - это одноразовая ловушка.он сработает только при активации темы.

На вашем месте я бы использовалinit или другие хуки.Нет,на вашем месте я бы вообще не использовал глобальные переменные ...

Я действительно не умею объяснять.Итак,вам следует взять книгу,если вы хотите углубиться в 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.

Вы всегда можете использовать одноэлементный шаблон через статические геттеры.

 <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