1

I have a taxonomy called portfolio_cat with its categories.So now I need to create a slider with that categories as a title and their post items. How I can do that? What loop do I need to have so that I could put in a slider categories with their posts?

I dont know how to customize this loop to fit in

<?php
   $query = new WP_Query( array('post_type' => 'portfolio', 'posts_per_page' => 7, 'order' => ASC ) );
while ( $query->have_posts() ) : $query->the_post(); 
?>
  • this question is too broad. the steps involves making the right html markup and knowing when and where to insert your javascript. – Reigel Dec 21 '15 at 5:54
  • So could you help me to make it properly, so with what i need to start with @Reigel? – Anahit DEV Dec 21 '15 at 5:55
2

I'm not going to discuss implementation of a slider, that is too broad. There are a couple of tutorials around which you can look at on how to implement simple sliders

The real issue here is the query itself. Sorting a query by the terms a post belongs to is quite heavy operations, and if not done correctly (no offense, as you have done in your answer), it can be really really expensive. The overly-used method of getting all terms and then looping through them and running a query for each term can have you stuck at an operation making 100 db calls, and that is only on a small site with only a few terms and posts. Very large sites can pack the meat on db calls which can see your SEO rating stuck at minus and page load times deep in the red.

I have done a few posts on this specific subject, so I actually wanted to mark this as duplicate, but I feel that this needs a fresh look with a different approach.

What I have done in the passed is to do everything (query all the posts, then sort the result and displaying them) in one single operation. This complete query result was then stored in a transient. The setback here is that we store a tremendous amount of serialized data in the transient which again is not really what transients should do.

What I will do here is to build a dynamic sorting script which will do all the hard work and will store only post ID's in a transient (this will take care of not having to store huge amounts of serialized data which can be slow). We will then use the sorted post ID's from the transient to get our posts that we will need. Because posts are saved in a cache, we do not hit the db hard to get our desired posts, we simply query and return the posts from the cache if they are already there

FEW IMPORTANT NOTES:

  • Although I have tested the code, it is not fully tested. On my install there are no obvious bugs at this stage. You should however test this fully with debug turned on on a local test install before moving this to production

  • For what it is worth, the code need at least PHP5.4, but you are already on at least PHP5.6, or even better, PHP7 ;-)

  • There are a few orderby parameters that is not excepted by the code. You can extend it if needed. Check the post search I have linked to. I have done a lot of different stuff with usort()

  • The code uses the first term returned by get_the_terms, so posts with multiple terms might be sorted incorrectly due to the first term being used

THE SORTING SCRIPTS:

What we will do is, we will get all the posts according to our needs, but we will only return the post object properties we need to save resources. We will then use usort() to sort the posts according to terms. Instead of creating something static that you will need to alter when needed, we will make this dynamic so you can reuse it as much as you like by only changing the values of the parameters passed

/**
 * Function to return an ordered list of post id's according to the terms they belong to.
 *
 * This function accepts four parameters
 * @param (string) $taxonomy The taxonomy to get posts and terms from
 * @param (array) $args An array of arguments valid in 'WP_Query'
 * @param (array) $term_args An array of arguments valid with 'get_terms'
 * @param (array) $sort An array of parameters used to sort posts in 'usort()'
 * @return $ids
 */
