1С под рукой нет. Напишите плиз кусок кода с goto (определение метки и переход к ней)

v8: Выделение строки в дереве

Не пользуйся метками, плохой стиль.

(1) спасибо
(2) во первых - нужно сейчас для теста парсера. во вторых - goto это как пикантные духи для женщины - когда много - отвратительно, а вот когда в тему - просто супер

(3) Покажи хоть один пример где супер? Goto это не пикантные духи для женщины, и пикантная ложечка дерьмеца в бочке меда..

сейчас сырцов на 1С нет. Гляну дома.

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

парсер должен все понимать. значит нужно и goto...

(4) Goto - средство для эмуляции отсутствующих структур управления. В 1С-ике отсутствует выход из вложенного цикла - для этой цели _придётся_ использовать goto (вариант с введением дополнительных переменных - ещё более дерьмопикантен).

(8) не _придётся_, если грамоте обучен...

(0)  Сделай поиск по конфигурации по слову "Перейти"

(8)  <<В 1С-ике отсутствует выход из вложенного цикла - для этой цели _придётся_ использовать goto

я вот тоже хотел, однако нельзя использовать метку в циклах )

Перейти ~Метка!;  

~ Метка!: Сообщить("Осуществлен переход по метке.");

шо за парсер?

Замечание! Метка в этом операторе не должна быть меткой перехода на оператор Процедура или Функция.

Замечание! Оператор безусловного перехода не может бьть использован для передачи управления на операторы, находящиеся внутри конструкций: Пока - КонецЦикла, Для КонецЦикла, Для каждого - КонецЦикла, Если КонецЕсли, Попытка - Исключение - КонецПопытки извне этих конструкций.

(8)
"В 1С-ике отсутствует выход из вложенного цикла - для этой цели _придётся_ использовать goto"


Бред сивого мерина в ясную лунную ночь - Прервать на...




(12) неверно

~ Метка: Сообщить - без воскл знака...

(15) Из вложенного.

Пока ... Цикл
   Пока ... Цикл
       // здесь надо выйти из обоих циклов
   КонецЦикла;
КонецЦикла;

И как это сделать через Прервать (в общем случае)?

(16)
Пока ... Цикл
   Флаг=Ложь;
   Пока ... Цикл
       // здесь надо выйти из обоих циклов
       Флаг=Истина;
       Прервать;
   КонецЦикла;
   Если Флаг=Истина Тогда
       Прервать;
   КонецЕсли;
КонецЦикла;

Как-то так...

(17) Блин, лучше уж goto... А если у тебя три цикла? Сколько вложенностей - столько флагов? Жуть же...

епта, доступно и всерьез...

(17) Это понятно.
Но насколько лучше дополнительная переменная, чем goto?
О чём и речь - goto применяется тогда, когда прямых способов сделать что-то - нет.

(18) Совсем не жуть, каждый цикл решает прерывать его самого или нет, и не думает за других. Просили без goto, получили.

Но вообще тема из цикла: "Каждый дрочит как умеет".

Замечу, что операторы Прервать, Продолжить и Возврат в процедуре тоже являются аналогами GoTo, их тоже никто не использует из-за плохого стиля?

(23) В чём состоит "аналогия"?

(24) не огорчай меня =)

Все 4 оператора передают управление в другую часть программы, тока GoTo более универсален

(24) Не обращай внимания, год выпуска в нем говорит.

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

(26) чем отличаются процедуры?

Процедура ДелаемЧтоТо()

Если Выходим() Тогда

Возврат;

КонецЕсли;

...

КонецПроцедуры

Если Выходим() Тогда

Перейти ~ВыходИзПроцедуры;

КонецЕсли;

...

~ ВыходИзПроцедуры:

КонецПроцедуры

(28) если не считать, что пропустил Процедура ДелаемЧтоТо() для второй процедуры

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

(30) то есть продолжить не передает управление в конец цикла? а возврат не передает управление в конец процедуры, а прервать не передает управление на первый оператор сразу после цикла????

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

(32) это отличие, остальное совпадает... в GoTo критикуется сам факт передачи управления внутри метода, а не произвольная точка перехода

+(33) легко можно заменить все Возврат и Прервать в коде на Перейти (с Продолжить в 1С не уверен)- это разве не является определением аналога?

(34) В этом все и дело, goto - безусловно в любую точку. конструкции цикла - в пределах цикла. Спор гроша выеденного не стоит.

