Saya telah melakukan penelitian yang cukup luas tentang cara menggunakan pre_get_postspada halaman benar dan halaman depan statis, dan tampaknya tidak ada metode bukti bodoh.

Opsi terbaik yang saya temukan sampai saat ini adalah dari pos yang dilakukan oleh @birgire di Stackoverflow . Saya telah menulis ulang menjadi kelas demo dan membuat kodenya sedikit lebih dinamis

class PreGeTPostsForPages
{
    /**
     * @var string|int $pageID
     * @access protected     
     * @since 1.0.0
     */
    protected $pageID;

    /**
     * @var bool $injectPageIntoLoop
     * @access protected     
     * @since 1.0.0
    */
    protected $injectPageIntoLoop;

    /**
     * @var array $args
     * @access protected     
     * @since 1.0.0
     */
    protected $args;

    /**
     * @var int $validatedPageID
     * @access protected     
     * @since 1.0.0
     */
    protected $validatedPageID = 0;

    /**
     * Constructor
     *
     * @param string|int $pageID = NULL
     * @param bool $injectPageIntoLoop = false
     * @param array| $args = []
     * @since 1.0.0
     */     
    public function __construct( 
        $pageID             = NULL, 
        $injectPageIntoLoop = true, 
        $args               = [] 
    ) { 
        $this->pageID             = $pageID;
        $this->injectPageIntoLoop = $injectPageIntoLoop;
        $this->args               = $args;
    }

    /**
     * Private method validatePageID()
     *
     * Validates the page ID passed
     *
     * @since 1.0.0
     */
    private function validatePageID()
    {
        $validatedPageID       = filter_var( $this->pageID, FILTER_VALIDATE_INT );
        $this->validatedPageID = $validatedPageID;
    }

    /**
     * Public method init()
     *
     * This method is used to initialize our pre_get_posts action
     *
     * @since 1.0.0
     */
    public function init()
    {
        // Load the correct actions according to the value of $this->keepPageIntegrity
        add_action( 'pre_get_posts', [$this, 'preGetPosts'] );
    }

    /**
     * Protected method pageObject()
     *
     * Gets the queried object to use that as page object
     *
     * @since 1.0.0
     */
    protected function pageObject()
    {
        global $wp_the_query;
        return $wp_the_query->get_queried_object();
    }

    /**
     * Public method preGetPosts()
     *
     * This is our call back method for the pre_get_posts action.
     * 
     * The pre_get_posts action will only be used if the page integrity is
     * not an issue, which means that the page will be altered to work like a
     * normal archive page. Here you have the option to inject the page object as
     * first post through the_posts filter when $this->injectPageIntoLoop === true
     *
     * @since 1.0.0
     */
    public function preGetPosts( \WP_Query $q )
    {
        // Make sure that we are on the main query and the desired page
        if (    is_admin() // Only run this on the front end
             || !$q->is_main_query() // Only target the main query
             || !is_page( $this->validatedPageID ) // Run this only on the page specified
        )
            return;

        // Remove the filter to avoid infinte loops
        remove_filter( current_filter(), [$this, __METHOD__] );

        // METHODS:
        $this->validatePageID();
        $this->pageObject();

        $queryArgs             = $this->args;

        // Set default arguments which cannot be changed 
        $queryArgs['pagename'] = NULL;

        // We have reached this point, lets do what we need to do
        foreach ( $queryArgs as $key=>$value ) 
            $q->set( 
                filter_var( $key, FILTER_SANITIZE_STRING ),
                $value // Let WP_Query handle the sanitation of the values accordingly
            );

        // Set $q->is_singular to 0 to get pagination to work
        $q->is_singular = false;

        // FILTERS:
        add_filter( 'the_posts',        [$this, 'addPageAsPost'],   PHP_INT_MAX );
        add_filter( 'template_include', [$this, 'templateInclude'], PHP_INT_MAX );  
    }

