Меню
Главная
Авторизация/Регистрация
 
Главная arrow Информатика arrow Основы языка программирования 1С 8.3

ЮНИТ 9. ЦИКЛ "ПОКА" В ЯЗЫКЕ 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;

КонецЦикла;

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

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

Пока Истина Цикл Сообщить("Привет!");

КонецЦикла;

Пока 1 = 1 Цикл Сообщить("Привет!");

КонецЦикла;

Пока "Мир" = "Мир" Цикл Сообщить("Привет!");

КонецЦикла;

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

А вот следующие примеры циклов:

Пока Ложь Цикл Сообщить("Прощай!");

КонецЦикла;

Пока 1 = 2 Цикл Сообщить("Прощай!");

КонецЦикла;

Пока "Мир" = "Земля" Цикл Сообщить("Прощай!");

КонецЦикла;

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

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

Решение

Шаг = 10;

Пока Шаг >= 1 Цикл Сообщить(Шаг);

Шаг = Шаг - 1;

КонецЦикла;

Задание №25. Напишите вывод таблицы умножения для числа 7, используя Цикл Пока.

Решение

Шаг = 1;

Пока Шаг <= 10 Цикл Сообщить("7 *" + Шаг + " = " + 7 * Шаг);

Шаг = Шаг + 1;

КонецЦикла;

Задание №26. Перепишите предыдущее задание так, чтобы вывод таблицы умножения происходил в обратном порядке. То есть сначала 7 * 10, потом 7 * 9 и так далее.

Решение

Шаг = 10;

Пока Шаг >= 1 Цикл Сообщить("7 * " + Шаг + " = " + 7 * Шаг);

Шаг = Шаг - 1;

КонецЦикла;

ЮНИТ 10. КОМБИНИРОВАНИЕ ПРОСТЫХ КОНСТРУКЦИЙ В ЯЗЫКЕ 1С

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

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

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

Для Шагі = 1 По 2 Цикл Сообщить(ШагІ);

КонецЦикла;

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

КонецЦикла;

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

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

Для Шагі = 1 По 2 Цикл Для Шаг2 = 1 По 3 Цикл

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

КонецЦикла;

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

Сообщения:

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

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

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

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

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

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

Решение

Для Шаг1 = 1 По 10 Цикл Для Шаг2 = 10 По 20 Цикл Для ШагЗ = 20 По 30 Цикл

Сообщить("Значения равны:" + Шаг1 + "" + Шаг2 + "" +

ШагЗ);

КонецЦикла;

КонецЦикла;

КонецЦикла;

Задание №28. Найдите все пары целых (в том числе одинаковых) чисел величиной от 1 до 9 каждое, сумма которых равна 10.

Решение

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

КонецЦикла;

КонецЦикла;

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

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

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

Ответ

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

КонецЦикла;

КонецЦикла;

ЮНИТ 11. МАССИВЫ В ЯЗЫКЕ 1С

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

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

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

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

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

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

СлучайныеЧисла = Новый Массив(4); // завели массив для

//хранения 4 чисел

СлучайныеЧисла[0] = 25; // поместили в ящик №0 первое

// число

СлучайныеЧисла[1] = 84; // поместили в ящик №1 второе

//число

СлучайныеЧисла[2] = 31; // и так далее

СлучайныеЧисла[3] = 96;

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

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

РазличныеЗначения = Новый Массив(З); // массив для

//хранения 3 значений

Различные3начения[0] = 100; // поместили в ящик №0

// число

РазличныеЗначения[1] = "Солнечный день."; // поместили

//в ящик № 1 строку

РазличныеЗначения[2] = '1999123Г; //поместили в ящик

// №2 дату

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

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

// мое ящика №0

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

// мое ящика №1

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

// мое ящика №2

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

Для Шаг = 0 По 2 Цикл // делаем цикл от 0 до 2

Сообгцить(РазличныеЗначения[Шаг]); //обращаемся

// к ящику массива по номеру

КонецЦикла;

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

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

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

Число 1 = 0;

Число2 = 0;

ЧислоЗ = 0;

Число4 = 0;

Число5 = 0;

ВвестиЧисло(Число1);

ВвестиЧисло(Число2);

