Теорема Бома — Якопини — утверждение о структурном программировании, согласно которому любой исполняемый алгоритм может быть преобразован к структурированному виду, то есть такому виду, когда ход его выполнения определяется только при помощи трёх структур управления: последовательностей (sequence), ветвлений (selection) и повторов (repetition).

Теорема была сформулирована и доказана итальянскими математиками Коррадо Бомом (англ. Corrado Böhm) и Джузеппе Якопини (Giuseppe Jacopini) в их статье 1966 года[1]. В статье также описывались методы преобразования неструктурированных алгоритмов в структурированные.

Публикация теоремы была толчком к началу дебатов о структурном программировании. Спустя 2 года вышла статья Эдсгера Дейкстры «Go To Statement Considered Harmful»[2], в которой он критиковал использование оператора GOTO и высказывался в пользу улучшения стиля программного кода за счёт использования структур управления и отказа от других инструкций, управляющих ходом алгоритма.

wiki:Теорема_Бома_—_Якопини

А как вы считаете - можно ли обойтись в программировании без GOTO (Перейти)? И считается ли плохим стилем программирования его использование или нет?

я бы убивал за метки

Лучше не использовать, но с осторожностью вполне можно применять.

Да можно, обхожусь.
Нет, не считаю, кто то использует и пусть использует дальше.

баян

(0) За исключением Ассемблера. И то, можно извратиться без меток.

больше GOTO хороших и разных

А я бы заставлял мучиться вечно.

Метки это как бомба в коде.

(4)+
v8: как goto правильно пишется?
OFF: 1C и GoTo
OFF: goto - ваше отношение к этому оператору

Полезные применения GOTO
* Выход из циклов многократной вложенности.
* Переход на точку выхода из функции.
* Переход в начало процедуры

баян немеряный, ещё с 68го года :-)
Нас этому в 93м учили...

Именно так.

(0) Если упрощает код и понимание кода, то почему бы и нет?

А в типовых - как-то не обращал внимание - часто метки применяются?

Использование программистом GOTO означает, что при кодировании, мысленно он управляет программным потоком, а не абстракциями. Короче, я бы такого не взял.

(15) Программист обязан мысленно управлять программным потоком, а не абстракциями.

Абстракциями должен управлять системный аналитик, системный архитектор.

Так

(16) Тут либо трусы, либо крестик. Таблица значений тоже абстракция. Либо используешь объекты, или строчки кода расставляешь.

У вменяемого прога ситуации в (10) не возникают.

1. Да, GOTO - нельзя использовать

Увлечение структурным программированием и архитектурой фон Неймана (в том числе отказ от GOTO) препятствует созданию мыслящих машин, распознающих образы, решающих неструктурированные задачи с неполными и приблизительными исходными данными. На выходе из-под пера программиста мы получаем тупые безмозглые автоматы, которые идут строго вперёд без отклонений.

(21) дада, гото в произвольное место кода - то, что нам нужно дли ИИ (половина мистян такие, а модераторы - так вообще все)

гото - просто низкоуровневая замена более красивым конструкциям

вот на что смотреть надо:
wiki:Цикломатическая_сложность

А я думаю все равно так

я в 1с даже не знаю как это писать

(25)

Перейти ~Метка1;
....

~Метка1:

Последние 13 лет не использую.
GOTO - удел стюдентов!

(25) Нашёл, чем хвастаться... Стыдись!


Перейти ~метка;

~метка:

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

Вполне можно использовать при выходе из ветвлений глубокой вложенности

(29) Это удел даже не "студентов" а "стЮдентов" - очень ЮННЫХ студентов

(10): (применительно к 1С)
* "Выход из циклов многократной вложенности" - есть Возврат, но лучше всего - (19);
* "Переход на точку выхода из функции" - Возврат;
* "Переход в начало процедуры" - рекурсия.

В моей практике ни разу не возникало задачи, которую можно было бы решить только через метки. И раза 3 приходилось переписывать после "пейсателей" код с метками - на код без меток.
Правда, не исключаю, что я просто мало знаю. А посему:

(31) я когда учился в универе, нам преподовали - что метки вполне можно использовать. И когда мы в своих текстах программах на С++, Delphi писали конструкцию вида "Перейти" - никто не снижал нам оценку

В машинном языке нет никаких циклов, ветвлений и процедур. Есть только GOTO

(34) ветвления есть, иначе цикл из GOTO будет бесконечен

единственное оправдание GOTO это выход из многовложенных циклов, но вот в Java молодцы, придумали break с меткой и проблему решили

нет ... в машинном языке все выглядит примерно так - 010001010100010001001111

:))

За 18 лет программирования использовал GoTo только на спекртуме. :)

Либо когда шла оптимизация на скорость.

Оправданное применение GOTO

wiki:GOTO#.D0.9E.D0.BF.D1.80.D0.B0.D0.B2.D0.B4.D0.B0.D0.BD.D0.BD.D0.BE.D0.B5_.D0.BF.D1.80.D0.B8.D0.BC.D0.B5.D0.BD.D0.B5.D0.BD.D0.B8.D0.B5

(38) Ну нафиг. Я лично (к чему и призываю) использую переменные-"флаги" в таких случаях. На каждый цикл, получается. Зато всё "видно" и, если что, расширябельно.

(38) там только "Программная генерация кода" нормально обоснована

(39) надо функции использовать вместо флагов

(41) Надо использовать GOTO!

(38) Вообще обход матрицы в теле процедуры практически всегда является "смешением уровней абстракций на одну процедуру" (Фаулер. "Чистый код") т.е. не вдаваясь в объяснения, поиск в коллекции должна выполнять отдельная процедура (идеально, метод коллекции). А в ней уже  возврат.

(41) Ну почему...

УсловиеВерно = (А = Б) - например...

...Если что - изменяешь его и выходишь благополучно откуда надо. Просто выбешивают меня эти метки, эти GoTo...

(42) можно, но не нужно

(42) Сам-то используешь?

+(43) Вру, не Фаулер, Роберт Мартин

собсна юзал ток на ассемблере (а еще в паскале в школе :)). Ума не приложу где бы пригодилось, если ток ты не кодишь 2ю неделю и тебе дали пространственную задачу.

почему в 1С не додумались сделать оператор

Прервать ~метка;

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

(46) Если понадобится, то буду использовать и не буду комплексовать по этому поводу.

я использую лишь при переборе строк документа и удаление ненужных, т.к. при удалении следующая строка проскакивает необработанной:

~Выбор: ВыбратьСтроки()
Пока ПолучитьСтроку() = 1 Цикл
Если <УсловиеУдаленияСработало> тогда
 Удалитьстроку();
 Перейти ~Выбор;
КонецЕсли;
КонецЦикла;

Какой алгоритм без перехода?

Когда-то рисовал проги без  меток. ;)

Вылетал из циклов просто в лоб меняя параметр цикла

Меня вот бесит, когда по телу функции разбросаны Возвраты. Уж лучше сделать одну точку выхода и по телу функции использовать GOTO ~Выход

(51) А на данный момент?
Когда последний раз?

(54) ну они же подсвечены

вот как в 1С можно относиться к рекомендации писать методы не более экрана примерно, если тексты запросов иногда...
хотя можно это считать исключением из правил

(52) Неоправданное применение. Надо делать двумя циклами, или перебирать в обратном порядке (снизу).

Использование GoTo - удел маргиналов, невежественной босоты и прочих неучей. Вы уж простите.

(52) можно закинуть элементы в массив и удалять их с массива, но и это как то криво :)

(52) обход в обратном направлении спасет

(55) Не переходи на личности.

честно забыл о существовании ПЕРЕЙТИ в коде... в типовом оно точно не встречается.

(52)
Для Сч = -КоличествоСтрок() По -1 Цикл
 Если УсловиеСработало Тогда
   УдалитьСтроку(-Сч);
 КонецЕсли
КонецЦикла;

(52) По рукам линейкой за такой код

(64) Отлично!

(64)+ и ведь работает не в пример быстрее

(54) это те же яйца, только в профиль ))

(52) НайтиСтроки() или запрос к табличной части.

(64) не читаемо

(64) спасибо

а еще бесит неоправданное юзание Попытка везде и всюду

(69) А если условие сложное и документ ещё не записан?

(64) +1. Ну не GoTo же...

(62) Почему?
Я написал об этом и не стесняюсь. 13 лет назад.

(70) да ладно, это классика

(54) А толку? Наоборот вместо понимания что выходим из функции, прог читающий код должен искать метку. Любую функцию получается развернуть чтобы в неё был один возврат, но это фетиш, реально читабельность не растет. Лучше не делать монструозных функций.

(72) А меня бесит использование Процедур вместо Функций. Тем более возвращаемое значение можно игнорировать.

(70) т.е. для того, чтобы удалить каждую вторую строку нужно пройтись по ТЧ 100500 раз?

(73) Массив условий делаем. Или структуру. Условий или их результатов.

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

(77) Надо правильно назвать метку, например, ~ВыходИзФункции

(78) о, так это Гений 1С предлагал
вопрос довольно таки спорный, процедура явно говорит, что ничего ты из нее получить не сможешь

(81) в 7.7 нету строк, есть только индексы. а при удалении строки индексы всех последующих строк - изменяются.

(82) "Возврат" есть же...

(81) +1. Получается длиннее, зато читабельно, что гораздо важнее.

(85) Вот меня бесят стопицот возвратов.