Интересно, почему одинэсники не перевели дословно и не сделали ИдиНа Метка?

Ух как бы я тогда метки называл!

(36) Тогда уж надо было бы ПНХ, и все метки с буквы "х"

(35) я говорю о том, что использование операторов Возврат, Продолжить, Прервать и Перейти по сути аналогичны и "чрезмерное его применение нарушает иерархическую структуру программы и приводит к созданию нечитаемого «спагетти-кода»"

Согласен со Stepa86. Разница только в том, что в случае Перейти точку перехода определяет программист, во всех остальных - интерпретатор по установленным правилам. По этой причине с помощью Перейти сделать код нечитабельные проще, чем с помощью других операторов, но, в общем, по своей сути они аналогичны.

Ааа... Goto... два лагеря... война Алых и Белых Роз...

(41) дык война давным давно закончена, вот тока многие партизаны до сих пор не в курсе =)

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

(c) http://ru.wikipedia.org/wiki/GOTO

В частности

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

... применение GOTO в некоторых случаях можно считать допустимым. ... К таким случаям можно отнести: Выход из нескольких вложенных циклов сразу

(18) Гы .. А ты из цикла просто выйти хочеш или по условию ?
Прервать всяко лучше!

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

тупые одинэсники не читали макконела и фаулера...

(47) я читал =)

... и продолжают долбить...

Вот сколько програмлю, ну ни разу goto в 1С не пользовал. Только в школе на фортране и бейсике.

(50) +1

(50) +2

(50) я не использовал, потому что научили, что это плохо... но (39)...

(50)
"...Словарь Вильяма Шекспира, по подсчету исследователей, составляет 12000 слов. Словарь негра из людоедского племени «Мумбо-Юмбо» составляет 300 слов. Эллочка Щукина легко и свободно обходилась тридцатью..."(с)

Из книги "Совершенный код".
Там же есть "Аргументы за goto"

Аргументы против goto
Основной аргумент против goto состоит в том, что код без goto — более качественный. Знаменитое письмо Дейкстры «Go To Statement Considered Harmful» («Обоснование пагубности оператора go to») в мартовском номере «Communications of the ACM» 1968 г. положило начало дискуссии. Дейкстра отметил, что качество кода обратно пропорционально количеству goto, использованных программистом.
В последующих работах Дейкстра утверждал, что корректность кода, не содержащего goto, доказать легче.
Код с операторами goto трудно форматировать. Для демонстрации логической структуры используются отступы, a goto влияет на логическую структуру. Однако использовать отступы, чтобы показать логику goto и места его перехода, сложно или даже невозможно.
Применение goto препятствует оптимизации, выполняемой компилятором. Некоторые виды оптимизации зависят от порядка выполнения нескольких выражений подряд. Безусловный переход goto усложняет анализ кода и уменьшает возможность оптимизации кода компилятором. Таким образом, даже если применение goto увеличивает эффективность на уровне исходного кода, суммарный эффект из-за невозможности оптимизации может уменьшиться.
Сторонники операторов goto иногда приводят довод, что они делают программу быстрее и проще. Но код, содержащий goto, обычно не самый быстрый и короткий из всех возможных. Изумительная классическая статья Дональда Кнута «Structured Programming with go to Statements» («Структурное программирование и операторы go to») содержит несколько примеров, в которых применение goto приводит к более медленному и объемному коду (Knuth, 1974).
На практике применение операторов goto приводит к нарушению принципа, что нормальный ход алгоритма должен быть строго сверху вниз. Даже если goto при аккуратном использовании не сбивают с толку, как только они появляются, они начинают распространяться по коду, как термиты по разрушающемуся дому. Если разрешен хотя бы один goto, вместе с пользой в код проникает и вред, так что лучше вообще запретить использование этого оператора.
В целом опыт двух десятилетий, прошедших с публикации письма Дейкстры показал всю недальновидность создания кода, перегруженного операторами goto.
В своем обзоре литературы Бен Шнейдерман (Ben Shneiderman) сделал вывод, что факты свидетельствуют в пользу Дейкстры и нам лучше обходиться без goto A980), а многие современные языки, включая Java, даже не содержат такой оператор.

(2), (4) goto  в типовых используется. посмотрите в КД обработку по экспорту метаданных

