如何设置和使用全局变量？还是为什么根本不使用它们

尽管我强烈建议您这样做,但它不会加快速度,但您的用法不正确.

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.

那么,当尝试停止复制和粘贴多行代码而不是将第一次运行的结果存储在全局变量中时,该怎么办?功能和OOP有几种方法.

甜味剂功能.它只是用于保存复制/粘贴的包装/宏

 // 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;
} 
 

这为您提供了与全局相同的行为,但具有每次访问时都确保初始化的优点.

您可以在OOP中使用类似的模式.我发现OOP通常不会在插件和主题中添加任何价值,但这是一个不同的讨论

 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 是一个众所周知的全局变量.

您知道何时将其声明并分配值吗?

每个页面加载.

同样,您需要确保要声明的那些变量将被声明,并在每次加载页面时为其分配相应的值.

尽管我不是主题设计师,但我可以说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