(84) ну её 7.7. там вообще все плохо )

+(85) уже писал в (68)

(87) А стопицот меток ~ВыходИзФункции не бесят?

(90) Нет

ибо даже любой из примеров "оправданного" применения можно переписать без готов и от этого станет только читабельнее

(87) да ладно, неужели есть такое? обычно в функции юзается переменная Результат, которая в конце и возвращается, ну и условия рулят

(91) странный

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

(87) Практически любую функцию можно написать так, что Возвраты в ней будут только в начале (проверки входных параметров и т.п.) и в конце - возврат результата.

Так, следующая тема будет про строгую типизацию, наследование и виртуальные методы?

(87) Не, ну в идеале - возврат должен быть один. Максимум - два, если

Если ... Тогда
   Возврат А
Иначе
   Возврат Б
КонецЕсли;

^^^^^^^^^^^^^^ но не больше. В остальных случаях я лично рекомендовал бы (да и сам так делаю) формировать некую переменную, назовём её "Результат", и в конце функции - один единственный "Ыозврат Результат". И НИКАКИХ GOTO!

(97) Ненавижу множественное наследование!

100

(98) Спасибо, кэп!

про баян уже говорили?

(101) Обращайся! ;-)

(99) я тоже против, но интерфейсы (как более мягкий вариант его) никто не отменяет

а отказ пир проверке входных данных осуществлять через
ВызватьИсключение "что вы в меня всякую гадость суете?"

(105)

ВсеОК = ПроверитьВходныеДанные();
Если ВсеОК Тогда
СДелатьЧтото();
КонецЕсли;

(105) Да, это стильно, модно, современно.

(105) я NS тоже предлагал исключения - понимания не нашёл. он меня убедил, что в крайних-крайних случаях без гоуту ну просто никуда

(1) а что такого дико страшного в Go to, что люди теоремы доказывают, темы создают?

(106) ну и нафига лишний уровень вложенности? тогда уж

Если ПроверитьПараметр1() Тогда
 Если ПроверитьПараметр2() Тогда
   Если ПроверитьПараметр2() Тогда
     ДелаемЧтоТо();
   КонецЕсли;
 КонецЕсли;
КонецЕсли;

(109) GoTo НЕЛЬЗЯ использовать. НЕЛЬЗЯ. И всё. Это - как плод греха у Адама и Евы. Он - есть, но использовать его НЕЛЬЗЯ.

(109) сама основа структурного программирования ломается...

На 1С ни разу не пользовал. А зачем? )

(110) Хороший выход -- бросить исключение, но есть языки, в которых исключения нельзя типизировать -- весь смысл теряется

(111) Это ваши комплексы. Свободные люди вправе использовать GOTO когда хотят и теоремы Бома-Якопини им не указ.

злоупотребляете исключениями

по сути, исключение - это то же самое гоуту.
как, впрочем и функции

Если ЗначениеЗаполнено(Объект.Родитель) И Объект.Родитель.Родитель=ПустаяСсылка Тогда
 Сообщить("ПустаяСсылка");
КонецЕсли;

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

+(117) кто на асмах писАл, того не проведёшь

(118) надо так:
Если Объект.Родитель.Родитель.Пустая() Тогда

(111) вот на таких стереотипах я и вырос, теперь даже не могу представить где бы уместно было применить go to.
А в школе, помню, активно его в basic-e использовал..., но шаблоны меня "поломали".
Так же никто толком не может объяснить шаблон: "в реляционных базах данных необходимо максимально часто использовать запросы".
Хотя "выгрузитьитоги", "сводныйитог" реально быстрее работает.
НЕЛЬЗЯ использовать. НЕЛЬЗЯ.....НЕЛЬЗЯ использовать. НЕЛЬЗЯ....НЕЛЬЗЯ использовать. НЕЛЬЗЯ...НЕЛЬЗЯ использовать. НЕЛЬЗЯ...НЕЛЬЗЯ использовать. НЕЛЬЗЯ....НЕЛЬЗЯ использовать. НЕЛЬЗЯ...НЕЛЬЗЯ использовать. НЕЛЬЗЯ...НЕЛЬЗЯ использовать. НЕЛЬЗЯ.

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

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

(122) Даже сам Никлаус Вирт, изобретатель языка Паскаль, был вынужден добавить GOTO в язык.

(122) а кроме живописных аллегорий будут вменяемые аргументы?

(124) Он это делал под стволом у виска!

(126) Накрутки детектед. Ты проголосовал уже 8 раз.

(127) Потому, что GoTo НЕЛЬЗЯ использовать!

(128) Я разрешаю

любой "возврат" и "прервать", тоже goto в той или иной степени

Тем, кто за первый вариант. Вы на ассемблере попробуйте без jmp программу написать. Или оптимизировать рендер в 3Д движке, когда за каждый лишний обработанный полигон в секунду анус рвешь.
Для каждого инструмента есть своя область применения. Не нужно ни злоупотреблять, ни огульно хаять. Надо знать и уметь использовать.

В КА последнем релизе находится 1165 конструкций Перейти ~
Стоит ли удивляться, что конфа получилась просто кучей кала.

Преимущество goto - его использование приближено к действительной логике процессора (jmp) и его легко понять новичку.

Недостаток - надо придумывать тучу имен меток и не видно направления перехода (вверх или вниз). Цикл с предпроверкой условия также реализуется на goto неаккуратно (на двух метках).

Исключения, кстати, - полезный оператор - им кодеры старой школы не владеют, а это - революционная подвижка по устойчивости кода.

(124) он потом убрал его в модула-2 на свалку

(132) если оттуда убрать Перейти ~, вряд ли конфигурация от этого улучшится

(132) просьба не путать гамнокод со структурным программированием и не вмешивать сюда гоуту

http://khpi-iip.mipk.kharkiv.edu/library/extent/dijkstra/pp/ewd215.html

(133) угу, очень, натыкались:

Попытка
 ...
 ВызватьИсключение(); аналог гото
 ...
 АТутЕщеОднаОшибка(); //внезапно потом дорисовали
 ...
Исключение //аналог метки
КонецПопытки;

и главное все работает! но криво правда

(133) Исключения до сих пор компиляторами с большими пенальти по производительности реализуются. В real-time коде его использовать плохо.
А для прикладных языков, где секунда туда / секунда сюда значения не имеет - да, очень удобно.

(134) Сравни, где Паскаль и где модула-2

предлагаю провести дружеский футбольный матч:
Сторонники goto vs Противники goto
по результатам оного и решим :-)

(135,136) А конфа сама собой пишется? Тысяча гоуту в одной конфе пишут те же люди, которые не спускают воду после себя в сортире. Неряхи в принципе не способны выдать нормальный код. Это уже органическое поражение мозга.

(141) Без трамватики не обойдётся

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

(142) программероиндусы и без гоуту тебе нахерачат такого - неделю разбираться будешь, так что не трынди

(141) Бейсбольные биты и цепи мотоциклетные выдавать на месте будут или свои приносить?

ну вот, вечно хорошую идею опошлят... :(

(144) Гнилые отмазки. В самых крутых языках есть GOTO:
С, С++, C#

(34) Глупости какие. Есть и ветвления (условные переходы) и циклы.

(148) Специально оставили. Дабы можно было отделить агнецов от козлищ.

(148) что же ты Java так опустил?

(138) Продолжить; Прервать; это тоже гооту.

(152) Нет.

Это развод! (с)

(152) в контексте (138) не догнал

(148) Это забыли убрать! От "Бейсика" осталось!!! >:-Е

(150) пора уже вылезать из своей 2-х цветной палитры

(0) Хорошо хоть теорема, а не аксиома, а то эти "английские ученые" такие ученые... :)

(156) ещё раз проголосуешь - получишь чёрную метку

(133) "Недостаток - надо придумывать тучу имен меток и не видно направления перехода (вверх или вниз). "

Ну для функций тоже надо придумывать кучу имен. Искать функцию тоже нисколько не быстрее.

б-о-й-а-н...

(159) тебе жалко что ли? На мисте голосовалка это способ самовыражения. Голосуй хоть тыщу раз за то, что тебе нравится.

(159) Хорошо хоть, что не "голубую".

ЗЫ: А что это такое?!

уже не помню когда использовал... разве при освоении программирования, так, попробовать...

можно обойтись и без нее

Как только во всех ходовых языках появятся именованные циклы и break/continue [имя], так сразу метки можно будет полностью выбросить - ваять хоронилища состояний частенько напрягает.

(162) мухлёж не приветствую. тем более в таком важном вопросе

вот это круче:

Если ЭлементыФормы.Флажок.Значение=Истина Тогда
 ЭлементыФормы.ПолеВвода.Доступность=Ложь;
ИначеЕсли ЭлементыФормы.Флажок.Значение=Ложь Тогда
 ЭлементыФормы.ПолеВвода.Доступность=Истина;
КонецЕсли;

(167) типичный код для начинающих

(167) Да, прикольно. Правильнее будет так:
ЭлементыФормы.ПолеВвода.Доступность = НЕ Флажок;

(170) ЭлементыФормы.ПолеВвода.Доступность = НЕ Флажок.Значение;

;-)

А считается признаком гамнокода фрагмент кода, вынесенный в отдельную функцию, причем эта функция отрабатывает всего лишь один раз?
А если эта функция экспортная и вынесена в обощий модуль?

(151) Java - недоязык. Там даже Goto нет

