get_terms( array|string $args = array(), array|string $deprecated = '' ): WP_Term[]|int[]|string[]|string|WP_Error

Retrieves the terms in a given taxonomy or list of taxonomies.

Description
Parameters
Return
Source
Hooks
Related
- Uses
- Used By
Changelog
User Contributed Notes

Description

You can fully inject any customizations to the query before it is sent, as well as control the output with a filter.

The return type varies depending on the value passed to $args['fields']. See WP_Term_Query::get_terms() for details. In all cases, a WP_Error object will be returned if an invalid taxonomy is requested.

The ‘get_terms’ filter will be called when the cache has the term and will pass the found term along with the array of $taxonomies and array of $args.
This filter is also called before the array of terms is passed and will pass the array of terms, along with the $taxonomies and $args.

The ‘list_terms_exclusions’ filter passes the compiled exclusions along with the $args.

The ‘get_terms_orderby’ filter passes the ORDER BY clause for the query along with the $args array.

Prior to 4.5.0, the first parameter of get_terms() was a taxonomy or list of taxonomies:

$terms = get_terms( 'post_tag', array(
    'hide_empty' => false,
) );

Since 4.5.0, taxonomies should be passed via the ‘taxonomy’ argument in the $args array:

$terms = get_terms( array(
    'taxonomy' => 'post_tag',
    'hide_empty' => false,
) );

Top ↑

Parameters

$args array|string Optional

Array or string of arguments. See WP_Term_Query::__construct() for information on accepted arguments.

More Arguments from WP_Term_Query::__construct( ... $query )

Array or query string of term query parameters.

