Как обойти дерево значений на клиенте в 1С

Обход дерева значений — типовая задача при работе с иерархическими данными на форме: номенклатурой по группам, структурой подразделений, деревом документов или строками отчёта. Сложность в том, что на клиенте недоступен запрос, нельзя вызывать серверные методы в цикле без потери производительности, а коллекция ДеревоЗначений имеет свои особенности обращения к строкам.

На клиенте доступны три практических подхода: рекурсивный обход через процедуру формы, итеративный обход со стеком и обход через НайтиСтроки(), когда нужны не все узлы, а только подходящие под условие. Выбор зависит от глубины дерева, объёма данных и того, что нужно сделать с каждой строкой — прочитать, изменить или собрать в массив.

Ниже разобраны рабочие варианты кода для управляемых форм, ограничения тонкого клиента, способы избежать лишних серверных вызовов и типичные ошибки, из-за которых обход «теряет» ветки или падает с ошибкой переполнения стека.

Что доступно на клиенте при работе с деревом значений

На управляемой форме дерево обычно хранится в реквизите формы типа ДеревоЗначений и отображается элементом «Таблица» с видом «Дерево». На клиенте доступны все коллекции строк: у корня дерева — метод ПолучитьЭлементы(), у каждой строки — тот же метод для перехода к потомкам. Этого достаточно для полного обхода без единого серверного вызова.

Недоступно на клиенте: прямой запрос к базе, методы менеджеров объектов, обращение к серверным экспортным процедурам без явного вызова &НаСервере. Поэтому правильная стратегия — загрузить дерево на форму один раз при создании или по команде, а дальше обходить его локально. Каждый вызов сервера из цикла обхода — это сетевой round-trip, и на дереве из тысячи строк форма «зависнет» на секунды или минуты.

Ещё одно ограничение: на клиенте нельзя создать новый объект ДеревоЗначений произвольной структуры — только работать с существующим реквизитом формы. Если нужно построить дерево программно, это делается на сервере, а клиент получает уже готовую структуру.

Рекурсивный обход дерева на клиенте

Классический способ — рекурсивная процедура, которая принимает коллекцию строк и вызывает сама себя для потомков каждой строки. Такой код читается естественно и подходит для деревьев умеренной глубины — до нескольких десятков уровней вложенности.

&НаКлиенте
Процедура ОбойтиДерево(КоллекцияСтрок)
Для Каждого Строка Из КоллекцияСтрок Цикл
// Действие со строкой: чтение или изменение
Строка.Пометка = Истина;
// Рекурсивный спуск к потомкам
ОбойтиДерево(Строка.ПолучитьЭлементы());
КонецЦикла;
КонецПроцедуры

&НаКлиенте
Процедура КомандаОбхода(Команда)
ОбойтиДерево(Дерево.ПолучитьЭлементы());
КонецПроцедуры

Обратите внимание на начальную точку: обход стартует с Дерево.ПолучитьЭлементы(), где Дерево — имя реквизита формы. Частая ошибка — передать сам реквизит вместо коллекции верхнего уровня, тогда цикл не выполнится или обратится не к тем данным.

Если внутри обхода нужно накапливать результат — например, собрать массив ссылок отмеченных строк — передавайте в процедуру второй параметр (массив или структуру). Массивы и структуры передаются по ссылке, поэтому изменения внутри рекурсии видны снаружи.

&НаКлиенте
Процедура СобратьОтмеченные(КоллекцияСтрок, Результат)
    Для Каждого Строка Из КоллекцияСтрок Цикл
        Если Строка.Пометка Тогда
            Результат.Добавить(Строка.Ссылка);
        КонецЕсли;
        СобратьОтмеченные(Строка.ПолучитьЭлементы(), Результат);
    КонецЦикла;
КонецПроцедуры

Итеративный обход со стеком для глубоких деревьев

Рекурсия в 1С ограничена глубиной стека вызовов. Для справочников с сильной вложенностью или деревьев, построенных из произвольных данных, глубина может достигать сотен уровней, и рекурсивный обход завершится ошибкой «Переполнение стека». Страховка — итеративный обход с явным стеком на основе массива.

&НаКлиенте
Процедура ОбойтиДеревоСтеком()
Стек = Новый Массив;
Для Каждого Строка Из Дерево.ПолучитьЭлементы() Цикл
Стек.Добавить(Строка);
КонецЦикла;
Пока Стек.Количество() > 0 Цикл
ТекущаяСтрока = Стек[Стек.Количество() - 1];
Стек.Удалить(Стек.Количество() - 1);
// Действие со строкой
ТекущаяСтрока.Обработано = Истина;
Для Каждого Потомок Из ТекущаяСтрока.ПолучитьЭлементы() Цикл
Стек.Добавить(Потомок);
КонецЦикла;
КонецЦикла;
КонецПроцедуры

Такой вариант обходит дерево в глубину, но без рекурсии: стек хранится в обычном массиве в памяти клиента и ограничен только объёмом данных, а не глубиной вызовов. Порядок обхода веток при этом обратный — если важен порядок следования строк на форме, добавляйте потомков в стек в обратном порядке или используйте очередь.

Дополнительный плюс итеративного подхода — его проще прервать по условию и легче отлаживать, потому что весь контекст виден в одном цикле, а не размазан по цепочке вызовов.