function get_sorted_query_results( 
    $taxonomy = 'category', 
    $args = [], 
    $term_args = [], 
    $sort = [] 
) {
    /** 
     * To avoid unexpected ordering, we will avoid any odering that is not done by a WP_Post
     * property. If we incounter any ordering outside that, we would simply return false and
     * stop execution
     */
    $avoid_this_ordering = [
        'none', 
        'type', 
        'rand', 
        'comment_count', 
        'meta_value', 
        'meta_value_num', 
        'post__in'
    ];
    if ( isset( $args['orderby'] ) ) {
        if ( in_array( $args['orderby'], $avoid_this_ordering ) )
            return null;
    }

    // Validate and sanitize the taxonomy name
    if (    'category' !== $taxonomy
         && 'post_tag' !== $taxonomy
    ) {
        $taxonomy = filter_var( $taxonomy, FILTER_SANITIZE_STRING );
        if ( !taxonomy_exists( $taxonomy ) )
           return null;
    }

    // Now that we have run important test, set the transient

    // Set a transient to store the post ID's. Excellent for performance
    $transient_name = 'pobt_' . md5( $taxonomy . json_encode( array_merge( $args, $term_args, $sort ) ) );
    if ( false === ( $ids = get_transient ( $transient_name ) ) ) {

        // Set up a variable to hold an array of post id and id that should not be duplicated       
        // Set our query defaults
        $defaults = [
            'posts_per_page' => -1,
            'order'          => 'DESC',
            'orderby'        => 'date'
        ];
        /**
         * If tax_query isn't explicitely set, we will set a default tax_query to ensure we only get posts
         * from the specific taxonomy. Avoid adding and using category and tag parameters
         */
        if ( !isset( $args['tax_query'] ) ) {   
            // Add 'fields'=>'ids' to $term_args to get only term ids
            $term_args['fields'] = 'ids';
            $terms = get_terms( $taxonomy, $term_args );
            if ( $terms ) { // No need to check for WP_Error because we already now the taxonomy exist
                $defaults['tax_query'] = [
                    [
                        'taxonomy' => $taxonomy,
                        'terms'    => $terms
                    ]
                ];
            } else {
                // To avoid unexpected output, return null
                return null;
            }
        }
        // Merge the defaults wih the incoming $args
        $query_args = $defaults;
        if ( $args )
            $query_args = wp_parse_args( $args, $defaults );

        // Make sure that 'fields' is always set to 'all' and cannot be overridden
        $query_args['fields'] = 'all';
        // Always allow filters to modify get_posts()
        $query_args['suppress_filters'] = false;

        /**
         * Create two separate arrays:
         * - one to hold numeric values like dates and ID's 
         * one with lettering strings like names and slugs. 
         * 
         * This will ensure very reliable sorting and also we
         * will use this to get only specific post fields
         */
        $orderby_num_array = [
            'date'       => 'post_date', 
            'modified'   => 'post_modified', 
            'ID'         => 'ID', 
            'menu_order' => 'menu_order',
            'parent'     => 'post_parent',
            'author'     => 'post_author'
        ];
        $orderby_letter_array = [
            'title'      => 'post_title',
            'name'       => 'post_name',
        ];
        // Merge the two arrays to use the combine array in our filter_has_var
        $orderby_comb_array = array_merge( $orderby_num_array, $orderby_letter_array );

        //Now we will filter get_posts to just return the post fields we need
        add_filter( 'posts_fields', function ( $fields ) 
            use ( 
                $query_args, 
                $orderby_comb_array 
            )
        {
            global $wpdb;

            remove_filter( current_filter(), __FUNCTION__ );

            // If $query_args['orderby'] is ID, just get ids
            if ( 'ID' === $query_args['orderby'] ) { 
                $fields = "$wpdb->posts.ID";
            } else { 
                $extra_field = $orderby_comb_array[$query_args['orderby']];
                $fields = "$wpdb->posts.ID, $wpdb->posts.$extra_field";
            }

            return $fields;
        });

        // Now we can query our desired posts
        $q = get_posts( $query_args );

        if ( !$q ) 
            return null;

        /**
         * We must now set defaults to sort by. 'order' will the order in which terms should be sorted
         * 'orderby' by defualt will be the value used to sort posts by in the query. This will be used
         * when a post has the same term as another post, then posts should be sorted by this value
         */
        $sort_defaults = [
            'order'   => 'ASC', // This will sort terms from a-z
            'orderby' => $query_args['orderby'] // Use the default query order
        ];

        // Merge the defaults and incoming args
        $sorting_args = $sort_defaults;
        if ( $sort )
            $sorting_args = wp_parse_args( $sort, $sort_defaults );

        /**
         * Now we can loop through the posts and sort them with usort()
         *
         * There is a bug in usort causing the following error:
         * usort(): Array was modified by the user comparison function
         * @see https://bugs.php.net/bug.php?id=50688
         * The only workaround is to suppress the error reporting
         * by using the @ sign before usort in versions before PHP7
         *
         * This bug have been fixed in PHP 7, so you can remove @ in you're on PHP 7
         */
        @usort( $q, function ( $a, $b ) 
            use ( 
                $taxonomy, 
                $sorting_args, 
                $orderby_num_array, 
                $orderby_letter_array 
            )
        {   

            /**
             * Get the respective terms from the posts. We will use the first
             * term's name. We can safely dereference the array as we already
             * made sure that we get posts that has terms from the selected taxonomy
             */
            $post_terms_a = get_the_terms( $a, $taxonomy )[0]->name;
            $post_terms_b = get_the_terms( $b, $taxonomy )[0]->name;

            // First sort by terms
            if ( $post_terms_a !== $post_terms_b ) {
                if ( 'ASC' === $sorting_args['order'] ) {
                    return strcasecmp( $post_terms_a, $post_terms_b );
                } else { 
                    return strcasecmp( $post_terms_b, $post_terms_a );
                }
            }

            /**
             * If we reached this point, terms are the same, we need to sort the posts by 
             * $query_args['orderby']
             */
            if ( in_array( $sorting_args['orderby'], $orderby_num_array ) ) {
                if ( 'ASC' === $sorting_args['order'] ) {
                    return $a->$orderby_num_array[$sorting_args['orderby']] < $b->$orderby_num_array[$sorting_args['orderby']];
                } else { 
                    return $a->$orderby_num_array[$sorting_args['orderby']] > $b->$orderby_num_array[$sorting_args['orderby']];
                }
            } elseif ( in_array( $sorting_args['orderby'], $orderby_letter_array ) ) { 
                if ( 'ASC' === $sorting_args['order'] ) {
                    return strcasecmp( 
                        $a->$orderby_num_array[$sorting_args['orderby']], 
                        $b->$orderby_num_array[$sorting_args['orderby']] 
                    );
                } else { 
                    return strcasecmp( 
                        $b->$orderby_num_array[$sorting_args['orderby']], 
                        $a->$orderby_num_array[$sorting_args['orderby']] 
                    );
                }
            }
        });

        // Get all the post id's from the posts
        $ids = wp_list_pluck( $q, 'ID' );

        set_transient( $transient_name, $ids, 30*DAY_IN_SECONDS );  
    }
    return $ids;
}

