Пользовательская таксономия, get_the_terms, вывод в порядке родитель > потомок

Довольно старая тема, но всё ещё актуальная, на мой взгляд, поскольку это по-прежнему вызывает сложности.

Я использую эту рекурсивную функцию, которая принимает два массива по ссылке. Она создаёт массив со следующей структурой: [term_id] => term_object->children->child_terms_array->children->child_terms_array.

<?php
function sort_terms_hierarchically( array &$terms, array &$into, $parent_id = 0 ) {
    foreach ( $terms as $i => $term ) {
        if ( $term->parent == $parent_id ) {
            $into[$term->term_id] = $term;
            unset( $terms[ $i ] );
        }
    }

    foreach ( $into as $top_term ) {
        $top_term->children = array();
        $this->sort_terms_hierarchically( $terms, $top_term->children, $top_term->term_id );
    }

}

$terms = get_the_terms( 'taxslug', $post );
$sorted_terms = array();
sort_terms_hierarchically( $terms, $sorted_terms );

// Выведет вложенные массивы объектов терминов в лог.
error_log( print_r( $sorted_terms, true ) );

Это единственное решение, которое я нашёл, сохраняющее объекты терминов и работающее с любым уровнем вложенности.

Хотя подход Maugly кажется немного более читаемым, выполнение цикла 3 раза для одного массива не кажется мне правильным. Вот альтернативный подход, который может быть менее читаемым для некоторых, но работает без трёхкратного прохода по массиву.

function print_taxonomy_ranks( $terms ) {
    // если terms не массив или он пуст, не продолжаем
    if ( ! is_array( $terms ) || empty( $terms ) ) {
        return false;
    }

    foreach ( $terms as $term ) {
        // если термин имеет родителя, устанавливаем дочерний термин как атрибут родительского
        if ( $term->parent != 0 )  {
            $terms[$term->parent]->child = $term;   
        } else {
            // записываем родительский термин
            $parent = $term;
        }
    }

    echo "Порядок: $parent->name, Семейство: {$parent->child->name}, Подсемейство: {$parent->child->child->name}";
}

У меня была ситуация, когда запись могла быть помечена несколькими группами категорий, а также несколькими дочерними элементами внутри родительских категорий, поэтому я хотел, чтобы моя иерархия отражала это. И мне нужен был всего несколько строк кода:

$terms = get_the_terms($id, 'department_categories');
foreach($terms as $key => $term){
    if($term->parent != 0){
        $terms[$term->parent]->children[] = $term;
        unset($terms[$key]);
    }
}

По сути, после того как код находит родителя категории, он перемещает её в объект родителя как дочерний элемент, а затем удаляет из исходной позиции в массиве. Я протестировал это с использованием нескольких соседних элементов, дочерних элементов и категорий разного уровня.

Надеюсь, это кому-то пригодится, если вы ищете логическое решение, а не "плагин"!

Вдохновленный ответом Michal Mau и ответом Manny Fleurmond, вот мое решение: У меня была та же проблема, что и у @Lucas Bustamante: что делать, если у поста две родительские категории?

Мое решение заключалось в создании еще одного массива объектов, сравнивая term_id и проверяя ключ parent

function print_taxonomic_ranks( $terms ){

    if ( ! is_array( $terms ) || empty( $terms ) ) {
        return false;
    }

    $parent_terms = array();

    // получаем только родительские элементы
    foreach ( $terms as $term ) {
        if ($term->parent === 0) {
            $term->child = Array();
            $parent_terms[] = $term;
        }
    }

    // сравниваем и вкладываем
    foreach ( $terms as $term ) {
        if ($term->parent != 0) {
            foreach ($parent_terms as $key => $value) {
                if ($term->parent === $value->term_id) {
                    $parent_terms[$key]->child[] = $term;
                }
            }
        }
    }

    // выводим результаты
    foreach ( $parent_terms as $term ) {

        // родительский элемент
        echo '<span class="d-block">'.$term->name.'';

        if ($term->child) {
            $i = 1;
            foreach ( $term->child as $child ) {
                //echo '<span class="text-danger">'.$i.'</span>';
                echo ($i <= 1)? ": " : "";
                echo '<span class="font-weight-normal">'.$child->name.'</span>';
                echo ($i < count($term->child))? ", " : "";
            $i++;                
            }          
        }
        echo '.<span>';
    }
}