    /**
     * Public callback method hooked to 'the_posts' filter
     * This will inject the queried object into the array of posts
     * if $this->injectPageIntoLoop === true
     *
     * @since 1.0.0
     */
    public function addPageAsPost( $posts )
    {
        // Inject the page object as a post if $this->injectPageIntoLoop == true
        if ( true === $this->injectPageIntoLoop )
            return array_merge( [$this->pageObject()], $posts );

        return $posts;
    }

    /**
     * Public call back method templateInclude() for the template_include filter
     *
     * @since 1.0.0
     */
    public function templateInclude( $template )
    {
        // Remove the filter to avoid infinte loops
        remove_filter( current_filter(), [$this, __METHOD__] );

        // Get the page template saved in db
        $pageTemplate = get_post_meta( 
            $this->validatedPageID, 
            '_wp_page_template', 
            true 
        );

        // Make sure the template exists before we load it, but only if $template is not 'default'
        if ( 'default' !== $pageTemplate ) {
            $locateTemplate = locate_template( $pageTemplate );
            if ( $locateTemplate )
                return $template = $locateTemplate;
        }

        /**
         * If $template returned 'default', or the template is not located for some reason,
         * we need to get and load the template according to template hierarchy
         *
         * @uses get_page_template()
         */
        return $template = get_page_template();
    }
}

$init = new PreGeTPostsForPages(
    251, // Page ID
    false,
    [
        'posts_per_page' => 3,
        'post_type'      => 'post'
    ]
);
$init->init();

Ini bekerja dengan baik dan halaman seperti yang diharapkan dengan menggunakan fungsi pagination saya sendiri .

MASALAH:

Karena fungsinya, saya kehilangan integritas halaman yang memuat fungsi lain yang bergantung pada objek halaman yang disimpan $post. $postsebelum loop diatur ke posting pertama di loop dan $postdiatur ke posting terakhir di loop setelah loop, yang diharapkan. Yang saya butuhkan adalah yang $postdiatur ke objek halaman saat ini, yaitu objek yang di-query.

Juga, $wp_the_query->postdan $wp_query->postpegang posting pertama di loop dan bukan objek yang diminta seperti pada halaman normal

Saya menggunakan yang berikut (di luar kelas saya ) untuk memeriksa global saya sebelum dan sesudah loop

add_action( 'wp_head',   'printGlobals' );
add_action( 'wp_footer', 'printGlobals' );
function printGlobals()
{
    $global_test  = 'QUERIED OBJECT: ' . $GLOBALS['wp_the_query']->queried_object_id . '</br>';
    $global_test .= 'WP_THE_QUERY: ' . $GLOBALS['wp_the_query']->post->ID . '</br>';
    $global_test .= 'WP_QUERY: ' . $GLOBALS['wp_query']->post->ID . '</br>';
    $global_test .= 'POST: ' . $GLOBALS['post']->ID . '</br>';
    $global_test .= 'FOUND_POSTS: ' . $GLOBALS['wp_query']->found_posts . '</br>';
    $global_test .= 'MAX_NUM_PAGES: ' . $GLOBALS['wp_query']->max_num_pages . '</br>';

    ?><pre><?php var_dump( $global_test ); ?></pre><?php
}

SEBELUM LOOP:

Sebelum loop, masalahnya sebagian diselesaikan dengan menyetel $injectPageIntoLoopke true yang menyuntikkan objek halaman sebagai halaman pertama dalam loop. Ini cukup berguna jika Anda perlu menampilkan info halaman sebelum posting yang diminta, tetapi jika Anda tidak menginginkannya, Anda kacau.

Saya dapat memecahkan masalah sebelum loop dengan langsung meretas global, yang saya tidak suka. Saya mengaitkan metode berikut ke wpdalam preGetPostsmetode saya

public function wp()
{
    $page                          = get_post( $this->pageID );
    $GLOBALS['wp_the_query']->post = $page;
    $GLOBALS['wp_query']           = $GLOBALS['wp_the_query'];
    $GLOBALS['post']               = $page;
}

dan preGetPostsmetode di dalam

add_action( 'wp', [$this, 'wp'] );

Dari ini, $wp_the_query->post, $wp_query->postdan $postsemua memegang halaman objek.

