Добрый день.
Сделал запрос обработкой результата.
    РезультатЗапроса = Запрос.Выполнить();
    
    ВыборкаДетальныеЗаписи = РезультатЗапроса.Выбрать();
    
    НовыйОбъект = Справочники["Номенклатура"].СоздатьГруппу();
    НовыйОбъект.Наименование = "НЕИСПОЛЬЗОВАТЬ";
    НовыйОбъект.Записать();
    
    Пока ВыборкаДетальныеЗаписи.Следующий() Цикл
        ВыбОбъект = ВыборкаДетальныеЗаписи.Ссылка.ПолучитьОбъект();
        ВыбОбъект.ПометкаУдаления = Истина;
        ВыбОбъект.Родитель = Справочники.Номенклатура.НайтиПоНаименованию("НЕИСПОЛЬЗОВАТЬ");
        ВыбОбъект.Записать();
    КонецЦикла;



При этом создаю новую группу для номенклатуры
    НовыйОбъект = Справочники["Номенклатура"].СоздатьГруппу();
    НовыйОбъект.Наименование = "НЕИСПОЛЬЗОВАТЬ";
    НовыйОбъект.Записать();


Теперь вопрос как сделать проверку... существует данная группа или нет? Потому что при выполнении данной обработки каждый раз создаётся новая группа.

НайтиПоНаименованию("НЕИСПОЛЬЗОВАТЬ")

проверяй перед созданием, есть такая или нет, и создавай только, если нет. В чем вопрос-то?

То есть
Если Справочники.Номенклатура.НайтиПоНаименованию("НЕИСПОЛЬЗОВАТЬ") = ЛОЖЬ

Тогда создаю. Иначе перехожу сразу к циклу.
Так?
Прошу прощение за глупые вопросы. Только учусь.

(3) во-первых вот так

        ВыбОбъект.Родитель = НовыйОбъект.Ссылка;

зачем вы ищете то, что уже есть?

(4) спасибо, не подумал об этом, хотя если Группа уже была и мне не придётся её создавать. Тогда поиск же всё равно нужен. Потому что переменной НовыйОбъект не будет...?

(3) = неопределено

но лучше на форму обработки выведи реквизит, в который ты будешь руками выбирать эту группу "Не использовать" и бери ссылку из реквизита.

ок. Всем спасибо

Навскидку как-то вот так ( sorry, если есть ошибки :)

РезультатЗапроса = Запрос.Выполнить();
ВыборкаДетальныеЗаписи = РезультатЗапроса.Выбрать();

ГруппаНеИспользовать = Справочники.Номенклатура.НайтиПоНаименованию("Не использовать");
Если ГруппаНеИспользовать = Неопределенно Тогда
   ГруппаНеИспользовать = Справочники.Номенклатура.СоздатьГруппу();
   ГруппаНеИспользовать.Наименование = "Не использовать";
   ГруппаНеИспользовать.Записать();
   ГруппаНеИспользовать = ГруппаНеИспользовать.Ссылка;
КонецЕсли;
...
   ВыбОбъект.Родитель = ГруппаНеИспользовать;
...

(6)(8) зубры по воскресеньям лажают? если не найдет по наименованию то вернет пустую ссылку, юзаю ЗначениеЗаполнено()

(9) А если пустая ссылка то почему сразу и не спросить это?
Если ГруппаНеИспользовать.Пустая() Тогда

(9) По воскресеньям даже у бога выходной - чего уж тут про прочих смертных... и зубров :)

пусть так. ?

12 к 10

Охота мозги напрячь или поговорить? Вспомните про RLS :))

(13) Ты тоже в нашем клубе, зубр :)

(9) Тогда уж "Пустая()". "ЗначениеЗаполнено" - корректно использовать для проверки составного типа, где может быть и пустая ссылка и неопределено. Здесь однозначно только ссылка, использлвание "ЗначениеЗаполнено" может ввести в заблуждение того, кто потом этот код будет прокуривать.

Если некто тормозит, глядя на ЗначениеЗаполнено(), то это...

- Ты кто?
- Песец!
- А чего такой толстый?
- Я не толстый, я - полный...

(15) такая корректность некорректна, все там ок, посмотрите в отладчике как работает ЗначениеЗаполнено(), это подходит практически для всего - почти все пишут Если ТЗ.КОличество() > 0 Тогда, достаточно Если ЗначениеЗаполнено(ТЗ, Массив.. любая коллекция) Тогда. Можно привести много вариантов более удобного использования относительно различных способов сравнения на ноль, на пустую строку, пустуюссылку и иже с ними.
касательно задачи ТС значениезаполнено() соответствует полностью, как и в большинстве случаев сравнений(откройте для себя ЗначениеЗаполнено(), не бойтесь, не кусается). В заблуждении будет только тот, кто не знает, что может возвращать тот или иной метод, а это уже недостаток грамотности.

