get_pages()

Paramètre

$args(array|string)optionnel

Tableau ou chaîne d'arguments.

'child_of'
(int) Id de la page dont ses enfant et petits-enfants seront retournés. La valeur de $hierarchical n'a aucune influence sur $child_of.
Par défaut : 0 (aucune restriction).

'sort_order'
(string) Comment trier les pages retournées. Accepte 'ASC' et 'DESC'.
Par défaut : 'ASC'.

'sort_column'
(string) Par quelle colonne de la table wp_post trier les pages retournées. On peut en mettre plusieurs en les séparant par des virgules. Accepte 'post_author' , 'post_date', 'post_title', 'post_name', 'post_modified', 'menu_order', 'post_modified_gmt', 'post_parent', 'ID', 'rand' et 'comment*count'.
Par défaut : 'post_title'.

'hierarchical'
(bool) True pour retourner les pages hiérarchiques. Si false $hierarchical et $child_of seront ignorés.
Par défaut : true.

'exclude'
(array) Tableau d'ids de pages à exclure.

'include'
(array) Tableau d'ids de pages à inclure. Ne peut pas être utilisé avec $child_of, $parent, $exclude, $meta_key, $meta_value ou $hierarchical.

'meta_key'
(string) Inclus seulement les pages avec ce champ de méta-donnée.

'meta_value'
(string) Inclus seulement les pages avec cette valeur de méta-donnée.

'authors'
(string) Liste d'ids d'auteurs séparés par une virgule.

'parent'
(int) Id de la page parente dont les enfants seront retournés.
Par défaut : -1 (aucune restriction).

'exclude_tree'
(string|array) Chaîne séparée par des virgules ou tableau d'ids de pages à exclure ainsi que les pages enfants.

'number'
(int) Le nombre de pages à retourner.
Par défaut : 0 (toutes les pages).

'offset'
(int) Le nombre de pages à passer avant d'exécuter la requête. Requière $number.
Par défaut : 0.

'post_type'
(string) Le type de poste à requérir.
Par défaut : 'page'.

'post_status'
(string|array) Une liste séparée par des virgules ou un tableau de status de postes à inclure.
Par défaut : 'publish'.

Valeur par défaut : array()

Retourne

(array|false) Tableau de pages correspondant aux arguments par défauts ou à $args.

Déclaration et structure de la fonction `get_pages()`

La fonction get_pages() est déclarée dans le fichier wp-includes/post.php à la ligne 6105 :

function get_pages( $args = array() ) {
    $defaults = array(
        'child_of'     => 0,
        'sort_order'   => 'ASC',
        'sort_column'  => 'post_title',
        'hierarchical' => 1,
        'exclude'      => array(),
        'include'      => array(),
        'meta_key'     => '',
        'meta_value'   => '',
        'authors'      => '',
        'parent'       => -1,
        'exclude_tree' => array(),
        'number'       => '',
        'offset'       => 0,
        'post_type'    => 'page',
        'post_status'  => 'publish',
    );

    $parsed_args = wp_parse_args( $args, $defaults );

    $number       = (int) $parsed_args['number'];
    $offset       = (int) $parsed_args['offset'];
    $child_of     = (int) $parsed_args['child_of'];
    $hierarchical = $parsed_args['hierarchical'];
    $exclude      = $parsed_args['exclude'];
    $meta_key     = $parsed_args['meta_key'];
    $meta_value   = $parsed_args['meta_value'];
    $parent       = $parsed_args['parent'];
    $post_status  = $parsed_args['post_status'];

    // Make sure the post type is hierarchical.
    $hierarchical_post_types = get_post_types( array( 'hierarchical' => true ) );
    if ( ! in_array( $parsed_args['post_type'], $hierarchical_post_types, true ) ) {
        return false;
    }

    if ( $parent > 0 && ! $child_of ) {
        $hierarchical = false;
    }

    // Make sure we have a valid post status.
    if ( ! is_array( $post_status ) ) {
        $post_status = explode( ',', $post_status );
    }
    if ( array_diff( $post_status, get_post_stati() ) ) {
        return false;
    }

    $query_args = array(
        'orderby'                => 'post_title',
        'order'                  => 'ASC',
        'post__not_in'           => wp_parse_id_list( $exclude ),
        'meta_key'               => $meta_key,
        'meta_value'             => $meta_value,
        'posts_per_page'         => -1,
        'offset'                 => $offset,
        'post_type'              => $parsed_args['post_type'],
        'post_status'            => $post_status,
        'update_post_term_cache' => false,
        'update_post_meta_cache' => false,
        'ignore_sticky_posts'    => true,
        'no_found_rows'          => true,
    );

    if ( ! empty( $parsed_args['include'] ) ) {
        $child_of = 0; // Ignore child_of, parent, exclude, meta_key, and meta_value params if using include.
        $parent   = -1;
        unset( $query_args['post__not_in'], $query_args['meta_key'], $query_args['meta_value'] );
        $hierarchical           = false;
        $query_args['post__in'] = wp_parse_id_list( $parsed_args['include'] );
    }

    if ( ! empty( $parsed_args['authors'] ) ) {
        $post_authors = wp_parse_list( $parsed_args['authors'] );

        if ( ! empty( $post_authors ) ) {
            $query_args['author__in'] = array();
            foreach ( $post_authors as $post_author ) {
                // Do we have an author id or an author login?
                if ( 0 == (int) $post_author ) {
                    $post_author = get_user_by( 'login', $post_author );
                    if ( empty( $post_author ) ) {
                        continue;
                    }
                    if ( empty( $post_author->ID ) ) {
                        continue;
                    }
                    $post_author = $post_author->ID;
                }
                $query_args['author__in'][] = (int) $post_author;
            }
        }
    }

    if ( is_array( $parent ) ) {
        $post_parent__in = array_map( 'absint', (array) $parent );
        if ( ! empty( $post_parent__in ) ) {
            $query_args['post_parent__in'] = $post_parent__in;
        }
    } elseif ( $parent >= 0 ) {
        $query_args['post_parent'] = $parent;
    }

    /*
     * Maintain backward compatibility for `sort_column` key.
     * Additionally to `WP_Query`, it has been supporting the `post_modified_gmt` field, so this logic will translate
     * it to `post_modified` which should result in the same order given the two dates in the fields match.
     */
    $orderby = wp_parse_list( $parsed_args['sort_column'] );
    $orderby = array_map(
        static function ( $orderby_field ) {
            $orderby_field = trim( $orderby_field );
            if ( 'post_modified_gmt' === $orderby_field || 'modified_gmt' === $orderby_field ) {
                $orderby_field = str_replace( '_gmt', '', $orderby_field );
            }
            return $orderby_field;
        },
        $orderby
    );
    if ( $orderby ) {
        $query_args['orderby'] = array_fill_keys( $orderby, $parsed_args['sort_order'] );
    }

    $order = $parsed_args['sort_order'];
    if ( $order ) {
        $query_args['order'] = $order;
    }

    if ( ! empty( $number ) ) {
        $query_args['posts_per_page'] = $number;
    }

    /**
     * Filters query arguments passed to WP_Query in get_pages.
     *
     * @since 6.3.0
     *
     * @param array $query_args  Array of arguments passed to WP_Query.
     * @param array $parsed_args Array of get_pages() arguments.
     */
    $query_args = apply_filters( 'get_pages_query_args', $query_args, $parsed_args );

    $pages = new WP_Query();
    $pages = $pages->query( $query_args );

    if ( $child_of || $hierarchical ) {
        $pages = get_page_children( $child_of, $pages );
    }

    if ( ! empty( $parsed_args['exclude_tree'] ) ) {
        $exclude = wp_parse_id_list( $parsed_args['exclude_tree'] );
        foreach ( $exclude as $id ) {
            $children = get_page_children( $id, $pages );
            foreach ( $children as $child ) {
                $exclude[] = $child->ID;
            }
        }

        $num_pages = count( $pages );
        for ( $i = 0; $i < $num_pages; $i++ ) {
            if ( in_array( $pages[ $i ]->ID, $exclude, true ) ) {
                unset( $pages[ $i ] );
            }
        }
    }

    /**
     * Filters the retrieved list of pages.
     *
     * @since 2.1.0
     *
     * @param WP_Post[] $pages       Array of page objects.
     * @param array     $parsed_args Array of get_pages() arguments.
     */
    return apply_filters( 'get_pages', $pages, $parsed_args );
}