taxonomy string|string[]
Taxonomy name, or array of taxonomy names, to which results should be limited.
object_ids int|int[]
Object ID, or array of object IDs. Results will be limited to terms associated with these objects.
orderby string
Field(s) to order terms by. Accepts:
- Term fields ('name', 'slug', 'term_group', 'term_id', 'id', 'description', 'parent', 'term_order'). Unless $object_ids is not empty, 'term_order' is treated the same as 'term_id'.
- 'count' to use the number of objects associated with the term.
- 'include' to match the 'order' of the $include param.
- 'slug__in' to match the 'order' of the $slug param.
- 'meta_value'
- 'meta_value_num'.
- The value of $meta_key.
- The array keys of $meta_query.
- 'none' to omit the ORDER BY clause.
Default 'name'.
order string
Whether to order terms in ascending or descending order.
Accepts 'ASC' (ascending) or 'DESC' (descending).
Default 'ASC'.
hide_empty bool|int
Whether to hide terms not assigned to any posts. Accepts 1|true or 0|false. Default 1|true.
include int[]|string
Array or comma/space-separated string of term IDs to include.
Default empty array.
exclude int[]|string
Array or comma/space-separated string of term IDs to exclude.
If $include is non-empty, $exclude is ignored.
Default empty array.
exclude_tree int[]|string
Array or comma/space-separated string of term IDs to exclude along with all of their descendant terms. If $include is non-empty, $exclude_tree is ignored. Default empty array.
number int|string
Maximum number of terms to return. Accepts ''|0 (all) or any positive number. Default ''|0 (all). Note that $number may not return accurate results when coupled with $object_ids.
See #41796 for details.
offset int
The number by which to offset the terms query.
fields string
Term fields to query for. Accepts:
- 'all' Returns an array of complete term objects (WP_Term[]).
- 'all_with_object_id' Returns an array of term objects with the 'object_id' param (WP_Term[]). Works only when the $object_ids parameter is populated.
- 'ids' Returns an array of term IDs (int[]).
- 'tt_ids' Returns an array of term taxonomy IDs (int[]).
- 'names' Returns an array of term names (string[]).
- 'slugs' Returns an array of term slugs (string[]).
- 'count' Returns the number of matching terms (int).
- 'id=>parent' Returns an associative array of parent term IDs, keyed by term ID (int[]).
- 'id=>name' Returns an associative array of term names, keyed by term ID (string[]).
- 'id=>slug' Returns an associative array of term slugs, keyed by term ID (string[]).
Default 'all'.
count bool
Whether to return a term count. If true, will take precedence over $fields. Default false.
name string|string[]
Name or array of names to return term(s) for.
slug string|string[]
Slug or array of slugs to return term(s) for.
term_taxonomy_id int|int[]
Term taxonomy ID, or array of term taxonomy IDs, to match when querying terms.
hierarchical bool
Whether to include terms that have non-empty descendants (even if $hide_empty is set to true). Default true.
search string
Search criteria to match terms. Will be SQL-formatted with wildcards before and after.
name__like string
Retrieve terms with criteria by which a term is LIKE $name__like.
description__like string
Retrieve terms where the description is LIKE $description__like.
pad_counts bool
Whether to pad the quantity of a term's children in the quantity of each term's "count" object variable. Default false.
get string
Whether to return terms regardless of ancestry or whether the terms are empty. Accepts 'all' or '' (disabled). Default ''.
child_of int
Term ID to retrieve child terms of. If multiple taxonomies are passed, $child_of is ignored. Default 0.
parent int
Parent term ID to retrieve direct-child terms of.
childless bool
True to limit results to terms that have no children.
This parameter has no effect on non-hierarchical taxonomies.
Default false.
cache_domain string
Unique cache key to be produced when this query is stored in an object cache. Default 'core'.
update_term_meta_cache bool
Whether to prime meta caches for matched terms. Default true.
meta_key string|string[]
Meta key or keys to filter by.
meta_value string|string[]
Meta value or values to filter by.
meta_compare string
MySQL operator used for comparing the meta value.
See WP_Meta_Query::__construct() for accepted values and default value.
meta_compare_key string
MySQL operator used for comparing the meta key.
See WP_Meta_Query::__construct() for accepted values and default value.
meta_type string
MySQL data type that the meta_value column will be CAST to for comparisons.
See WP_Meta_Query::__construct() for accepted values and default value.
meta_type_key string
MySQL data type that the meta_key column will be CAST to for comparisons.
See WP_Meta_Query::__construct() for accepted values and default value.
meta_query array
An associative array of WP_Meta_Query arguments.
See WP_Meta_Query::__construct() for accepted values.

Default: array()

$deprecated array|string Optional

Argument array, when using the legacy function parameter format.
If present, this parameter will be interpreted as $args, and the first function parameter will be parsed as a taxonomy or array of taxonomies.

Default: ''

Top ↑

Return

WP_Term[]|int[]|string[]|string|WP_Error Array of terms, a count thereof as a numeric string, or WP_Error if any of the taxonomies do not exist.
See the function description for more information.

Top ↑

Source

File: wp-includes/taxonomy.php. View all references