(2) (4) Меня всё время умиляли люди, которые говорили "не надо использовать такую конструкцию языка - это плохо!". Спрашивается, а на кой ляд тогда придумали сами авторы языка такую конструкцию и не слишком ли много на себя берут вот такие люди уча других программировать?

+(57) Это не повод к драке, просто реально интересно стало. Уж извиняйте если кого обидел.

(57) Почитай (55)...

В принципе, если его (goto) раз в год использовать, а не как во встроенном бейсике УК-НЦ, то можно... хотя мне лично не нравится...

(57) кстати в java такое резервное слово есть, но не работает ))

(57) Да можно использовать. Вопрос в том, что очень редко. Любой ценой переходов избегать тоже плохо, не надо до абсурда доводить. Но в принципе, 99,9% вещей выглядят красивей без goto.

Из той же книги, аргуметт за

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

(63) у тебя в каком виде эта книга?

2005г. OFF: 1C и GoTo
...
2006г. OFF: goto - ваше отношение к этому оператору
...
2008г. Чем опасны (вредны) метки?
...
2009г. v8: как goto правильно пишется?
...

(63) +1 :)
(65) аааа) Помню же, что было уже...

(65) чо то 2007 год ущербный был...

(64) djvu

Использовать... не использовать... безполезняк... какие мелочи...

Вот вы такие здесь все умные - ответьте мне: этично или нет пользоваться топором, если я в курсе, что Раскольников им старушек убивал для мелочи?

(67) В 2007 тоже споры были - но не чета перечисленным :)

(69) Не этично! Пользуйтесь пилой для убийства старушек!

(70) Бензопилой предлагаете? Раз - была одна старушка. Два - стало две.

(71) "Не скажите, гражданин судья! Пять старушек - уже рубль!"(с)

(70) Динамитом их надо, динамитом! ;)

Просто попробуйте отладить текст с goto и этими метками. И не просто текст, а приличный проект. Опплюетесь, да после этого единственным желанием станет переписать не фрагмент, а всю программу.
(50) +3
(39) не аналогичны. Они передают управление в конец/начало программного кода группы операторов/оператора, функции. В случае с goto передача идет без учета всяких прибамбасов с моментами инициализации переменных, массивов или подобных промежуточных вычислений. Как следствие, это может быть нерациональное использование памяти, снижение быстродействия. И наконец просто ошибки. Поиск которых сводится к затратам на перепись программной реализации. Это в 1с можно практически где угодно объявить переменную и она может быть доступна. В языках, где построже с инициализацией переменных, всё сразу становится на свои места.
В мою память, в вузах за это двойки ставили.

(74) на (28) ответь, если не аналогичны

я раз пользовал "го то"

доктор, я буду жить?

(76) а смысл?

(13) свой. Нужен оказался.
(65) Не прав. НЕ хотел этого холивара. Просто на машине где писал нет 1С. Соответственно СП.
Для всех - пофигу плохо это или хорошо. Будет нужно - буду использовать. Не будет нужно - не буду.

(57) GOTO придумали ещё в начале 1950-х годах. Когда языки программирования находились в зачаточном состоянии - и с точки зрения теории, и с точки зрения практики их использования.
По мере развития языков программирования GOTO заменялось более эффективными конструкциями. И сейчас сохраняется разве что "на всякий случай" - который, как правило, не наступает.

(75) Два отличия:
А) Вариант с Перейти - чуток тормознутее (практически незаметно - но всё же).
Б) Для умного компилятора (каковым компилятор 1С-ика не является) - значительно тормознутее (поскольку компилятор не вправе при наличии Перейти применять бОльшую часть оптимизирующих преобразований).

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

(79) но он досих пор продолжает быть

Из тойже книги
И, наконец, операторы goto входят во множество современных языков, включая Visual Basic, C++ и Ada — наиболее тщательно продуманный язык программирования в истории. Ada создавался уже после того, как были приведены все аргументы с обеих сторон дискуссии по goto, и после всестороннего рассмотрения вопроса разработчики Ada решили включить в него goto.

(80) то есть разница только в скорости работы... когда есть 2 решения и одно из них универсально, то оно почти всегда дольше выполняется...

(81) В начале 1981-х Кушниренко, преподавая Фортран на ВМК МГУ, рассказывал о GOTO как о специальном синтаксисе для записи условных операторов и циклов в Фортране:

1 IF (.NOT.Условие) GOTO 2
......
2 GOTO 1