I have commented the code to make it easy to follow. A few notes on the parameters though

  • $taxonomy. This is the taxonomy to get terms and posts from

  • $args. An array of any valid argument that is acceptable in WP_Query. There are a few defaults set,

    $defaults = [
        'posts_per_page' => -1,
        'order'          => 'DESC',
        'orderby'        => 'date'
    ];
    

    so you can use this parameter to set any extras like 'post_type' and a tax_query if you need more specific posts

  • $term_args. An array of parameters valid with get_terms. This is used to get more spefic terms from $taxonomy.

  • $sort An array of arguments used to determine the sort order in usort(). Valid arguments are order and orderby

Remember, if you do not need to set a parameter and you need to set one adjacent, pass an empty array, except for $taxonomy which must be set to a valid taxonomy

EXAMPLE

$taxonomy = 'my_taxonomy';
$args = [
    'post_type' => 'my_post_type'
];
$term_args = [];
$sort = [
    'order' => 'DESC'
];
$q = get_sorted_query_results( $taxonomy, $args, $term_args, $sort );

This, on my install runs 3 db queries in +/- 0.002 seconds.

We have save all the relevant sorted post ID's in a transient which expires every 30 days. We need to flush it as well when we publish a new post, update, delete or undelete a post. Very generically, you can make use of the transition_post_status hook to flush the transient on the above cases

add_action( 'transition_post_status', function ()
{
    global $wpdb;
    $wpdb->query( "DELETE FROM $wpdb->options WHERE `option_name` LIKE ('_transient%_pobt_%')" );
    $wpdb->query( "DELETE FROM $wpdb->options WHERE `option_name` LIKE ('_transient_timeout%_pobt_%')" );
});

There are quite a lot of examples on site with specific uses to target specific post status changes. You also have the post object available, so you can target specific post types, authors, etc

Now that you have an array of sorted id's you can now query complete posts. Here we would use the post__in parameter and as orderby value to return the desired posts already sorted

From the above example, we would do

if ( $q ) { // Very important check to avoid undesired results if $q is empty
    $query_args = [
        'post__in' => $q,
        'order'    => 'ASC',
        'orderby'  => 'post__in',
        // Any other parameters
    ];
    $query = new WP_Query( $query_args );
    // Run your loop, see code below
}

All we need to do now is to display the terms names as headings. This is quite simple, compare the current post term with the previous post's term, if they do not match, display term name, otherwise, display nothing

if ( $query->have_posts() ) {
    // Define variable to hold previous post term name
    $term_string = '';
    while ( $query->have_posts() ) {
    $query->the_post();
        // Get the post terms. Use the first term's name
        $term_name = get_the_terms( get_the_ID(), 'TAXONOMY_NAME_HERE' )[0]->name;
        // Display the taxonomy name if previous and current post term name don't match
        if ( $term_string != $term_name )
            echo '<h2>' . $term_name . '</h2>'; // Add styling and tags to suite your needs

        // Update the $term_string variable
        $term_string = $term_name;

        // REST OF YOUR LOOP

    }
    wp_reset_postdata();
}

