Цикл 1с – Внутренний язык программирования 1С 8.3 для начинающих программистов: список значений в 1С

Содержание

Циклы в языке 1С 8.3, 8.2 (в примерах)

Циклы в языке 1С 8.3, 8.2 (в примерах)

Вступайте в мою группу помощник программиста.
В ней мы обсуждаем программирование в 1С.

2017-12-18T22:10:00+00:00Дата Если Массивы Математика Процедуры Строки Циклы
Диалоги ОписаниеТипов ОперационнаяСистема Приложение Соответствие
СписокЗначений Структура ТаблицаЗначений ФайловаяСистема Формат

ОбщиеОбъекты Запросы ПрикладныеОбъекты УниверсальныеФункции

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

Полный синтаксис (нажмите, чтобы раскрыть)

Цикл Для

Описание:

Оператор цикла Для предназначен для циклического повторения операторов, находящихся внутри конструкции Цикл – КонецЦикла.

Перед началом выполнения цикла значение Выражение 1 присваивается переменной Имя_переменной. Значение Имя_переменной автоматически увеличивается при каждом проходе цикла. Величина приращения счетчика при каждом выполнении цикла равна 1.

Цикл выполняется, пока значение переменной Имя_переменной меньше или равно значению Выражение 2. Условие выполнения цикла всегда проверяется в начале, перед выполнением цикла.

Синтаксис:

Для <Имя_переменной> = <Выражение 1> По <Выражение 2> Цикл
    // Операторы
    [Прервать;]
    // Операторы
    [Продолжить;]
    // Операторы
КонецЦикла;

Параметры:

Имя_переменнойИдентификатор переменной (счетчика цикла), значение которой автоматически увеличивается на 1 при каждом повторении цикла. Так называемый счетчик цикла.
Выражение 1Числовое выражение, которое задает начальное значение, присваиваемое счетчику цикла при первом проходе цикла.
ПоСинтаксическая связка для параметра Выражение 2.
Выражение 2Максимальное значение счетчика цикла. Когда переменная Имя_переменной становится больше чем Выражение 2, выполнение оператора цикла Для прекращается.
ЦиклОператоры, следующие за ключевым словом Цикл выполняются, пока значение переменной Имя_переменной меньше или равно значения Выражение 2.
// ОператорыИсполняемый оператор или последовательность таких операторов.
ПрерватьПозволяет прервать выполнение цикла в любой точке. После выполнение этого оператора управление передается оператору, следующему за ключевым словом КонецЦикла.
ПродолжитьНемедленно передает управление в начало цикла, где производится вычисление и проверка условий выполнения цикла. Операторы, следующие в теле цикла за ним, на данной итерации обхода не выполняются.
КонецЦиклаКлючевое слово, которое завершает структуру оператора цикла.
  

Цикл Для Каждого

Описание:

Оператор цикла Для каждого предназначен для циклического обхода коллекций значений. При каждой итерации цикла возвращается новый элемент коллекции. Обход осуществляется до тех пор, пока не будут перебраны все элементы коллекции.

Синтаксис:

Для Каждого <Имя_переменной_1> Из <Имя_переменной_2> Цикл
    // Операторы
    [Прервать;]
    // Операторы
    [Продолжить;]
    // Операторы
КонецЦикла;

Параметры:

Имя_переменной_1Переменная, которой при каждом повторении цикла присваивается значение очередного элемента коллекции.
ИзСинтаксическая связка для параметра Имя_переменной_2.
Имя_переменной_2Переменная или выражение, предоставляющее коллекцию. Элементы этой коллекции будут присваиваться параметру Имя_переменной_1.
ЦиклОператоры, следующие за ключевым словом Цикл выполняются для каждого элемента коллекции.
// ОператорыИсполняемый оператор или последовательность таких операторов.
ПрерватьПозволяет прервать выполнение цикла в любой точке. После выполнение этого оператора управление передается оператору, следующему за ключевым словом КонецЦикла.
ПродолжитьНемедленно передает управление в начало цикла, где производится вычисление и проверка условий выполнения цикла. Операторы, следующие в теле цикла за ним, на данной итерации обхода не выполняются.
КонецЦиклаКлючевое слово, которое завершает структуру оператора цикла.
  

Цикл Пока

Описание:

Оператор цикла Пока предназначен для циклического повторения операторов, находящиеся внутри конструкции Цикл – КонецЦикла. Цикл выполняется, пока логическое выражение равно Истина. Условие выполнения цикла всегда проверяется вначале, перед выполнением цикла.

Синтаксис:

Пока <Логическое выражение> Цикл
    // Операторы
    [Прервать;]
    // Операторы
    [Продолжить;]
    // Операторы
КонецЦикла;

Параметры:

Логическое выражениеЛогическое выражение.
ЦиклОператоры, следующие за ключевым словом Цикл, выполняются, пока результат логического выражения равен
Истина
.
// ОператорыИсполняемый оператор или последовательность таких операторов.
ПрерватьПозволяет прервать выполнение цикла в любой точке. После выполнение этого оператора управление передается оператору, следующему за ключевым словом КонецЦикла.
ПродолжитьНемедленно передает управление в начало цикла, где производится вычисление и проверка условий выполнения цикла. Операторы, следующие в теле цикла за ним, на данной итерации обхода не выполняются.
КонецЦиклаКлючевое слово, которое завершает структуру оператора цикла.