как принятую в Фортране запись для

WHILE Условие DO
...
END

(83) Не только в скорости (хотя она тоже важна).

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

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

(84) C парадигмой не поспоришь. Однако даже на бейске за оформление подпрограммы с помощью goto двойка была обеспечена.
Я потому и сказал что спор по этому вопросу бессмысленный.

(87) Для C и C++, к примеру? :-)

Традиции достаточно сильны. Вирт как-то признался, что оставил begin ... end в Паскале (в составных операторах внутри if и циклов) именно для того, чтобы сторонники популярного тогда Алгола-60 чувствовали себя "как дома".
В последующих языках (Модула, Оберон и пр.) он ввёл явное завершение для условного оператора и цикла.

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

(88) Насчёт бессмысленности сомнений нет.
Но - как показывает эта ветка, есть достаточно много народу, которые малость не в курсе, что, откуда и куда. :-)

(89) Ты бы так поступил? Я нет. Надеюсь создатели этих языков сейчас не стали бы ради совместимости оставлять устаревшие конструкции.

(92) разработчики C# запретили "проваливание" в ветки ниже оператора case. И могли бы это сделать декларативно: не проваливается и все! Ан нет, заставили для совместимости писать разработчиков в каждой ветки break;

(92) В современные языки goto и не включают :-)
Языки "мейнстрима" - это разработки начала 1980-х годов.

Насчёт "так поступил": язык, которым никто не пользуется, - зачем создавать? Облегчить людям переход с привычных им языков - имеет смысл. Лишь бы это "облегчение" не мешало работать. goto в современных языках не мешает - поскольку им разумные люди стараются не пользоваться.

(94) до-диез - современный язык?

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

А может современные языки создают не современные люди?

(95) "С-подобный" :-)
Сохранение синтаксиса "для совместимости".

(96) Язык программирования должен быть _работающим_. Его разработка - весьма долгий процесс (я имею в виду и развитие "с учётом эксплуатации").
Ультрасовременность - это к любителям вешать на "Жигули" блямбу с "Мерседеса".

(98) без goto он будет неработающим?

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

100

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

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

А взять эти вложенные циклы и вынести в отдельную процедуру и выходить из N вложенных циклов единственным Возврат?

2(101,103) в принципе - можно сделать тоже самое и без гоуту.. переменная-индикатор и оператор Прервать...
ps/ Но у меня вообще нет предубеждений против каких-то слов - это с одной стороны, а с другой, иногда чужой код и без гоуту  может бесить так что готов исколоть портрет автора иголками...

(104) С тем, что отсутствие goto - не панацея против кривизны рук "программиста", - спору нет.
Но goto - это конструкция, которая создаёт проблемы и человеку, и транслятору, и даже процессору. В таком случае зачем её использовать?

гоуту плохой :)))
можно подумать, что противники этого гоуту ужасно от него пострадали. ну вот ей богу, ну ведь нигде его почти не встречали и нигде он вам не мешал, а столько рёва, что аж страшно. можно подумать, что вы с утра до вечера сидите и переписываете программу на фортранев 100000 строк 1978 года написания и вся она истыкана этими гоуту.
чудики :))

(103) В 1С-ике?
А локальные переменные - в качестве параметров передавать? Новый кадр на стеке заводить?
Очень далеко не всегда это хорошее решение.

(106) Не поверишь - встречал. И переписывал с Фортрана программы, все истыканные этими goto. Правда, давно это было - ещё в начале 1980-х. Но - было.

(108) Ну так забудь уже. Или к бабке сходи, пусть испуг снимет наконец. )

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

Насчет 1С: там нельзя сделать переход в ЛЮБОЕ место кода. Есть ограничения, сходные с ограничениями в Java. Поэтому, вероятность возникновения ошибок ниже.

Зачем goto в С++ -- понятно (обратная совместимость с тем же С и тем, что, вероятно, было до него).

Зачем этот оператор в 1С -- загадка еще та

(109) гы, этапять! :)

(107) В 1С-ке. И локальные переменные - да, передавать как параметры (не глобальными же их делать). Этот вариант тоже не беспроблемный, но, имхо, лучше, чем использование безусловного перехода.

блин, он же парсер пишет, т.е. работает уже с тем, что ЕСТЬ.
к чему базар "зло/не зло"?

(113) Как к чему?! Чтобы рабочее время оплачиваемое работодателем быстрее пролетало)))