function get_terms( $args = array(), $deprecated = '' ) {
	$term_query = new WP_Term_Query();

	$defaults = array(
		'suppress_filter' => false,
	);

	/*
	 * Legacy argument format ($taxonomy, $args) takes precedence.
	 *
	 * We detect legacy argument format by checking if
	 * (a) a second non-empty parameter is passed, or
	 * (b) the first parameter shares no keys with the default array (ie, it's a list of taxonomies)
	 */
	$_args          = wp_parse_args( $args );
	$key_intersect  = array_intersect_key( $term_query->query_var_defaults, (array) $_args );
	$do_legacy_args = $deprecated || empty( $key_intersect );

	if ( $do_legacy_args ) {
		$taxonomies       = (array) $args;
		$args             = wp_parse_args( $deprecated, $defaults );
		$args['taxonomy'] = $taxonomies;
	} else {
		$args = wp_parse_args( $args, $defaults );
		if ( isset( $args['taxonomy'] ) && null !== $args['taxonomy'] ) {
			$args['taxonomy'] = (array) $args['taxonomy'];
		}
	}

	if ( ! empty( $args['taxonomy'] ) ) {
		foreach ( $args['taxonomy'] as $taxonomy ) {
			if ( ! taxonomy_exists( $taxonomy ) ) {
				return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
			}
		}
	}

	// Don't pass suppress_filter to WP_Term_Query.
	$suppress_filter = $args['suppress_filter'];
	unset( $args['suppress_filter'] );

	$terms = $term_query->query( $args );

	// Count queries are not filtered, for legacy reasons.
	if ( ! is_array( $terms ) ) {
		return $terms;
	}

	if ( $suppress_filter ) {
		return $terms;
	}

	/**
	 * Filters the found terms.
	 *
	 * @since 2.3.0
	 * @since 4.6.0 Added the `$term_query` parameter.
	 *
	 * @param array         $terms      Array of found terms.
	 * @param array|null    $taxonomies An array of taxonomies if known.
	 * @param array         $args       An array of get_terms() arguments.
	 * @param WP_Term_Query $term_query The WP_Term_Query object.
	 */
	return apply_filters( 'get_terms', $terms, $term_query->query_vars['taxonomy'], $term_query->query_vars, $term_query );
}

View on Trac View on GitHub

Top ↑

Hooks

apply_filters( 'get_terms', array $terms, array|null $taxonomies, array $args, WP_Term_Query $term_query )

Filters the found terms.

Top ↑

Uses

Uses
Uses	Description
WP_Term_Query::__construct() wp-includes/class-wp-term-query.php	Constructor.
taxonomy_exists() wp-includes/taxonomy.php	Determines whether the taxonomy name exists.
__() wp-includes/l10n.php	Retrieves the translation of $text.
wp_parse_args() wp-includes/functions.php	Merges user defined arguments into defaults array.
apply_filters() wp-includes/plugin.php	Calls the callback functions that have been added to a filter hook.
WP_Error::__construct() wp-includes/class-wp-error.php	Initializes the error.

Show 4 more uses Hide more uses

Top ↑

Used By