SETELAH LOOP

Di sinilah masalah besar saya, setelah loop. Setelah meretas global melalui wphook dan metode,

• $wp_the_query->postdan $wp_query->postdiatur kembali ke pos pertama dalam loop, seperti yang diharapkan

• $post diatur ke pos terakhir di loop.

Yang saya butuhkan adalah ketiga diatur kembali ke objek tanya / objek halaman saat ini.

Saya telah mencoba mengaitkan wpmetode ke loop_endtindakan, yang tidak berhasil. Mengaitkan wpmetode dengan get_sidebartindakan berhasil, tetapi sudah terlambat.

add_action( 'get_sidebar', [$this, 'wp'] );

Berjalan printGlobals()langsung setelah loop di templat mengonfirmasi bahwa as $wp_the_query->postdan $wp_query->postmasih diatur ke pos pertama dan $postke pos terakhir.

Saya dapat secara manual menambahkan kode di dalam wpmetode setelah loop di dalam template, tetapi idenya bukan untuk mengubah file template secara langsung karena kelas harus dapat ditransfer dalam plugin antar tema.

Apakah ada cara yang tepat untuk memecahkan masalah ini di mana satu run pre_get_postspada halaman yang benar dan halaman depan statis dan masih menjaga integritas $wp_the_query->post, $wp_query->postdan $post( memiliki set mereka ke objek tanya ) sebelum dan sesudah loop.

EDIT

Tampaknya ada kebingungan tentang apa yang saya butuhkan dan mengapa saya membutuhkannya

Apa yang saya butuhkan

Saya perlu mempertahankan nilai $wp_the_query->post, $wp_query->postdan $postdi seluruh template, dan nilai itu harus menjadi objek yang ditanyakan. Pada tahap ini, dengan kode yang telah saya posting, nilai-nilai dari ketiga variabel tersebut tidak menampung objek halaman, melainkan memposting objek tulisan dalam loop. Saya harap itu cukup jelas.

Saya telah memposting kode yang dapat Anda gunakan untuk menguji variabel-variabel ini

Kenapa saya membutuhkannya?

Saya membutuhkan cara yang dapat diandalkan untuk menambahkan posting pre_get_postske templat halaman dan halaman depan statis tanpa mengubah fungsionalitas halaman penuh. Pada tahap ini, seperti kode yang dimaksud berdiri, itu merusak fitur breadcrumb saya dan fitur halaman terkait setelah loop karena $postyang memegang objek posting "salah".

Yang paling penting, saya tidak ingin mengubah template halaman secara langsung. Saya ingin dapat menambahkan posting ke templat halaman tanpa modifikasi APAPUN pada templat

Saya akhirnya berhasil, tetapi tidak dengan kode dalam pertanyaan saya. Saya benar-benar membatalkan seluruh gagasan itu dan memulai lagi dengan arah yang baru.

CATATAN:

Jika ada yang bisa menyelesaikan masalah dalam pertanyaan saya, jangan ragu untuk mengirim jawaban. Juga, jika Anda memiliki solusi lain, jangan ragu untuk mengirim jawaban.

KELAS DAN SOLUSI YANG DITINJAU KEMBALI:

Apa yang saya coba lakukan di sini adalah menggunakan post injection, daripada sepenuhnya mengubah kueri utama dan terjebak dengan semua masalah di atas, termasuk (a) secara langsung mengubah global, (b) berlari ke masalah nilai global, dan (c) menugaskan kembali template halaman.

Dengan menggunakan pasca injeksi, saya mampu menjaga integritas posting penuh, jadi $wp_the_query->post, $wp_query->post, $postsdan $posttinggal konstan sepanjang template. Masing-masing variabel referensi objek halaman saat ini (seperti halnya dengan halaman sebenarnya). Dengan cara ini, fungsi seperti remah roti tahu bahwa halaman saat ini adalah halaman yang benar dan bukan semacam arsip.

Saya harus sedikit mengubah kueri utama ( melalui filter dan tindakan ) untuk menyesuaikan pagination, tapi kami akan sampai pada itu.

