详解 WordPress `wp_get_object_terms()` 函数的源码：它如何获取文章或对象的分类术语。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

Alright everyone, settle down, settle down! Professor WordPress here, ready to dissect one of WordPress’s unsung heroes: wp_get_object_terms(). Think of it as the detective of WordPress, sniffing out which categories and tags (or any custom taxonomy terms) are attached to a specific post, page, or any other type of object.

We’re going to go deep into the code, see how it works, and even learn how to bend it to our will (responsibly, of course!). Buckle up, it’s gonna be a fun ride!

Our Mission: Cracking wp_get_object_terms()

The function’s primary job is simple: given an object (like a post) and a taxonomy (like ‘category’), it returns an array of term objects associated with that object. But under the hood, there’s a bit of magic happening. Let’s peek behind the curtain.

The Grand Entrance: Function Signature and Parameters

First, let’s look at the function’s declaration:

/**
 * Retrieves the terms associated with the given object(s), in the specified taxonomies.
 *
 * @since 2.3.0
 *
 * @param int|int[] $object_ids The ID(s) of the object(s) to get the terms for.
 * @param string|string[] $taxonomies The taxonomies to get the terms for.
 * @param array $args Optional. An array of arguments. Default empty array.
 * @return WP_Term[]|WP_Error Array of WP_Term objects. WP_Error on failure.
 */
function wp_get_object_terms( $object_ids, $taxonomies, $args = array() ) {
    // ... function body ...
}

Let’s break down those parameters like a seasoned code-cracker:

$object_ids: This is the star of the show! It’s the ID (or an array of IDs) of the object we’re interested in. Could be a post ID, a page ID, or even the ID of a custom post type. Think of it as the "who" in our investigation.
$taxonomies: This is the type of classification we’re looking for. It can be a single taxonomy name (like ‘category’ or ‘post_tag’) or an array of taxonomy names. It’s the "what" we’re searching for.
$args: This is the wildcard parameter. It’s an array of optional arguments that give us more control over the results. Think of it as our detective’s toolkit, filled with gadgets to refine the search. We’ll dig into these arguments later.

Inside the Detective’s Office: Code Walkthrough

Now, let’s step inside the function and see how it works its magic. I’ve simplified the code for clarity, focusing on the core logic:

function wp_get_object_terms( $object_ids, $taxonomies, $args = array() ) {
    global $wpdb;

    $defaults = array(
        'orderby' => 'name',
        'order' => 'ASC',
        'fields' => 'all',
    );

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

    $object_ids = (array) $object_ids;
    $taxonomies = (array) $taxonomies;

    $object_ids = array_map( 'intval', $object_ids );
    $taxonomies = array_map( 'sanitize_key', $taxonomies );

    // Security check - Ensure taxonomy exists
    foreach ( $taxonomies as $taxonomy ) {
        if ( ! taxonomy_exists( $taxonomy ) ) {
            return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
        }
    }

    // Build the SQL query
    $select = '';
    $from = "FROM {$wpdb->terms} AS t INNER JOIN {$wpdb->term_taxonomy} AS tt ON t.term_id = tt.term_id INNER JOIN {$wpdb->term_relationships} AS tr ON tt.term_taxonomy_id = tr.term_taxonomy_id";
    $where = "WHERE tr.object_id IN (" . implode( ',', $object_ids ) . ") AND tt.taxonomy IN ('" . implode( "', '", $taxonomies ) . "')";
    $orderby = "ORDER BY {$args['orderby']} {$args['order']}";

    if ( 'count' === $args['orderby'] ) {
        $orderby = "ORDER BY tt.count {$args['order']}";
    }

    if ( 'term_id' === $args['orderby'] ) {
        $orderby = "ORDER BY t.term_id {$args['order']}";
    }

    switch ( $args['fields'] ) {
        case 'ids':
            $select = 't.term_id';
            break;
        case 'names':
            $select = 't.name';
            break;
        case 'all':
        default:
            $select = 't.*, tt.*';
            break;
    }

    $query = "SELECT {$select} {$from} {$where} {$orderby}";

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

    // Process and return the results
    if ( ! $terms ) {
        return array();
    }

    if ( 'ids' === $args['fields'] ) {
        $term_ids = array();
        foreach ( $terms as $term ) {
            $term_ids[] = (int) $term->term_id;
        }
        return $term_ids;
    }

    if ( 'names' === $args['fields'] ) {
        $term_names = array();
        foreach ( $terms as $term ) {
            $term_names[] = $term->name;
        }
        return $term_names;
    }

    // For 'all' or default fields, create WP_Term objects
    $terms_objects = array();
    foreach ( $terms as $term ) {
        $term_objects[] = get_term( (int) $term->term_id, $term->taxonomy );
    }

    return $term_objects;
}