Поиск строк по условию без полного обхода

Когда задача — не обработать каждую строку, а найти конкретные узлы, собственный обход не нужен вовсе. Метод НайтиСтроки() у дерева значений принимает структуру отбора и второй параметр — признак поиска по всем уровням иерархии:

&НаКлиенте
Процедура НайтиНужныеСтроки()
Отбор = Новый Структура("Пометка", Истина);
Найденные = Дерево.НайтиСтроки(Отбор, Истина);
Для Каждого Строка Из Найденные Цикл
// Работа с найденной строкой
КонецЦикла;
КонецПроцедуры

Второй параметр Истина — ключевой: без него поиск выполняется только среди строк верхнего уровня, и дочерние узлы в результат не попадут. Это одна из самых частых причин «неправильной работы» поиска по дереву у начинающих разработчиков.

Ограничение метода — отбор только на равенство и только по колонкам дерева. Если условие сложнее (сравнение, проверка нескольких полей, поиск подстроки), придётся писать собственный обход с проверкой внутри цикла.

Как не убить производительность: серверные вызовы и крупные деревья

Главный враг обхода на клиенте — серверные вызовы внутри цикла. Конструкция вида «для каждой строки вызвать серверную функцию» превращает обход в серию сетевых обращений. Если внутри обхода нужны данные, которых нет на клиенте (например, остатки или реквизиты ссылок), соберите сначала массив ссылок на клиенте, передайте его одним вызовом на сервер, получите соответствие с данными и используйте его в обходе.

Второй фактор — обновление интерфейса. Если в цикле меняются значения строк дерева, форма может перерисовываться на каждое изменение. На больших деревьях имеет смысл выполнять массовые изменения (например, установку пометок) на сервере одним вызовом: передать туда отбор или всю структуру, обработать и вернуть результат.

Третий момент — размер дерева. Дерево значений на форме целиком передаётся между клиентом и сервером при каждом контекстном вызове. Дерево на десятки тысяч строк делает каждый серверный вызов тяжёлым. В таких случаях храните на форме только нужные колонки и рассмотрите вариант обхода и обработки полностью на сервере, а клиенту оставьте только отображение.

Работа с текущей строкой и разворачивание дерева

Частая сопутствующая задача — после обхода позиционироваться на найденной строке или развернуть дерево до нужного узла. Для этого у элемента формы (таблицы дерева) есть свойство ТекущаяСтрока, которому присваивается идентификатор строки, полученный методом ПолучитьИдентификатор():

&НаКлиенте
Процедура Спозиционироваться(СтрокаДерева)
Элементы.Дерево.ТекущаяСтрока = СтрокаДерева.ПолучитьИдентификатор();
КонецПроцедуры

Разворачивание выполняется методом Развернуть() элемента формы с тем же идентификатором строки. Чтобы развернуть всё дерево, придётся обойти его и вызвать Развернуть() для каждой строки, у которой есть потомки, — встроенной команды «развернуть всё» у элемента формы нет. Здесь как раз пригодится рекурсивный обход.

Учтите: идентификаторы строк действительны только в рамках текущего сеанса работы формы. После перезаполнения дерева на сервере идентификаторы меняются, и сохранённые ранее значения становятся бесполезными — позиционирование нужно выполнять заново после каждого обновления данных.

1. 1
   Убедитесь, что дерево заполнено: реквизит формы загружен на сервере при создании или по команде
2. 2
   Напишите процедуру &НаКлиенте, принимающую коллекцию строк, с рекурсивным вызовом для ПолучитьЭлементы() каждой строки
3. 3
   Запустите обход из обработчика команды, передав Дерево.ПолучитьЭлементы()
4. 4
   Если нужны данные с сервера — соберите массив ссылок в обходе и получите данные одним серверным вызовом
5. 5
   Проверьте результат на дереве с несколькими уровнями вложенности и пустыми ветками

Типичные ошибки при обходе дерева на клиенте

Первая и самая распространённая — обход только верхнего уровня: разработчик перебирает Дерево.ПолучитьЭлементы() и забывает спуститься к потомкам. Внешне всё работает, пока в тестовых данных все строки лежат на первом уровне. Проверяйте обход на данных с реальной иерархией.

Вторая ошибка — вызов НайтиСтроки() без второго параметра и вывод, что «поиск не работает». Третья — попытка использовать запрос или обращение к базе внутри клиентского обхода: код либо не компилируется, либо порождает серию серверных вызовов. Четвёртая — модификация коллекции во время её перебора: удаление строк внутри цикла Для Каждого приводит к пропуску элементов. Удалять нужно либо с конца по индексу, либо собирать строки на удаление в отдельный массив и удалять после обхода.

Как проверить, что обход отработал правильно

Простой приём проверки — счётчик обработанных строк. Заведите переменную, увеличивайте её внутри обхода и сравните с ожидаемым количеством строк. Если числа не совпадают, значит, часть веток пропущена — чаще всего из-за ошибки в рекурсивном вызове или изменения коллекции во время обхода.

Для визуальной проверки удобно временно добавить в дерево служебную колонку, например «ПорядокОбхода», и записывать в неё номер итерации. Развернув дерево на форме, вы сразу увидите, в каком порядке обходились узлы и не пропущена ли какая-то ветка. После отладки колонку скрывают или удаляют.

Частые вопросы