Fonctions utilisées par `get_pages()`

wp_parse_list(): Nettoie un tableau ou une liste de valeurs scalaires séparées par des virgules et/ou espaces.
wp_cache_get_last_changed(): Obtient la dernière date de mis en cache d'un groupe.
wp_cache_get(): Retourne les contenus du cache en donnant la clé et le groupe.
wp_cache_set(): Sauvegarde les données dans le cache.
wp_unslash(): Supprime les slashes d'une chaîne ou d'un tableau de chaînes.
get_user_by(): Retourne les infos d'un utilisateur par un champ donné.
wp_parse_args(): Fusionne des arguments définis par l'utilisateur dans un tableau par défaut.
wp_array_slice_assoc(): Extrait une partie d'un tableau en donnant une liste de clés.
wp_parse_id_list(): Nettoie un tableau ou une liste d'ids séparés par des virgules et/ou espaces.
apply_filters(): Appel les fonctions qui ont été attaché à un filtre (hook).
update_post_cache(): Met à jour les postes dans le cache.
get_page_children(): Identifie les descendants d'un id de page donné dans une liste d'objets de page.
sanitize_post(): Nettoie tous les champs d'un poste.
get_post_types(): Retourne une liste d'objets des types de poste enregistrés.
get_post_stati(): Retourne une liste des status de poste.

Hook utilisé par `get_pages()`

get_pages: Filtre la liste de pages retournée.

Où est utilisée la fonction `get_pages()` dans le CMS WordPress

Exemples

Liste de pages avec leur url :

$pages = get_pages(); 

$option = '<select name="page-dropdown">';
 $option .= '<option value="">- Sélectionner une page -</option>';
  foreach ( $pages as $page ) {
    $option .= '<option value="' . get_page_link( $page->ID ) . '">';
    $option .= $page->post_title;
    $option .= '</option>';
  }
$option .= '</select>';

 echo $option;

Afficher les pages enfants de la page actuelle :

$mypages = get_pages( array( 'child_of' => $post->ID, 'sort_column' => 'post_date', 'sort_order' => 'desc' ) );
 
foreach( $mypages as $page ) {      
    $content = $page->post_content;

    // Vérifier si la page est vide
    if ( ! $content ) continue;

    $content = apply_filters( 'the_content', $content );

    echo '<h2><a href="'.get_page_link( $page->ID ).'">'.$page->post_title.'</a></h2>';
    echo '<div class="entry">'.$content.'</div>';
}

Sources

Codex WordPress : get_pages()

Autres fonctions dans le même fichier : wp-includes/post.php

Retour

Paramètre

Retourne

Déclaration et structure de la fonction get_pages()

Fonctions utilisées par get_pages() Étendre

Hook utilisé par get_pages() Étendre