(171) У тебя программа не сработает.

(166) Типа как тут проголосуют, так ты и будешь писать? А вот мне пофигу на голосовалку, моего мнения она не изменит.

(173) вот шутник

(174) Ой, йооо...

ЭлементыФормы.ПолеВвода.Доступность = НЕ ЭлементыФормы.Флажок.Значение;

(173) Ухожу в Java. Только по этой причине. ;-)))

(170) вот, вот

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

(177) В твоей программе много лишних символов.

def SetStates(self):
       sd_assgn = len(self.m_dirPicker2.Path) > 0
       fd_assgn = len(self.m_dirPicker21.Path) > 0
       use_fd = self.m_checkBox1.Value

       self.m_dirPicker21.Enable(use_fd)
       if use_fd and fd_assgn and not sd_assgn:
           self.m_dirPicker2.Path = self.m_dirPicker21.Path
           sd_assgn = True

       jobenabled = sd_assgn and (fd_assgn or not use_fd)
       self.m_button2.Enable(jobenabled)
       return jobenabled

:-P

(181) да он распалился так, что не вкурит :-)

(180) Напиши обработку для 1С с парсингом голосовалок мисты и выводом реального результата :-)

(172) Нет. Это один из приемов рефакторинга.

(120) не факт, что сработает. если Родитель окажется НЕОПРЕДЕЛЕННО.

(186) Это как так может получится?

(15) должен заметить, что некоторым аналогом инструкции GOTO применительно к фразеологии общепринятого русского языка можно полагать употребление знака "запятая" -- во многих случаях незаменимо, однако избыток указывает не только на слабое понимание высказывающимся основ основ грамоты, но и на весьма посредственное владение оного собственно предметом обсуждения.

Например:
"Использование программистом GOTO означает, что при кодировании, мысленно он...".
Запятые (что вполне очевидно) размещены интуитивно, более того -- наобум. Недостаток грамотности автор готов компенсировать количеством запятых, размещаемых по принципу "на всякий случай".

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

Абстракция и обоснование мнения: честно говоря, до сих пор не могу понять как может более-менее связно писать на совершенно чуждом человеческой натуре "машинном языке" русскоязычный автор, не вполне владеющий совершенно естественным, более того -- повседневным!-- русским.

(187) переделываю пример...

Если Объект <> НЕОПРЕДЕЛЕНО И Объект.Родитель.Пустая() Тогда
 Сообщить("Пусто в родителе");
КонецЕсли;

в случае если Объект = НЕОПРЕДЕЛЕНО по идеи должна быть ошибка (не выполнимо Объект.Родитель), но 1с не проверяет второе условие, если первое уже ложь.

с метками или без - главное в коде чтобы его легко было понимать и чтобы эффективный был. остальное - религия

а, забыл проголосовать: 2

Всё зависит от школы. Если начинал работать бардачком, то и появляются безусловные переходы. В любой системе можно обойтись без этих переходов.
В чем ценность их отсутствия - это отладка сложных алгоритмов. С goto это просто головная боль.
Опыт: ассемблер, си, дельфи, ещё масса специализированных языков, и конечно же наша платформа.

(192) если поставить самоцелью "секс стоя в гамаке на лыжах с шестом и винтовкой" то вполне можно зачать дитя. Только будет ли ОНО Бубкой? Или Пылевой?

(192) после асма ты категорически против goto? странно...

+(192) вот ещё в чем недостаток приемов программирования с безусловными переходами. Применяя их, поневоле игнорируешь операции, что делают операторы(комилляторы) со стеками то ли процессора, то ли подпрограмм. Т.е. засоряешь ресурсы компа. И иногда это дает о себе знать в процессе отладки. Появляется непонятная информация или непонятные ссылки.

(195) Интересно, а такого что делает компилятор со стеком процессора и что такое стек подпрограмм?

(194) Да, там есть косвенная адресация, но описывая вызовы подпрограмм, приходилось очищать стеки, регистры, области памяти. Вот оттуда и неприятие безусловных переходов.

Причем случай должен быть самый крайний :)
И только в черновом коде , на бело все равно без GOTO перписывать

(197) странные проблемы. честно.

(0) Чо, ООП уже не торт?

(188) Повторяю (198) по просьбам трудящихся, с элементами самоцензуры.
Кстати, о чем говорят двойные тире, тире после восклицательного знака и маленькие буквы после восклицательного знака?

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

(204) неправильные входные параметры должны генерировать исключение?

(205) Угу. А не приводить к зависанию, или ещё хуже, возвращать рандомный результат.

(205)(206) валидность параметров должна проверяться штатно

кстати, кто-нибудь проверял, насколько 1с тормозит на попытках?

(207) что есть "штатно"?

(208) При работе с 1С основной тормоз - это запросы.

(0) Обойтись можно всегда, бывают случае, когда использование goto дает более читабельный код. Например выход из вложенных циклов "вниз"

И конечно-же.

(210) да не, тормоз - отсутствие у программиздов желания учить матчасть

(210) Основной тормоз - это неправильная "прокладка"

(205) Да, если это невозможные (запрещенные по задумке) ветви алгоритма.

(209) проверками

миллионы строк кода были наваяны на фортране в разных его инкарнациях, где использование гоуту являлось вполне обычным делом. И ничего - все работало, летало, плавало. Не то что сейчас.
.
А если взять всякие спецалгоритмы на низкоуровневых языках - там вообще все завязано на сплошные гоуту - по адресам с разными типами адресации...
.
Использование гоуту само по себе ни плохо, ни хорошо. Все определяется тямой в голове того, кто пишет. Сколько встречал гоуту в сторонних разработках 1С - трудностей в принципе не вызывали - были к месту и вполне понятны, не то что некоторые шедевры типа
GOTO М1 //перейти к М1

Использование GOTO определяет стиль мышления программиста.
Уже 40 лет программировать учат без GOTO. Но это - часть правды. А вся правда состоит в том, что там еще есть куча условий, чтобы программа была удобной (для отладки и сопровождения). Например, программные модули должны быть небольшими (максимум, несколько сот операторов). Или: не писать универсальных модулей для обработки различных условий совершенно разнородных объектов.
Учитывая, сто конфигурации 1С совершенно не удовлетворяют требованиям структурного программирования - используют они GOTO или не используют - ничего в корне не меняют.
Я - не использую.

(217) А потом появился структурный Фортран (RATFOR), и я все свои программы на него переписал.

(219) ну ифигли, мы в основном на ForEx прогили на Бэсм6 - гоуту тоже практически на нет сошло

(216) Исключение -- тоже своего рода проверка. Очень удобно бросить исключение своего типа затем его перехватить и обработать....

В 1С такое не катит, т.к. я могу вызвать исключение, но будет абсолютно непонятно, что его породило, т.е. мне еще это исключение нужно будет парсить, чтобы разобрать что это было

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

(222) Я именно его и имел в виду...

ИМХО, с некоторыми оговорками допустимо использовать только "прервать" и "продолжить", переход по метке необходимо забыть и никогда не вспоминать.

(211) В большинстве языков на этот случай есть оператор "прервать".

(225) Пардон, не прочитал про вложенность.

+(165) даже не именованные циклы, а именованные блоки операторов. Соответственно, будет возможным в пределах модуля и находясь внутри именованного блока прыгать к его началу, или концу, вне зависимости от принадлежности блока к циклам. как-то так.

ну если по сути то jmp еще никому не удалось заменить ... а вот языках высокго уровня гоняться за джампом моветон ...

так что в контексте всего структурно-объектного программирования ... да гото использовать низя

(133) Глупость. Кто мешает тебе использовать переход только вниз, либо писать в комментарии куда идешь.

(228) Когда научишься обрабатывать ошибки в С без goto - напиши в Майкрософт, и расскажи какие они лохи, раз используют goto...

(217) правильно так:

GOTO М1 //перейти к М1, ваш К.О.

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

10 лет назад использовал, когда совсем не понимал, что делаю.
Последние 10 лет даже не вспоминал.
ИМХО использование GOTO - свидетельство некомпетентности,  вернее, тупости.

(227) функции и процедуры, не?

(233) Слишком громкие слова, исхотя из твоих слов - некомпитентен либо ты, либо нижеописанные:

"Обработка ошибок

Этот случай применим к языкам, не содержащим конструкции try ... finally — например, к C без применения SEH, существующего только в Windows. В этом случае goto используется для перехода на код «очистки» — находящийся в конце функции и уничтожающий созданные ею объекты перед выходом из неё. Этот метод широко используется при написании драйверов.

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

Главным критерием применимости goto во всех случаях, включая указанные, является ненарушение используемой парадигмы программирования. В приведенных примерах это — структурное программирование, то есть должны сохраняться иерархическая организация программы и таковая же логика её работы." (с) Wiki

(235) Ну ты загнул. Ещё бы про ассемблерные вставки рассказал.

(236) При чем тут ассемблерные вставки? Читабельный переход вниз из вложенных циклов делается только при помощи метки. Это для примера. Даже в языках где есть способ выхода из вложенных циклов - используется метка (метка начала вложенных циклов)

(234) Не, ибо не решают проблему "глубокого выхода". В окончательном варианте: выход в начало блока для циклов и в конец для любых - так будет концептуально чисто.

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

Уже несколько раз в ветке прозвучало - возврат, прервать, попытка...исключение это самые настоящие гото. Поэтому те, кто пишут нельзя использовать, должны из принципа отказаться от использования этих операторов...