QUERY INJECTION POST

Untuk menyelesaikan injeksi pos, saya menggunakan kueri khusus untuk mengembalikan posting yang diperlukan untuk injeksi. Saya juga menggunakan $found_pagesproperti kueri khusus untuk menyesuaikan properti dari kueri utama agar pagination berfungsi dari kueri utama. Posting disuntikkan ke dalam kueri utama melalui loop_endtindakan.

Untuk membuat kueri khusus dapat diakses dan dapat digunakan di luar kelas, saya memperkenalkan beberapa tindakan.

• Kait Pagination untuk menghubungkan fungsi pagination:

  • pregetgostsforgages_before_loop_pagination

  • pregetgostsforgages_after_loop_pagination

• Penghitung kustom yang menghitung pos dalam loop. Tindakan ini dapat digunakan untuk mengubah cara posting ditampilkan di dalam loop sesuai dengan nomor posting.

  • pregetgostsforgages_counter_before_template_part

  • pregetgostsforgages_counter_after_template_part

• Kait umum untuk mengakses objek permintaan dan objek posting saat ini

  • pregetgostsforgages_current_post_and_object

Kait ini memberi Anda pengalaman lepas tangan total, karena Anda tidak perlu mengubah apa pun di templat laman itu sendiri, yang merupakan niat awal saya sejak awal. Halaman sepenuhnya dapat diubah dari plugin atau file fungsi, yang membuat solusi ini sangat dinamis.

Saya juga telah menggunakan get_template_part()untuk memuat bagian templat, yang akan digunakan untuk menampilkan tulisan. Sebagian besar tema saat ini menggunakan bagian templat, yang membuatnya sangat berguna di kelas. Jika menggunakan tema Anda content.php, Anda hanya bisa lewat contentke $templatePartbeban content.php.

Jika Anda membutuhkan dukungan pasca format untuk bagian-bagian Template, mudah - Anda hanya bisa lewat contentke $templatePartdan set $postFormatSupportke true. Akibatnya, bagian templat content-video.phpakan dimuat untuk pos dengan format pos video.

QUERY UTAMA

Perubahan berikut dilakukan untuk kueri utama melalui masing-masing filter dan tindakan:

• Untuk menjeda pertanyaan utama:

  • Nilai $found_postsproperti kueri injector diteruskan ke nilai objek kueri utama melalui found_postsfilter.

  • Nilai parameter yang dilewati pengguna posts_per_pagediatur ke kueri utama pre_get_posts.

  • $max_num_pagesdihitung menggunakan jumlah posting di $found_posts dan posts_per_page. Karena is_singularbenar pada halaman, itu menghambat LIMITklausa yang ditetapkan. Cukup menetapkan is_singularke false menyebabkan beberapa masalah, jadi saya memutuskan untuk mengatur LIMITklausa melalui post_limitsfilter. Aku terus offsetdari LIMITklausul set untuk 0menghindari 404 pada halaman dengan pagination dihidupkan.

Ini menangani pagination dan masalah apa pun yang mungkin timbul dari injeksi postingan.

TUJUAN HALAMAN

Objek halaman saat ini tersedia untuk ditampilkan sebagai posting dengan menggunakan loop default pada halaman, pisahkan dan di atas posting yang disuntikkan. Jika Anda tidak membutuhkan ini, Anda dapat mengatur $removePageFromLoopke true, dan ini akan menyembunyikan konten halaman agar tidak ditampilkan.

Pada tahap ini, saya menggunakan CSS untuk menyembunyikan objek halaman melalui loop_startdan loop_endtindakan karena saya tidak dapat menemukan cara lain untuk melakukan ini. Kelemahan dari metode ini adalah segala sesuatu yang dikaitkan dengan the_postaction hook di dalam permintaan utama juga akan disembunyikan.

KELAS

The PreGetPostsForPageskelas dapat ditingkatkan dan harus benar-namespace juga. Meskipun Anda bisa menjatuhkan ini di file fungsi tema Anda, akan lebih baik untuk memasukkan ini ke dalam plugin khusus.