Оглавление (нажмите, чтобы раскрыть)

&НаКлиенте
Процедура ВыполнитьКод(Команда)
 
    /// Как организовать цикл в 1с 8.3, 8.2
 
    // Для Цикл
    Для Счетчик = 1 По 5 Цикл
        Сообщить(Счетчик); // 1 2 3 4 5
    КонецЦикла;
 
    // Для Каждого Цикл
 
    Дни = Новый Массив();
    Дни.Добавить("Понедельник");
    Дни.Добавить("Вторник");
    Дни.Добавить("Среда");
 
    Для Каждого Элемент Из Дни Цикл
        Сообщить(Элемент); // Понедельник Вторник Среда
    КонецЦикла;
 
    // Пока Цикл
    Счетчик = 0;
    Пока Счетчик < Дни.Количество() Цикл        
        Сообщить(Дни[Счетчик]); // Понедельник Вторник Среда
        Счетчик = Счетчик + 1;     
    КонецЦикла;     
 
    /// Как организовать обратный цикл в 1с 8.3, 8.2     
 
    Счетчик = Дни.Количество() - 1;     
    Пока Счетчик >= 0 Цикл
        Сообщить(Дни[Счетчик]); // Среда Вторник Понедельник
        Счетчик = Счетчик - 1;
    КонецЦикла;
 
    /// Как прервать цикл в 1с 8.3, 8.2
 
    Для Счетчик = 1 По 5 Цикл
        Если Счетчик > 2 Тогда
            Прервать;
        КонецЕсли;
        Сообщить(Счетчик); // 1 2
    КонецЦикла;
 
    /// Как принудительно продолжить цикл в 1с 8.3, 8.2
 
    Для Счетчик = 1 По 5 Цикл
        Если Счетчик <> 3 Тогда
            Продолжить;
        КонецЕсли;
 
        Сообщить(Счетчик); // 3
    КонецЦикла;   
 
КонецПроцедуры
 
/// Скачать и выполнить эти примеры на компьютере

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

Циклы в языке 1С 8.3, 8.2 (в примерах)

Дата Если Массивы Математика Процедуры Строки Циклы
Диалоги ОписаниеТипов ОперационнаяСистема Приложение Соответствие
СписокЗначений Структура ТаблицаЗначений ФайловаяСистема Формат

ОбщиеОбъекты Запросы ПрикладныеОбъекты УниверсальныеФункции

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

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

Нажмите одну из кнопок, чтобы поделиться:

Циклы в 1С 8.3 на примерах

Цикл в программировании — это любая многократно исполняемая последовательность инструкций, организованная любым способом. Именно так описывается цикл во всех языках программирования. По сути циклы в 1С 8.3 не исключение. Но как всегда, каждый язык программирования имеет свою конструкцию, синтаксис, что выражаясь на обычном языке можно описать как правописание. Перейдем к изучении основных понятий и к примерам.

Цикл «Для…»

Оператор цикла Для предназначен для циклического повторения операторов, в конструкции Цикл – КонецЦикла. Условие выполнения цикла всегда проверяется в начале, перед выполнением цикла.

Для <Переменная> = <Знач1> По <Знач2> Цикл

   // Код

КонецЦикла;

Где:

  • Переменная является счетчиком и при каждом повторении цикла автоматически увеличивается на 1. Иначе говоря, это счетчик цикла.
  • Знач1 число, которое задает начальное значение счетчику цикла.
  • Знач2 число, которое задает максимальное значение счетчику цикла. Если значение счетчика цикла становится больше чем Знач2 цикл прекращается.

Пример 1 — Простой обход циклом с счетчиком

Для Сч = 1 По 10 Цикл

Сообщить(Сч); // Ответ - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

КонецЦикла;

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

Пример 2 — Обход с увеличением

Но, при решении конкретных задач, автоматическое увеличение значения счетчика цикла на единицу не всегда уместно. Так что же делать, ведь это же автоматическая функция?! Но всегда есть выход.

Рассмотрим конкретный пример в котором попробуем счетчику цикла задать шаг ровной к 5-и:

Для Сч = 0 По 50 Цикл

Сообщить(Сч); // Ответ - 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50

Сч = Сч + 5 - 1;

КонецЦикла;

Пример 3 — С выходом из цикла «Прервать» (проверка на вечный цикл)

Приведем пример, где Сч, Счетчик, Сдвиг, Шаг, КоличествоСообщений являются переменными. Во избежание вхождения программы в вечный цикл, проводиться проверка и при необходимости цикл прерывается:

КолСообщений = 0;

Для Сч = Счетчик По Сдвиг Цикл

Сообщить(Сч);

КолСообщений = КолСообщений + 1;

Если КолСообщений  >  КоличествоСообщений Тогда

Сообщить ("Количество сообщений больше заданного значения. Цикл прерван!");

Прервать;

КонецЕсли;

Сч = Сч + Шаг - 1;

КонецЦикла;

*Данный пример мы привели во внешней обработке.

Цикл «Для Каждого…»

Оператор цикла Для Каждого предназначен для циклического обхода коллекций значений. При каждой итерации цикла возвращается новый элемент коллекции. Обход осуществляется до тех пор, пока не будут перебраны все элементы коллекции.