Used By
Used By	Description
WP_Posts_List_Table::formats_dropdown() wp-admin/includes/class-wp-posts-list-table.php	Displays a formats drop-down for filtering items.
taxonomy_meta_box_sanitize_cb_input() wp-admin/includes/post.php	Sanitizes POST values from an input taxonomy metabox.
WP_REST_Terms_Controller::get_items() wp-includes/rest-api/endpoints/class-wp-rest-terms-controller.php	Retrieves terms associated with a taxonomy.
WP_Term_Query::get_terms() wp-includes/class-wp-term-query.php	Retrieves the query results.
WP_Customize_Nav_Menus::search_available_items_query() wp-includes/class-wp-customize-nav-menus.php	Performs post queries for available-item searching.
WP_Customize_Nav_Menus::load_available_items_query() wp-includes/class-wp-customize-nav-menus.php	Performs the post_type and taxonomy queries for loading available menu items.
export_wp() wp-admin/includes/export.php	Generates the WXR export file for download.
wp_terms_checklist() wp-admin/includes/template.php	Outputs an unordered list of checkbox input elements labelled with term names.
wp_popular_terms_checklist() wp-admin/includes/template.php	Retrieves a list of the most popular terms from the specified taxonomy.
wp_link_category_checklist() wp-admin/includes/template.php	Outputs a link category checklist element.
wp_ajax_get_tagcloud() wp-admin/includes/ajax-actions.php	Ajax handler for getting a tagcloud.
wp_ajax_ajax_tag_search() wp-admin/includes/ajax-actions.php	Ajax handler for tag search.
WP_Terms_List_Table::prepare_items() wp-admin/includes/class-wp-terms-list-table.php
_wp_ajax_menu_quick_search() wp-admin/includes/nav-menu.php	Prints the appropriate response to a menu quick search.
wp_nav_menu_item_taxonomy_meta_box() wp-admin/includes/nav-menu.php	Displays a meta box for a taxonomy menu item.
Walker_Category::start_el() wp-includes/class-walker-category.php	Starts the element output.
wp_tag_cloud() wp-includes/category-template.php	Displays a tag cloud.
wp_dropdown_categories() wp-includes/category-template.php	Displays or retrieves the HTML dropdown list of categories.
get_tags() wp-includes/category.php	Retrieves all post tags.
get_categories() wp-includes/category.php	Retrieves a list of category objects.
get_category_by_path() wp-includes/category.php	Retrieves a category based on URL containing the category slug.
get_all_category_ids() wp-includes/deprecated.php	Retrieves all category IDs.
WP_Widget_Links::form() wp-includes/widgets/class-wp-widget-links.php	Outputs the settings form for the Links widget.
_get_term_hierarchy() wp-includes/taxonomy.php	Retrieves children of taxonomy as term IDs.
wp_get_object_terms() wp-includes/taxonomy.php	Retrieves the terms associated with the given object(s), in the supplied taxonomies.
wp_insert_term() wp-includes/taxonomy.php	Adds a new term to the database.
wp_count_terms() wp-includes/taxonomy.php	Counts how many terms are in taxonomy.
get_term_by() wp-includes/taxonomy.php	Gets all term data from database by term field and data.
term_exists() wp-includes/taxonomy.php	Determines whether a taxonomy term exists.
wp_list_bookmarks() wp-includes/bookmark-template.php	Retrieves or echoes all of the bookmarks.
wp_get_nav_menus() wp-includes/nav-menu.php	Returns all navigation menu objects.
wp_xmlrpc_server::wp_getTerms() wp-includes/class-wp-xmlrpc-server.php	Retrieve all terms for a taxonomy.
wp_xmlrpc_server::_insert_post() wp-includes/class-wp-xmlrpc-server.php	Helper method for wp_newPost() and wp_editPost(), containing shared logic.

Show 28 more used by Hide more used by

Top ↑

Changelog

Changelog
Version	Description
4.8.0	Introduced `'suppress_filter'` parameter.
4.5.0	Changed the function signature so that the `$args` array can be provided as the first parameter. Introduced `'meta_key'` and `'meta_value'` parameters. Introduced the ability to order results by metadata.
4.4.0	Introduced the ability to pass `'term_id'` as an alias of `'id'` for the `orderby` parameter. Introduced the `'meta_query'` and `'update_term_meta_cache'` parameters. Converted to return a list of WP_Term objects.
4.2.0	Introduced `'name'` and `'childless'` parameters.
2.3.0	Introduced.

Top ↑

User Contributed Notes

Contributed by kopernik1elfka — 6 years ago

All get_terms attributes with default values:
(I try default from this article and it didn’t work. This works.)

$get_terms_default_attributes = array (
			'taxonomy' => 'category', //empty string(''), false, 0 don't work, and return empty array
			'orderby' => 'name',
			'order' => 'ASC',
			'hide_empty' => true, //can be 1, '1' too
			'include' => 'all', //empty string(''), false, 0 don't work, and return empty array
			'exclude' => 'all', //empty string(''), false, 0 don't work, and return empty array
			'exclude_tree' => 'all', //empty string(''), false, 0 don't work, and return empty array
			'number' => false, //can be 0, '0', '' too
			'offset' => '',
			'fields' => 'all',
			'name' => '',
			'slug' => '',
			'hierarchical' => true, //can be 1, '1' too
			'search' => '',
			'name__like' => '',
			'description__like' => '',
			'pad_counts' => false, //can be 0, '0', '' too
			'get' => '',
			'child_of' => false, //can be 0, '0', '' too
			'childless' => false,
			'cache_domain' => 'core',
			'update_term_meta_cache' => true, //can be 1, '1' too
			'meta_query' => '',
			'meta_key' => array(),
			'meta_value'=> '',
	);