(240)+ В 1С ни разу не использовал, но тем не менее...

гадость

Всегда можно обойтись без goto, но некоторым проще воткнуть его, чем отписать "красивый" код.

Противники использования вдолбили себе в голову постулаты и не задумываются...

(243) Критерии "красивовго кода" в студию. Иначе голословно...

Как отладочный прием вполне себе нормально

(243) можно и без условий обойтись...

1.Да - обойтись можно (и нужно)
2.Да - использование goto плохой(ужасный) стиль программирования

всем, выбравшим п.1, запретить кодить

(249) так они и не кодят, они разрабатывают - в этом и есть большая разница между п.1 и п2,3

(249) Я просто перестану считать их мнение на этом форуме проффесиональным... Несмотря на мое к этим участникам форума уважение....

(251)+ :) ... профессиональным....

(250) ...а за употребление при этом слова "разрабатывать" расстреливать

(243) пример давно приведен, именно красивого кода -

Для цикл
Для цикл
 Если Тогда
  перейти ~метка; // комментарий
 КонецЕсли;
КонецЦикла;
КонецЦикла;
Сформировать();

~метка:

(251) Просто им на твоё мнение об их профессиональности наплевать...

(255) Примеры красивого кода в УПП 1.3:
Глобальный поиск по "Перейти ~" - 1174 вхождения...

(255) Мне не наплевать - если у меня есть вопрос, и я хочу НАЙТИ грамотный ответ, то....

(257) Ответ приведен в википедиях - и русскоязычной, и англоязычной. Если не устраивает википедия - пожалуйста, Crafty - эталонный код, используется для оценки производительности компиляторов. Goto есть в наличии. Именно для выхода из вложенных циклов вниз.

(256) А нам-то чо? Мы УПП не писали... Тем, кто писал, вход на мисту заказан...

(256) - к (243), к (250)

(259) Лукавите, уважаемый... :) А Nasf ???? Шучу...
Я же про п.1 и п.2 голосовалки, про красивости кода....

(261) А мы с Насиповым Фаритом по оператору GOTO не пересекаемся. Внезапно, да?

(262) А иного и не ожидал... Я не про готу, а про вход на мисту...
По теме - не люблю категоричных суждений, особенно там - где им не место. Судя по ветке - кроме штампа, что гото - это ересь, ни одного убедительного довода, одни догмы...

(263) Ты скажи прямо. Ты за GOTO или ты категорически против goto. Если ты ещё не определился, ты мой клиент. Из адекватных, то бишь. Тут тестируется логика, подверженность авторитетам, независимость суждений, способность к аргументации.

p.s. Разумеется, конструкция GOTO недопустима в современных учётных системах. Если программист допускает (создаёт) такую конструкцию, он должен её обосновать, даже в виде служебной записки. А если оправданий нет, то ему стыд и позор, ибо Дейкстра, и пусть исправляет. GOTO - ересь, но ересь научная, оправданная, свидетельствующая об офигененном уровне профессионализма.

(263) Доводы очень простые - использование goto приводит к не читабельности кода и запутывания его "вусмерть", в правильно составленном алгоритме goto не может понадобится в принципе.
(имхо)

(266) Единственное GOTO на модуль не может привести к столь печальным последствиям, как нечитабельность кода. А может дело в способности читаемости программистов?

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

(266) разверни (254), избавившись от goto, и реши что читабельнее

(265)(266) В свое оправдание я уже привел результат в виде 1174 случая использвания переходов по меткам в УПП. Ответ я дал где-то выше - п.2 (ближе п.4 - но он слишком общий и невнятный). Любой код (красивый он или не красивый, есть  в нем гото или нет) должен прежде всего отвечать задачам, которые этот код решает. А код ради кода - это  тоже самое, что учет ради учета...

Мое мнение - самоый главный пункт в законе о бух. учете - это пункт о рациональности в ведении бух. учета. Многие (в том числе и методологи от 1С) об этом забывают...

(270)+Я к тому, что рациональность - она не только в бух.учете...

(269) >>в правильно составленном алгоритме goto не может понадобится в принципе.

(267) Пример не единственного goto из crafty

              fp = ptbd->m_rgfpFiles[side][iExtent];
               if (NULL == fp)
                   {
                   fp = fopen (pszFileName, "rb");
                   if (NULL == fp)
                       {
#if defined (STOP_ON_ERROR)
                       printf ("*** Unable to open file %s\n", pszFileName);
                       fflush (stdout);
                       exit(1);
#endif
                       goto ERROR_LABEL;
                       }
                   }
               }
           ptbd->m_rgfpFiles[side][iExtent] = fp;
           }
       else
           goto ERROR_LABEL;
       }

   // File opened. Now seek and read necessary chunk
   if (NULL == ptbd->m_rgpdiDecodeInfo[side][iExtent])
       {
       long lPos;
       int  iResult;

       lPos = (long) (iPhysicalChunk*TB_CB_CACHE_CHUNK);
#if defined (T33_INCLUDE) || defined (T42_INCLUDE)
       if (lPos < 0)
           {
           iResult = fseek (fp, 0L, SEEK_SET);
           if (iResult)
               {
#if defined (STOP_ON_ERROR)
               printf ("*** Unable to seek file %s offset %08X\n",
                       pszFileName, 0);
               fflush (stdout);
               exit(1);
#endif
               goto ERROR_LABEL;
               }
           do
               {
               iResult = fseek (fp, 0x40000000, SEEK_CUR);
               if (iResult)
                   {
#if defined (STOP_ON_ERROR)
                   printf ("*** Unable to seek file %s offset %08X\n",
                           pszFileName, 0x40000000);
                   fflush (stdout);
                   exit(1);
#endif
                   goto ERROR_LABEL;
                   }
               lPos -= 0x40000000;
               } while (lPos < 0);
           iResult = fseek (fp, lPos, SEEK_CUR);
           }
       else
#endif
           iResult = fseek (fp, lPos, SEEK_SET);
       // Read uncompressed file
       if (iResult)
           {
#if defined (STOP_ON_ERROR)
           printf ("*** Unable to seek file %s offset %08X\n",
                   pszFileName, lPos);
           fflush (stdout);
           exit(1);
#endif
           goto ERROR_LABEL;
           }

(270) Присылай своё резюме. Нам нужны мыслящие люди.

(272) Точно! В правильном алгоритме мелкой правки дизайна печатной формы - goto не может потребоваться в принципе.

(274) Ко мне за советами приходят разработчики Итилиума и ремонт-Эксперта. Как же я их брошу? :) Не, меня и тут неплохо кормят. Но в аську отвечу, есть что спросить...

Чуваки, сохраняющие своё право на GOTO, нам интересны. Ждём Ваши резюме.

(272) goto - это уровень _реализации_ алгоритма. поэтому я говорил именно о кодинге

(275) оценил :) жалко только, что приходится править не только дизайн печатной формы.

(278) в данном конкретном случае - кода будет на 2 строчки больше - зато на порядок понятнее, а если не дай бог goto уйдет на другую страницу текста кода - иди пытайся читать этот код...

(280) в данном случае мы получим лишь лёгенькую обфускацию...

(280) В чём измеряется "понятность кода"?

+280 а дойдешь до этой метка - там обязательно будет очередной прыжок к другой метке - вот и прыгай так по коду как горный козел - принципе наверно увлекательно но видимо просто не для меня.

(282) судя по всему в том же в чем измеряется "красота кода".

(284) Категорически не согласен. Красота и понятность - вещи совершенно разные

+(281)(280) разбираясь, прыгаю по чужим модулям и не испытываю проблем
(283) в рассматриваемом случае прыжка не будет, так ведь? а если без гоуту?

(285) отчего-же ? в 99% случаях - красивый код - не может быть не понятный.

(287) Думаю, в процентах 0,1%. Красивый код должен быть поначалу непонятен. Это принцип красоты, эстетики. Это же не быдлокод, который ожидаем

(287) красивый код как правило более мощный, потому напрягает сильнее

(286) >>в рассматриваемом случае прыжка не будет, так ведь?
не факт, приведенный код абстрактный (с пустым циклом - поэтому прыжка как бы нету) а в реальности внутри цикла может быть не одна страница текста.


>>разбираясь, прыгаю по чужим модулям и не испытываю проблем

прыгать по модулям и по меткам - сравнения мягко говоря не корректное.

(285) Угу , но в практическом применении к 1С , лучше понятно чем красиво
(287) Далеко не всегда , красивый код может использовать разные хаки , и не стандартные приемы

(291) соглашусь

(мощность кода - количество смысла на единицу текста)

(290)
> а в реальности внутри цикла может быть не одна страница текста.
это ничего не меняет

> прыгать по модулям и по меткам - сравнения мягко говоря не корректное.
это же относится и к страницам текста

(291) Сложно не согласиться. Лучше понятнее и красивее, чем путано и уродско. Красивый код является более защищённым по сравнению с говнокодом.

(294) Ну если и понятно и красиво и эффективно одновременно - это идеал к которому надо стремится , но достаточно труднодостижимо , как правило приходится чем то жертвовать

(295) Дёшево, качественно, быстро - вот идеал.
Оператор GOTO - это какая-то мизерная часть к слову "качественно", совершенно незначительная. Ветка смысла не имеет

(296) Быстро, качественно, дешево - выбери любые два :)
Отказ от GOTO в первую очередь , это выбор стиля , парадигмы , и соблюдение дисциплины программирования