ВвестиЧисло(ЧислоЗ);

ВвестиЧисло(Число4);

ВвестиЧисло(Число5);

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

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

Числа = Новый Массив(5);// объявили массив с 5 ящиками Для Шаг = 0 По 4 Цикл

ВвестиЧисло(Числа[Шаг]); //в каждый ящик вводим число КонецЦикла

СуммаЧисел = 0; //в этом имени будем накапливать

// сумму чисел

Для Шаг = 0 По 4 Цикл // пробегаемся циклом от 0 до 4 СуммаЧисел=СуммаЧисел+Числа[Шаг];//суммируем числа

// из массива

КонецЦикла;

ОткрытьЗначение("Сумма чисел равна " + СуммаЧисел);

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

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

Решение

Числа = Новый Массив(Ю);

Для Шаг = 0 По 9 Цикл ВвестиЧисло(Числа[Шаг]);

КонецЦикла;

ПроизведениеЧисел = 1;

Для Шаг = 0 По 9 Цикл

ПроизведениеЧисел = ПроизведениеЧисел * Числа[Шаг]; КонецЦикла;

ОткрытьЗначение("Произведение чисел равно" + ПроизведениеЧисел);

При помощи массивов можно решать достаточно сложные задачи.

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

Решение

МассивЧисел = Новый Массив(5); // объявим массив на 5

// ящиков

Для Шаг = 0 По 4 Цикл // пробежимся от 0 до 4

ВвестиЧисло(МассивЧисел[Шаг]); // в каждый ящик

// положим число

КонецЦикла;

// изначально будем считать, что первый элемент самый

// маленький

НаименьшееЧисло = МассивЧисел [0];

Для Шаг = 0 По 4 Цикл // пробегаемся по всем значениям

// массива

// если в массиве есть число меньшее, чем НаименьшееЧисло Если МассивЧисел[Шаг] <НаименьшееЧисло Тогда // тогда его и делаем новым наименьшим числом НаименьшееЧисло = МассивЧисел[Шаг];

КонецЕсли;

КонецЦикла;

ОткрытьЗначение("Наименьшее из введенных чисел равно " + НаименьшееЧисло);

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

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

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

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

Если необходимо объявить пустой массив:

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

// числа в скобках

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

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

// не содержит ящиков!

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

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

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

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

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

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

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

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

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

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

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

Решение

// объявим массив на 7 элементов МассивЧисел = Новый Массив(7);

// пробежимся по каждому элементу массива и введем туда // число от пользователя Для Шаг = 0 По 6 Цикл

ВвестиЧисло(МассивЧисел[Шаг]);

КонецЦикла;

// изначально положим, что самым большим является // первое число в массиве НаибольшееЧисло = МассивЧисел [0];

// снова пробежимся по всем числам массива Для Шаг = 0 По 6 Цикл

// если текущее число больше уже известного нам самого // большого числа

Если МассивЧисел[Шаг] > НаибольшееЧисло Тогда // тогда объявим текущее число как самое большое НаибольшееЧисло = МассивЧисел[Шаг];

КонецЕсли;

КонецЦикла;

// выведем пользователю самое большое из всех чисел массива ОткрытьЗначение("Наибольшее из введенных чисел равно " + НаибольшееЧисло);

ЮНИТ 12. СТРУКТУРЫ В ЯЗЫКЕ 1С

Следующий тип данных, с которым нам предстоит познакомиться — это Структура.

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

Можно, конечно, так:

Фамилия = "Пупкин";

Имя = "Василий";

Отчество = "Алибабаевич";

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

Можно поместить все три параметра в массив:

Человек = Новый Массив(З);

Человек[0] = "Пупкин";

Человек! 1] = "Василий";

Человек[2] = "Алибабаевич";

Вроде бы цель достигнута — связали все три параметра с одним объектом. Но работать с таким объектом неудобно, потому что обращаться к значениям массива придется по числовому индексу, то есть, чтобы нам вывести отчество, придется написать:

Сообщить(Человек[2]); // вывод отчества человека

Что, конечно же, очень неудобно! Хотелось бы обращаться к параметрам объекта по их именам. Вот для этого и были придуманы Структуры.

