Por que não usar apenas get_pages() ?

por exemplo,

<?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;
) );
?>

Mas, se realmente for um objeto WP_Query() , use um método semelhante:

<?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 );
?>

O problema

O que você está tendo problemas para entender é "Como eu faço X?" Essa não é uma ação de 1 passo, é um processo de várias etapas e precisa ser desmembrada.

Você não precisa fazer isso:

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

Você precisa fazer isso:

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

A solução geral

Então, para entender como fazê-lo infinitamente até chegar ao fim, sem codificá-lo, você precisa entender as funções recursivas.

por exemplo,

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

Aplicando recursão a este problema para uma solução

Assim, seu pai é $parid e sua postagem meta tem uma chave de $metakey .

Vamos passá-lo para uma função para pegar seus filhos.

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

Em seguida, classificaremos a matriz $ children, as chaves serão as IDs das postagens e os valores serão os valores meta.

asort($children);

e vamos definir a função como:

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();
    }
}

Isso fornece uma matriz de IDs e valores de postagem, ordenados do menor para o maior. Você pode usar outras funções de classificação do PHP para fazer isso do mais alto ao mais baixo.

Agora, o que acontece com as crianças?

No meio do nosso loop, precisamos fazer uma chamada recursiva, passando o filho em vez do ID pai.

Então isso:

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

Torna-se assim:

$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 );

Com esta modificação, a função recupera agora os filhos, os filhos das crianças, as crianças das crianças ..... etc

No final, você pode cortar os valores na matriz para obter IDs como este:

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

Usando essa estratégia, você pode substituir o valor da meta key por qualquer outra métrica ou usar funções recursivas de outras formas.

Como o código completo requer apenas alguns segundos de compreensão básica e uma rápida cópia de pasta, eu não insulto sua inteligência com um bloco de código em pasta cheia de cópias.

Vantagens

• Com a modificação funciona para qualquer tipo de postagem e forma de dados
• Pode ser modificado para gerar marcação aninhada
• Armazenar em cache com facilidade para acelerar, colocando as matrizes retornadas em transientes
• Pode ser configurado com paginação, aplicando paginação ao final WP_Query

Problemas que você irá encontrar

• Você não tem como saber quantos filhos existem até encontrá-los, por isso os custos de desempenho não são reduzidos
• O que você deseja gerará muitas consultas e é inerentemente caro devido às profundidades potenciais envolvidas.

Minha recomendação

Recomendamos que você aplainar sua hierarquia de páginas ou usar uma taxonomia. Por exemplo. se você estiver classificando postagens, tenha uma taxonomia de classificação de página com os termos 1,2,3,4 e 5 etc. Isso fornecerá uma listagem de postagem imediata.

Como alternativa, use menus de navegação e ignore este problema inteiramente

Obtém recursivamente todas as subpáginas atuais

Aqui está uma abordagem recursiva usando get_children . Coloque o seguinte no seu functions.php :

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;
}

Como usar

Use a função acima onde quiser, por exemplo, assim:

$all_current_subpages = get_all_subpages(0);

A função suporta um parâmetro args (string de consulta ou array) e um tipo output (veja acima).

Você também pode usá-lo assim:

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

E devido à dependência get_children = > get_posts = > WP_Query você pode usar valores meta, como inicialmente solicitado pelo autor desta pergunta.

Não tenho certeza se é exatamente isso que você procura, mas você pode usar a função wp_list_pages e usar os parâmetros 'child_of' e 'depth'.

Veja a página seguinte no Codex para mais informações: enlace

Eu fiz uma função recursiva que obtém todos os ids filhos de uma página pai. Depois que temos os ids, fazemos consultas para as páginas e podemos ordenar os resultados por meta key / value.

// 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 );

Se você precisar classificar os filhos por meta key / value de uma maneira hierárquica, você deve passar os valores meta_key e order_by para a WP_Query na função _get_children_ids (em vez da WP_Query final).

Se não, um método mais simples para obter todo o ID filho é:

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

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

EU FAÇO ESTE TRABALHO, APENAS COPIE COLOQUE O CÓDIGO NA PÁGINA.PHP FILE

//REDIRECT TO FIRST CHILD FROM PARENT PAGE

// Build WP_Query() argument array
$page_tree_query_args = array(
    'post_parent' => $post -> ID,
    'post_type' => 'page',
    'order' => 'asc'
);
// Get child pages as a WP_Query() object
$page_tree_query = new WP_Query( $page_tree_query_args );
if(!empty($page_tree_query -> posts)){
    $first_subpage = $page_tree_query -> posts[0] -> ID;
    wp_redirect( get_permalink( $first_subpage ) );
    exit;   
}