(254) Для цикл
Для цикл
Если Тогда
 Возврат КодОшибки;
КонецЕсли;
КонецЦикла;
КонецЦикла;
Сформировать();

Не катит?

(297) Отказ от GOTO - это собственноручная роспись в непонимании слова "качественно".

(297) вот так бы соглашался и соглашался.

(298) Но там же нет выхода из модуля.
А если ты хочешь оформить этот код в виде функции - получаешь кучу гемора. Например с недоступными локальными переменными.

(297) Если дисциплинироваться, то по-полной. Зачем же одним goto ограничиваться?

(302) Возврат СписокПараметровОшибки;

Не катит?

(303) Дисциплина программирования не может ограничиваться возвратом списка параметров ошибок.

(304) Ок пусть структура (в V77 больше плясок) - в винде вроде так...

Качественно (для кода) - слишком всеобъемлющая категория
ИМХО - для 1С качественный код должен в первую очередь структурирован и понятен
Для драйверов (или шахматных движков) совсем другое дело

Я что-то не понимаю всех этих извратов. В (254) Совершенно понятный и читаемый код. Заставить от него отказаться, либо кричать что написавший такое непрофессионал - могут заставить только очень серьезные тараканы в голове.

(306) И что тебе в (254) непонятно?

(308) Мне все понятно , и кстати я проголосовал за п.2 , и я использую GOTO , в первую очередь в отладке , бывает и в рабочем коде , но в рабочем коде стараюсь обойтись без него .

(307) Код в 254 именно простой - тут и применение goto самый простой способ, если алгоритм будет сложный и циклов больше, то без проблем вывалиться из всех циклов, а потом найти и понять, что и где не так будет просто.

(210) пройтись по цепочке проверок/выходов конечно же проще?

(311) При чем тут проверки/выходы? Если алгоритм предполагает безусловное завершение (goto безусловный переход) - значит случилось что то фатальное - т.е. продолжение выполнения не имеет смысла. Возвращается только информация о том, чем это вызвано.

(312) Там может быть выход из двух циклов, вложенных в третий.

(305) Дисциплина программирования не может быть ограничена конкретной программной конструкцией типа GOTO или структурой.

(310) Сделать непонятно мжно и без goto. А если использовать goto в меру, только там где это действительно необходимо (а необходимо это бывает весьма редко), то это никапли не вредит коду, более того - делает его понятным.

(313) Опять же  - для вызывающей процедуры - фатальные ошибки в вызываемой процедуре не всегда фатальные. Т.е. крах вызываемой функции не всегда приводит к не возможности продолжить выполнение алгоритма - goto выкидывает сразу из кода, а возврат с описанием ошибки позволяет обойти локальный сбой, или наоборот "намотать" ошибки в какую нить структуру.
(310) Согласен на 100% - но нужно без него.

(315) Я бы не много не так сформулировал
Умеренное и грамотное использование GOTO там где это необходимо не делает код более непонятным , т.е. не ухудшает его читабельность

Но что бы умеренно и грамотно применять GOTO и именно там где надо прог должен иметь определенный уровень понимания

(+316) Точнее в вызываемых/вызывающих функциях а не процедурах.

(316) речь идёт не о завершении по ошибке, а скорей о сколь либо сложном расчёте

(319) Дык разговор идет о быстром выходе из вложенных циклов - в остальном goto вообще не нужен - или я не прав?

(230)обязательно ... особенно иосле прочтения венгерской нотации ...

http://msdn.microsoft.com/ru-ru/library/yb3kz605.aspx
Note
Structured exception handling works with C and C++ source files. However, it is not specifically designed for C++. You can ensure that your code is more portable by using C++ exception handling. Also, the C++ exception handling mechanism is much more flexible, in that it can handle exceptions of any type.

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

и.т.п.

(322)предлагаю аналогию "пожарный выход".

+хожу через парадный

вот вариант (254) для 1С без ~метки:

   Попытка
       Для цикл
           Для цикл
                 Если Тогда
                     ВызватьИсключение;//а=а/0;
               КонецЕсли;
           КонецЦикла;
       КонецЦикла;
       Сформировать();
   Исключение
   КонецПопытки;

хотя, по сути, тоже GoTo, но формально нет :)

(325) Использовать исключение для обычных действий не фонтан.
- Трудности отладки (все время будет на этом месте спотыкаться).
- Не ясность поведения программы в этом месте.
- Не будет отловлена настоящая ошибка, например в процедуре Сформировать()

По этому я все равно за GOTO, в крайних случаях.

(0)Писать без гоутов вполне реально, в оракле если не изменяет память, его нет до сих пор - пишут-же!
С другой стороны иногда без него обойтись сложно, т.е. можно но необоснованно усложняется код!
Да и вообще что все так к гоуту прицепились? Начните для начала комментировать код - как предполагает хороший стиль программиирования (хотя-бы что какая функция делает и т.д.)

типа так

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

(277) сколько?

(330)обычно 1шт резюме достаточно

Когда надо сделать выбор между рекурсией и GOTO, я выбираю GOTO.

партия любителей goto уже имеет место быть?

(288) У вас все пишут загадками? А понятие как читабельность кода ни о чем не говорит?

как-то так ...
хотя последний раз использовал в 7,7, лет так 8-9 назад

(333) Конечно.

Давайте рассмотрим вот этот случай:
надо перебирать m^n

1 вариант Для цикл Для цикл КонецЦикла; КонецЦикла;  
2 вариант рекурсия
3 вариант  GOTO

(336) Такой вариант не рассматривается?

4.
Функция НайтиЧоТамНужно(Матрица_N_M)
Для Цикл
 Для Цикл
   Если Тогда
     Возврат ...
   КонецЕсли
 КонецЦикла
КонецЦикла
Возврат Неопределено;
КонецФункции

(337) 4 чем отличается от 1?

(338) А, ну если это имелось ввиду. Я то думал под номером 1 вариант "красивого кода" из (254)

(339) Если n переменная 1 вариант не прокатит.

(325) расстрельный код

(325) Это понятный, читабельный и красивый код?!

(301) А в чем проблема передать переменные в функцию? Мы вроде договаривались, что у нас будет два простых вложенных цикла, а теперь оказалось, что там ещё куча переменных меняется, которые даже в функцию не влезают.

(343) а ради двух простых вложенных циклов созидать функцию - это кравиво, да...

(344) *красиво

Во люди, вместо того чтоб признать что goto имеет право на существование, они будут часами придумывать кривой способ уйти от его использования.

Кстати, кто может объяснить, почему данный код валится с ошибкой?

   Пока Истина Цикл
       выполнить("Прервать");
   Конеццикла;


{(1,9)}: Оператор Прервать (Break) может употребляться только внутри цикла
Прервать<<?>>

Платформа 8.1.15.14

(344) Функция создается не только для того, чтобы спрятать GOTO. Функция прячет копание в коллекции.

(347) вероятно у "выполнить" свой контекст

(348) где упоминались коллекции?

Никогда лично не использовал. Местами видел.

(349) Ну в принципе, я так и подумал. Ну фигово это. Можно сказать баг платформы тогда. Иначе можно было бы нарисовать, что то типа этого:

Функция ВложенныйЦикл(Флаг)
   сч =  0;
   Пока сч < 10 цикл
       сч = сч + 1;
       Если Флаг = 1 тогда
           возврат "Прервать";
       ИначеЕсли Флаг = -1 тогда
           возврат "Продолжить"
       Иначе
           // крутим до конца
       КонецЕсли;
   конеццикла;
   возврат "";
Конецфункции


Процедура НажалиКнопку()
   сч =  0;
   Пока сч < 10 цикл
       сч = сч + 1;
       выполнить(ВложенныйЦикл(1));
   конеццикла;
КонецПроцедуры

(0) - неправильно.

Достаточно всего лишь 2-х конструкций: цикл "пока" и следование

(352) Это не баг, а фича - защита от любителей самострела коленки.
По поводу решения с функциями.
Появляются лишние сущности в виде условий, флагов и самой функции. Кроме того, функция будет определена далеко от тела цикла.

(354) Почему фича? Платформа теряет контекст, то есть не возвращает его туда откуда взяла. Взяла изнутри цикла, вот и верни внутрь цикла. А такая нежная забота со стороны платформы обо мне нафига нужна?

А вообще мне трудно понять людей, которых, например, не напрягает прыгать по десятку вложенных модулей в любой типовой восьмерочной конфе, а вот наличие метки в том же модуле мгновенно делает для них код нечитаемым...

(355) Аргумент "выполнить" является инородным по отношению к контексту исполнения. Или нет?

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

(356) Ну я например просто не умею ими пользоваться :-)
Как переходить по меткам? В процедуры и функции по  F12; циклы по Ctrj [ и ], а по меткам как?
(357) почему? В данном месте я хочу выполнить произвольный код. Что мешает?
Вот такой код чудненько отрабатывает:

Процедура НажалиКнопочку()
   сч =  0;
   Пока сч < 3 цикл
       //сч = сч + 1;
       выполнить("сч = сч + 1");
   конеццикла;
КонецПроцедуры

А я за ГоТов...
Куда хочу, туда верчу и нефих мне указывать своей мужской логикой, куда мне двигаться!

GOTO - задница, если бы так и дальше шло, то появился бы GOBACK, GOJUMP и т.д.