Структура — это составной объект, в который входят элементы любых типов, обращаться к которым можно по имени этих элементов.

С использованием структур предыдущий пример будет выглядеть так:

Человек = Новый Структура("Фамилия, Имя, Отчество");

Человек.Фамилия = "Пупкин";

Человек.Имя = "Василий";

Человек. Отчество = "Алибабаевич";

Сообщить(Человек. Отчество);

По приведенному выше примеру пройдите следующий тест:

Задание 34. Необходимо ввести имена и возраст трех людей. Затем найти, кто из них самый старший и вывести его имя.

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

// объявляем массив с тремя ящиками

Люди = Новый Массив(З);

Для Шаг = 0 По 2 Цикл

// вводим информацию по каждому из трех людей // и сохраняем ее в структуру, которую // кладем в соответствующий ящик массива Люди[Шаг] = Новый Структура("Имя, Возраст"); ВвестиСтроку(Люди[Шаг].Имя); // вводим имя ВвестиЧисло(Люди1 Шаг].Возраст); // вводим возраст

КонецЦикла;

// изначально положим, что самым старшим

// является человек из первой ячейки массива

ИмяСамогоСтаршегоЧеловека = Люди[0].Имя;

Наибольший Возраст = Люди[0]. Возраст;

Для Шаг = 0 По 2 Цикл // пробежимся по всем людям // и сравним их возраста с наибольшим // возрастом на текущий момент

Если Л юди[Шаг]. Возраст > Наибольший Возраст Тогда // нашли человека, который старше предыдущего // сохраним его возраст Наибольший Возраст = Люди[Шаг]. Возраст;

// и имя

ИмяСамогоСтаршегоЧеловека = Люди[Шаг].Имя; КонецЕсли;

КонецЦикла;

ОткрытьЗначение(

"Самый старший человек - " +

ИмяСамогоСтаршегоЧеловека + ". Ему" + НаибольшийВозраст + " лет.");

По аналогии с этим примером решите следующую задачу.

Задание №35. Необходимо ввести имена и вес четырех человек, найти самого легкого из них и вывести его имя.

Решение

// объявляем массив с четырьмя ящиками Люди = Новый Массив(4);

Для Шаг = 0 По 3 Цикл

// вводим информацию по каждому из четырех людей // и сохраняем ее в структуру, которую // кладем в соответствующую ячейку массива Люди[Шаг] = Новый Структура("Имя, Вес"); ВвестиСтроку(Люди[Шаг|.Имя); // вводим имя ВвестиЧисло(Люди[Шаг].Вес); // вводим вес КонецЦикла;

// изначально положим, что самым легким // является человек из первой ячейки массива ИмяСамогоЛегкогоЧеловека = Люди[0].Имя;

НаименьшийВес = Люди[0]. Вес;

Для Шаг = 0 По 3 Цикл // пробежимся по всем людям // и сравним их вес с наименьшим // весом на текущий момент Если Люди[Шаг].Вес < НаименьшийВес Тогда // нашли человека, который легче предыдущего // сохраним его вес

НаименьшийВес = Люди[Шаг].Вес;

// и имя

ИмяСамогоЛегкогоЧеловека = Люди[Шаг].Имя; КонецЕсли;

КонецЦикла;

ОткрытьЗначение(

"Самый легкий человек - " +

ИмяСамогоЛегкогоЧеловека + ". Его вес " +

НаименьшийВес + " кг.");

ЮНИТ 13. ФУНКЦИИ И ПРОЦЕДУРЫ В ЯЗЫКЕ 1С

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

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

Функции

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

А = 0;

ВвестиЧисло(А);

Б = 0;

ВвестиЧисло(Б);

Результат = (А + Б) * (А - Б);

ОткрытьЗначение( Результат);

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

Результат = (А + Б) * (А - Б);

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

Пусть этим именем будет ПроизведениеСуммыИРазности.

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

Результат = ПроизведениеСуммыИРазности;

И все? Нет, конечно! Ведь непонятно, произведение суммы и разности каких именно чисел нужно считать. Гораздо лучше будет передать эти числа нашему имени в качестве параметров, как мы обычно делаем при вызове команды:

Результат = ПроизведениеСуммыИРазности(А, Б);

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

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

