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.

Structure de la fonction get_pages()

Définie dans le fichier wp-includes/post.php à la ligne 5391 :

function get_pages( $args = array() ) {
    global $wpdb;

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

    // $args can be whatever, only use the args defined in defaults to compute the key.
    $key          = md5( serialize( wp_array_slice_assoc( $parsed_args, array_keys( $defaults ) ) ) );
    $last_changed = wp_cache_get_last_changed( 'posts' );

    $cache_key = "get_pages:$key:$last_changed";
    $cache     = wp_cache_get( $cache_key, 'posts' );
    if ( false !== $cache ) {
        // Convert to WP_Post instances.
        $pages = array_map( 'get_post', $cache );
        /** This filter is documented in wp-includes/post.php */
        $pages = apply_filters( 'get_pages', $pages, $parsed_args );
        return $pages;
    }

    $inclusions = '';
    if ( ! empty( $parsed_args['include'] ) ) {
        $child_of     = 0; // Ignore child_of, parent, exclude, meta_key, and meta_value params if using include.
        $parent       = -1;
        $exclude      = '';
        $meta_key     = '';
        $meta_value   = '';
        $hierarchical = false;
        $incpages     = wp_parse_id_list( $parsed_args['include'] );
        if ( ! empty( $incpages ) ) {
            $inclusions = ' AND ID IN (' . implode( ',', $incpages ) . ')';
        }
    }

    $exclusions = '';
    if ( ! empty( $exclude ) ) {
        $expages = wp_parse_id_list( $exclude );
        if ( ! empty( $expages ) ) {
            $exclusions = ' AND ID NOT IN (' . implode( ',', $expages ) . ')';
        }
    }

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

        if ( ! empty( $post_authors ) ) {
            foreach ( $post_authors as $post_author ) {
                // Do we have an author id or an author login?
                if ( 0 == intval( $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;
                }

                if ( '' === $author_query ) {
                    $author_query = $wpdb->prepare( ' post_author = %d ', $post_author );
                } else {
                    $author_query .= $wpdb->prepare( ' OR post_author = %d ', $post_author );
                }
            }
            if ( '' !== $author_query ) {
                $author_query = " AND ($author_query)";
            }
        }
    }

    $join  = '';
    $where = "$exclusions $inclusions ";
    if ( '' !== $meta_key || '' !== $meta_value ) {
        $join = " LEFT JOIN $wpdb->postmeta ON ( $wpdb->posts.ID = $wpdb->postmeta.post_id )";

        // meta_key and meta_value might be slashed.
        $meta_key   = wp_unslash( $meta_key );
        $meta_value = wp_unslash( $meta_value );
        if ( '' !== $meta_key ) {
            $where .= $wpdb->prepare( " AND $wpdb->postmeta.meta_key = %s", $meta_key );
        }
        if ( '' !== $meta_value ) {
            $where .= $wpdb->prepare( " AND $wpdb->postmeta.meta_value = %s", $meta_value );
        }
    }

    if ( is_array( $parent ) ) {
        $post_parent__in = implode( ',', array_map( 'absint', (array) $parent ) );
        if ( ! empty( $post_parent__in ) ) {
            $where .= " AND post_parent IN ($post_parent__in)";
        }
    } elseif ( $parent >= 0 ) {
        $where .= $wpdb->prepare( ' AND post_parent = %d ', $parent );
    }

    if ( 1 === count( $post_status ) ) {
        $where_post_type = $wpdb->prepare( 'post_type = %s AND post_status = %s', $parsed_args['post_type'], reset( $post_status ) );
    } else {
        $post_status     = implode( "', '", $post_status );
        $where_post_type = $wpdb->prepare( "post_type = %s AND post_status IN ('$post_status')", $parsed_args['post_type'] );
    }

    $orderby_array = array();
    $allowed_keys  = array(
        'author',
        'post_author',
        'date',
        'post_date',
        'title',
        'post_title',
        'name',
        'post_name',
        'modified',
        'post_modified',
        'modified_gmt',
        'post_modified_gmt',
        'menu_order',
        'parent',
        'post_parent',
        'ID',
        'rand',
        'comment_count',
    );

    foreach ( explode( ',', $parsed_args['sort_column'] ) as $orderby ) {
        $orderby = trim( $orderby );
        if ( ! in_array( $orderby, $allowed_keys, true ) ) {
            continue;
        }

        switch ( $orderby ) {
            case 'menu_order':
                break;
            case 'ID':
                $orderby = "$wpdb->posts.ID";
                break;
            case 'rand':
                $orderby = 'RAND()';
                break;
            case 'comment_count':
                $orderby = "$wpdb->posts.comment_count";
                break;
            default:
                if ( 0 === strpos( $orderby, 'post_' ) ) {
                    $orderby = "$wpdb->posts." . $orderby;
                } else {
                    $orderby = "$wpdb->posts.post_" . $orderby;
                }
        }

        $orderby_array[] = $orderby;

    }
    $sort_column = ! empty( $orderby_array ) ? implode( ',', $orderby_array ) : "$wpdb->posts.post_title";

    $sort_order = strtoupper( $parsed_args['sort_order'] );
    if ( '' !== $sort_order && ! in_array( $sort_order, array( 'ASC', 'DESC' ), true ) ) {
        $sort_order = 'ASC';
    }

    $query  = "SELECT * FROM $wpdb->posts $join WHERE ($where_post_type) $where ";
    $query .= $author_query;
    $query .= ' ORDER BY ' . $sort_column . ' ' . $sort_order;

    if ( ! empty( $number ) ) {
        $query .= ' LIMIT ' . $offset . ',' . $number;
    }

    $pages = $wpdb->get_results( $query );

    if ( empty( $pages ) ) {
        wp_cache_set( $cache_key, array(), 'posts' );

        /** This filter is documented in wp-includes/post.php */
        $pages = apply_filters( 'get_pages', array(), $parsed_args );
        return $pages;
    }

    // Sanitize before caching so it'll only get done once.
    $num_pages = count( $pages );
    for ( $i = 0; $i < $num_pages; $i++ ) {
        $pages[ $i ] = sanitize_post( $pages[ $i ], 'raw' );
    }

    // Update cache.
    update_post_cache( $pages );

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

    $page_structure = array();
    foreach ( $pages as $page ) {
        $page_structure[] = $page->ID;
    }

    wp_cache_set( $cache_key, $page_structure, 'posts' );

    // Convert to WP_Post instances.
    $pages = array_map( 'get_post', $pages );

    /**
     * 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 et Hook utilisés 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 informations 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.

get_pages

Filtre la liste de pages retournée.

sanitize_post()

Nettoie tous les champs d'un poste.

get_post_types()

Retourne une liste d'objets de tous les types de poste enregistrés.

get_post_stati()

Donne une liste de status de poste.

Où trouver 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