Contributed by ancawonka — 6 years ago

As of WordPress 4.6.1, here’s the array that’s returned (to add to Leo’s helpful note above)

array(1) {
  [0]=&gt;
  object(WP_Term) (11) {
    ["term_id"]=&gt;  //int
    ["name"]=&gt;	//string 
    ["slug"]=&gt;  //string 
    ["term_group"]=&gt;  //int
    ["term_taxonomy_id"]=&gt; //int
    ["taxonomy"]=&gt;	//string
    ["description"]=&gt;	//string
    ["parent"]=&gt;	//int
    ["count"]=&gt;	// int
    ["filter"]=&gt;	//string
    ["meta"]=&gt; array(0) { // presumably this would be some returned meta-data?
    }
  }
}

Skip to note 3 content

You must log in to vote on the helpfulness of this noteVote results for this note: 20You must log in to vote on the helpfulness of this note

Contributed by mitch827 — 7 years ago
If parent => 0 is passed, only top-level terms will be returned
```
$terms = get_terms( array( 
    'taxonomy' => 'tax_name',
    'parent'   => 0
) );
```
Log in to add feedback

Contributed by CdWritted — 6 years ago

Get categories and subcategories by custom taxonomies:

$taxonomies = get_terms( array(
	'taxonomy' => 'taxonomy_name',
	'hide_empty' => false
) );

if ( !empty($taxonomies) ) :
	$output = '<select>';
	foreach( $taxonomies as $category ) {
		if( $category->parent == 0 ) {
			$output.= '<optgroup label="'. esc_attr( $category->name ) .'">';
			foreach( $taxonomies as $subcategory ) {
				if($subcategory->parent == $category->term_id) {
				$output.= '<option value="'. esc_attr( $subcategory->term_id ) .'">
					'. esc_html( $subcategory->name ) .'</option>';
				}
			}
			$output.='</optgroup>';
		}
	}
	$output.='</select>';
	echo $output;
endif;

Contributed by znowebdev — 8 years ago

Get all post categories ordered by count.

String syntax:

$categories = get_terms( 'category', 'orderby=count&hide_empty=0' );

Array syntax:

$categories = get_terms( 'category', array(
	'orderby'    => 'count',
	'hide_empty' => 0,
) );

Get all the links categories:

$my_links_categories = get_terms( 'link_category', 'orderby=count&hide_empty=0' );

List all the terms in a custom taxonomy, without a link:

$terms = get_terms( 'my_taxonomy' );
if ( ! empty( $terms ) && ! is_wp_error( $terms ) ){
	echo '<ul>';
	foreach ( $terms as $term ) {
		echo '<li>' . $term->name . '</li>';
	}
	echo '</ul>';
}

List all the terms, with link to term archive, separated by an interpunct (·):

$args = array( 'hide_empty=0' );

$terms = get_terms( 'my_term', $args );
if ( ! empty( $terms ) && ! is_wp_error( $terms ) ) {
	$count = count( $terms );
	$i = 0;
	$term_list = '<p class="my_term-archive">';
	foreach ( $terms as $term ) {
		$i++;
		$term_list .= '<a href="' . esc_url( get_term_link( $term ) ) . '" alt="' . esc_attr( sprintf( __( 'View all post filed under %s', 'my_localization_domain' ), $term->name ) ) . '">' . $term->name . '</a>';
		if ( $count != $i ) {
			$term_list .= ' &middot; ';
		}
		else {
			$term_list .= '</p>';
		}
	}
	echo $term_list;
}

Contributed by Khoi Pro — 6 years ago

Working with Advanced Custom Fields (field type: Taxonomy, output: Object) for filtering taxonomies.

Case: Create a filter with main categories defined by ACF field, and all another should belongs to *others*.

Solution:

// Define Featured Category IDs first
$featured_category_ids = array();
// It must be output WP_Object
$featured_categories = get_field('main_category_filters');

