wake-up-neo.com

Mit wp_query werden alle Unterseiten des übergeordneten Elements abgerufen

Hier ist mein Code

$my_wp_query = new WP_Query();
$all_wp_pages = $my_wp_query->query(array('post_type' => 'page','post_parent'=>$parid,'orderby'=>'title','order'=>'ASC' ));

Es werden nur die Unterseiten der ersten Ebene angezeigt. Ich brauche alle Unterseiten, Unterseiten ... und alles. Ich habe nach einer Lösung gesucht und kann mit get_pages und wp_list_pages alle Unterseiten abrufen.

Aber ich muss die Reihenfolge wirklich nach benutzerdefiniertem Post-Meta-Wert sortieren. Also muss ich benutzerdefinierte Abfrage verwenden.

bitte helfen Sie. Vielen Dank

wp-queryquery-postsquery
12
phpuser

Warum nicht einfach get_pages() benutzen?

z.B.

<?php
// Determine parent page ID
$parent_page_id = ( '0' != $post->post_parent ? $post->post_parent : $post->ID );
// Get child pages as array
$page_tree_array = get_pages( array(
    'child_of' => $parent_page_id;
) );
?>

Wenn es sich aber wirklich um ein WP_Query()-Objekt handeln muss, verwenden Sie eine ähnliche Methode:

<?php
// Determine parent page ID
$parent_page_id = ( '0' != $post->post_parent ? $post->post_parent : $post->ID );
// Build WP_Query() argument array
$page_tree_query_args = array(
    'post_parent' => $parent_page_id;
);
// Get child pages as a WP_Query() object
$page_tree_query = new WP_Query( $page_tree_query_args );
?>
6
Chip Bennett

Das Problem

Was Sie Probleme haben zu erfassen, ist "Wie mache ich X?" Dies ist keine 1-Schritt-Aktion, sondern ein mehrstufiger Prozess, der getrennt werden muss.

Das brauchen Sie nicht zu tun:

get all the posts that are a child of X ordered by meta

Sie müssen dies tun:

get all the posts that are a child of X
    for each child, get all the posts that are a child
        foreach child of that child get all the posts that are a child
            ...
                hmmm we don't have any more children left

Take our list of posts and order them by meta

Die allgemeine Lösung

Um zu verstehen, wie man es unendlich oft macht, bis man das Ende erreicht, ohne es hart zu codieren, muss man rekursive Funktionen verstehen.

z.B.

function make_zero( $amount ) {
    $amount = $amount - 1;
    if ( $amount > 1 ){
        return make_zero( $amount );
    }
    return $amount;
}

Rekursion auf dieses Problem anwenden Für eine Lösung

Ihr Elternteil ist also $parid und Ihr Post-Meta hat den Schlüssel $metakey.

Lasst es uns in eine Funktion umwandeln, um seine Kinder zu fassen.

$children = get_children_with_meta( $parid, $metakey );

Dann sortieren wir das $ children-Array, die Schlüssel sind die Post-IDs und die Werte sind die Meta-Werte.

asort($children);

und lassen Sie uns die Funktion definieren als:

function get_children_with_meta( $parent_id, $metakey ) {
    $q = new WP_Query( array( 'post_parent' => $parent_id, 'meta_key' => $metakey ));
    if ( $q->have_posts() ) {
        $children - array();
        while ( $q->have_posts() ) {
            $q->the_post();
            $meta_value = get_post_meta(get_the_ID(), $metakey, true );
            $children[get_the_ID() ] = $meta_value;
        }
        return $children;
    } else {
        // there are no children!!
        return array();
    }
}

Auf diese Weise erhalten Sie eine Reihe von Beitrags-IDs und Werten, die von der niedrigsten zur höchsten geordnet sind. Sie können andere PHP Sortierfunktionen verwenden, um von der höchsten zur niedrigsten zu gelangen.

Was ist nun mit den Kindern der Kinder?

In der Mitte unserer Schleife müssen wir einen rekursiven Anruf tätigen und das untergeordnete Element anstelle der übergeordneten ID übergeben.

Also das:

$q->the_post();
$meta_value = get_post_meta(get_the_ID(), $metakey, true );
$children[get_the_ID() ] = $meta_value;

Wird dies:

$q->the_post();
$meta_value = get_post_meta(get_the_ID(), $metakey, true );
$children[get_the_ID() ] = $meta_value;

// now get the childrens children
$grandchildren = get_children_with_meta( get_the_ID(), $metakey );

// merge the grandchildren and the children into the same list
$children = array_merge( $children, $grandchildren );

Mit dieser Änderung ruft die Funktion jetzt die Kinder, die Kinder der Kinder, die Kinder der Kinder ..... etc. ab

Am Ende können Sie die Werte im Array abschneiden, um die folgenden IDs zu erhalten:

