Der beste Weg, um Variablen auf allen WordPress-Seiten zu verwenden

Ich erstelle ein benutzerdefiniertes Design mit vielen Variablen, die ich durchgehend verwenden möchte.

Beispiel:

$tv     = $options['tv'];
$movies = $options['movies'];
$print  = $options['print'];
//....and about 50 more.

Zu diesem Zweck habe ich sie einfach alle in einer Datei namens vars.php abgelegt und dann in die header.php des Themes eingefügt …

require_once('vars.php');

Obwohl dies funktioniert, fühlt es sich nicht wie der beste Weg an. Ich habe bei zahlreichen Gelegenheiten gelesen, dass die Verwendung globaler Variablen (vermutlich in functions.php) keine gute Idee ist, aber ist das wahr?

Aber wenn es in Ordnung ist, globale Variablen in functions.php zu verwenden (sogar viele davon), ist dies der richtige Weg?:

global $tv;
$tv     = $options['tv'];

global $movies
$movies = $options['movies'];

global $print
$print  = $options['print'];

Der beste Weg dafür ist, alle Variablen explizit in der functions.php oder in der Haupt-Plugin-Datei für das Plugin zu definieren. Ich habe überprüft, dass dies die Art und Weise ist, wie die meisten beliebten Plugins einschließlich Akismet verwenden. Insbesondere müssen Sie dies tun.

define( MYVAR_TV, $options['tv'] );
define( MYVAR_MOVIES, $options['movies'] );
define( MYVAR_PRINT, $options['print'] );

Danach können Sie sie einfach verwenden, wo immer Sie möchten

echo MYVAR_TV;

Ich hoffe es hilft.

Es ist in Ordnung, global zu verwenden, aber es wird nicht empfohlen (Sie können hier mehr lesen. Werden globale Variablen in PHP als schlechte Praxis angesehen? Wenn ja, warum?). Sie können die Singleton-Implementierung in Betracht ziehen:

<?php
class GlobalVariable {
    /**
     * @var array
     */
    public static $option = [];
}

// You can set the variable using this way
GlobalVariable::$option['movies'] = 1;

// And get the variables using that array
print_r(GlobalVariable::$option);

Hoffe das kann dir helfen.

Was ist mit dem Erstellen einer Funktion in functions.php, die ein Array Ihrer Variablen zurückgibt?

Beispiel: $options = get_my_custom_vars();

Ich gehe davon aus, dass Sie globale Variablen möchten, bei denen ein Array mit all Ihren Variablen erstellt wird. Um es zu benutzen:

$GLOBALS['your-varriable']

Quelle:
PHP-Dokumentation

Ich persönlich benutze gerne Acf-Options-Addon. Es ist auch nützlich, diese zu ändern und sie über das wpml-Plugin übersetzbar zu machen.

Diese Optionen können auf einer “Optionsseite” im Backend hinzugefügt/bearbeitet werden oder wie im Link beschrieben programmiert werden.

Nach der Initialisierung des Addons über die functions.php

if( function_exists('acf_add_options_page') ) {

acf_add_options_page();

}

Rufen Sie diese einfach in der Vorlage über auf

<?php the_field('header_title', 'option'); ?>

• Diese Beispiele wurden der Acf Options Page-Dokumentation entnommen.
• Merken Sie sich https://www.advancedcustomfields.com/ muss installiert werden, damit dies funktioniert.

Sie können auch einen benutzerdefinierten Stream-Wrapper implementieren. Auf diese Weise können Sie mit Funktionen wie z. B. auf Daten zugreifen und diese speichern file_get_contents, file_put_contents, fread, fwriteusw. Genau wie das Lesen und Schreiben aus einer Datei oder das Abrufen von Informationen von einer Remote-URL.

Tatsächlich gibt es ein Beispiel im PHP-Handbuch, Verwenden Sie globale Variablen, wie Sie fragen. Aber lassen Sie es von dort aus in der Reihenfolge der Vollständigkeit ziehen und es an Ihren Anwendungsfall in WP und Anwendungsbeispielen anpassen.

<?php
// variable-stream-class.php just this is pulled from the PHP manual

class VariableStream {
    var $position;
    var $varname;

    function stream_open($path, $mode, $options, &$opened_path)
    {
        $url = parse_url($path);
        $this->varname = $url["host"];
        $this->position = 0;

        return true;
    }

    function stream_read($count)
    {
        $ret = substr($GLOBALS[$this->varname], $this->position, $count);
        $this->position += strlen($ret);
        return $ret;
    }

    function stream_write($data)
    {
        $left = substr($GLOBALS[$this->varname], 0, $this->position);
        $right = substr($GLOBALS[$this->varname], $this->position + strlen($data));
        $GLOBALS[$this->varname] = $left . $data . $right;
        $this->position += strlen($data);
        return strlen($data);
    }