Gunakan, modifikasi, dan penyalahgunaan sesuai keinginan Anda. Kode ini dikomentari dengan baik, sehingga harus mudah diikuti dan disesuaikan

class PreGetPostsForPages
{
    /**
     * @var string|int $pageID
     * @access protected     
     * @since 1.0.0
     */
    protected $pageID;

    /**
     * @var string $templatePart
     * @access protected     
     * @since 1.0.0
     */
    protected $templatePart;

    /**
     * @var bool $postFormatSupport
     * @access protected     
     * @since 1.0.0
     */
    protected $postFormatSupport;

    /**
     * @var bool $removePageFromLoop
     * @access protected     
     * @since 1.0.0
     */
    protected $removePageFromLoop;

    /**
     * @var array $args
     * @access protected     
     * @since 1.0.0
     */
    protected $args;

    /**
     * @var array $mergedArgs
     * @access protected     
     * @since 1.0.0
     */
    protected $mergedArgs = [];

    /**
     * @var NULL|\stdClass $injectorQuery
     * @access protected     
     * @since 1.0.0
     */
    protected $injectorQuery = NULL;

    /**
     * @var int $validatedPageID
     * @access protected     
     * @since 1.0.0
     */
    protected $validatedPageID = 0;

    /** 
     * Constructor method
     *
     * @param string|int $pageID The ID of the page we would like to target
     * @param string $templatePart The template part which should be used to display posts
     * @param string $postFormatSupport Should get_template_part support post format specific template parts
     * @param bool $removePageFromLoop Should the page content be displayed or not
     * @param array $args An array of valid arguments compatible with WP_Query
     *
     * @since 1.0.0
     */      
    public function __construct( 
        $pageID             = NULL,
        $templatePart       = NULL,
        $postFormatSupport  = false,
        $removePageFromLoop = false,
        $args               = [] 
    ) {
        $this->pageID             = $pageID;
        $this->templatePart       = $templatePart;
        $this->postFormatSupport  = $postFormatSupport;
        $this->removePageFromLoop = $removePageFromLoop;
        $this->args               = $args;
    }

    /**
     * Public method init()
     *
     * The init method will be use to initialize our pre_get_posts action
     *
     * @since 1.0.0
     */
    public function init()
    {
        // Initialise our pre_get_posts action
        add_action( 'pre_get_posts', [$this, 'preGetPosts'] );
    }

    /**
     * Private method validatePageID()
     *
     * Validates the page ID passed
     *
     * @since 1.0.0
     */
    private function validatePageID()
    {
        $validatedPageID = filter_var( $this->pageID, FILTER_VALIDATE_INT );
        $this->validatedPageID = $validatedPageID;
    }

    /**
     * Private method mergedArgs()
     *
     * Merge the default args with the user passed args
     *
     * @since 1.0.0
     */
    private function mergedArgs()
    {
        // Set default arguments
        if ( get_query_var( 'paged' ) ) {
            $currentPage = get_query_var( 'paged' );
        } elseif ( get_query_var( 'page' ) ) {
            $currentPage = get_query_var( 'page' );
        } else {
            $currentPage = 1;
        }
        $default = [
            'suppress_filters'    => true,
            'ignore_sticky_posts' => 1,
            'paged'               => $currentPage,
            'posts_per_page'      => get_option( 'posts_per_page' ), // Set posts per page here to set the LIMIT clause etc
            'nopaging'            => false
        ];    
        $mergedArgs = wp_parse_args( (array) $this->args, $default );
        $this->mergedArgs = $mergedArgs;
    }