(15) нет. ЗначениеЗаполнено() нужно использовать всегда, когда аргумент точно не будет мутабельным.
Метод Пустая(), во-первых, выполняет больше действий, а, во-вторых, он скопытится, если там неопределено, булево, пустая строка или число.

Я хотел сказать что при проверке на пустоту *Ссылки* метод Пустая() более корректно применять, чем ЗначениеЗаполнено.
Нафига тогда вообще нужен метод "Пустая()"? Не для того ли как-раз, чтобы в коде сразу отличать реквизит ссылочного типа от составного?
Просто пример - в модуле обработки проведения натыкано "ЗначениеЗаполнено". При разработке понадобилось понять - составной это тип, или нет. Если бы был использован метод "Пустая" - было бы ясно, что ссылочный. Если ЗначениеЗаполнено - надо лезть в объект конфигурации, и там проверять тип реквизита.
Это еще реквизит. А если надо знать составного ли типа переменная в коде?
з.ы. в случае неудачного поиска конструкция
  Элем = Справочники.Номенклатура.НайтиПоНаименованию("Не использовать");
Если Элем.Пустая() Тогда..
- Отработает 100%, и ни разу не скопытится...

(19) нет, пустая() не является более корректным методом. Пустая() - это атавизм, оставленный для обратной совместимости с теми временами, когда в платформе не было метода ЗначениеЗаполнено()

(20) Откуда такие сведения?

(21) Опыт. В 8.0 не было ЗначениеЗаполнено() и там проверки осуществлялись посредством сравнения с пустыми значениями соответствующего типа или вызова Пустая(). Во все типовых была функция в модуле ОбщегоНазначенияГлоб.ЗначениеНеЗаполнено(), в которой это было написано. Потом в 8.1 или 8.2 - не помню - появилось ЗначениеЗаполнено() и в описании обновления платформы была пометочка, что используйте его и не долбите мозг с Пустая() и прочими велосипедами.

К сожалению, нет на ИТС рекомендаций по этому поводу. Все-равно - лучше использовать все по назначению. Считал, и буду считать что ЗначениеЗаполнено - только когда невозможно однозначно определить тип. Во всех остальных случаях на пустоту надо проверять соотв. методами класса. Потому что удобно прямо в коде понимать - переменная составного типа, или нет.

(23) ну, считать ты можешь даже, что земля плоская.
Прямо в коде ты не понимаешь, а предполагаешь - типизация не жесткая, значение может быть любым.

(24) Если вижу Элем.Пустая() - именно понимаю)

я б вообще через КД делал и не парил бы себе мозг наличием или отсутствием группы...

Смотри, даже в сп написано, что Найтипонаименованию может вернуть "неопределено". А неопределено.пустая() вернет лажу, какую, даже писать лень

(27) хватит умничать. Лучше сам что-нибудь умное скажи.

(умное говорю, своё) Если в справочнике есть элемент с наименованием "НЕИСПОЛЬЗОВАТЬ", то вы все будете глупо выглядеть :)

PS: никто не обратил внимание, что отсутствует поиск/проверка на группу.

(29) Конечно глупо. Ведь "НЕ" пишется отдельно от глаголов.

(27) И проверка на Пустая() в этом случае вызовет совершенно логичное исключение. Логичное, потому что поиск по наименованию (при отсутствии оного) - это бред. Это если мы говорим о поиске в справочнике заранее известного вида. А если ты ищешь по наименованию в справочнике (не в произвольном, а заранее известном), и у него при этом наименования нет, а ты проверяешь на ЗначениеЗаполнено - это уже не просто бред, а твоя грубая ошибка.
Впрочем, как если бы ты искал и в произвольном - не представляю чем было бы полезно использование ЗначениеЗаполнено в этом случае. Т.к. Пустая() вернет исключение, и будет ясно что что-то не так. Как минимум - что результаты такого поиска некорректны.

Я дико извиняюсь за оф. топ.

(31) всё-таки объясни нормально свою ненависть к ЗначениеЗаполнено

(0) Перед циклом
    ГруппаНеИспользоватьСсылка = Справочники.Номенклатура.НайтиПоНаименованию("Не использовать", Истина);
    Если ГруппаНеИспользоватьСсылка.Пустая() Тогда
        ГруппаНеИспользоватьОбъект = Справочники.Номенклатура.СоздатьГруппу();
        ГруппаНеИспользоватьОбъект.Наименование = "Не использовать";
        ГруппаНеИспользоватьОбъект.Записать();
        
        ГруппаНеИспользоватьСсылка = ГруппаНеИспользоватьОбъект.Ссылка;        
    КонецЕсли;