$post_ids = array_keys( $children );
$q = new WP_Query( array( 'post__in' => $post_ids );
// etc

Mit dieser Strategie können Sie den Metaschlüsselwert durch eine beliebige andere Metrik ersetzen oder rekursive Funktionen auf andere Weise verwenden.

Da der vollständige Code nur ein paar Sekunden Grundkenntnis und schnelles Einfügen von Texten erfordert, beleidige ich Ihre Intelligenz nicht mit einem Codeblock zum vollständigen Einfügen von Texten.

Vorteile

  • Mit Modifikation funktioniert für jeden Beitragstyp und jede Datenform
  • Kann geändert werden, um verschachtelte Markups zu generieren
  • Einfacher Cache zur Beschleunigung, indem die zurückgegebenen Arrays in Transienten versetzt werden
  • Kann mit Paging eingerichtet werden, indem Paging auf das Ende von WP_Query angewendet wird

Probleme, auf die Sie stoßen werden

  • Sie können nicht wissen, wie viele Kinder es gibt, bis Sie sie gefunden haben, sodass die Leistungskosten nicht ansteigen
  • Was Sie wollen, wird eine Menge von Abfragen erzeugen und ist aufgrund der möglichen Tiefen, die damit verbunden sind, von Natur aus kostspielig.

Meine Empfehlung

Ich würde Ihnen empfehlen, entweder Ihre Seitenhierarchie zu reduzieren oder stattdessen eine Taxonomie zu verwenden. Z.B. Wenn Sie Posts bewerten, haben Sie eine Seitenbewertungstaxonomie mit den Begriffen 1,2,3,4 und 5 usw. Dadurch erhalten Sie eine sofort einsatzbereite Post-Liste.

Verwenden Sie alternativ die Navigationsmenüs und umgehen Sie dieses Problem vollständig

4
Tom J Nowell

Ruft rekursiv alle aktuellen Unterseiten ab

Hier ist ein rekursiver Ansatz mit get_children. Tragen Sie folgendes in Ihren functions.php ein:

function get_all_subpages($page, $args = '', $output = OBJECT) {
    // Validate 'page' parameter
    if (! is_numeric($page))
        $page = 0;

    // Set up args
    $default_args = array(
        'post_type' => 'page',
    );
    if (empty($args))
        $args = array();
    elseif (! is_array($args))
        if (is_string($args))
            parse_str($args, $args);
        else
            $args = array();
    $args = array_merge($default_args, $args);
    $args['post_parent'] = $page;

    // Validate 'output' parameter
    $valid_output = array(OBJECT, ARRAY_A, ARRAY_N);
    if (! in_array($output, $valid_output))
        $output = OBJECT;

    // Get children
    $subpages = array();
    $children = get_children($args, $output);
    foreach ($children as $child) {
        $subpages[] = $child;

        if (OBJECT === $output)
            $page = $child->ID;
        elseif (ARRAY_A === $output)
            $page = $child['ID'];
        else
            $page = $child[0];

        // Get subpages by recursion
        $subpages = array_merge($subpages, get_all_subpages($page, $args, $output));
    }

    return $subpages;
}

Wie man es benutzt

Verwenden Sie die obige Funktion, wo immer Sie möchten, zum Beispiel so:

$all_current_subpages = get_all_subpages(0);

Die Funktion unterstützt einen args-Parameter (Abfragezeichenfolge oder Array) und einen output-Typ (siehe oben).

Sie könnten es also auch so verwenden:

$args = array(
    'post_status' => 'private',
    'order_by' => 'post_date',
    'order' => 'DESC',
);
$all_current_subpages = get_all_subpages(42, $args, ARRAY_A);

Und aufgrund der Abhängigkeit get_children => get_posts => WP_Query können Sie Metawerte verwenden, wie ursprünglich vom Autor dieser Frage angefordert.

3
tfrommen

Ich habe eine rekursive Funktion erstellt, die alle untergeordneten IDs einer übergeordneten Seite abruft. Nachdem wir die IDs haben, fragen wir nach den Seiten und können die Ergebnisse nach Metaschlüssel/Wert sortieren.

// Gets all the children ids of post_parent
function _get_children_ids( $post_parent ) {
    $results = new WP_Query( array(
        'post_type' => 'page',
        'post_parent' => $post_parent
    ) );

    $child_ids = array();
    if ( $results->found_posts > 0 )
        foreach ( $results->posts as $post ) // add each child id to array
            $child_ids[] = $post->ID;

    if ( ! empty( $child_ids ) )
        foreach ( $child_ids as $child_id ) // add further children to array
            $child_ids = array_merge( $child_ids, _get_children_ids( $child_id ) );

    return $child_ids;
}

$children_ids = _get_children_ids( 9 ); // use your numeric page id or get_the_id()

$results = new WP_Query( array(
    'post_type'   => 'page',
    'post__in'   => $children_ids
    #'meta_key'   => 'meta_key', // your meta key
    #'orderby'    => 'meta_key',
    /* 'meta_query' => array( // optional meta_query
        array(
            'key' => 'meta_key', // key
            'value' => array(3, 4), // values
            'compare' => 'IN', // operator
        )
    ) */
) );

var_dump( $results );

Wenn Sie die untergeordneten Elemente hierarchisch nach Metaschlüssel/-wert sortieren müssen, müssen Sie die Werte meta_key und order_by an WP_Query in der Funktion _get_children_ids übergeben (anstelle der endgültigen WP_Query).

Wenn nicht, ist eine einfachere Methode zum Abrufen der gesamten untergeordneten ID:

$children = get_pages( 'child_of=9');

$children_ids = array();
if ( ! empty( $children ) )
    foreach ( $children as $post )
        $children_ids[] = $post->ID;
2
Nicü

Wir sind uns nicht sicher, ob Sie genau danach suchen, aber Sie können die Funktion wp_list_pages verwenden und die Parameter 'child_of' und 'depth' verwenden.

Weitere Informationen finden Sie auf der folgenden Seite im Codex: http://codex.wordpress.org/Function_Reference/wp_list_pages

2
Kris Nielsen