Let’s break it down, piece by piece:

Initialization and Argument Parsing:
- The function grabs the global $wpdb object, which is our gateway to the WordPress database.
- It defines default arguments (orderby, order, fields) and merges them with any arguments passed by the user. This ensures that we have sensible defaults if the user doesn’t provide specific instructions.
Data Sanitization and Validation:
- It converts $object_ids and $taxonomies into arrays, even if they’re passed as single values. This makes the code more flexible.
- It sanitizes the object IDs and taxonomy names to prevent security vulnerabilities (like SQL injection). Good hygiene is crucial in coding!
- It checks if the specified taxonomies actually exist using taxonomy_exists(). If a taxonomy doesn’t exist, the function politely throws a WP_Error and exits.
Building the SQL Query:

This is where the magic happens! The function constructs a SQL query to retrieve the relevant data from the WordPress database. Let’s dissect the query parts:
- SELECT: Specifies which columns to retrieve from the database. This depends on the $args['fields'] parameter. If 'ids', only the term IDs are selected. If 'names', only the term names are selected. Otherwise (the default), it selects all columns from the terms and term_taxonomy tables.
- FROM: Specifies the tables to retrieve data from and how they’re joined. It joins the wp_terms, wp_term_taxonomy, and wp_term_relationships tables. These tables are the foundation of WordPress’s taxonomy system.
- WHERE: This is the heart of the query. It specifies the conditions that the data must meet. It filters the results to include only terms associated with the specified object IDs and belonging to the specified taxonomies.
- ORDER BY: Specifies how the results should be sorted. This depends on the $args['orderby'] and $args['order'] parameters. You can order by term name, term ID, or the number of objects associated with the term (count).
Executing the Query and Processing Results:
- The function uses $wpdb->get_results() to execute the SQL query and retrieve the results.
- If no terms are found, the function returns an empty array.
- The function then processes the results based on the $args['fields'] parameter.
  - If 'ids' is specified, it returns an array of term IDs.
  - If 'names' is specified, it returns an array of term names.
  - Otherwise (the default), it iterates through the results and creates WP_Term objects for each term. WP_Term objects are the standard way to represent terms in WordPress.
Returning the Results:
- Finally, the function returns the array of term IDs, term names, or WP_Term objects.

The Database Dance: Tables and Relationships

To truly understand wp_get_object_terms(), we need to understand how WordPress stores taxonomy data in the database. There are three key tables involved:

Table Name	Description
`wp_terms`	Stores the actual terms themselves (e.g., "WordPress", "PHP", "Web Design"). Contains columns like `term_id` and `name`.
`wp_term_taxonomy`	Stores information about the relationship between terms and taxonomies. Contains columns like `term_id`, `taxonomy`, and `count`.
`wp_term_relationships`	Stores the relationships between objects (e.g., posts) and term taxonomies. Contains columns like `object_id` and `term_taxonomy_id`.

Here’s how these tables relate to each other:

wp_terms.term_id is linked to wp_term_taxonomy.term_id
wp_term_taxonomy.term_taxonomy_id is linked to wp_term_relationships.term_taxonomy_id
wp_term_relationships.object_id stores the ID of the object (e.g., post ID) that is associated with the term.

The SQL query in wp_get_object_terms() cleverly joins these tables together to retrieve all the necessary information.

Unlocking the Toolkit: The $args Parameter

The $args parameter is where things get really interesting. It allows us to fine-tune the behavior of wp_get_object_terms(). Here are some of the most useful arguments:

Argument	Description	Default Value	Possible Values
`orderby`	Specifies how the terms should be sorted.	`'name'`	`'name'`, `'slug'`, `'term_group'`, `'term_id'`, `'id'`, `'description'`, `'count'` (number of objects associated with the term), `'none'`
`order`	Specifies the order of the sorted terms.	`'ASC'`	`'ASC'` (ascending), `'DESC'` (descending)
`fields`	Specifies which fields should be returned.	`'all'`	`'all'` (returns `WP_Term` objects), `'ids'` (returns an array of term IDs), `'names'` (returns an array of term names)
`slug`	Retrieve terms with a specific slug (or an array of slugs).	`''`	String or array of strings
`hide_empty`	Whether to hide terms that are not associated with any objects.	`false`	`true`, `false`
`number`	Maximum number of terms to return.	`''`	Integer
`offset`	Number of terms to skip before starting to return terms.	`''`	Integer
`search`	Search terms that match a specific string.	`''`	String
`name__like`	Retrieve terms where the name contains a specific string. Similar to `search`, but specifically for names.	`''`	String
`term_taxonomy_id`	Retrieve terms based on their term_taxonomy_id.	`''`	Integer or array of integers

Examples in Action: Putting It All Together

Let’s see some practical examples of how to use wp_get_object_terms() with different arguments:

Get all categories for a post (ID 123), ordered by name:

$categories = wp_get_object_terms( 123, 'category', array( 'orderby' => 'name', 'order' => 'ASC' ) );

if ( ! empty( $categories ) && ! is_wp_error( $categories ) ) {
    foreach ( $categories as $category ) {
        echo '<a href="' . esc_url( get_term_link( $category ) ) . '">' . esc_html( $category->name ) . '</a>';
    }
}

Get only the IDs of the tags for a post (ID 456):

$tag_ids = wp_get_object_terms( 456, 'post_tag', array( 'fields' => 'ids' ) );

if ( ! empty( $tag_ids ) && ! is_wp_error( $tag_ids ) ) {
    foreach ( $tag_ids as $tag_id ) {
        echo $tag_id . '<br>';
    }
}

Get all categories and tags for a post (ID 789), but only return the names:

$terms = wp_get_object_terms( 789, array( 'category', 'post_tag' ), array( 'fields' => 'names' ) );

if ( ! empty( $terms ) && ! is_wp_error( $terms ) ) {
    foreach ( $terms as $term_name ) {
        echo $term_name . '<br>';
    }
}

Get categories for a post (ID 1011), limiting the results to 5 and ordering by the number of posts in each category:

$categories = wp_get_object_terms( 1011, 'category', array( 'orderby' => 'count', 'order' => 'DESC', 'number' => 5 ) );

if ( ! empty( $categories ) && ! is_wp_error( $categories ) ) {
    foreach ( $categories as $category ) {
        echo '<a href="' . esc_url( get_term_link( $category ) ) . '">' . esc_html( $category->name ) . '</a> (' . $category->count . ')<br>';
    }
}

Things to Keep in Mind (The Fine Print)

Performance: While wp_get_object_terms() is a powerful function, it can be database-intensive, especially if you’re calling it repeatedly in a loop. Consider caching the results to improve performance. WordPress has built in object caching that helps reduce the number of database queries.
Error Handling: Always check for errors using is_wp_error() after calling wp_get_object_terms(). This will help you gracefully handle situations where the function fails.
Context: Be mindful of the context in which you’re using the function. For example, if you’re using it within a theme template, you might need to use template tags like get_term_link() to generate URLs for the terms.
Security: Always sanitize and validate any user input before passing it to wp_get_object_terms(). This will help prevent security vulnerabilities.

Conclusion: You’re Now a wp_get_object_terms() Master!

Congratulations, you’ve just completed a deep dive into the inner workings of wp_get_object_terms(). You now have a solid understanding of how it works, how to use it effectively, and how to avoid common pitfalls. Go forth and build amazing things with WordPress! Remember to always code responsibly and have fun! Class dismissed!

发表回复 取消回复

发表回复取消回复