А вот нам в универе неуд. не ставили за goto. Правда препод сразу сказала, что учитесь лучше без него писать программы. Но если используешь и сумеешь объяснить нафига надо - то не проблема.

(112) Куда хуже.

Кстати, в Комплексной, отчет "Регламентированные отчеты" с использованием меток написан...

(105) >> Но goto - это конструкция, которая создаёт проблемы и человеку, и транслятору, и даже процессору. В таком случае зачем её использовать?
Жесть. особенно про процессор :) коли так - чем заменить jmp?
(113) дописал уже практически. Ща тестирую

Для всех - ветка подтолкнула на идею добавить трансформеру возможность раскрывать конструкции while/for/for-each в сравнения и переход к меткам. Так что если так извратиться, а потом еще пройтись обфусикатором - код станет 100% нечитаемый. И противники гото приобретут еще один большой плюс в свою поддержку :)

yield return на вас нет!

(119) я бы сказал лиспа и схемы на всех нет:) А также пролога. (кстати, в прологе по моему нет goto) Может всем перейти на него?

(116)чем?

Вообще-то выход из вложенных циклов вещь сама по себе сомнительная... Примерчик можно, где оно обосновано?

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

Иначе получается что-то вроде из функции 1 вызвали функцю 2, из функции 2 функцию 3, и хотим из функции 3 вернуться в функцию 1 не ставя об этом в известность функцию 2. Очевидно что структурно и ошибки вылезут почти наверняка, причем такие, которые сложно будет выловить.

Очевидно что структурно = Очевидно что структурно неверно

(124) Не вгоняй народ в заблуждение. Циклы не функции и ничего страшного не случиться.

(126) Согласен что не одно и то же, но смысл именно такой. Если для примера брать двухмерный массив в котором надо найти определенное число, то конечно ничего не случится, но в реальной проге после вложенного цикла могут быть и еще какие-то операторы, возможно даже с тем вложенным и не связанные. Например перебираем элементы справочника, во вложенном перебираем подчиненные и что-то там с ними делаем, после вложенного делаем с элементом основного справочника что-то еще. Изначально написали без прерываний, потом какой-то тру одинэсник увидел что после какого-то элемента подчиненного дальнейший перебор не имеет смысла и оптимизировал код выкинув по "возврат" из процедуры, в итоге код по элементу основного работать перестал. Ошибка весьма неочевидная, искать ее тяжко потом. Потому и говорю что лучше если каждая структура будет только за себя решать когда прерваться, но никак не за вышестоящие. Фик с ним что лишняя проверка во внешнем цикле будет, зато не накосячишь.

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

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

(118) Помедитируй на тему "конвейер команд".

(129) Конвейер и обычный оператор ветвления сбрасывает ))

(127) потом какой то сферический 1сник... Поставил доп проверку только в одном из внешних циклов а в одном пропустил... Фиг с ним с этим. я вот чего не понимаю. Условие, цикл, прервать,возврат,.. все это условные переходы как их не называй. Есть конечно какой то загадочный предсказатель переходов. :) Но вот вопрос как там с ним и 1с...

(130) Конечно. Но для регулярных управляющих структур компилятор (достаточно умный, естественно) сгенерирует код, который поменьше сбрасывает конвейер. А в случае с goto - тут в 99% случаев будут проблемы.

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

(132) я думал мы про 1с...

ВремяДоСтарта=ТекущаяДата();
ВремяТекущее=ВремяДоСтарта;
Пока ВремяДоСтарта=ВремяТекущее Цикл;
 ВремяТекущее=ТекущаяДата();
КонецЦикла;
Пока а<>1000000 Цикл
а=а+1;
КонецЦикла;
ВремяФиниш=ТекущаяДата();
Сообщить(ВремяФиниш-ВремяТекущее);
7мь секунд

ВремяДоСтарта=ТекущаяДата();
ВремяТекущее=ВремяДоСтарта;
Пока ВремяДоСтарта=ВремяТекущее Цикл;
 ВремяТекущее=ТекущаяДата();
КонецЦикла;
~Метка: а=а+1;
Если а<>1000000 Тогда
Перейти ~Метка;
КонецЕсли;
ВремяФиниш=ТекущаяДата();
Сообщить(ВремяФиниш-ВремяТекущее);
7мь секунд