Here is the complete query as I have run it on my install

$taxonomy = 'category';
$args = [
    'post_type' => 'post'
];
$term_args = [];
$sort = [
    'order' => 'DESC'
];
$q = get_sorted_query_results( $taxonomy, $args, $term_args, $sort );

if ( $q ) { // Very important check to avoid undesired results if $q is empty
    $query_args = [
        'posts_per_page' => count( $q ),
        'post__in'       => $q,
        'order'          => 'ASC',
        'orderby'        => 'post__in',
        // Any other parameters
    ];
    $query = new WP_Query( $query_args );

    if ( $query->have_posts() ) {
        // Define variable to hold previous post term name
        $term_string = '';
        while ( $query->have_posts() ) {
        $query->the_post();
            // Get the post terms. Use the first term's name
            $term_name = get_the_terms( get_the_ID(), 'category' )[0]->name;
            // Display the taxonomy name if previous and current post term name don't match
            if ( $term_string != $term_name )
                echo '<h2>' . $term_name . '</h2>'; // Add styling and tags to suite your needs

            // Update the $term_string variable
            $term_string = $term_name;

            // REST OF YOUR LOOP
            the_title();

        }
        wp_reset_postdata();
    }
}

On test with 21 posts and 6 categories, the whole operation cost me 7 queries in 0.1 seconds

With the overly-used easy method

$terms= get_terms( 'category' );
foreach ( $terms as $term ) {
    echo $term->name;
    $args = [
        'tax_query' => [
            [
                'taxonomy' => 'category',
                'terms' => $term->term_id,
            ]
        ],
    ];
    $query = new WP_Query( $args );
    while ( $query->have_posts() ) {
        $query->the_post();

        the_title();
    }
    wp_reset_postdata();
}

I got 32 queries in 0.2 seconds. That is 25 queries (5times more) more, and that is only on 6 categories and 21 posts.

  • thank you very much for the detailled explanation @Pieter Goosen!i will integrate it with my webiste – Anahit DEV Dec 22 '15 at 15:35
3

You may do this:

$args = array(
    'posts_per_page' => '-1',
    'post_type' => 'portfolio'
    'tax_query' => array(
        array(
            'taxonomy' => 'portfolio_cat',
            'field' => 'name',
            'terms' => array('cat1', 'cat2', 'cat3'))
        )
    )
);
$wp_query = new WP_Query( $args );
  • 1
    see my answer.yes i have customized a bit your answer @Trix – Anahit DEV Dec 21 '15 at 8:01
  • A BIIIIIGGGG NOTE: Do not use names in a tax_query. There is an issue when with names if the name contains special characters, spaces and more than one word – Pieter Goosen Dec 22 '15 at 7:21
1

Here is the working example

<?php
$member_group_terms = get_terms( 'member_group' );
 ?>
Then, loop through each one, running a new query each time:

<?php
 foreach ( $member_group_terms as $member_group_term ) {
 $member_group_query = new WP_Query( array(
    'post_type' => 'member',
    'tax_query' => array(
        array(
            'taxonomy' => 'member_group',
            'field' => 'slug',
            'terms' => array( $member_group_term->slug ),
            'operator' => 'IN'
        )
    )
) );
?>
<h2><?php echo $member_group_term->name; ?></h2>
<ul>
<?php
if ( $member_group_query->have_posts() ) : while ( $member_group_query->have_posts() ) : $member_group_query->the_post(); ?>
    <li><?php echo the_title(); ?></li>
<?php endwhile; endif; ?>
</ul>
<?php
// Reset things, for good measure
$member_group_query = null;
wp_reset_postdata();
}
?>
  • That is EXTREMELY expensive, you are probably running about 150 db queries just on a relatively small site with only a few terms and posts – Pieter Goosen Dec 21 '15 at 8:03
  • so what you suggest @PieterGoosen ? – Anahit DEV Dec 21 '15 at 8:24
  • Query all posts as you have done in your question, then use usort to sort the result of $posts. Just a tip, never ever use $wp_query as a local variable. $wp_query holds the main query object which is very important to a huge amount of functions, breaking the vaue of $wp_query breaks all those functions. So if you use $q = new WP_Query( $args );, you would use usort() to sort the results of $q->posts – Pieter Goosen Dec 21 '15 at 8:41
  • Also, make use of transients to store data from queries like this – Pieter Goosen Dec 21 '15 at 8:42
  • could you post an answer so i coold see the whole view please @PieterGoosen – Anahit DEV Dec 21 '15 at 8:43

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.