Для Каждого <Переменная> Из < КоллекцияЗначений> Цикл

// Код

КонецЦикла;
  • Переменная: при каждом входе в цикл переменной присваивается значение очередного элемента коллекции.
  • КоллекцияЗначений: коллекция значений, элементы которой будут присваиваются переменной Переменная.

Пример 1 — Простой обход таблицы значения

Создадим таблицу значений. Как мы помним, делается это на сервере.

Таб = Новый ТаблицаЗначений;

Таб.Колонки.Добавить("Автомобиль");

Таб.Колонки.Добавить("Класс");

Таб.Колонки.Добавить("Вес");


Стр = Таб.Добавить();

Стр.Автомобиль = "KIA";

Стр.Класс = "A Класс";

Стр.Вес = 1100;


Стр = Таб.Добавить();

Стр.Автомобиль = "Ford";

Стр.Класс = "B Класс";

Стр.Вес = 1300;


Стр = Таб.Добавить();

Стр.Автомобиль = "BMW";

Стр.Класс = "C Класс";

Стр.Вес = 1400;

Получите 267 видеоуроков по 1С бесплатно:

И так, мы создали таблицу значений. Вскроем таблицу, для лучшего понимания.

Индекс Значение элемента Тип элемента Автомобиль Класс Вес
0 СтрокаТаблицыЗначений СтрокаТаблицыЗначений «KIA» «A Класс» 1 100
1 СтрокаТаблицыЗначений СтрокаТаблицыЗначений «Ford» «B Класс» 1 300
2 СтрокаТаблицыЗначений СтрокаТаблицыЗначений «BMW» «C Класс» 1 400

Теперь реализуем обход по коллекции с помощью цикла Для Каждого.

Для Каждого Ст Из Таб Цикл

Сообщить("Автомобиль " + Ст.Автомобиль + " " + Ст.Класс + "а имеет вес " + Ст.Вес +" кг.");

КонецЦикла;

// Ответ 1 - Автомобиль KIA A Класса имеет вес 1 100 кг.

// Ответ 2 - Автомобиль Ford B Класса имеет вес 1 300 кг.

// Ответ 3 - Автомобиль BMW C Класса имеет вес 1 400 кг.

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

*Данный пример мы привели во внешней обработке.

Пример 2 — Обход массива

Создадим еще одну коллекцию. Массив, в отличии от таблиц значений, можно создать на клиенте тоже.

МоиПодруги = Новый Массив;

МоиПодруги.Добавить("Арина");

МоиПодруги.Добавить("Марина");

МоиПодруги.Добавить("Карина");

Взглянем на коллекцию:

Индекс Значение элемента Тип элемента
0 «Арина» Строка
1 «Марина» Строка
2 «Карина» Строка

А теперь реализуем обход по коллекции, с помощью цикла Для Каждого:

Для Каждого Имя Из МоиПодруги Цикл

Сообщить(Имя);

КонецЦикла;

// Ответ 1 - Арина

// Ответ 2 - Марина

// Ответ 3 – Карина

Пример 3 — Оператор «Продолжить»

Еще один пример, где применим оператор Продолжить:

МоиЛюбимыеЦифры = Новый Массив;

МоиЛюбимыеЦифры.Добавить(3);

МоиЛюбимыеЦифры.Добавить(7);

МоиЛюбимыеЦифры.Добавить(8);

МоиЛюбимыеЦифры.Добавить(9);
Индекс Значение элемента Тип элемента
0 3 Число
1 7 Число
2 8 Число
3 9 Число
Для Каждого Ст Из МоиЛюбимыеЦифры Цикл

Если   Ст <> 8 Тогда

Продолжить;

Иначе

Сообщить("Я люблю цифру " +  Ст + "!")

КонецЕсли;

КонецЦикла;

// Ответ - Я люблю цифру 8!

Цикл «Пока…»

Оператор цикла Пока предназначен для циклического повторения операторов, находящиеся внутри конструкции Цикл – КонецЦикла. Цикл выполняется, пока логическое выражение равно Истина. Условие выполнения цикла всегда проверяется вначале, перед выполнением цикла. (Описание: синтакс-помощник)

Пока <Выражение> Цикл

// Код

КонецЦикла;

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

Пример 1 — Обход массива с счетчиком

МоиЛюбимыеКонфеты = Новый Массив ();

МоиЛюбимыеКонфеты.Добавить("Снегурочка N1");

МоиЛюбимыеКонфеты.Добавить("Баядерка N2");

МоиЛюбимыеКонфеты.Добавить("Синяя птица N3");

МоиЛюбимыеКонфеты.Добавить("Красная Шапочка N4");

Взглянем на коллекцию.

Индекс Значение элемента Тип элемента
0 «Снегурочка N1» Строка
1 «Баядерка N2» Строка
2 «Синяя птица N3» Строка
3 «Красная Шапочка N4» Строка
Сч = 0;

Пока Сч <  МоиЛюбимыеКонфеты.Количество() Цикл

Сообщить(МоиЛюбимыеКонфеты[Сч]);

Сч = Сч + 1;

КонецЦикла;

//Ответ 1 – Снегурочка N1