(131) Если этот же сферический 1сник в вакууме натыкает goto, конфа лучше работать не станет ))
(132) Там все равно система предсказания переходов (как-то так она называется) используется. Но разве система, основанная на вероятностях может гарантировать стабильную работу (в смысле, постоянный успех)? И по-моему, это фича процессора

Просто goto в руках бухгалтера, который думает, что программировать на 1с ему дано от Бога, творит тру чудеса ))

Свое личное отношение я уже высказывал...

А вот зачем этот оператор в 1с?

(128) На самом деле это очень частая ситуация когда прогу дописывают в течение долгого времени. Сначала целью вложенных циклов была работа с подчиненными элементами, потом дописали что-то по основному туда же, чтобы два раза не перебирать, потом полезли опять с подчиненными что-то делать, а про основные забыли. Весь модуль разбирать не станешь, написанный черти когда пусть и тобой же, но уже фик вспомнишь что он вообще делает, не говоря уж о том как. Работать будешь определенный кусок кода, а ошибка вылезет 1000 строк спустя, как-то так...
(131) Разница в том что эти переходы ведут в конец структуры, если видишь Прервать, ты знаешь куда кривая выведет, а с гоуту это совсем не очевидно, особенно с  учетом того что если кто-то начал их лепить, и одним выкинул за циклы, будь уверен что через пару строк найдешь еще один, который тебя швырнет куда-то вверх. Уж это к бабке не ходи...

(128) Частая ситуация. Но если начинаешь менять структуру программы - то ведь не ради единственного goto.

(136) Тут речь не по гоуту, а про выход из структуры "через голову" вышестоящей. Не надо перепрыгивать вышестоящий цикл, код со временем разрастется и концов  не найдешь. Лучше поставь два раза одно и то же условие и прервать во внутреннем и внешнем, сколько потом кода не пиши, работать будут как и с самого начала.

ОПА!
Гоуту!!!
А можна испльзовать комментарии внутри циклов?!
Они же игнорируются!!!
А так как мы имеем интэрпэтатор, то на это игнорирование тратим время.
Вот какая мысля на тему гоуту!

(138) У тебя довольно слабые представления о работе этого интерпретатора :) Сначала все же компилятор работает, который переводит твою писанину в промежуточный код, там нет комментариев, и много чего еще нет и что возможно оптимизировано :)

(135) здравствуйте... Думаю вы заработались. Я говорил о том что иногда нужно выйти из вложенных циклов. За всю жизнь пару раз надо было. Я не говорил про переход наверх. Не надо придумывать :)  Чем больше кода тем неудобней читать...

//Выйдем из всех циклов
Перейти ВыходИзЦиклов:

Красивей чем 5 раз
Если флВыйтиИзЦиклов Тогда
Прервать;
КонецЕсли;
Чем больше кода тем больше ошибок...  
(139)+1 20 строчек комментариев внутри цикла все те же 7мь секунд выполнения (133)

(140) Сколько раз встречал гоуту, ни разу не видел чтобы этим ограничились. :) В любом случае если и делать выход из всех сразу, то понятнее будет, если засунуть их в отдельную функцию. А лучше вообще этого не делать, так как все вложенные делают "общее дело" только когда изначально это пишешь, а когда потом туда еще какого функционала навтыкаешь может и боком выйти такой выход...

(141) Так это же как наркотик: "Ага, использовали гоуту для выхода из цикла 5-го уровня вложенности... блин, тут бы еще... так ведь уже есть один гоуту, была-не-была, на те второй".

о блин. холивар то запустил...

Порадуйтесь за меня - работает все. Осталось облагородить и можно дальше идти

(144) Осталось выкинуть вариант с переходами и написать по-нормальному :)

(145) ??? как их выкинуть если они часть тестов? Ведь какой же это будет анализатор кода если он не будет анализировать и гото?

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

(142) зачем?
(145) зачем? :) всегда можно прийти взяться за голову и сказать у вас все написано не правильно.... И срубить еще бабла.
Клиника она не лечится... У меня вот живой пример... Завод проплатил пару лямов за мега систему на СКЮЛЬ+клиенты на VB... в месяц 60 штук за доработки... уже второй год платят. Итого нет ни каких гоуто... За то список заявок(журнал документов по 1сному) для каждого клиента формируется в отдельную временную таблицу... Страшно представить как идет обновление временных таблиц при добавлении заявки в центре... И подобных ляпов не мерянно.

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

