グローバル変数を設定して使用する方法は？または、それらをまったく使用しないのはなぜですか

これには強くお勧めしますが、スピードアップはしませんが、使い方は正しくありません.

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アプリケーションとは異なり、各リクエストはアプリケーションの新しいコピーをロードし、リクエストが完了すると終了します.このため、1つのリクエストに設定されたグローバル変数は、次のリクエストまで存続しません

補足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;
 

これは不器用なコードですが、常に使用されているために事前計算したい値がいくつかある場合は、これが最適な方法です.基本的に、これはすべてのグローバルを整理された方法で含むオブジェクトです.このオブジェクトのインスタンスがグローバルになるのを避けるために(1つのインスタンスが必要です.そうでない場合は値を再計算します)、シングルトンパターン(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は1回限りのフックであることがわかります.テーマがアクティブ化されたときにのみトリガーされます.

私があなたなら、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