//Ответ 2 – Баядерка N2

//Ответ 3 - Синяя птица N3

//Ответ 4 - Красная Шапочка N4

Как мы знаем, индексы строк в коллекции начинаются с 0-я. Это прекрасно видно на развернутом виде коллекции.

  • МоиЛюбимыеКонфеты.Количество() определяет количество срок в коллекции, что в данном случае рано 4-ом.
  • МоиЛюбимыеКонфеты[Сч] определяет элемент коллекции по индексу, где Сч играет роль индекса, и при каждом входе в цикл прибавляется на единицу. Тем самим, мы с каждым разом обращаемся к следующей строке коллекции, начиная со строки с индексом 0. И цикл будет продолжаться, пока значение логического выражение Сч <  МоиЛюбимыеКонфеты.Количество() не станет ровному Ложь.

*Данный пример мы привели во внешней обработке.

Пример 2 — Обратный цикл с счетчиком

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

Обратимся к тому же массиву, но напишем код обратного цикла.

МоиЛюбимыеКонфеты = Новый Массив();

МоиЛюбимыеКонфеты.Добавить("Снегурочка N1");

МоиЛюбимыеКонфеты.Добавить("Баядерка N2");

МоиЛюбимыеКонфеты.Добавить("Синяя птица N3");

МоиЛюбимыеКонфеты.Добавить("Красная Шапочка N4");


Сч = МоиЛюбимыеКонфеты.Количество() - 1;

Пока Сч >= 0 Цикл

Сообщить(МоиЛюбимыеКонфеты[Сч]); // Среда Вторник Понедельник

Сч = Сч - 1;

КонецЦикла;

//Ответ 4 - Красная Шапочка N4

//Ответ 3 - Синяя птица N3

//Ответ 2 – Баядерка N2

//Ответ 1 – Снегурочка N1

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

*Данный пример мы привели во внешней обработке.

«Прервать» и «Продолжить» в циклах 1С 8.3

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

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

Видео Школы 1С по теме циклов

К сожалению, мы физически не можем проконсультировать бесплатно всех желающих, но наша команда будет рада оказать услуги по внедрению и обслуживанию 1С. Более подробно о наших услугах можно узнать на странице Услуги 1С или просто позвоните по телефону +7 (499) 350 29 00. Мы работаем в Москве и области.

Циклы в 1С 8.3 | 1s-up.ru

В платформе 1С 8.3 существует три вида циклов. Это циклы «Для Цикл», «Для каждого Цикл» и «Пока Цикл». При помощи циклов «Для Цикл» и «Пока Цикл» можно осуществлять цикличное повторение произвольных операторов. А цикл «Для каждого Цикл» необходим для обхода коллекций значений (массивов, таблиц значений и т.п.). В этой статье на разберем простые примеры всех трёх видов циклов.

Цикл «Для Цикл»

Разберем самый простой вид цикла. Этот цикл имеет следующий синтаксис.

Для НазваниеПерем = СчетчНачало по СчетчКонец Цикл

    <Операторы>

КонецЦикла;


В этом цикле, переменной НазваниеПерем в самом начале присваивается выражение СчетчНачало, которое имеет числовое значение (целое число). Потом, в каждой итерации цикла переменная   НазваниеПерем увеличивается на 1. Цикл будет выполняться пока переменная  НазваниеПерем  меньше или равно переменной СчетчКонец.

СчетчНачало и СчетчКонец могут быть как числами, так и переменными с типом число.

Для н = 1 по 100 Цикл
    <Операторы>
КонецЦикла;


Или

Нач = 1;
Кон = 100;
Для н = Нач по Кон Цикл
    <Операторы>
КонецЦикла;


Причем СчетчНачало может быть меньше нуля.

Для н = -100 по 100 Цикл
    <Операторы>
КонецЦикла;


Чтобы цикл корректно работал СчетчНачало должно быть меньше СчетчКонец.

Такой код будет не корректен!!

Для н = 100 по  -100 Цикл
    <Операторы>
КонецЦикла;


С этим циклом удобно работать, когда нам нужно линейно заполнить какие-нибудь величины. Например, заполним массив в 1С цифрами от -3 до 3.

массивЦифр = Новый Массив;
Для н = -3 до 3 Цикл
    массивЦифр.Добавить(н);
КонецЦикла;


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

Для н = 0 по массивЦифр.ВГраница() Цикл
    ЭлементМассива = массивЦифр[н];
КонецЦикла;


Цикл «Пока Цикл»

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

Данный цикл имеет следующий синтаксис

Пока ЗначениеВыражения Цикл
     <Операторы>;
КонецЦикла;


ЗначениеВыражения – какое-то логическое выражение. Пока это выражение истинно, то операторы цикла будут выполняться.  Если выражение принимает значение Ложь,  то цикл прекращается.

При помощи данного цикла можно делать различные нестандартные обходы. Например, выше мы заполнили массив цифрами начиная от -3 до 3, но циклом «Для Цикл» мы не можем заполнить массив цифрами от 3 до -3.  Но, мы можем это сделать  при помощи цикла «Пока Цикл»

Массив = Новый Массив;
НачЗначение = 3;
КонЗначение = - 3;
ТекЗнач = НачЗначение;
Пока ТекЗнач >= КонЗначение Цикл
    Массив.Добавить(ТекЗнач);
    ТекЗнач = ТекЗнач - 1;