(148) насчет клиники - это абстрактно? или в продолжение предложения переписать и выкинуть?

(149) Пример нужности в студию

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

(151) Проспал весь холивар :) "Поехали"(с)

Пока ... Цикл
  Пока ... Цикл
     Перейти ~Выход;
  КонецЦикла;
КонецЦикла;
~Выход:

было. не интересно. придумал лучше.
метки = новый соответствие;
метки[1] = "x1";
метки[3] = "x2";
метки[4] = "x3";
метки[5] = "x4";

блин...

метки = новый соответствие;
метки[1] = "x1";
метки[3] = "x2";
метки[4] = "x3";
метки[5] = "x4";

х = ВвестиЧисло();
выполнить( " перейти "+метки[x]);

~x1:
 ....
 goto end;
~x2:
 ....
 goto end;
~x3:
 ....
 goto end;
~x4:
 ....
 goto end;
~end:


как в басике "on x goto x1,x2,x3,x4" - в каком-то из дилектов было такое

(155) а под "goto end" ты предпологаешь еще один goto? ... я б просто ифомом сделал...

(155) Абалдеть. Ценители чистоты кода охренеют :)

(155) o_O

(153) Смотри выше, делается через процедуру с возвратом, а по мне так лучше вообще так не делать.
(155) Да, case'а в 1С нет, но это не повод для goto, набор из ИначеЕсли будет смотреться не хуже чем это, и по скорости не думаю что будет ощутимая разница. Что несколько проверок, что работа со строкой в  " перейти "+метки[x], думаю то на то и выйдет...

в (155) ляпнул не подумавши, но вот сейчас после достаточно бурной дискуссии с другом пришел к выводу что в принципе после анализа AST можно развести процедуры/функции примерно к такому ядру

массивПереходов = новый соответствие;
массивПереходов[1] = "х1";
массивПереходов[2] = "х2";
массивПереходов[3] = "х3";
.....
массивПереходов[1000] = "х1000";

текСостояние = Неопределено;

~Старт:
 выполнить("перейти "+массивпереходов[текСосотяние]);

~x1:
 тут какието действия
 текСостояние = 2;//переход в новое состояние
 перейти Старт;
....
~x1000:
 тут какието действия
 текСостояние = 912;//переход в новое состояние
 перейти Старт;

Код становиться абсолютно нечитаемым, неотлаживаемым.

Переход = "КодСтановиться";
~Старт:
  Выполнить("Перейти ~" + Переход);
~Абсолютно:
  Переход = "Нечитаемым";
  Перейти ~Старт;
~Неотлаживаемым:
  Переход = "Финиш";
  Перейти ~Старт;
~Нечитаемым:
  Переход = "Неотлаживаемым";
  Перейти ~Старт;
~КодСтановиться:
  Переход = "Абсолютно";
  Перейти ~Старт;
~Финиш:

уловил... но лучше индексный доступ Ведь можно организовать индкексацию так Инд1[Инд2[Инд3[Инд4[Инд5[]]]]] - причем определения Инд2...ИндN погут формироваться и переписываться между переходами. Практически самомодифицирующийся код...

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

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

Так вот если заниматься не "написанием" программы, а "описанием" реальности,
то просто по природе не возникнет потребность в ГоТо.

Так что ГоТо в помойку, учимся грамотно моделировать.
Захотел использовать ГоТо - ляг, поспи, а проснувшись, используй рекурсию.

не прав. За любой пулей - гото в никуда.
а моделирование - либо четко математически - у тут без гото никуда :) (автоматы, цепи Маркова), либо набор операций куда включать или не включать гото - дело вкуса. Да и рекрсия невсегда рулит

(163) Отсыпь мне тоже немного этой чудо-травы :)

(163) За жисть...
А кирпич упадет на голову — вот и переход... :)
А мешок с лимонами найти — вот и нах работа...
:)

(164) Четко математически (автоматы, цепи Маркова) - тут как раз goto бесполезен: количество меток определено заранее, множество же состояний автомата - определяется в ходе выполнения программы.

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

Удивительно, что 30-летней давности споры, давно уже решённые, всплывают вновь и вновь.

Чисто практически. Переписать это без goto. (8.0)
Но что бы не выглядело монстрообразным :-)