(32) Да при чем тут ненависть? Я говорю о том, что объект на пустоту надо проверять соответствующим методом класса, т.к. это на выходе дает более прозрачный код. Смотри (19).

(34) зоопарк из "" пустая() 0 неопределено решается одной функцией, угадай, какой. хотя совершенной универсальности нет - исключение будет при мутабельных значениях. я больше о светлом будущем и универсальности. Одним словом Пустая() - лажа, видимо перекочевавшая из 8.0. А "прозрачный код" это конечно здорово, но еще лучше, когда человек знает и помнит, какие методы/функции какие типы возвращают

тут конечно могут быть варианты - если надо отличать Неопределено от пустой ссылки, тогда только сравнением, но если надо только понять есть/нет, то даже заморачиваться не стоит

"когда человек знает и помнит, какие методы/функции какие типы возвращают" - вот это ключевой момент. А теперь представь что ты не один работаешь)) И твою нетленку приходиться сопровождать кому-то еще.
Да и я *очень* сильно сомневаюсь что ты будешь помнить все возвращаемые значения, если только корректно поддерживать описание методов.
Еще момент - в слабо связанном коде довольно трудно допустить момент когда на вход проверки уходит "зоопарк из "" пустая() 0 неопределено".

(37) я тебя местами не понимаю
"если только корректно поддерживать описание методов" это о чем? вроде русским по белому, но к предложению по смыслу не подходит, вот как здесь сказано
"в слабо связанном коде" и это как?

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

(38)
"если только корректно поддерживать описание методов" - это я о https://its.1c.ru/db/v8std#content:2149184102:hdoc, если корректно поддерживать то конечно проблем не будет. Только я сомневаюсь что кто-то на нетиражном решении с этим загоняется.
"в слабо связанном коде" - это когда архитектура твоего решения построена таким образом, что функциональный блок разбит на независимые друг от друга небольшие модули, т.е. достигается минимальная их зависимость друг от друга. К удивлению своему не нашел четкого определения этому термину сейчас, хотя он часто встречается в статьях о разработке через тестирование

(все это тоже нужно помнить, а это так трудно!) - гораздо труднее как-раз помнить какой тип тебе вернет тот или иной метод. А посмотреть лишний раз в СП описание методов класса никогда не вредно.

я сдаюсь!!)))

для составного типа нельзя проверять на пустая()

(42) см. (15) и (19)

(43) а зачем отличать ссылочный тип от составного?

потребуется тебе потом тип рассширить, так нужно буедт искать все места гда пустая().
ЗначениеЗаполнено более безопасный метод

(43) сколько тебе лет? сори за личностное и оффтоп

(44) Чтобы знать какие типы может принимать переменная, что порой важно при разработке
(45) Слышал такое утверждение.  Только если потребуется расширить тип - значит потребуется проверить те места, где это используется. Если изначально была проверка на Пустая() - с этим проблем не будет. Если ЗначениеЗаполнено - при плохой архитектуре особенно - никогда качественно все не проверишь.
(46) заполнил в ЛК

Я к тому, что лучше уж получить исключение по Пустая(), и 100% знать в чем дело, чем трудноуловимую ошибку из-за конфликта типов

(0)такие ссылки как Группа номенклатуры НЕ ИСПОЛЬЗОВАТЬ и при частом использовании лучше хранить в базе например в константах, или сделать предопределенный элемент справочника или создать справочник Предопределенные элементы и т.п.

(47) Чтоб проверить нужно тесты делать изначально

развели тут....

Zhuravlik, ты - старовер. Смирись с тем, что с тобой будут постоянно не согласны в этом вопросе.

2(0) Это Код для внешних пользователей, или для базы, в которой ты есть пользователем? Если второй - создай руками раз и потом используй.

(50) На каждый чих тест не сделаешь
(51) Ни разу :) Я использую метод "Пустая()" не потому что привык, и не могу отвыкнуть, а потому что это логично.
Кодить надо так, чтобы потом легко вносить изменения\сопровождать. Масштабируемость называется. А еще параллельно идет термин "Защитное программирование". Так что не смирюсь) Пока на ИТС не будет обоснованно доказано обратное.
Определенные зерна сомнения появились после (18) ("... больше действий.." - сомнительно). Потестю, как будет время, создам ветку по этой теме.

(47) Для функций проверки можно добавить описание, чтобы не гадать, какие типы проверяются

(53) Точно старовер