    function stream_tell()
    {
        return $this->position;
    }

    function stream_eof()
    {
        return $this->position >= strlen($GLOBALS[$this->varname]);
    }

    function stream_seek($offset, $whence)
    {
        switch ($whence) {
            case SEEK_SET:
                if ($offset < strlen($GLOBALS[$this->varname]) && $offset >= 0) {
                     $this->position = $offset;
                     return true;
                } else {
                     return false;
                }
                break;

            case SEEK_CUR:
                if ($offset >= 0) {
                     $this->position += $offset;
                     return true;
                } else {
                     return false;
                }
                break;

            case SEEK_END:
                if (strlen($GLOBALS[$this->varname]) + $offset >= 0) {
                     $this->position = strlen($GLOBALS[$this->varname]) + $offset;
                     return true;
                } else {
                     return false;
                }
                break;

            default:
                return false;
        }
    }

    function stream_metadata($path, $option, $var) 
    {
        if($option == STREAM_META_TOUCH) {
            $url = parse_url($path);
            $varname = $url["host"];
            if(!isset($GLOBALS[$varname])) {
                $GLOBALS[$varname] = '';
            }
            return true;
        }
        return false;
    }
}

Angenommen, Sie haben ein Plugin, um Ihre Funktionen zu isolieren, es zum Debuggen zu deaktivieren und es nicht zu verlieren, wenn Sie das aktive Design ändern. Ich würde empfehlen, so etwas in Ihren Plugin-Einstiegspunkt zu setzen:

<?php
/**
 * Plugin Name: Stream Wrapper for global variables
 * Plugin URI: https://stackoverflow.com/q/46248656/
 * Description: Utility class and functions to enable global data sharing in WordPress
 * Author: Jesús E. Franco Martínez and the PHP Documentation Group
 * Contributors: tzkmx
 * Version: 0.1
 * Author URI: https://tzkmx.wordpress.com
 */
require 'variable-stream-class.php';

stream_wrapper_register("var", "VariableStream")
    or wp_die("Failed to register protocol", null, ['back_link' => true]);

Dann können Sie in Ihren Vorlagen oder anderen Site-Plugins die oben genannten Funktionen verwenden oder benutzerdefinierte Aliase verwenden. Lassen Sie uns Ihre Anfrage erweitern:

// functions.php in your theme or better, in the same plugin.php above

// Using a hook just for frontend in order to get populated
// our variables without require calls in the theme.

add_action('wp_head', 'populate_my_awesome_plugin_options');

function populate_my_awesome_plugin_options() {

// Let's say you get your data from a single get_option call
    $options = get_option( 'my_awesome_plugin_options' );

    foreach( $options as $key => $value ) {
        file_put_contents( 'var://' . $key, $value );
    }
}

function pop_get_var( $var_name ) {
    return file_get_contents( 'var://' . $var_name );
}

In der header.php oder einer anderen Vorlagendatei, in der Sie Ihre Daten verwenden, lautet der Aufruf schließlich wie folgt:

<p>TV favorite show: <strong><?= pop_get_var( 'tv' ) ?></strong></p>

<p>Movies I like: <strong><?= pop_get_var( 'movies' ) ?></strong></p>

<p>Impressum: <em><?= pop_get_var( 'print' ) ?></em></p>

Ich weiß, dass es auf den ersten Blick wie eine Menge Boilerplate aussehen mag, aber aufgrund der Trennung von Bedenken sind Sie nicht nur auf skalare Werte wie die Verwendung von Konstanten beschränkt, sondern Ihr Stream-Wrapper könnte auch ein Adapter für jeden beliebigen Datenspeicher sein und nicht nur in Speicher oder in der WordPress-Optionstabelle gespeichert. Und die Verwendung einer benutzerdefinierten Funktion erleichtert Ihnen das Schreiben so langer Aufrufe an eine Singleton-Klasse oder das Aufrufen von global, wo immer Sie auf Ihre benutzerdefinierten Daten zugreifen möchten.

Wenn Sie die Beispiele im PHP-Handbuch lesen, finden Sie tatsächlich ein Beispiel für die Verwendung des Wrappers zum Speichern eines gesamten Textes, mit dem Sie aufrufen könnten include. Nichts hindert Sie daran, auch serialisierte Daten zu verwenden, zum Beispiel mit json_encode/json_decode, und mit Ihrem Wrapper gespeichert, sogar direkt in der Datenbank mit wenig Aufwand. Es gibt ein weiteres Beispiel zum Schreiben/Lesen von Daten aus einer Datenbank mit PDO, das jedoch leicht auf die Verwendung von WordPress portiert werden kann $wpdb Objekt.