// Creating loop to insert IDs to array.
foreach( $featured_categories as $cat ) {
	$featured_category_ids[] = $cat-&gt;term_id;
}

// Now, if Featured Categories are match, add their IDs via 'exclude'
if( $featured_categories ) {
	$args = array(
		'taxonomy' =&gt; 'event_cat',
		'parent' =&gt; 0,
		'exclude' =&gt; $featured_category_ids
	);
} else {
    // If no featured, just display all terms
	$args = array(
		'taxonomy' =&gt; 'event_cat',
		'parent' =&gt; 0
	);
}

// Starting query terms now
$other_categories = get_terms($args);

Skip to note 7 content

You must log in to vote on the helpfulness of this noteVote results for this note: 4You must log in to vote on the helpfulness of this note

Contributed by Siobhan — 9 years ago
Get all post categories ordered by count.

String syntax:
```
$categories = get_terms( 'category', 'orderby=count&hide_empty=0' );
```
Array syntax:
```
$categories = get_terms( 'category', array(
 	'orderby'    => 'count',
 	'hide_empty' => 0
) );
```
Log in to add feedback
Skip to note 8 content

You must log in to vote on the helpfulness of this noteVote results for this note: 2You must log in to vote on the helpfulness of this note

Contributed by rezapr2 — 6 years ago
List terms limit to those matching a specific metadata key and metadata value
```
    $terms= get_terms( array(
        'taxonomy' =&gt; 'taxonomy name',
        'meta_key' =&gt; 'metadata key',
        'meta_value' =&gt; 'metadata value'
    ) );
```
Log in to add feedback
Skip to note 9 content

You must log in to vote on the helpfulness of this noteVote results for this note: 2You must log in to vote on the helpfulness of this note

Contributed by Utsav Singh Rathour — 3 years ago
Get list of terms that match a certain meta_key
```
$args = array(
    'hide_empty' => false, 
	'meta_query' => array(
      array(
         'key'       => 'project_status',
         'value'     => 'New',
         'compare'   => '='
      )
 ));
$projects = get_terms( 'Projects', $args );
```
Log in to add feedback

Contributed by samjco — 2 years ago

If `get_terms` doesnt works for some odd reason with custom taxonomy not showing registered, try using `WP_Term_Query`:

$term_query = new WP_Term_Query( array( 
    'taxonomy' => 'regions', // <-- Custom Taxonomy name..
    'orderby'                => 'name',
    'order'                  => 'ASC',
    'child_of'               => 0,
    'parent'                 => 0,
    'fields'                 => 'all',
    'hide_empty'             => false,
) );

// Show Array info
echo '<pre>';
print_r( $term_query->terms );
echo '</pre>';


//Render html
if ( ! empty( $term_query->terms ) ) {
    foreach ( $term_query->terms as $term ) {
        echo wp_kses_post( $term->name ) . ", ";
        echo esc_html( $term->term_id ) . ", ";
        echo esc_html( $term->slug ) . ", ";
        echo "<br>";
    }
} else {
    echo 'No term found.';
}

Get all args from here: https://developer.wordpress.org/reference/classes/WP_Term_Query/__construct/

Contributed by Md Aminur Islam — 2 years ago

Custom Taxonomy and Sub Category Lists.
Your can use this to create list table also.

$taxonomies = get_terms( array(
    'taxonomy' => 'product_cat', //Custom taxonomy name
    'hide_empty' => false
) );
if ( !empty($taxonomies) ) :
    foreach( $taxonomies as $category ) {
        if( $category->parent == 0 ) {
            
            //remove uncategorized from loop
            if( $category->slug == 'uncategorized' ){
                continue;
            }

            //Parent category information
 			echo esc_html__($category->name, 'text-domain');
 			echo esc_html__($category->description, 'text-domain');
 			echo esc_html__($category->slug, 'text-domain');
 			echo esc_html__($category->count, 'text-domain');


 			//Sub category information
	        foreach( $taxonomies as $subcategory ) {
	            if($subcategory->parent == $category->term_id) {
			        echo esc_html__($subcategory->name, 'text-domain');
			        echo esc_html__($subcategory->description, 'text-domain');
			        echo esc_html__($subcategory->slug, 'text-domain');
			        echo esc_html__($subcategory->count, 'text-domain');
	            }
	        }

        }
    }