КонецЦикла;


Этот цикл можно также использовать, когда нужно что-то заполнить датами.

Массив = Новый Массив;
НачЗначение = '20100101';
КонЗначение = '20100131';
ТекЗнач = НачЗначение;
Пока ТекЗнач <= КонЗначение Цикл
    Массив.Добавить(ТекЗнач);
    ТекЗнач = ТекЗнач + 24*3600;
КонецЦикла;


В этом коде мы заполняем массив датами, начиная с 1 января и заканчивая 31 января.

Цикл «Для каждого Цикл»

Этот вид цикла предназначен для обхода различных коллекций, например, массивов, таблиц значений, табличных частей и т.д.

Этот цикл имеет следующий синтаксис:

Для Каждого ЭлементКоллеции из КакаяТоКоллекция цикл
    <Операторы>
КонецЦикла


Переменной ЭлементКоллекции присваивает очередное значение элемента коллекции.

Например, если мы напишем вот такой код.

Массив1 = Новый Массив;
Массив1.Добавить(100);
Массив1.Добавить(45);
Массив1.Добавить(1000);

Для Каждого элМассива из Массив1 Цикл

КонецЦикла;



То при первом обходе переменная ЭлМассива будет равна 100, при втором — 45, а при третьем – 1000.

Это массив, у него, по сути, каждый элемент это значение какого-то типа, а если будет обход более сложной коллекции?  Например, таблицы значений. В том случае, если будет обход таблицы, значений, то в переменной ЭлементКоллекции будет содержать очередная строка этой таблицы значений. Мы можем получить значение колонок в этой строке через оператор «.».

Пример в этом коде

ТЗ = Новый ТаблицаЗначений;
ТЗ.Колонки.Добавить("НазваниеУслуги");
ТЗ.Колонки.Добавить("Сумма");

СтрокаТЗ = ТЗ.Добавить();
СтрокаТЗ.НазваниеУслуги = "За ремонт";
СтрокаТЗ.Сумма    = 100;

СтрокаТЗ = ТЗ.Добавить();
СтрокаТЗ.НазваниеУслуги = "Транспортные";
СтрокаТЗ.Сумма    = 1000;

Для Каждого стрТЗ из ТЗ Цикл
    Сообщить("------------");
    Сообщить("Название услуги: " + стрТЗ.НазваниеУслуги);
    Сообщить("Сумма: " + стрТЗ.Сумма);
КонецЦикла


И результат работы этого кода

Обход циклом Для каждого цикл

 

Прервать цикл 1С

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

 Для НазваниеПерем = СчетчНачало по СчетчКонец Цикл

    <Операторы>
    Прервать;
   <Операторы>

КонецЦикла;


КонецЦикла;

После выполнения этого оператора Прервать все последующие операторы в  теле цикла не выполняются, и следующим выполняется оператор после ключевого слова КонецЦикла.

Рассмотрим следующий пример.

Для Счетчик = - 5 по 5 Цикл

    Если Счетчик = 0 Тогда
        Прервать;
    КонецЕсли;

    Х = 1/Счетчик;

КонецЦикла;



В этом примере мы обходим  простым  циклом ряд чисел от -5 до 5, и делим  1 на обходимое число. Если же переменная счетчика равна 0, то чтобы не происходила исключительная ситуация, то выходим из цикла. Т.е. мы выполним деление только для отрицательных чисел.

Продолжить цикл 1С

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

Для НазваниеПерем = СчетчНачало по СчетчКонец Цикл

    <Операторы>
    Продолжить;
   <Операторы>

КонецЦикла;



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

Рассмотрим такой пример.

Для Счетчик = - 5 по 5 Цикл

    Если Счетчик = 0 Тогда
        Продолжить;
    КонецЕсли;

    Х = 1/Счетчик;

КонецЦикла;


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

Более подробно и основательно начальные вопросы программирования в 1С есть в моей книге:

Книга «Программировать в 1С за 11 шагов»

Изучайте программирование в 1С в месте с моей книги «Программировать в 1С за 11 шагов»

  1. Книга написана понятным и простым языком — для новичка.
  2. Книга посылается на электронную почту в формате PDF. Можно открыть на любом устройстве!
  3. Научитесь понимать архитектуру 1С;
  4. Станете писать код на языке 1С;
  5. Освоите основные приемы программирования;
  6. Закрепите полученные знания при помощи задачника;

О том как разрабатывать под управляемым приложением 1С, читайте в книге Книга «Основы разработки в 1С: Такси»

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

  1. Очень доступный и понятный язык изложения
  2. Книга посылается на электронную почту в формате PDF. Можно открыть на любом устройстве!
  3. Поймете идеологию управляемого приложения 1С
  4. Узнаете, как разрабатывать управляемое приложение;
  5. Научитесь разрабатывать управляемые формы 1С;
  6. Сможете работать с основными и нужными элементами управляемых форм
  7. Программирование под управляемым приложением станет понятным

Промо-код на скидку в 15% — 48PVXHeYu

Вступайте в мои группы:

Вконтакте: https://vk.com/1c_prosto
Фейсбуке: https://www.facebook.com/groups/922972144448119/
ОК: http://ok.ru/group/52970839015518
Твиттер: https://twitter.com/signum2009

циклы в 1С часть 2

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

Войдите на сайт как ученик

Войдите как ученик, чтобы получить доступ к материалам школы

Внутренний язык программирования 1С 8.3 для начинающих программистов: циклы в 1С часть 2

Автор уроков и преподаватель школы: Владимир Милькин

На прошлом занятии мы изучили первый из двух существующих в языке 1С циклов: Цикл Для.

Сегодня нас ждет второй вид цикла: Цикл Пока.

Цикл Пока

Конструкция цикла выглядит так:

Пока ЛогическоеВыражение Цикл
  Команда1();
  Команда2();
  ...
КонецЦикла;

Команды, заключенные между словами Цикл и КонецЦикла выполняются пока ЛогическоеВыражение равно Истине.

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

Решение задачи вывода чисел от 1 до 10, с применением только что изученного цикла, будет выглядеть так:

Шаг = 1;
Пока Шаг <= 10 Цикл
    Сообщить(Шаг);
    Шаг = Шаг + 1;
КонецЦикла;

Компьютер встретив такую конструкцию выполняет её так:

Порядок выполнения цикла компьютером

  • Первой командой компьютер сопоставит имени Шаг значение равное 1.
  • Так как имя Шаг на данном этапе равно единице - условие цикла верно (Шаг <= 10) - компьютер выводит единицу и увеличивает имя Шаг до 2.
  • Имя Шаг равно 2, но условие цикла по-прежнему верно, поэтому компьютер выводит 2 и увеличивает имя Шаг до 3.
  • ...
  • Имя Шаг равно 10, условие цикла всё ещё верно - компьютер выводит 10 и увеличивает имя Шаг до 11.
  • Стоп! Условие цикла перестало выполняться, теперь Шаг (вернее его значение 11) больше 10. Команды цикла больше не выполняются.

Задание №23. Измените приведенный выше пример, чтобы выводились числа от 10 до 100.

Не торопитесь смотреть ответ! Сначала попробуйте выполнить задание сами.

Ответ

Шаг = 10;
Пока Шаг <= 100 Цикл
    Сообщить(Шаг);
    Шаг = Шаг + 1;
КонецЦикла;

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

А как вы думаете сколько раз выполнятся следующие циклы:

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

А вот следующие примеры можно смело пробовать на компьютере:

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

Задание №24. Напишите программу, которая выводит на экран числа от 10 до 1, используя Цикл Пока. Вы читаете ознакомительную версию урока, полноценные уроки находятся здесь. Программа должна занимать ровно пять строк.

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

комбинирование простых конструкций в 1С

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

Войдите на сайт как ученик

Войдите как ученик, чтобы получить доступ к материалам школы

Внутренний язык программирования 1С 8.3 для начинающих программистов: комбинирование простых конструкций в 1С

Автор уроков и преподаватель школы: Владимир Милькин

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

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

Комбинирование простых конструкций языка 1С

К примеру, пусть у нас есть два цикла:

Для Шаг1 = 1 По 2 Цикл
    Сообщить(Шаг1);	
КонецЦикла;
 
Для Шаг2 = 1 По 3 Цикл
    Сообщить(Шаг2);
КонецЦикла;

Эти циклы хорошо нам знакомы и мы понимаем, что в результате первого цикла выведутся числа от 1 до 2, а в результате второго - от 1 до 3.

А что если мы вложим выполнение одного цикла внутрь другого? Вот так:

Для Шаг1 = 1 По 2 Цикл
 
    Для Шаг2 = 1 По 3 Цикл
 
        Сообщить("Значения равны: " + Шаг1 + " " + Шаг2);
 
    КонецЦикла;
 
КонецЦикла;

Если запустить этот пример на компьютере, то получатся следующие результаты:

Значения равны: 1 1
Значения равны: 1 2
Значения равны: 1 3
Значения равны: 2 1
Значения равны: 2 2
Значения равны: 2 3

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

У нас есть внешний цикл от 1 до 2. Это значит, что всё, что находится у него между словами Цикл и КонецЦикла выполнится 2 раза. А у него между этими словами находится другой цикл от 1 до 3, который внутри себя содержит команду Сообщить.

Итого такая вложенность приводит к тому, что команда Сообщить выполняется целых 6 раз. Шесть, потому что 2 * 3 = 6.

Теперь обратите внимание, как меняется значение Шаг1 и Шаг2. Вы читаете ознакомительную версию урока, полноценные уроки находятся здесь. В начале Шаг1 равен 1, а Шаг2 меняется от 1 до 3. Затем Шаг1 уже равен 2 (следующее значение цикла) и снова Шаг2 меняется от 1 до 3.

Задание №27. По аналогии с предыдущим примером напишите тройной вложенный цикл с выводом Шаг1, Шаг2 и Шаг3 соответственно от 1 до 10, от 10 до 20 и от 20 до 30. Выполните задание на компьютере, посмотрите результат и убедитесь, что понимаете почему получаются такие результаты.

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

Войдите на сайт как ученик


Авторизуйтесь, чтобы получить доступ ко всем материалам школы