И это будет выглядеть примерно так:

Удачи!

Спасибо, Maugly,

Вот моя модифицированная версия вашего кода, которая включает постоянные ссылки для терминов, если кому-то это понадобится

function print_show_location( $terms = '' ){

// проверка входных данных
if ( empty( $terms ) || is_wp_error( $terms ) || ! is_array( $terms ) )
    return;

// устанавливаем ID переменных в 0 для удобной проверки 
$country_id = $state_id = $city_id = 0;

// получаем страну
foreach ( $terms as $term ) {
    if ( $country_id || $term->parent )
        continue;
    $country_id  = $term->term_id;
    $country_slug = $term->slug;
    $country = '<a href="'.get_term_link($country_slug, 'location').'">'.$term->name.'</a>';
}

// получаем регион
foreach ( $terms as $term ) { 
    if ( $state_id || $country_id != $term->parent )
        continue;
    $state_id = $term->term_id;
    $state_slug = $term->slug;
    $state = '<a href="'.get_term_link($state_slug, 'location').'">'.$term->name.'</a>';
}

// получаем город
foreach ( $terms as $term ) { 
    if ( $city_id || $state_id != $term->parent ) 
        continue;
    $city_id = $term->term_id;
    $city_slug = $term->slug;
    $city = '<a href="'.get_term_link($city_slug, 'location').'">'.$term->name.'</a>';
}

// вывод
echo "$city, $state - $country";

}

У меня есть несколько рекурсивных функций, которые я использую в зависимости от потребностей. Обеим функциям нужен список терминов, начальный ID родителя и начальный (обычно пустой) массив, куда будет помещаться результирующий список.

ПЕРВАЯ ВЕРСИЯ

$terms = [список объектов терминов, используйте get_terms или что-то подобное]
$ordered_terms = array(); // здесь будут упорядоченные термины от корня до последнего потомка

function list_terms_by_parent($parent_id = 0, &$terms, &$ordered_terms){
  $root_parent = $parent_id;

  foreach($terms as $index => $term){
    if($term->parent == (int) $parent_id){
      $ordered_terms[$term->term_id] = $term;
      $root_parent = $term->term_id;
      unset($terms[$index]);
    }
  }

  if(!empty($terms)) list_terms_by_parent($root_parent, $terms, $ordered_terms);
}

ВТОРАЯ ВЕРСИЯ

$term_ids = [должен быть список ID в формате child_id => parent_id]

// быстрый способ получить такой список - использовать WP_Term_query, например:
//$terms_query = new WP_Term_Query(array(
//  'taxonomy' => 'product_categories'
//  ,'object_ids' => $post->ID
//  ,'hide_empty' => false
//  ,'fields' => 'id=>parent'
//));

$ordered_terms = array(); // здесь будут упорядоченные термины от корня до последнего потомка

function list_term_ids_by_parent($parent_id = 0, &$term_ids, &$ordered_terms){
  $child_id = array_search($parent_id, $term_ids);

  if($child_id){
    $ordered_terms[] = $child_id;
    unset($term_ids[$child_id]);
  }

  if(!empty($term_ids)) order_terms($child_id, $term_ids, $ordered_terms);
}

ТРЕТЬЯ ВЕРСИЯ

Это не моя функция, я нашел ее где-то, вероятно здесь или на stackoverflow. Она немного отличается по выводу, так как генерирует каскадный список терминов с одним корневым элементом, у которого есть свойство children, содержащее следующий термин со своим свойством children и так далее..

// $ordered_terms предполагается пустым массивом, как в предыдущих примерах

function sort_terms_hierarchically(&$terms, &$ordered_terms, $parentId = 0){
  foreach($cats as $i => $cat){
    if($cat->parent == $parentId){
      $into[$cat->term_id] = $cat;
      unset($cats[$i]);
    }
  }

  foreach ($into as $topCat) {
    $topCat->children = array();
    sort_terms_hierarchically($cats, $topCat->children, $topCat->term_id);
  }
}