Übergabe einer Variablen an get_template_part

55

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?

Florian
quelle
Hatte ungefähr die gleiche Frage und bekam es zum Arbeiten mit set_query_varund get_query_var, dies war jedoch für die Verwendung der Werte eines $argsArrays, das an a übergeben wird WP_Query. Könnte für andere hilfreich sein, die anfangen, dies zu lernen.
Lowtechsun

Antworten:

53

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'
Kaiser
quelle
1
funktioniert immer noch gut
Huraji
23

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;
}
djb
quelle
Fügen Sie dem Projekt 1300 Codezeilen (von github HM) hinzu, um einen Parameter an eine Vorlage zu übergeben. Kann dies nicht in meinem Projekt tun :(
Gediminas
11

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'));
Murray Chapman
quelle
Die Verwendung includewird den Test nicht bestehen .
Lowtechsun
Brauchen wir wirklich etwas, das dem W3C-Checker für WP-Themes ähnelt?
Fredy,
5
// 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.

Hugo R
quelle
2

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>
John O.
quelle
1

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 .

Drittanbieter
quelle
1

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>
Veedka
quelle
0

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.

Mattijs
quelle
0

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/

Gediminas
quelle