Задание №28. Найдите все пары целых (в том числе одинаковых) чисел величиной от 1 до 9 каждое, сумма которых равна 10. Сделайте это на листочке. Без помощи компьютера. Должно получится 9 вариантов.  Первые два варианта я подскажу: 1 + 9 = 10 и 9 + 1 = 10. Оставшиеся 7 вариантов найдите сами.

Выполнили? Отлично. А теперь я покажу, как можно было заставить компьютер выполнить ту же самую работу за вас.

Для Шаг1 = 1 По 9 Цикл
 
    Для Шаг2 = 1 По 9 Цикл
 
        Если Шаг1 + Шаг2 = 10 Тогда
 
            Сообщить(" " + Шаг1 + " + " + Шаг2 + " = 10");
 
        КонецЕсли;
 
    КонецЦикла;
 
КонецЦикла;

Мы перебираем одно число в цикле от 1 до 9 (Шаг1). И второе число в другом цикле от 1 до 9 (Шаг2). Вы читаете ознакомительную версию урока, полноценные уроки находятся здесь. А так как числа для складывания нам нужны одновременно - мы делаем второй цикл вложенным в первый. Осталось воспользоваться условной конструкцией, чтобы отобрать только такие числа, сумма которых равна 10.

Пройдите тест

Вопросы задаются по следующему примеру:

Для Шаг1 = 1 По 3 Цикл
    Для Шаг2 = 4 По 5 Цикл
        Сообщить(" " + Шаг1 + " " + Шаг2);
    КонецЦикла;
КонецЦикла;

 Напишите программу, которая найдет все варианты двух чисел от 1 до 30, произведение которых равно 30.

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

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

Циклы в 1С

Алгоритмы многих программ зачастую предполагают циклическое повторение определённых действий. 1С в этом случае не является исключением. Циклы в 1С позволяют:

  • Перебрать элементы справочника;
  • Заполнить области макета;
  • Выполнить определенные действия с выборкой документов;
  • И многое многое другое.

Типы циклов

В 1С принято различать три типа циклов в зависимости от набора слов, входящих в конструкцию:

  1. Для каждого «Переменная» из «Коллекция значений»;
  2. Для «Переменная» = «Нач. значение» По «Кон. Значение»;
  3. Пока «Выражение».

Рассмотрим их подробнее.

Для каждого из

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

  • Переменная, определяющая текущий элемент коллекции;
  • Определение коллекции значений.

Наиболее часто возникающая ошибка в этом случае показана на рис.1

Рис.1

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

Для  по

В качестве параметров, передаваемых в строку, в этом случае выступают:

  1. Имя переменной – итератора;
  2. Начальное значение переменной;
  3. Конечное значение переменной.

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

Такая конструкция очень часто используется при обходе табличных частей.

При использовании данного обходчика важно различать количество строк табличной части и индекс отдельной взятой строки. В первом случае начальное значение будет равно 1, конечное можно получить с помощью оператора Количество(). Индексы начинаются с 0 и заканчиваются Количество()-1. В противном случае можно получить ошибку (Рис.2).

Рис.2

Пока

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

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

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

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

Прерывание выполнения нажатием комбинации клавиш

Если в теле цикла прописать процедуру ОбработкаПрерыванияПользователя(), то в любой момент его выполнения, нажав комбинацию клавиш Ctrl+PauseBreakможно остановить его работу. В этом случае в окне сообщений будет выведена строка (Рис.3).

Рис.3

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

Прерывание по условию

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

Правильно записанный в код программы этот оператор выделяется красным цветом.

Перескакивание некоторых операций цикла

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

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

Оператор «Продолжить» в теле кода выделяется красным цветом и переносит выполнение цикла в его начало.


Внутренний язык программирования 1С 8.3 для начинающих программистов: массивы в 1С

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

Войдите на сайт как ученик

Войдите как ученик, чтобы получить доступ к материалам школы

Внутренний язык программирования 1С 8.3 для начинающих программистов: массивы в 1С

Автор уроков и преподаватель школы: Владимир Милькин

Сегодня мы познакомимся с новым типом данных языка 1С, который называется Массив.

Массивы в языке 1С

Что такое массивы и зачем они вообще нужны программисту?

Давайте представим, что у нас есть 4 разных числа. Вы читаете ознакомительную версию урока, полноценные уроки находятся здесь. К примеру: 25, 84, 31 и 96. Если бы мы захотели использовать их в своей программе, то нужно было бы дать имя каждому из чисел. А что если хранить их все вместе, под одним общим именем, к примеру, СлучайныеЧисла. И обращаться к ним как СлучайныеЧисла0СлучайныеЧисла1, СлучайныеЧисла2 и так далее.

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

Ещё полезно представлять себе массив как шкаф, у которого множество нумерованных ящиков (начиная с нуля). Шкаф - это массив, а ящики - это номера. Содержимое ящиков - элементы массива. Доступ к содержимому конкретного ящика осуществляется по имени шкафа и номеру ящика.

В языке 1С это будет выглядеть так:

СлучайныеЧисла = Новый Массив(4); // завели массив для хранения 4 чисел
СлучайныеЧисла[0] = 25; // поместили в ящик №0 первое число 
СлучайныеЧисла[1] = 84; // поместили в ящик №1 второе число 
СлучайныеЧисла[2] = 31; // и так далее
СлучайныеЧисла[3] = 96;

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