(359) > В данном месте я хочу выполнить произвольный код
Выполни его непосредственно.

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

(362) Это понятно. Просто конструкцию  из "Если" можно было бы заменить одной строкой. Было бы красиво. Собственно не вижу причин, почему платформа рогом упирается.
Пока Истина Цикл
Прервать;
Конеццикла;
она кушает, а
Пока Истина Цикл
Выполнить("Прервать");
Конеццикла;
ей видите ли не нравится. Где логика?

(353) Можно и по другому сказать. Достаточно двух конструкций -- ветвление и goto ;-)

(363) логика очевидна...

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

А как сделать  обход по массиву/тз/сз/структуре/и тп если кол-во элементов у него меняется ? Ну допустим в цикле стоит чот-то типа УдалитьСтроку() ? Без GOTO никак не знаю способов больше. Метка в начало цикла сбрасывает счетчик кол-ва элементов/итерраций.

Клас, красота кода в УСО 1,3 :)
Глобальный поиск по "Перейти ~" найдено 1175 вхождений :)

(367) читай всю ветку

(367) Тихая жесть ...

Пригодились, когда только писал на ассемблере...А так, ни разу не было в них нужды.

"Если есть GOTO, значит это кому-нибудь надо?" (с)

Порой изящнее поставить GOTO, чем городить конструкции IF/ELSE и пр.

(158) Не хочешь ли ты сказать, что эта теорема неверна?

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

(367) ППЦ...

(367)обернуть этот цикл в другой цикл "пока"

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

Гоуту - это граната в руках обезьян, взрывающая мозг.
Даже в тех редчайших случаях, когда без гоуту получается более громоздкий код, он всё равно читается легче. Потому что такой код имеет единообразно читаемую структуру.
Гоуту имеет сомнительное право на жизнь, как временная заплатка при отсутствии времени на рефакторинг, например.
Там где оно в типовых встречается - вреда от него особого нет, но необходимости тоже. Зато в жизни ТАКОЕ встречаешь, что без полного рефакторинга дорабатывать просто нереально.
Поэтому считаю что лучше бы его вообще не было. Вреда намного больше, чем пользы. Лучше бы на форумах были вопросы "Как реализовать", чем допускать безконтрольное размножение гоуту в дикой природе.

Хе-хе. Продолжим вбрасывать.
Я бы конструкцию:

Пока Условие1() Цикл
   Последовательность1();
   Пока Условие2() Цикл
       Последовательность2();
       Если Условие3() Тогда
           Перейти ~МеткаВыход;
       КонецЕсли;
   КонецЦикла;    
КонецЦикла;
~МеткаВыход;

преписал бы так:

Если Условие1() Тогда
   Сост = 1;
Иначе
   Сост = 3;
КонецЕсли;
Пока Сост < 3 Цикл
   Если Сост = 1 Тогда
       Последовательность1();
       Если Условие2() Тогда
           Сост = 2;
       ИначеЕсли Условие1() Тогда
           Сост = 1;
       Иначе
           Сост = 3;
       КонецЕсли;
   ИначеЕсли Сост = 2 Тогда
       Последовательность2();
       Если Условие3() Тогда
           Сост = 3;
       ИначеЕсли Условие2() Тогда
           Сост = 2;
       Иначе    
           Сост = 1;
       КонецЕсли;        
   КонецЕсли;
КонецЦикла;

Не читабельно? Зато методологично!
Кто красивше?

(379) во первых нечитабельно. Вообще хрень какая то. Во вторых Условиями вложенные циклы не ограничиваются. Например может быть перебор строк ТЗ которыми заполнена другая ТЗ. Тогда твой код вообще работать не будет потому что код перевёрнут по отношению к вложенным циклам.

(342)А чем он отличается от (254) кроме синтаксиса?
Оппа будет когда надо сделать выход из нескольких мест в одно, это да.

(379)

Пока Условие1 И НЕ БезусловноеЗавершение Тогда
  Последовательность1();
  Пока Условие2 И НЕ БезусловноеЗавершение Тогда
    Последовательность2();
    Если Условие3 Тогда
       БезусловноеЗавершение = Истина;
    КонецЕсли;
  КонецЕсли;
КонецЦикла

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

+ насчет "понятный, читабельный и красивый" это к эстетам. Никогда не претендовал, хотя стараюсь

Коллеги! Кажется кто-то из вас забыл, что операторы Возврат и Прервать являются выделенными (частными) случаями оператора GoTo. Остальные случаи должны быть с должным подходом реализованы с помощью оператора Перейти.
  Если отказываться от этого оператора то пишите такой код (382)! А то статистику портите.

(382) Продолжить; забыл
   Если Условие3 Тогда
      БезусловноеЗавершение = Истина;
      Продолжить;
   КонецЕсли;

(382)
Пока Условие1 И НЕ БезусловноеЗавершение Тогда
 Последовательность1();
 Пока Условие2 И НЕ БезусловноеЗавершение Тогда
   Последовательность2();
   Если Условие3 Тогда
      БезусловноеЗавершение = Истина;
      Продолжить;
   КонецЕсли;
 КонецЦикла;
 Последовательность3();
КонецЦикла

И брюки превращаются...

(380) Ты ничего не понял.

(386) А я добалю состояние и чуть поправлю диаграму переходов:


Если Условие1() Тогда
   Сост = 1;
Иначе
   Сост = 4;
КонецЕсли;
Пока Сост < 4 Цикл
   Если Сост = 1 Тогда
       Последовательность1();
       Если Условие2() Тогда
           Сост = 2;
       Иначе
           Сост = 3;
       КонецЕсли;
   ИначеЕсли Сост = 2 Тогда
       Последовательность2();
       Если Условие3() Тогда
           Сост = 4;
       ИначеЕсли Условие2() Тогда
           Сост = 2;
       Иначе    
           Сост = 3;
       КонецЕсли;
   ИначеЕсли Сост = 3 Тогда
       Последовательность3();    
       Если Усолвие1() Тогда
           Сост = 1;
       Иначе
           Сост = 4;
       КонецЕсли;    
   КонецЕсли;
КонецЦикла;


(388) Получил вывих мозга от твоего кода. Если ты методичку пишешь, тогда у тебя "Если" не может заканчиваться на "ИначеЕсли", ибо одно это уже рвёт мозг и заставляет лихорадочно искать последнюю "Иначе". Сидишь и думаешь, то ли пора очки заказывать, то ли автор кода где то ошибся, то ли так и было задумано.

(389) >> Если ты методичку пишешь, тогда у тебя "Если" не может заканчиваться на "ИначеЕсли"

Я ж не виноват, что в 1С оператора выбора нет. Приходится иначееслями заменять.
А код может быть трудно читается с непривычки, зато хорошо рисуеццо ;-)
И вообще, декларативно описывается.

(390)Case можно сэмулировать СЗ

Никогда не пользовался, дите С++ и джави, поэтому

Хотелось бы обратить внимание на факт опосредованного отношения теоремы Бома — Якопини к учётным системам вообще и к 1С "XYZ" в частности.

(392) а что говорит C++ о (379)?

(390) Конечно, если уж совсем читстоу стиля блюсти, то следовало бы написать так:

Сост = 0;
Пока Сост < 4 Цикл
   Если Сост = 0 Тогда
       Если Условие1() Тогда
           Сост = 1;
       Иначе
           Сост = 4;
       КонецЕсли;
   ИначеЕсли Сост = 1 Тогда
       Последовательность1();
       Если Условие2() Тогда
           Сост = 2;
       Иначе
           Сост = 3;
       КонецЕсли;
   ИначеЕсли Сост = 2 Тогда
       Последовательность2();
       Если Условие3() Тогда
           Сост = 4;
       ИначеЕсли Условие2() Тогда
           Сост = 2;
       Иначе    
           Сост = 3;
       КонецЕсли;
   ИначеЕсли Сост = 3 Тогда
       Последовательность3();    
       Если Условие1() Тогда
           Сост = 1;
       Иначе
           Сост = 4;
       КонецЕсли;    
   КонецЕсли;
КонецЦикла;


(390)>Я ж не виноват, что в 1С оператора выбора нет. Приходится иначееслями заменять.
Пиши так:
   ИначеЕсли Сост = 3 Тогда
       Последовательность3();    
       Если Усолвие1() Тогда
           Сост = 1;
       Иначе
           Сост = 4;
       КонецЕсли;
  Иначе
   // нифига не делаем
   КонецЕсли;

Тогда, я буду спокоен, я буду знать, что ты обработал все возможные условия, а не просто заюыл про "Иначе"

(391) Хмм, без ИначеЕсли?
Как?

(396) А вот это уже занудство ;-)

(398) Это методически правильное занудство :-)

(394) Да все то же самое, только там switch-case будет.

(400) там можно более красивую чем в (391) таблицу изменения состояний наваять

(401) Более красивую можно и в 1С наваять. Просто я на скорую руку.

(402) или поставить несчастный goto))

(403) Это неспортивно!

(388) Как раз хотел сказать, что необходимость в безусловном выходе и хитрых скачках гоуту по хитрым веткам чаще всего появляется при кривых попытках реализации диаграммы состояний. Помню, в какой-то из веток это уже обсасывали.
Но я настаиваю, что даже при реализации (386) в лоб на флагах, код будет более читабелен, хотя и более громоздок.
Бегло разбирая чужие алгоритмы (или свои спустя время) часто пропускаешь безусловные переходы в глубоких ветвлениях, что чревато неприятными сюрпризами. Как минимум, заметив потом использование меток, придется заново переосмысливать уже вроде бы разобранный блок.
Ведь при разборе кода в первую очередь опираешься на целостные структурные блоки, а гоуту ломает их целостность и усложняет восприятие.