    /**
     * Public method preGetPosts()
     *
     * This is the callback method which will be hooked to the 
     * pre_get_posts action hook. This method will be used to alter
     * the main query on the page specified by ID.
     *
     * @param \stdClass WP_Query The query object passed by reference
     * @since 1.0.0
     */
    public function preGetPosts( \WP_Query $q )
    {
        if (    !is_admin() // Only target the front end
             && $q->is_main_query() // Only target the main query
             && $q->is_page( filter_var( $this->validatedPageID, FILTER_VALIDATE_INT ) ) // Only target our specified page
        ) {
            // Remove the pre_get_posts action to avoid unexpected issues
            remove_action( current_action(), [$this, __METHOD__] );

            // METHODS:
            // Initialize our method which will return the validated page ID
            $this->validatePageID();
            // Initiale our mergedArgs() method
            $this->mergedArgs();
            // Initiale our custom query method
            $this->injectorQuery();

            /**
             * We need to alter a couple of things here in order for this to work
             * - Set posts_per_page to the user set value in order for the query to
             *   to properly calculate the $max_num_pages property for pagination
             * - Set the $found_posts property of the main query to the $found_posts
             *   property of our custom query we will be using to inject posts
             * - Set the LIMIT clause to the SQL query. By default, on pages, `is_singular` 
             *   returns true on pages which removes the LIMIT clause from the SQL query.
             *   We need the LIMIT clause because an empty limit clause inhibits the calculation
             *   of the $max_num_pages property which we need for pagination
             */
            if (    $this->mergedArgs['posts_per_page'] 
                 && true !== $this->mergedArgs['nopaging']
            ) {
                $q->set( 'posts_per_page', $this->mergedArgs['posts_per_page'] );
            } elseif ( true === $this->mergedArgs['nopaging'] ) {
                $q->set( 'posts_per_page', -1 );
            }

            // FILTERS:
            add_filter( 'found_posts', [$this, 'foundPosts'], PHP_INT_MAX, 2 );
            add_filter( 'post_limits', [$this, 'postLimits']);

            // ACTIONS:
            /**
             * We can now add all our actions that we will be using to inject our custom
             * posts into the main query. We will not be altering the main query or the 
             * main query's $posts property as we would like to keep full integrity of the 
             * $post, $posts globals as well as $wp_query->post. For this reason we will use
             * post injection
             */     
            add_action( 'loop_start', [$this, 'loopStart'], 1 );
            add_action( 'loop_end',   [$this, 'loopEnd'],   1 );
        }    
    }    

    /**
     * Public method injectorQuery
     *
     * This will be the method which will handle our custom
     * query which will be used to 
     * - return the posts that should be injected into the main
     *   query according to the arguments passed
     * - alter the $found_posts property of the main query to make
     *   pagination work 
     *
     * @link https://codex.wordpress.org/Class_Reference/WP_Query
     * @since 1.0.0
     * @return \stdClass $this->injectorQuery
     */
    public function injectorQuery()
    {
        //Define our custom query
        $injectorQuery = new \WP_Query( $this->mergedArgs );

        // Update the thumbnail cache
        update_post_thumbnail_cache( $injectorQuery );

        $this->injectorQuery = $injectorQuery;

        return $this->injectorQuery;
    }

    /**
     * Public callback method foundPosts()
     * 
     * We need to set found_posts in the main query to the $found_posts
     * property of the custom query in order for the main query to correctly 
     * calculate $max_num_pages for pagination
     *
     * @param string $found_posts Passed by reference by the filter
     * @param stdClass \WP_Query Sq The current query object passed by refence
     * @since 1.0.0
     * @return $found_posts
     */
    public function foundPosts( $found_posts, \WP_Query $q )
    {
        if ( !$q->is_main_query() )
            return $found_posts;

        remove_filter( current_filter(), [$this, __METHOD__] );

        // Make sure that $this->injectorQuery actually have a value and is not NULL
        if (    $this->injectorQuery instanceof \WP_Query 
             && 0 != $this->injectorQuery->found_posts
        )
            return $found_posts = $this->injectorQuery->found_posts;

        return $found_posts;
    }