В массивах можно хранить значения разных типов, а не только числа:

РазличныеЗначения = Новый Массив(3); // массив для хранения 3 значений
РазличныеЗначения[0] = 100; // поместили в ящик №0 число 
РазличныеЗначения[1] = "Солнечный день."; // поместили в ящик №1 строку
РазличныеЗначения[2] = '19991231'; // поместили в ящик №2 дату

В ящики массива  значения можно не только класть, но и доставать:

Сообщить(РазличныеЗначения[0]); // выведем содержимое ящика №0
Сообщить(РазличныеЗначения[1]); // выведем содержимое ящика №1
Сообщить(РазличныеЗначения[2]); // выведем содержимое ящика №2

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

Для Шаг = 0 По 2 Цикл // делаем цикл от 0 до 2
    Сообщить(РазличныеЗначения[Шаг]); //обращаемся к ящику массива по номеру
КонецЦикла;

Задание №30. Необходимо ввести от пользователя 5 чисел, найти их сумму и вывести результат.

Давайте решим эту задачу двумя способами.

Сначала без использования массива:

Число1 = 0;
Число2 = 0;
Число3 = 0;
Число4 = 0;
Число5 = 0;
ВвестиЧисло(Число1);
ВвестиЧисло(Число2);
ВвестиЧисло(Число3);
ВвестиЧисло(Число4);
ВвестиЧисло(Число5);
СуммаЧисел = Число1 + Число2 + Число3 + Число4 + Число5;
ОткрытьЗначение("Сумма чисел равна " + СуммаЧисел);

А теперь с использованием массива:

Числа = Новый Массив(5); // объявили массив с 5 ящиками
Для Шаг = 0 По 4 Цикл
    ВвестиЧисло(Числа[Шаг]); // в каждый ящик вводим число
КонецЦикла;
СуммаЧисел = 0; // в этом имени будем накапливать сумму чисел
Для Шаг = 0 По 4 Цикл // пробегаемся циклом от 0 до 4
    СуммаЧисел = СуммаЧисел + Числа[Шаг]; // суммируем числа из массива
КонецЦикла;
ОткрытьЗначение("Сумма чисел равна " + СуммаЧисел);

Вроде бы сэкономили всего три строки. А если бы нужно было ввести не 5, а 100 чисел?

Задание №31. Переделайте приведенный выше пример, чтобы вводилось 10 чисел и находилось произведение.

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

Войдите на сайт как ученик


Авторизуйтесь, чтобы получить доступ ко всем материалам школы

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

Задание №32. Необходимо ввести от пользователя 5 чисел, найти наименьшее из них и вывести его.

Решение будет таким:

МассивЧисел = Новый Массив(5); // объявим массив на 5 ящиков
 
Для Шаг = 0 По 4 Цикл // пробежимся от 0 до 4
    ВвестиЧисло(МассивЧисел[Шаг]); // в каждый ящик положим число
КонецЦикла;
 
// изначально будем считать, что первый элемент самый маленький
НаименьшееЧисло = МассивЧисел[0]; 
 
// пробегаемся по всем значениям массива
// кроме нулевого, ведь нулевой элемент
// изначально принят нами за наименьший
Для Шаг = 1 По 4 Цикл
    // если в массиве есть число меньшее, чем НаименьшееЧисло
    Если МассивЧисел[Шаг] < НаименьшееЧисло Тогда 
        // тогда его и делаем новым наименьшим числом
        НаименьшееЧисло = МассивЧисел[Шаг];
    КонецЕсли;
КонецЦикла;
 
ОткрытьЗначение("Наименьшее из введенных чисел равно " + НаименьшееЧисло);

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

Идём далее. Обратите внимание на то, что во всех примерах выше мы создаём массив сразу с нужным количеством ящиков. Например:

МассивНа5Ящиков = Новый Массив(5);

Это означает, что у этого массива есть ящики под номерами 0, 1, 2, 3, 4.

А, что если мы бы захотели объявить пустой массив? Это делается вот так:

ДругойМассив = Новый Массив; // мы не указали никакого числа в скобках

Если мы сразу после объявления пустого массива попытаемся обратиться к одному из его ящиков, то получим ошибку:

Сообщить(ДругойМассив[0]); // ОШИБКА!!! Массив пока не содержит ящиков!

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

ДругойМассив.Добавить(123); // первый ящик
ДругойМассив.Добавить(456); // второй ящик
ДругойМассив.Добавить(789); // третий ящик

И вот теперь мы можем обращаться к этим ящикам по их номерам (помните, что в 1С массивы нумеруются с нуля):

Сообщить(ДругойМассив[0]); // выведет 123
Сообщить(ДругойМассив[1]); // выведет 456
Сообщить(ДругойМассив[2]); // выведет 789

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

Сообщить(ДругойМассив.Количество()); // выведет 3

Пройдите тест

Задание №33. Необходимо ввести от пользователя 7 чисел, найти наибольшее из них и вывести его. Задание решается по аналогии с предыдущим. Это первая по-настоящему серьезная задача, которую вам предстоит решить. Не жалейте времени и усилий, чтобы справиться самостоятельно.

Отправить ответ

avatar
  Подписаться  
Уведомление о