Функция ПроизведениеСуммыИРазности(А, Б)

Результат = (А + Б) * (А — Б);

Возврат Результат;

КонецФункции

Что включает в себя определение этой функции?

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

Затем следуют имена параметров, заключенные в круглые скобки. Параметры — это данные, которые мы передадим в нашу функцию при ее вызове. Она с ними что-то сделает и возвратит результат. Каждый параметр имеет свое имя, которое мы также придумываем сами. Это имя можно использовать только внутри функции.

Дальше идет тело. Это команды компьютеру, которые будут выполняться в тот момент, когда мы сделаем вызов нашей функции. Тело заканчивается ключевым словом КонецФункции.

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

Возврат Результат;

Где вместо Результат может быть любое выражение, которое вернется из функции в качестве ее результата.

Мы можем вызывать функцию в программе столько раз, сколько нам потребуется (рис. 18).

На рис. 19 показан пример формирования функции как объекта программы.

Функция Сумма(Число1/ Число2)

Сообщить("Сейчас мы вычислим сумму двух чисел.");

.. _ , „ . Возвращаем результат

Возврат Число1 + Число2; г г -

работы функции

КонецФункции -

Результат = Сумма(10/ 5);

Рис. 19. Пример формирования и вызова функции

как объекта программы.

Процедуры

Процедуры это те же самые функции, но они не возвращают результат и объявляются при помощи других ключевых слов: Процедура и КонецПроцедуры (рис. 20).

Формирование процедуры

Рис. 20. Формирование процедуры

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

Пример формирования и запуска процедуры

Рис. 21. Пример формирования и запуска процедуры,

как объекта программы.

На рис. 22 представлена процедуры Команда 1 и Команда2. Схематически показаны вызов процедуры Команда2ш процедуры Команда 1 и возврат в процедуру Команда 1 после выполнения процедуры Команда2.

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

1. Раскройте список "Общие" в дереве конфигурации.

Ком Фигурами я

Действия » © ^

Конфигурация

О

© о* Общие