http://imgs.xkcd.com/comics/goto.png

Бывает, что неиспользование настолько усложняет задачу, что проще и быстрее использовать. Хотя сам уже лет 10 не пользовался.

если очень хочется то можно (c)

Когда я был студентом, я оптимизировал выход из рекурсии с помощью GOTO.  Жестко, на ассемблере. Вместо PUSP, POP (все параметры функции передаются через стек) банальноее GOTO и зачистка регистра стеков на расчетное количество вызовов.

Это все равно, что в 1С сделать из тела функции перейти в другую процедуру, наплевав на все параметры.

Препод сначала хотел двойку за такое поставить, но потом оказалось, что мой код побил предыдущий рекорд среди его студентов в 6 раз. Задачка на обход доски шахматным конем,
С 12 секунд до 2 секунд на первом пне 133.

2 секунды - очень долго для такой задачи.
Выход из рекурсии производится только когда нашли решение - у кого-то он десять секунд занимал?! Бред какой-то.

в ассемблере гоуту ... вот это на самом деле жестко

а за решение явно надо было двойку ставить ...и отчислять из института

(411) да ладно, в ассемблере 95% переходов - условные, а гоуту - безусловный

(413) ну да, ну да... а перепрыг альтернатив чем делать? на два условных один безусловный

(414)а, ну да :)

(395) Адо, ты прав, можно обходится без ГОТО.

Также можно обходится идти влево, если постоянно идти вправо.
Земля ведь круглая, так?

(413) Ну и что? Разве нельзя поставить условие для ГОТО?

(417) в jmp то?

нет

(417)было бы прикольно посмотреть

(420 открой для себя фортран :-)

(421)речь идет об ассемблере ... и даже конкретной команды jmp

Поскольку "Использовать можно, но в крайнем случае", поэтому лучше раз и навсегда сказать себе

Читабельность конечно стадает, но иногда (очень редко) вместо наворотов кучи флагов/циклов и прочей байды удобнее и быстрее сделать через ГОТО

Сравните и сделайте вывод какой код легче читать?
Задача: Выполнить некие действия только для трёх пользователей: "Вася,Федя,Степа". Причем Степе предоставить право выбора делать/не делать эти действия.

1.Вариант с (Go To)- коротко и читабельно:
Пользователи = "0001,0002,0003";
Если Найти(Пользователи,СокрЛП(глПользователь.Код))>0 Тогда
   Если (СокрЛП(глПользователь.Код)="0003") И (Вопрос("Стёпа, хочешь это сделать прямо сейчас?",4)<>6 Тогда) Тогда
           Перейти ~Метка1;    
   КонецЕсли;
   
   //начало неких действий
   //...
   //конец неких действий
   
КонецЕсли;    
~Метка1;    

2. Вариант без GO TO - громоздко и трудно читаемо:
Пользователи = "0001,0002";
Если Найти(Пользователи,СокрЛП(глПользователь.Код))>0 Тогда

   //начало неких действий
   //...
   //конец неких действий
   
КонецЕсли;    

Если СокрЛП(глПользователь.Код))>"0003" Тогда
   Если Вопрос("Стёпа, хочешь это сделать прямо сейчас?",4)=6 Тогда
   
   //начало неких действий
   //...
   //конец неких действий
   КонецЕсли;
КонецЕсли;

(425) За программный код, рассчитанный на конкретных пользователей (с проверкой на код элемента справочника), надо отрывать руки, независимо от наличия GOTO

(425) бред...

Если ЭтоВасяФедя или (ЭтоСтепа и СтепаСогласен()) Тогда

(427) Только лучше что-то вроде
Если ЕстьПраво() И (НЕ НужноИнтерактивноеПодтверждение ИЛИ ПолучитьИнтерактивноеПодтверждение()) Тогда

(427) Так лучше:
Если ЭтоВася или ЭтоФедя или (ЭтоСтепа и СтепаСогласен()) Тогда

(427)(429) нифига себе! Заводить отдельную функцию "СтепаСогласен()", в которой еще громоздить кучу кода это вы считаете улучшением читабельности?

обойдусь без GOTOв

Если ЭтоВася() = Истина Тогда
    Перейти ЭтоВася
КонецЕсли;
Если ЭтоВася() = Ложь Тогда
    Перейти ЭтоНеВася;
КонецЕсли;

(430) не надо ничего заводить, это метакод, замени ее своим Вопрос()

Во всем нужно руководствоваться здравым смыслом, а не догмами.

(433) я пробовал так:
"Если (СокрЛП(глПользователь.Код)="0003") И (Вопрос("Стёпа, хочешь это сделать прямо сейчас?",4)=6) Тогда"

Вопрос у каждого юзера вылазит.

(435) в 8-ке нет ))

(425) можно ввести цикл с параметром и брякать его

Если НужноЧтотоДелать() Тогда
   // что-то делаем
КонецЕсли;

и весь свой овнокод в функцию локализовать, чтобы человека, который потом это будет читать - сразу на клавиатуру не вырвало

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

(437)(438) вот меня как раз уже тошнит от ваших бесконечных функций и прыганий по ним, а от шедевра:
Для НомерИтерации=1 П 2 Цикл
Если НомерИтерации=1 Тогда
...
иначе
...
КонецЕсли
КонецЦикла  

материться хочется

(440) чо?... а что это у тебя?

(439) Задача озвучена.
Твоё стройное решение в студию...

З.Ы.: Обязательным условиям является повышенная читабельность кода

(435) Не понял. А в исходном коде почему тогда не вылазит? Всех троих Стёпой обзывать должно.

(440)
Пользователи = "0001,0002,0003";
Если Найти(Пользователи,СокрЛП(глПользователь.Код))>0 Тогда
  Для БудетПрерывание=1 По 1 Цикл // сразу говорит о прерывании
     Если (СокрЛП(глПользователь.Код)="0003") И (Вопрос("Стёпа, хочешь это сделать прямо сейчас?",4)<>6 Тогда) Тогда
             Прервать;    
     КонецЕсли;
 
     //начало неких действий
     //...
     //конец неких действий
  КонецЦикла;
КонецЕсли;

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

(442) лол

СтепаСогласен=Истина;
ВходитВСписокТрех=СписокТрех.НайтиПоЗначению(текПользователь); // или как там будет задано правило.

Если ВходитВСписокТрех тогда
 Если текПользователь=Степа тогда
   СтепаСогласен=Вопрос(блабла);
 КонецЕсли;
КонецЕсли;

Если ВходитВСписокТрех И СтепаСогласен тогда
///
КонецЕсли;

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

пингвинофилы есть в ветке ?

именно так

(446) какой Стёпа на всё согласный))

Не помню, отвечал или нет на голосовалку.

При реальной необходимости использовать можно. Но это возникает чрезвычайно редко. Совершенно не помню, когда использовал последний раз, наверное в школе на gw basic (это было Очень давно :) ).

(450) Ну да, получается, в отсутcnвие Степы считаем его согласным на все по дефолту :D

(451) Точно. Я за 10 лет работы с 1с только 2 или 3 раза пользовал и то можно было обойтись, но код громоздкий получался

Если рассматривать язык 1С как язык программирования, то в нём без Goto приходится сильно извращаться, так как:
- Нет стандартного цикла Do {Тело} Loop While {Условие}, а писать While 1=1 ещё более глупо, чем Goto.
- Нет возможности выхода сразу из нескольких циклов. Приходится или писать Goto за пределы цикла (что очень неудобно из-за необходимости вводить метки и задавать им имена) или выносить циклы в отдельную процедуру, чтобы использовать Return (что тоже не всегда удобно и сильно усложняет читаемость).
- Возможность повторения кода с начала после устранения ошибки. Тут или Goto или "вечный цикл" и Continue (не знаю, но применение Goto выглядит более понятным, чем цикл).
Поэтому, если и используется Goto, то нужно писать комментарий, чтобы было понятно, где у нас находится метка.

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

(455) не всегда наглядно

а что такое GoTo ? =)

(456) это да. но у меня, например, при массовом перепроведении и блокировках используется конструкция

Для СчПопыток = 1 по МаксимумПопыток Цикл
 Попытка
   // действия
   Прервать;
 Исключение
   Если НеОшибкаБлокировки(ОписаниеОшибки()) Тогда Прервать; КонецЕсли;
   глПауза(20);
 КонецПопытки;
КонецЦикла;

фигово, но с метками - хуже

(455) Иногда для понимания алгоритма проще, чтобы был один текст, который занимает два-три экрана, чем пять-шесть экранов процедур, в которые приходится передавать кучу параметров.

(459) А если понадобится внутри алгоритма повторить выполнение его сначала (например, поменяли условие), то цикл будет выглядеть ещё более непонятно (особенно, если выход нужно сделать из вложенного цикла) - с метками проще, чем заводить всякие флаги завершения или переключения режима обработки.

(461) в (459) и есть "повторение алгоритма сначала"

меня бесит только отсутствие конструкции ОбработкаПрерыванияПользователя("ЧтоВыполнятьВСлучаеПрерывания"). ну и лямбда фукнкций вместо "выполнить()"