    /**
     * Public callback method postLimits()
     *
     * We need to set the LIMIT clause as it it is removed on pages due to 
     * is_singular returning true. Witout the limit clause, $max_num_pages stays
     * set 0 which avoids pagination. 
     *
     * We will also leave the offset part of the LIMIT cluase to 0 to avoid paged
     * pages returning 404's
     *
     * @param string $limits Passed by reference in the filter
     * @since 1.0.0
     * @return $limits
     */
    public function postLimits( $limits )
    {
        $posts_per_page = (int) $this->mergedArgs['posts_per_page'];
        if (    $posts_per_page
             && -1   !=  $posts_per_page // Make sure that posts_per_page is not set to return all posts
             && true !== $this->mergedArgs['nopaging'] // Make sure that nopaging is not set to true
        ) {
            $limits = "LIMIT 0, $posts_per_page"; // Leave offset at 0 to avoid 404 on paged pages
        }

        return $limits;
    }

    /**
     * Public callback method loopStart()
     *
     * Callback function which will be hooked to the loop_start action hook
     *
     * @param \stdClass \WP_Query $q Query object passed by reference
     * @since 1.0.0
     */
    public function loopStart( \WP_Query $q )
    {
        /**
         * Although we run this action inside our preGetPosts methods and
         * and inside a main query check, we need to redo the check here aswell
         * because failing to do so sets our div in the custom query output as well
         */

        if ( !$q->is_main_query() )
            return;

        /** 
         * Add inline style to hide the page content from the loop
         * whenever $removePageFromLoop is set to true. You can
         * alternatively alter the page template in a child theme by removing
         * everything inside the loop, but keeping the loop
         * Example of how your loop should look like:
         *     while ( have_posts() ) {
         *     the_post();
         *         // Add nothing here
         *     }
         */
        if ( true === $this->removePageFromLoop )
            echo '<div style="display:none">';
    }   

    /**
     * Public callback method loopEnd()
     *
     * Callback function which will be hooked to the loop_end action hook
     *
     * @param \stdClass \WP_Query $q Query object passed by reference
     * @since 1.0.0
     */
    public function loopEnd( \WP_Query $q )
    {  
        /**
         * Although we run this action inside our preGetPosts methods and
         * and inside a main query check, we need to redo the check here as well
         * because failing to do so sets our custom query into an infinite loop
         */
        if ( !$q->is_main_query() )
            return;

        // See the note in the loopStart method  
        if ( true === $this->removePageFromLoop )
            echo '</div>';

        //Make sure that $this->injectorQuery actually have a value and is not NULL
        if ( !$this->injectorQuery instanceof \WP_Query )
            return; 

        // Setup a counter as wee need to run the custom query only once    
        static $count = 0;    

        /**
         * Only run the custom query on the first run of the loop. Any consecutive
         * runs (like if the user runs the loop again), the custom posts won't show.
         */
        if ( 0 === (int) $count ) {      
            // We will now add our custom posts on loop_end
            $this->injectorQuery->rewind_posts();

            // Create our loop
            if ( $this->injectorQuery->have_posts() ) {

                /**
                 * Fires before the loop to add pagination.
                 *
                 * @since 1.0.0
                 *
                 * @param \stdClass $this->injectorQuery Current object (passed by reference).
                 */
                do_action( 'pregetgostsforgages_before_loop_pagination', $this->injectorQuery );


                // Add a static counter for those who need it
                static $counter = 0;

                while ( $this->injectorQuery->have_posts() ) {
                    $this->injectorQuery->the_post(); 

                    /**
                     * Fires before get_template_part.
                     *
                     * @since 1.0.0
                     *
                     * @param int $counter (passed by reference).
                     */
                    do_action( 'pregetgostsforgages_counter_before_template_part', $counter );

                    /**
                     * Fires before get_template_part.
                     *
                     * @since 1.0.0
                     *
                     * @param \stdClass $this->injectorQuery-post Current post object (passed by reference).
                     * @param \stdClass $this->injectorQuery Current object (passed by reference).
                     */
                    do_action( 'pregetgostsforgages_current_post_and_object', $this->injectorQuery->post, $this->injectorQuery );

                    /** 
                     * Load our custom template part as set by the user
                     * 
                     * We will also add template support for post formats. If $this->postFormatSupport
                     * is set to true, get_post_format() will be automatically added in get_template part
                     *
                     * If you have a template called content-video.php, you only need to pass 'content'
                     * to $template part and then set $this->postFormatSupport to true in order to load
                     * content-video.php for video post format posts
                     */
                    $part = '';
                    if ( true === $this->postFormatSupport )
                        $part = get_post_format( $this->injectorQuery->post->ID ); 

                    get_template_part( 
                        filter_var( $this->templatePart, FILTER_SANITIZE_STRING ), 
                        $part
                    );

                    /**
                     * Fires after get_template_part.
                     *
                     * @since 1.0.0
                     *
                     * @param int $counter (passed by reference).
                     */
                    do_action( 'pregetgostsforgages_counter_after_template_part', $counter );

                    $counter++; //Update the counter
                }

                wp_reset_postdata();

                /**
                 * Fires after the loop to add pagination.
                 *
                 * @since 1.0.0
                 *
                 * @param \stdClass $this->injectorQuery Current object (passed by reference).
                 */
                do_action( 'pregetgostsforgages_after_loop_pagination', $this->injectorQuery );
            }
        }

        // Update our static counter
        $count++;       
    }
}  

