Übergabe einer Variablen an get_template_part

Der WP Codex sagt dazu:

// You wish to make $my_var available to the template part at `content-part.php`
set_query_var( 'my_var', $my_var );
get_template_part( 'content', 'part' );

Aber wie mache ich echo $my_vardas im Template Teil? get_query_var($my_var)funktioniert bei mir nicht

Ich habe Tonnen von Empfehlungen für die Verwendung locate_templatestattdessen gesehen. Ist das der beste Weg?

Wenn Posts ihre Daten über the_post()(bzw. über setup_postdata()) einrichten und daher über die API zugänglich sind ( get_the_ID()z. B.), nehmen wir an, dass wir eine Gruppe von Benutzern durchlaufen (indem setup_userdata()die globalen Variablen des aktuell angemeldeten Benutzers und von isn 'gefüllt werden). t nützlich für diese Aufgabe) und versuchen Sie, Metadaten pro Benutzer anzuzeigen:

<?php
get_header();

// etc.

// In the main template file
$users = new \WP_User_Query( [ ... ] );

foreach ( $users as $user )
{
    set_query_var( 'user_id', absint( $user->ID ) );
    get_template_part( 'template-parts/user', 'contact_methods' );
}

Dann wpse-theme/template-parts/user-contact_methods.phpmüssen wir in unserer Datei auf die Benutzer-ID zugreifen:

<?php
/** @var int $user_id */
$some_meta = get_the_author_meta( 'some_meta', $user_id );
var_dump( $some_meta );

Das ist es.

Die Erklärung liegt genau über dem Teil, den Sie in Ihrer Frage angegeben haben:

Wird load_template()jedoch indirekt aufgerufen, indem get_template_part()alle WP_QueryAbfragevariablen in den Bereich der geladenen Vorlage extrahiert werden .

Die native PHP- extract()Funktion "extrahiert" die Variablen (die global $wp_query->query_varsEigenschaft) und fügt jeden Teil in eine eigene Variable ein, die genau den gleichen Namen wie der Schlüssel hat. Mit anderen Worten:

set_query_var( 'foo', 'bar' );

$GLOBALS['wp_query'] (object)
    -> query_vars (array)
        foo => bar (string 3)

extract( $wp_query->query_vars );

var_dump( $foo );
// Result:
(string 3) 'bar'

Die hm_get_template_partFunktion von Humanmade ist extrem gut und ich benutze es die ganze Zeit.

Du rufst an

hm_get_template_part( 'template_path', [ 'option' => 'value' ] );

und dann verwenden Sie in Ihrer Vorlage

$template_args['option'];

um den Wert zurückzugeben. Es macht Caching und alles, obwohl Sie das herausnehmen können, wenn Sie möchten.

Sie können die gerenderte Vorlage sogar als Zeichenfolge zurückgeben, indem Sie sie 'return' => truean das Array key / value übergeben.

/**
 * Like get_template_part() put lets you pass args to the template file
 * Args are available in the tempalte as $template_args array
 * @param string filepart
 * @param mixed wp_args style argument list
 */
function hm_get_template_part( $file, $template_args = array(), $cache_args = array() ) {
    $template_args = wp_parse_args( $template_args );
    $cache_args = wp_parse_args( $cache_args );
    if ( $cache_args ) {
        foreach ( $template_args as $key => $value ) {
            if ( is_scalar( $value ) || is_array( $value ) ) {
                $cache_args[$key] = $value;
            } else if ( is_object( $value ) && method_exists( $value, 'get_id' ) ) {
                $cache_args[$key] = call_user_method( 'get_id', $value );
            }
        }
        if ( ( $cache = wp_cache_get( $file, serialize( $cache_args ) ) ) !== false ) {
            if ( ! empty( $template_args['return'] ) )
                return $cache;
            echo $cache;
            return;
        }
    }
    $file_handle = $file;
    do_action( 'start_operation', 'hm_template_part::' . $file_handle );
    if ( file_exists( get_stylesheet_directory() . '/' . $file . '.php' ) )
        $file = get_stylesheet_directory() . '/' . $file . '.php';
    elseif ( file_exists( get_template_directory() . '/' . $file . '.php' ) )
        $file = get_template_directory() . '/' . $file . '.php';
    ob_start();
    $return = require( $file );
    $data = ob_get_clean();
    do_action( 'end_operation', 'hm_template_part::' . $file_handle );
    if ( $cache_args ) {
        wp_cache_set( $file, $data, serialize( $cache_args ), 3600 );
    }
    if ( ! empty( $template_args['return'] ) )
        if ( $return === false )
            return false;
        else
            return $data;
    echo $data;
}

Ich habe mich umgesehen und eine Vielzahl von Antworten gefunden. Es scheint auf einer nativen Ebene, Wordpress ermöglicht den Zugriff auf Variablen in Template-Teilen. Ich habe festgestellt, dass die Verwendung des Include in Verbindung mit locate_template den Zugriff auf den Gültigkeitsbereich der Variablen in der Datei ermöglicht.

include(locate_template('your-template-name.php'));

// you can use any value including objects.

set_query_var( 'var_name_to_be_used_later', 'Value to be retrieved later' );
//Basically set_query_var uses PHP extract() function  to do the magic.


then later in the template.
var_dump($var_name_to_be_used_later);
//will print "Value to be retrieved later"

Ich empfehle, über die Funktion PHP Extract () zu lesen.

Ich bin auf dasselbe Problem bei einem Projekt gestoßen, an dem ich gerade arbeite. Ich habe mich dazu entschlossen, ein eigenes kleines Plugin zu erstellen, mit dem Sie Variablen mithilfe einer neuen Funktion expliziter an get_template_part übergeben können.

Für den Fall, dass Sie es nützlich finden, finden Sie hier die Seite auf GitHub: https://github.com/JolekPress/Get-Template-Part-With-Variables

Und hier ist ein Beispiel, wie es funktionieren würde:

$variables = [
    'name' => 'John',
    'class' => 'featuredAuthor',
];

jpr_get_template_part_with_vars('author', 'info', $variables);


// In author-info.php:
echo "
<div class='$class'>
    <span>$name</span>
</div>
";

// Would output:
<div class='featuredAuthor'>
    <span>John</span>
</div>

Ich mag das Pods- Plugin und die Funktion pods_view . Es funktioniert ähnlich wie hm_get_template_partin der Antwort von djb. Ich verwende eine zusätzliche Funktion ( findTemplateim folgenden Code), um zuerst im aktuellen Design nach einer Vorlagendatei zu suchen. Wenn sie nicht gefunden wird, wird die gleichnamige Vorlage im /templatesOrdner meines Plugins zurückgegeben . Dies ist eine ungefähre Vorstellung davon, wie ich pods_viewmein Plugin verwende:

/**
 * Helper function to find a template
 */
function findTemplate($filename) {
  // Look first in the theme folder
  $template = locate_template($filename);
  if (!$template) {
    // Otherwise, use the file in our plugin's /templates folder
    $template = dirname(__FILE__) . '/templates/' . $filename;
  }
  return $template;
}

// Output the template 'template-name.php' from either the theme
// folder *or* our plugin's '/template' folder, passing two local
// variables to be available in the template file
pods_view(
  findTemplate('template-name.php'),
  array(
    'passed_variable' => $variable_to_pass,
    'another_variable' => $another_variable,
  )
);

pods_viewunterstützt auch Caching, aber ich brauchte das nicht für meine Zwecke. Weitere Informationen zu den Funktionsargumenten finden Sie auf den Pods-Dokumentationsseiten. Siehe die Seiten für pods_view und Partial Page Caching und Smart Template Parts with Pods .

Basierend auf der Antwort von @djb unter Verwendung von Code von humanmade.

Dies ist eine kompakte Version von get_template_part, die Argumente akzeptieren kann. Auf diese Weise werden Variablen lokal auf diese Vorlage beschränkt. Keine Notwendigkeit zu haben global, get_query_var, set_query_var.

/**
 * Like get_template_part() but lets you pass args to the template file
 * Args are available in the template as $args array.
 * Args can be passed in as url parameters, e.g 'key1=value1&key2=value2'.
 * Args can be passed in as an array, e.g. ['key1' => 'value1', 'key2' => 'value2']
 * Filepath is available in the template as $file string.
 * @param string      $slug The slug name for the generic template.
 * @param string|null $name The name of the specialized template.
 * @param array       $args The arguments passed to the template
 */

function _get_template_part( $slug, $name = null, $args = array() ) {
    if ( isset( $name ) && $name !== 'none' ) $slug = "{$slug}-{$name}.php";
    else $slug = "{$slug}.php";
    $dir = get_template_directory();
    $file = "{$dir}/{$slug}";

    ob_start();
    $args = wp_parse_args( $args );
    $slug = $dir = $name = null;
    require( $file );
    echo ob_get_clean();
}

Zum Beispiel in cart.php:

<? php _get_template_part( 'components/items/apple', null, ['color' => 'red']); ?>

In apple.php:

<p>The apple color is: <?php echo $args['color']; ?></p>

Wie wäre es damit?

render( 'template-parts/header/header', 'desktop', 
    array( 'user_id' => 555, 'struct' => array( 'test' => array( 1,2 ) ) )
);
function render ( $slug, $name, $arguments ) {

    if ( $arguments ) {
        foreach ( $arguments as $key => $value ) {
                ${$key} = $value;
        }
    }

$name = (string) $name;
if ( '' !== $name ) {
    $templates = "{$slug}-{$name}.php";
    } else {
        $templates = "{$slug}.php";
    }

    $path = get_template_directory() . '/' . $templates;
    if ( file_exists( $path ) ) {
        ob_start();
        require( $path);
        ob_get_clean();
    }
}

Mit ${$key}können Sie die Variablen in den aktuellen Funktionsumfang aufnehmen. Funktioniert für mich schnell und einfach und es tritt nicht aus oder wird nicht im globalen Bereich gespeichert.

Für diejenigen, die eine einfache Möglichkeit zur Übergabe von Variablen suchen, können Sie die Funktion folgendermaßen ändern:

include (locate_template ('YourTemplate.php', false, false));

Und dann können Sie alle Variablen verwenden, die definiert wurden, bevor Sie die Vorlage einbinden, ohne zusätzlich jede für die Vorlage zu übergeben.

Credits gehen an: https://mekshq.com/passing-variables-via-get_template_part-wordpress/

Dies ist eine exakte Lösung und es hat gut funktioniert. https://developer.wordpress.org/reference/functions/set_query_var/