(460) Воооот! Истину глаголишь!
+мульон и всё такое

прыгание по функциям и процедурам весьма весьма за...
особо когда один и тот же параметр стописят раз переименовывется от функции к функции

(464) а ты не переименовывай

В (459) Нет вложенных циклов.
Например:
// Начало алгоритма
While 1=1 Do
// исполняем предварительную часть
DoPart1();
// Исполняем какой-то цикл
ContinueFlag=0;
For i=1 To 10 Do
 // что-то выполняем
 DoPart2();
 If RepeatCondition()=1 Then
  // здесь предполагается переход на начало
  // то есть проще было бы написать Goto ~НачалоИсполнения;
  ContinueFlag=1;
  Break;
 EndIf;
EndDo;
If ContinueFlag=1 Then Continue;EndIf;
EndDo;

(465) Основная проблема в скорости исполнения, если при каждом вызове функции мы передаём три-четыре параметра.
Хотя, при достаточном умении можно и вложенные циклы в один загнать.

наверное когда просят примеры кода прислать они не только сами кодить не умеют на 1С но ещё и ищут GOTO
всё так серьёзно с этим GOTO

(466) херня какая-то написана. зачем там флаг - непонятно

(469) А как перейти к началу, если мы находимся во внутреннем цикле ?

(470) я так понял, что после If ContinueFlag=1 Then Continue;EndIf; ты забыл написать, что там типа еще код есть

(470) Пересмотреть алгоритм, сделать по другому. Я не знаю почему но когда я кодидирую мне даже в мысли не приходять break, continue, goto. Я бы точно такое не написал (466)

(471) Ну да - предполагается, что условие проверки на повторение в середине вложенного цикла (и проверяется на каждой итерации), а после вложенного цикла могут быть другие вычисления и, в том числе, тоже вложенные циклы.

(472) Проще вложенные циклы вынести в отдельные процедуры, которые возвращают код результата, а уже по этому коду и действовать, но, переписывать передачу параметров и не забывать их считать и правильно передать - тоже не так просто.

Например, в VbScript или Java (JavaScript) goto нет, но никто от этого не умер.
А в 1С создатели, видимо, без Goto не справились - и, слава богу, что нельзя использовать GoTo для входа в циклы и условия - то есть "макаронные сопли" исключены.

У меня может опыта кодирования мало, но я вобще не понимаю где такая конструкция может пригодиться

While 1=1 Do

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

(476) мало у тебя опыта

Или вот это например. Чётко указали что хотим сделать десять шагов и тутже Break. Я так не могу кодить...


For i=1 To 10 Do
// что-то выполняем
DoPart2();
If RepeatCondition()=1 Then
 // здесь предполагается переход на начало
 // то есть проще было бы написать Goto ~НачалоИсполнения;
 ContinueFlag=1;
 Break;
EndIf;
EndDo;

(466) В даннном конкретном случае - заменить While 1=1 на
While ContinueFlag

Можно еще изобретать конструкции, где goto необходимо.
На поверку в 99% случаев окажется, что плохо спроектирован алгоритм.

В 1% (или 0.1%) случаев - да, пригодится. У меня за, наверное, с полсотни тысяч строк на 1С, таких случаев не было.

потому что 1с - филосовский язык:

Пока Истина...

вот ниачем ваще спор - сколько раз запускал замер производительности - любая кодова охинея ничто по сравнению с чтением какого-нибудь чего-то

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

(459) тыж истинный пингвинофил, как же тогда это (ведь элементарно без готушек) ?


static int set_one_prio(struct task_struct *p, int niceval, int error)
{
       int no_nice;

       if (p->uid != current->euid &&
               p->uid != current->uid && !capable(CAP_SYS_NICE)) {
               error = -EPERM;
               goto out;
       }
       if (niceval < task_nice(p) && !capable(CAP_SYS_NICE)) {
               error = -EACCES;
               goto out;
       }
       no_nice = security_task_setnice(p, niceval);
       if (no_nice) {
               error = no_nice;
               goto out;
       }
       if (error == -ESRCH)
               error = 0;
       set_user_nice(p, niceval);
out:
       return error;
}


(425) А так не проще?


Пользователи = "0001,0002,0003";
Если Найти(Пользователи,СокрЛП(глПользователь.Код))>0 Тогда
  Если НЕ((СокрЛП(глПользователь.Код)="0003") И (Вопрос("Стёпа, хочешь это сделать прямо сейчас?",4)<>6)) Тогда
      //начало неких действий
      //...
      //конец неких действий  
  КонецЕсли;    
КонецЕсли;    


+(484) Либо так:


Пользователи = "0001,0002,0003";
Если Найти(Пользователи,СокрЛП(глПользователь.Код))>0 Тогда
  Если (СокрЛП(глПользователь.Код)<>"0003") ИЛИ (Вопрос("Стёпа, хочешь это сделать прямо сейчас?",4)=6) Тогда
      //начало неких действий
      //...
      //конец неких действий  
  КонецЕсли;    
КонецЕсли;    


(476) Нигде. Это просто плохой стиль, который удобно применять, если лень задумываться о читабельности кода.

+(485) На худой конец так:

Пользователи = "0001,0002,0003";
Если Найти(Пользователи,СокрЛП(глПользователь.Код))>0 Тогда
  Если (СокрЛП(глПользователь.Код)="0003") И (Вопрос("Стёпа, хочешь это сделать прямо сейчас?",4)<>6) Тогда
  Иначе
      //начало неких действий
      //...
      //конец неких действий  
  КонецЕсли;    
КонецЕсли;    


(484)(485)(486) Но лучше всего так, как преложено в (446), ибо опираться на особенности вычисления 1С-ом логических выражений я бы не стал.

(488) Тогда так:
Если ЕстьПраво() Тогда
  Отказ = Ложь;
  Если НужноИнтерактивноеПодтверждение Тогда
     Отказ = НЕ ПолученоИнтерактивноеПодтверждение();
  КонецЕсли;
  Если НЕ Отказ Тогда
  КонецЕсли;
КонецЕсли;

пингвинофилы слились ?

(490) боюсь что я не они а они молчат

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

"бонзы" подтянулися ))

(493) давай, клевещи))

Кто бы что ни говорил, но написать алгоритм вида "клеточный автомат" без меток достаточно непросто, кроме того теряется изящность и читаемость кода.
В остальных случаях использование меток серьёзных преимуществ не даёт.
P.S. лучше бы в 1С грамотно реализовали вызов исключений, чем goto (реализация goto - очень простая задача).

(492) Софтпоинт занимается оптимизацией 1С с помощью гоуту? :-)
А в связке с "если бюджет ограничен" очень двусмысленно читается.
-Щас мы вам тут задёшево наоптимизируем, хренак, хренак, нафтыкали гоуту. ВСЁ! Работа сделана! :-)

(496) Гы. Внезапно :)

пипец, 5 страниц из-за goto ...ивращенцы :)

(495) Чушь.

500

(500) Ты во всех ветках караулишь? Или бота написал? :-)

(501) нет, просто по случаю стреляю иногда

мало что ли способов по другому усложнить код

За каким ???

только из классовой ненависти к гоутуненавистникам

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

Любой код можно написать без использования GOTO, но иногда ставя всего лишь одну метку можно избавится от головной боли и существенно уменьшить размер кода, количество условий и прочее. Так что иногда можно и ставить метку. Но именно иногда и обязательно её комментируя.

(506) Если ДлинаЛогина <= 2 Тогда
Сообщить("человек по определению ущербен");
КонецЕсли;

(508) Бегом марш в википедию, читать определение ущербности.

(508) сочувствую

(509) Зачем? Ты тоже дал прекрасное определение, записав более чем 39%(по последним данным опроса) программистов в ущербные.

(511) Я не давал определение ущербности, учись читать.

(512) отмазки левые.

(513) Ссылку на данное мной определение приведешь?
Или кроме значения слова "ущербный", ты в придачу не знаешь и значения слова "определение"?
Что такое "ссылка" знаешь? :)

(514) Конечно дам! вот она - (506)
Признай уже что ступил.

ПС
Человек человеку волк, а зомби зомби зомби.

(515) Точно, значение слова "определение" ты естественно не знаешь.
Там написано "по определению", но самого определения нет, ибо мне казалось что все знают определение (и значения) этого слова.

(516) ПоОпределению(<Определение в озвучании писателя>). Читай СП РусЯза!

(518) Ну ты тормоз.
Использующий не в полной мере называется неполноценным, а неполноценный - синоним ущербного. Вот определение.

Которого я в своем посте конечно-же не давал.

(519) Перечитываю твой пост 506 и сравниваю с постом 519 - один в один твое "определение", тока заменил один синоним другим.

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

(506) +1 :)

(520) (521) Виноват. 90-ый это уже не поколение пепси.

(523) Скорее поколение Виндовс XP

Может поспорим что считать поколением? :)

"современная Яга-школота, она же «поколение Next», поколение гламура и Камеди клаб.

Стоит отметить высер быдла, что «хуже Поколения Пепси не будет ничего». Оказалось будет. Поколение Яги тому пример. Даже сами поцреоты таки это признают." :)
(с) Лукморе.
http://lurkmore.ru/index.php?title=Поколение_Пепси&stable=1

я один раз использовал - доктор, я буду жить?

(526) Дааа. В наше время такого не было. Все девочки были целочки до 30 лет, а парни ходили в армию на 10 лет.