PEMAKAIAN

Anda sekarang dapat memulai kelas ( juga di plugin atau file fungsi ) sebagai tindak lanjut untuk menargetkan halaman dengan ID 251, di mana kami akan menampilkan 2 posting per halaman dari postjenis posting.

$query = new PreGetPostsForPages(
    251,       // Page ID we will target
    'content', //Template part which will be used to display posts, name should be without .php extension 
    true,      // Should get_template_part support post formats
    false,     // Should the page object be excluded from the loop
    [          // Array of valid arguments that will be passed to WP_Query/pre_get_posts
        'post_type'      => 'post', 
        'posts_per_page' => 2
    ] 
);
$query->init(); 

MENAMBAH PAGINASI DAN GAYA KUSTOM

Seperti yang saya sebutkan sebelumnya, ada beberapa tindakan dalam permintaan injector untuk menambahkan pagination dan / atau styling kustom.

Dalam contoh berikut, saya menambahkan pagination setelah loop menggunakan fungsi pagination saya sendiri dari jawaban yang ditautkan . Juga, menggunakan penghitung khusus saya, saya menambahkan <div>untuk menampilkan posting saya dalam dua kolom.

Berikut adalah tindakan yang saya gunakan

add_action( 'pregetgostsforgages_counter_before_template_part', function ( $counter )
{
    $class = $counter%2  ? ' right' : ' left';
    echo '<div class="entry-column' . $class . '">';
});

add_action( 'pregetgostsforgages_counter_after_template_part', function ( $counter )
{
    echo '</div>';
});

add_action( 'pregetgostsforgages_after_loop_pagination', function ( \WP_Query $q )
{
    paginated_numbers();    
});

Perhatikan bahwa pagination diatur oleh kueri utama, bukan kueri injektor, jadi fungsi bawaan seperti the_posts_pagination()juga harus berfungsi.

Ini adalah hasil akhirnya

HALAMAN DEPAN STATIS

Semuanya berfungsi seperti yang diharapkan pada halaman depan statis bersama dengan fungsi pagination saya tanpa memerlukan modifikasi lebih lanjut.

KESIMPULAN

Ini mungkin tampak seperti banyak overhead, dan mungkin saja, tetapi pro lebih besar daripada waktu besar con.

PRO BESAR

• Anda tidak perlu mengubah template halaman untuk halaman tertentu dengan cara apa pun. Ini membuat semuanya dinamis dan dapat dengan mudah ditransfer antar tema tanpa membuat modifikasi pada kode apa pun, selama semuanya dilakukan dalam sebuah plugin.

• Paling-paling, Anda hanya perlu membuat content.phpbagian template di tema Anda jika tema Anda belum memilikinya.

• Setiap pagination yang berfungsi pada kueri utama akan berfungsi pada halaman tanpa jenis perubahan apa pun atau tambahan apa pun dari kueri yang diteruskan ke fungsi.

Ada lebih banyak pro yang tidak dapat saya pikirkan sekarang, tetapi ini adalah yang penting.