Подсистемы Г*Щ Общие модули <г Параметры сеанса ^ Роли

  • • Общие реквизиты (§Э Планы обмена 53 Критерии отбора ^ Подписки на события О Регламентные задания I::: Функциональные опции _Параметры Функциональных опи|
  • 2. Найдите в нем пункт "Общие модули" и нажмите на нем правой кнопкой мыши. Выберите "Добавить".

3. Добавился модуль. В правой части окна конфигуратора задайте его имя и свойства, как показано ниже.

Свойства: Уроки __X

"ІІВДІНІ х *

4. Перейдите в этот модуль. Здесь можно писать наши функции и процедуры. Напишите процедуру с именем Привет, без параметров, после вызова которой компьютер будет просто здороваться с нами.

0 Общий модуль Уроки: Модуль

Е

3 Процедура Привет() Экспорт Сообщить("Привет!");

Сообщить("Я процедура!");

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

Обратите внимание на ключевое слово Экспорт, которое идет следом за круглыми скобками. Его наличие обязательно, так как мы определяем функцию в одном модуле {Уроки), а использовать будем совсем в другом {модуль управляемого приложения).

5. Теперь вернитесь в модуль управляемого приложения.

Конфигурация

Действия ?

& ^ * О О Ш

[+|У

п

7

X

5$ Открыть модуль управляемого приложения

^ I 55 Открыть модуль сеанса

© ( 7?! Ожрыть модуль внешнего соединения

Открыть командный интерфейс конфигурации

© & общ!

6. И сделайте вызов нашей процедуры. Так как она находится в другом модуле, к ее имени добавляется "Уроки.".

7. Запустите 1С и убедитесь, что все работает!

Сообщения:

  • — Привет!
  • — Я процедура!

Примеры функций //ПРИМЕР №1

//*** Расположить этот код в общем модуле Уроки. *** Функция СуммаДвухЧисел(ЧислоА, ЧислоБ) Экспорт // в функцию передаются при вызове два числа // ЧислоА и ЧислоБ

// находим их сумму и возвращаем наружу Возврат ЧислоА + ЧислоБ;

КонепФункции

//*** Расположить этот код в модуле управляемого //приложения. ***

// вызвали функцию СуммаДвухЧисел // передали ей в качестве параметров два числа Сумма = Уроки.СуммаДвухЧисел(2, 5);

// теперь Сумма равна тому, что вернула нам // функция т.е. 2 + 5 = 7 Сообщить(Сумма);

// ПРИМЕР№2

//*** Расположить этот код в общем модуле Уроки. *** Функция ОписаниеЗнакаЧисла(ЛюбоеЧисло) Экспорт // в функцию передается число ЛюбоеЧисло // сравниваем его с нулем и в случае // если число больше или равно нулю // возвращаем наружу одну фразу // иначе другую.

Если ЛюбоеЧисло >= 0 Тогда Возврат "Положительное число.";

Иначе

Возврат "Отрицательное число.";

КонецЕсли;

КонецФункции

//*** Расположить этот код в модуле управляемого //приложения. ***

// вызвали функцию ОписаниеЗнакаЧисла // передали ей в качестве параметра одно число Описание = Уроки.ОписаниеЗнакаЧисла(-З);

// теперь Описание равно строке "Отрицательное число." // эту строку нам вернула функция Сообщить(Описание);

// ПРИМЕР№3

//*** Расположить этот код в общем модуле Уроки. *** Функция ДлинаОкружности(Радиус) Экспорт // в функцию передается число Радиус Пи = 3.14; //объявляем Пи // вычисляем результат по формуле Результат = 2* Пи * Радиус;

// возвращаем этот результат

// наружу в место откуда была вызвана функция

Возврат Результат;

КонецФункции

ц*** Расположить этот код в модуле управляемого //приложения. ***

// вызвали функцию, которая вычисляет длину // окружности по переданному радиусу Длина = Уроки.ДлинаОкружности(25);

// теперь Длина равна 157

// именно это число вернула нам функция в качестве

// результата работы

Сообщить(Длина);

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

Задание №36. Напишите функцию, которая принимает два числа и возвращает меньшее из них. Покажите пример использования этой функции.

Решение

//*** Модуль уроки ***//

Функция МеньшееИзЧисел(А, Б) Экспорт Если А < Б Тогда Возврат А;

Иначе Возврат Б;

КонецЕсли;

КонецФункции

//*** Модуль управляемого приложения ***//

ПервоеЧисло = 0;

ВвестиЧисло( ПервоеЧисло);

ВтороеЧисло = 0;

ВвестиЧисло( ВтороеЧисло);

// пример использования функции МеньшееИзЧисел ОткрытьЗначение(

"Меньшее из введенных вами чисел равно " +

Уроки.МеньшееИзЧисел(ПервоеЧисло, ВтороеЧисло)

);

ЮНИТ 14. ФУНКЦИИ И ПРОЦЕДУРЫ В ЯЗЫКЕ 1С (ПРОДОЛЖЕНИЕ)

В юните 13 мы начали знакомство с функциями и процедурами в языке 1С 8.3. Так как это действительно важная тема, продолжим их изучение.

Функции — продолжение...

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

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

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

ЧерныйЯщик();

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

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

Но черные ящики (функции) имеют такую особенность:

  • 1. Они могут содержать входные отверстия (одно или несколько) для того, чтобы мы в них могли что-то положить (параметры).
  • 2. И они обязательно содержат одно выходное отверстие, из которого мы сможем забрать результат работы ящика.
  • 3. Ящик-функция просто обязан вернуть нам хотя бы какой-то результат в выходное отверстие.

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

  • 1. Придумываем имя для этого ящика — "Сумма Чисел”.
  • 2. Придумываем имена для входных отверстий этого ящика (параметров). Их два (числа), поэтому пусть будет — "ЧислоА" и "ЧислоБ'.
  • 3. Пишем объявление самого ящика (функции):

Функция СуммаЧисел(ЧислоА, ЧислоБ)

КонецФункции

4. Теперь нам осталось поместить внутри ящика команды, которые посчитают сумму входных параметров (ЧислоА и ЧислоБ) и вернут их в выходное отверстие (команда Возврат):

Функция СуммаЧисел(ЧислоА, ЧислоБ)

Результат = ЧислоА + ЧислоБ;

Возврат Результат;

КонецФункции

5. Отлично! Теперь мы можем использовать этот черный ящик в своей работе. Вызывается он так:

ЧислоС = СуммаЧисел(К), 25);

Сообщить(ЧислоС); // выведет 35

6. Обращаю ваше внимание, что при вызове мы указали имя ящика (СуммаЧисел), а затем его входные параметры в круглых скобках. Ящик выполнил свою работу и вернул результат в переменную ЧислоС, значение которой мы вывели командой Сообщить.

А вот как выглядит ящик, который принимает всего одно число и возвращает квадрат этого числа:

Функция КвадратЧисла(ЧислоА)

Результат = ЧислоА * ЧислоА;

Возврат Результат;

КонецФункции

Вызывается он так:

Сообщить(КвадратЧисла(10)); //выведет 100

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

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

Функция Привет()

Возврат "Привет";

КонецФункции

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

Строка = Привет();

Сообщить(Строка);

Процедуры — продолжение...

Что же такое процедуры? Да те же черные ящики:

И входные отверстия (параметры) у них имеются.

И команды они в себе также могут содержать.

И другие ящики они также в себя могут включать.

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

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

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

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

  • 1. Определим имя нашего ящика — "ОписаниеЧисла".
  • 2. Определим имя входного параметра — "ЧислоА"
  • 3. Определим описание нашего ящика:

Процедура ОписаниеЧисла(ЧислоА)

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

4. Теперь поместим внутрь ящика команды, которые выведут описание числа в зависимости от его знака:

Процедура ОписаниеЧисла(ЧислоА)

Если ЧислоА >= 0 Тогда Сообщить("положительное число");

Иначе

Сообщить("отрицательное число");

КонецЕсли;

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

5. А вызывать наш ящик будем так:

ОписаниеЧисла(-З);

Задание №37. Напишите ящик, который принимает радиус круга, а возвращает его площадь. Продемонстрируйте его использование.

Решение

//*** Модуль уроки ***///

Функция ПлощадьКруга( Радиус) Экспорт Пи = 3.14;

Возврат Пи * Радиус * Радиус;

КонецФункции

//*** Модуль управляемого приложения ***///

Радиус = 0;

ВвестиЧисло( Радиус);

ОткрытьЗначение(

"Площадь круга радиусом " + Радиус +

" равна " + Уроки.ПлощадьКруга(Радиус)

);

Задание №38. Напишите ящик, который принимает две строки, а возвращает их объединение (или, как говорят, конкатенацию). То есть передали "Иван" и "Петров", а вернул "Иван Петров". Продемонстрируйте его использование.

Решение

//*** Модуль уроки ***///

Функция ФИО(Имя, Фамилия) Экспорт Возврат Имя + "" + Фамилия;

КонецФункции

//*** Модуль управляемого приложения ***///

ВашеИмя =

ВвестиСтроку(ВашеИмя, "Введите ваше имя");

ВашаФамилия =

ВвестиСТроку(ВашаФамилия, "Введите вашу фамилию"); ОткрытьЗначение("Здравствуйте," +

Уроки.ФИО(ВашеИмя, ВашаФамилия));

Задание №939. Напишите ящик, который принимает два числа, а при своей работе выводит на экран все целые числа в промежутке от первого до второго числа. Например, передали 1 и 5, а он вывел: 12 3 4 5. Продемонстрируйте его использование.

Решение

//*** Модуль уроки ***//

Процедура ВывестиЧисла(ПервоеЧисло, ПоследнееЧисло) Экспорт

Строка =

Для Шаг = ПервоеЧисло По ПоследнееЧисло Цикл Строка = Строка + Шаг + "";

КонецЦикла;

ОткрытьЗначение(Строка);

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

//*** Модуль управляемого приложения ***//

ПервоеЧисло = 0;

ВвестиЧисло(ПервоеЧисло, "Введите первое число");

ВтороеЧисло = 0;

ВвестиЧисло(ВтороеЧисло, "Введите второе число"); Уроки.ВывестиЧисла(ПервоеЧисло, ВтороеЧисло);

 
Если Вы заметили ошибку в тексте выделите слово и нажмите Shift + Enter
< Пред   СОДЕРЖАНИЕ   След >
 

Популярные страницы