전역 변수를 설정하고 사용하는 방법은 무엇입니까? 아니면 전혀 사용하지 않는 이유

내가이 문제에 대해 강력히 권고하며 속도가 빨라지지는 않지만 귀하의 사용법은 올바르지 않습니다.

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의 요청 기간 동안 캐시되고 디버깅 도구에 표시되며 개체 캐시가있는 경우 요청간에 유지됩니다.

Sidenote 1 : 어떤 사람들은 이것이 PHP가 작동하는 방식이 아니라는 것을 모르고 요청에 걸쳐 전역 변수에 데이터를 유지하려고합니다. 노드 애플리케이션과 달리 각 요청은 애플리케이션의 새 사본을로드 한 다음 요청이 완료되면 종료됩니다. 이러한 이유로 하나의 요청에 설정된 전역 변수는 다음 요청까지 유지되지 않습니다.

Sidenote 2 : 업데이트 된 질문으로 판단 할 때 글로벌 변수는 성능 향상을 전혀 제공하지 않습니다. 필요할 때 HTML을 생성하면됩니다. 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