endif;

Contributed by ctousignant — 5 years ago

Meta Query using a custom field, and then ordering using a different custom field.

$terms = get_terms( array(
    'taxonomy' => 'tax_slug',
    'hide_empty' => false,
    'meta_query' => array(
        [
            'key' => 'meta_key_slug_1',
            'value' => 'desired value to look for'
        ]
    ),
    'meta_key' => 'meta_key_slug_2',
    'orderby' => 'meta_key_slug_2'

) );

Skip to note 13 content

You must log in to vote on the helpfulness of this noteVote results for this note: 0You must log in to vote on the helpfulness of this note

Contributed by kalor — 6 years ago
Order by parent term ID – not documented, but also works.
```
$categories = get_terms( 'category', array(
    'orderby'    => 'parent',
) );
```
Log in to add feedback

Contributed by Mehedi Foysal — 1 year ago

Get all child taxonomy of a parent taxonomy

function get_child_taxonomies( $taxonomy_name, $termId, $args = array() ) {
	$defaults = array(
		'taxonomy'   => $taxonomy_name,
		'orderby'    => 'name',
		'order'      => 'ASC',
		'hide_empty' => true,
		'child_of'   => $termId,
	);

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

	if ( empty( $taxonomies ) || is_wp_error( $taxonomies ) ) {
		return false;
	}	
	return $taxonomies;

}

Contributed by Habib — 1 year ago

Get All Terms id and name in a array for make dropdown select:

function custom_get_term_lit( $taxonomy = 'category' ) {
    $terms = get_terms( [
        'taxonomy'   => $taxonomy,
        'hide_empty' => false,
    ] );
    if ( ! empty( $terms ) && ! is_wp_error( $terms ) ) {
        return wp_list_pluck( $terms, 'name', 'term_id' );
    }
    return false;
}

$category = custom_get_term_lit('custom-taxonomy-id');
echo "<select name='category' id='category-dropdown'>";
foreach ( $category as $cat_id => $cat_name ) {
    echo "<option value='" . esc_attr( $cat_id ) . "'>" . esc_html__( $cat_name, 'text-domain' ) . "</option>";
}
echo "</select>";

Contributed by elnajar1 — 1 year ago

list categories( or custom taxonomy ) and subcategory in organazid way

        
        //parent category (then child(category) and subchild, then posts in each category ) 
        $parent_ID = 0; 
        
        //-level_one_clilds-
        $level_one_clilds = get_terms( array(
            'taxonomy'   => 'lecture_category',
            'parent'     => $parent_ID ,
            'depth'      => 1,
            'hide_empty' => false
        ) );
        foreach( $level_one_clilds as $level_one_clild ):
            
            echo $level_one_clild->name . "<hr>" ;
            
            //--level_tow_clilds--
            $level_tow_clilds = get_terms( array(
              'taxonomy'    => 'lecture_category',
              'parent'      => $level_one_clild->term_id, 
              'depth'       => 1,
              'hide_empty'  => false
            ));
            foreach( $level_tow_clilds as $level_tow_clild ):
              echo "- " . $level_tow_clild->name . "<hr>" ;
              
               //---level_three_clild ---
               $level_three_clilds = get_terms( array(
                'taxonomy'    => 'lecture_category',
                'parent'      => $level_tow_clild->term_id, 
                'depth'       => 1,
                'hide_empty'  => false
              ));
              foreach( $level_three_clilds as $level_three_clild ):
                echo "-- " . $level_three_clild->name . "<hr>" ;
              endforeach ; //level_three_clild
              
            endforeach ;  //level_tow_clild
            
        endforeach ; //level_one_clilds