// Сравнение таблиц, добавление отсутствующих в третью
Для каждого тзсс Из ТЗ Цикл
   Для каждого сс Из Основная Цикл
       Если сс.Сотрудник = тзсс.Сотрудник и сс.Должность = тзсс.Должность Тогда
           Перейти ~Метка;
       КонецЕсли;
   КонецЦикла;
   нс = ТЗДобавляемых.Добавить();
   нс.Сотрудник = тзсс.Сотрудник;
   нс.Должность = тзсс.Должность;
   ~Метка:;
КонецЦикла;

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

Для каждого тзсс Из ТЗ Цикл

НайденныеСтроки = Основная.НайтиСтроки( Новый Структура( "Сотрудник,Должность" , тзсс.Сотрудник , тзсс.Должность ) );

Если НайденныеСтроки.Количество() = 0 Тогда
   нс = ТЗДобавляемых.Добавить();
   нс.Сотрудник = тзсс.Сотрудник;
   нс.Должность = тзсс.Должность;
КонецЕсли;

КонецЦикла;

(170) Вот это дело

+(170) даже лучше так:

Для каждого цСтрока Из ТЗ Цикл

НайденныеСтроки = Основная.НайтиСтроки( Новый Структура( "Сотрудник,Должность" , цСтрока.Сотрудник , цСтрока.Должность ) );

Если НайденныеСтроки.Количество() = 0 Тогда

   ЗаполнитьЗначенияСвойств( ТЗДобавляемых.Добавить() , цСтрока );

КонецЕсли;

КонецЦикла;

(172) Блин - не подозревал про такую функцию

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

Симпозиум программистов 1С на тему "Роль goto в народном хозяйстве"

надо доказать теорему: "Любой алгоритм на 1С можно привести к алгоритму на 1С без goto"

(174) спорщиков "Я не могу жить без goto" обычно не бывает, бывают "Мне пофиг goto не goto лишь бы работало и меньше писанины"

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

Есть правило про переход:
Допустимо использовать Goto, если конструкция помещается на экране ... Т. е. код читается ...
ЗЫ: я редко но использую.

(176) Уже доказана. Лет 30 назад. Теорема Бома-Якопини. Применима не только к 1С.

(180) Во дают. Теоремы даже есть на эту тему, а goto всё живет. И тебя переживет. Потому что нужно!

(181) Кому? :-)
Пишут люди программы безо всяких goto. Давно уже. И успешно.
Что тебе всё неймётся-то?

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

(182) Мне неймётся? :)))

(182) пока в 1с не появится «continue n» и «break n» с n больше 1 - оно облегчает... как появится - отпадет необходимость... хотя с такими вещами - в фунцкции циклы заворачиваю, и ничего...

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

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

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

(188) "что это не рекомендуется использовать, в циклах и т.д."
Это где ты такое вычитал?

пардон
(187)

(190)(189)В жЁлтой книге :)

(190)"в циклах" - при выходе из циклов :)

(191) Там такого быть не может. Это глупость. Какая страница?

метки нельзя ставить в теле цикла. а goto в циклах ставь, хоть заставься

(194) С чего ты взял что нельзя метку в теле, но можно метку из тела, при это пофигу как себя поведет компилятор при использовании ГО_ТО для выхода из цикла.
В примере "выше" приведен эфект твоей логики, ведь проблема не в том что ГО_то нельзя, а проблема в том какой эфект будет ;)

Ведь язык 1С не ты писал и как показывает практика, команда Го_ТО не доработана ;)

(194)Для тебя пример, v8: Выделение строки в дереве

(195) Я имею ввиду что нельзя делать переход на метку, которая расположена в другом цикле, не в том, где goto

(197)А в примере в (2) или в (196) показано, что при выходе из цикла по коменде ДО_ГО :)
Теряется логика ;)
Вернее прога делает немого не так

(196) Ну там всё правильно. Классический выход вложенного из цикла.

из вложенного цикла

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

Кроме того, вариант с goto смотрится лучше, чем вариант с "кривым" циклом:
// ЦИКЛ do-loop
~Label:
// тело цикла
RunBodyAlgo();
// условие выхода
if Condition()=1 then
 goto ~Label;
endif;
или вариант без goto:
while(1=1)do
// тело цикла
RunBodyAlgo();
// условие выхода
if Condition()<>1 then
  break;
endif;
enddo;

Вот и получается, что без goto как-то тоскливо.

(195) На нее просто наложены строгие ограничения для уменьшегия потенциальных ошибок применения. Как в Java