Skip to note 17 content

You must log in to vote on the helpfulness of this noteVote results for this note: 0You must log in to vote on the helpfulness of this note

Contributed by rottenschnitzel — 9 months ago
If you have a term assigned to something else than a post, here is a warning:
'hide_empty' is default true so it only shows terms assigned to posts. So if you get an empty Array returned be aware that terms (e.g. categories) assigned to attachments for example are not shown by default unless you use 'hide_empty' => false:
```
$wpdocs_categories = get_terms( array(
	'taxonomy' => 'category',
	'hide_empty' => false,
	'name__like' => 'foo'
) );
```
Log in to add feedback
Skip to note 18 content

You must log in to vote on the helpfulness of this noteVote results for this note: 0You must log in to vote on the helpfulness of this note

Contributed by princeofabyss — 6 months ago
Be very careful as the code below:
```
$terms = get_terms( array(
    'taxonomy' => 'class_languages',
    'hide_empty' => false,
 ) );
```
can return valid terms, but can also return a WP_Error if, for example, the taxonomy is invalid…

Therefore this check alone isn’t enough to save you from bugs in your code:
```
   
if ( ! empty( $terms ) ) {
    // whatever code
}
```
Instead, better to use the one below:
```
if ( ! empty( $terms ) && ! is_wp_error( $terms ) ) {
    // whatever code
}
```
Log in to add feedback
Skip to note 19 content

You must log in to vote on the helpfulness of this noteVote results for this note: 0You must log in to vote on the helpfulness of this note

Contributed by jonburnaby — 4 months ago

Categories and Tags are the two pre-defined Taxonomies. The Taxonomy Name, when included as an element ‘taxonomy’ of the array specified as the first parameter $args, has a value of ‘category’ for Categories and ‘post_tag’ for Tags.
'taxonomy' => 'category' 'taxonomy' => 'post_tag'

Log in to add feedback

-1

Contributed by Marco — 3 years ago

Loop through taxonomy and list all subcategories.

    $taxonomy = 'my_taxonomy';

    function listTaxonomies($taxonomy,$term_id = '0') {
        $output = '';

        $args = array(
            'taxonomy' => $taxonomy,
            'parent' => $term_id
        );
        $categories = get_terms($args);

        if($categories) {
			$output.= '<div style="padding-left:2em;">';
            foreach( $categories as $category ) {
                $output.= esc_attr( $category->name ) . ' (' . $category->slug . ')<br>';
                $output.= listTaxonomies($taxonomy,$category->term_id);
            }
			$output.= '</div>';
        }
        return $output;
    }

    listTaxonomies($taxonomy);

-3

Contributed by Ulugov — 6 years ago

Get Terms filtered by first letter

$authors = get_terms('book-authors', array('name__like' => $first_l));

function custom_tax_query( $pieces, $taxonomies, $args ) {
  if ( 'book-authors' == $taxonomies[0] ) {
    $pieces['where'] = str_replace("LIKE '%", "LIKE '", $pieces['where']);
  }
return $pieces;
}

Skip to note 22 content

You must log in to vote on the helpfulness of this noteVote results for this note: -5You must log in to vote on the helpfulness of this note

Contributed by Asgaros — 6 years ago
Get terms ordered by value of meta-key:
```
$terms = get_terms(
    'taxonomy_name',
    array(
        'meta_key' => 'custom_meta_key',
        'orderby' => 'custom_meta_key'
    )
);
```
Log in to add feedback

You must log in before being able to contribute a note or feedback.

Developer Resources

get_terms( array|string $args = array(), array|string $deprecated = '' ): WP_Term[]|int[]|string[]|string|WP_Error

Contents

Description

Parameters

Return

Source

Hooks

Changelog

User Contributed Notes