Transcription
Как интересно то оказаться. Да, как говорится, пока объяснял, сам всё понял.
Всем привет! Я Алексей Лапицкий, и сегодня в этом длинном видео я буду рассказывать про основы языка 1С, азы программирования в 1С. Итак, начнём с создания новой базы.
Если у вас уже есть 1С, то вы можете её запустить в режиме конфигуратора. Если же у вас нет программы 1С, то вы можете скачать так называемую коммьюнити-лицензию, которая для разработчиков и в которой нельзя вести полноценную работу для бизнеса или для госпредприятий. Ну, в реальном режиме времени, для реальной деятельности. Туда нельзя формировать отчётность, потому что эта коммьюнити-лицензия будет предназначена только для разработчиков, только для того, чтобы можно было изучать 1С, что-то пробовать. И в будущем, когда вы уже поймёте, что вас устраивает, вы в ней будете работать, вы уже после этого должны будете купить полноценную лицензию.
Итак, для того чтобы скачать коммьюнити-лицензию, вы должны перейти на вот этот сайт, который сейчас перед вами на экране. Адрес у него developer.1c.ru. Переходите по нему, спускаетесь вниз, и здесь будет написана ссылка, которая ведёт вас к скачиванию 1С-движка и к регистрации на портале 1С. После регистрации на портале вы можете попасть в личный кабинет портала и оттуда уже скачать себе данные для лицензии, для коммьюнити-лицензии. Вот по этой ссылочке перейдёте, и там далее уже всё понятно. В этом видео я не буду это рассматривать, потому что здесь мы рассматриваем с вами программирование и его азы.
Итак, начнём с самого первого шага. Запускаем конфигуратор и создадим пустую базу. Я запустил 1С, и перед нами появилось окно, которое вы всегда будете видеть, когда стартует 1С. В этом окне написано "Запуск 1С:Предприятие". Справа две самые главные кнопки - это "1С:Предприятие" и "Конфигуратор". В режиме конфигуратора происходят программирование, и в этом режиме всегда работают программисты, разработчики и иногда аналитики 1С. А в режиме "1С:Предприятие" уже видно, как работает программный код, и в режиме "1С:Предприятие" работают непосредственно пользователи, для которых и пишется всякая программа на 1С. Нам сейчас с вами понадобится конфигуратор.
Далее мы увидим кнопки "Добавить", "Изменить", "Удалить", "Настройка" и "Выход". Слева мы видим те информационные базы, которые я уже когда-то создал в 1С, и они находятся либо у меня на жёстком диске локально, или на каком-то сетевом, либо находятся на так называемом SQL-сервере. Что такое SQL-сервер, мы сейчас рассматривать не будем. Мы с вами будем рассматривать только 1С в файловом варианте.
Давайте добавим новую информационную базу по кнопке "Добавить". Здесь предлагается создать новую информационную базу либо добавить существующую информационную базу. Мы с вами первый раз запускаем, у нас, представим, нет никаких информационных баз, поэтому нужно создать новую пустую информационную базу. Ставим переключатель на "Создание новой информационной базы", нажимаем "Далее". Какое-то время она может подумать и выдаст вот такой список: "Создание информационной базы из шаблона". Если у вас на жёстком диске где-то в каталоге установлены шаблоны, то вы увидите те шаблоны, которые вам доступны. Но нам с вами нужна пустая информационная база для того, чтобы мы могли потренироваться в разработке, поэтому переключаем кнопку на "Создание информационной базы без конфигурации для разработки" и нажимаем "Далее".
Далее предложит ввести название для нашей новой базы. Давайте назовём её "Обучение Азы 1С". И выберите тип расположения информационной базы. Здесь есть переключатель "На данном компьютере" или "На сервере". Сервера у нас, представим, сейчас нет, и нам нужна файловая база, поэтому оставляем переключатель на "На данном компьютере или на компьютере в локальной сети", нажимаем "Далее". Здесь указываем каталог, в котором 1С создаст нам пустую конфигурацию. По умолчанию каталог создаётся в "Моих документах", и 1С предлагает название по умолчанию "infobase". Давайте так и оставим, нажимаем "Далее". Вариант аутентификации выбирать "Автоматически", оставляем "Выбирать автоматически", далее.
И мы видим, что в списке баз у нас появилась новая база под названием "Обучение Азы 1С", которую мы с вами сейчас только что добавили. Устанавливаем курсор на "Обучение Азы 1С", которую мы сейчас создали. Если вы вводили другое название, то найдите это название в списке и нажимаем "Конфигуратор". Попадаем в конфигуратор.
Значит, что мы видим в конфигураторе? Сверху у нас меню. Меню выглядит довольно традиционно для Windows-приложений. Слева кнопка "Файл", "Правка", "Конфигурация", "Отладка", "Администрирование", "Сервис", "Окна", "Справка". Дальше идут панели инструментов, которые содержат в себе наиболее часто используемые кнопки с точки зрения разработчиков 1С. Здесь мы что видим? Здесь мы видим "Создать файл", "Открыть файл". Справа у нас такой значок есть под названием "Синтаксис-помощник". Ещё есть интересная кнопка с буквой "i" английской и жёлтый кружочек. Что будет, если нажать? У нас появляется основная информация о запущенной версии 1С и о запущенной в данный момент конфигурации, то есть, то есть в той конфигурации, в которой у нас сейчас открыта. Эта информация может понадобиться как для самого разработчика, так и для взаимодействия со службой поддержки. Эту кнопку может нажать пользователь, чтобы сообщить программисту или службе поддержки о нахождении, где находится у него база, в какой базе, в какой версии он работает. Нажмём "ОК" и выйдем из этого окошка.
Итак, где же наша конфигурация? Где же нам писать код? Вот, как говорится, в чём вопрос. Нажимаем кнопку "Конфигурация", "Открыть конфигурацию". Попадаем в пустую конфигурацию. Здесь у нас дерево объектов конфигурации. В этом дереве у нас есть ветки, в которых происходит разработка. Если конфигурации большие, здесь будет много-много разных объектов. А в нашем случае здесь почти всё пусто. То есть, нажимая плюсиком, разворачивая наши ветки дерева, мы ничего не увидим.
Давайте ещё посмотрим, что у нас находится в меню "Конфигурация". В меню "Конфигурация", кроме кнопки "Открыть конфигурацию", которую мы только что открыли, есть кнопка "Закрыть конфигурацию". Окошко конфигурации пропадёт, но оно никуда не исчезнет, не удалится. Оно просто визуально закроется. Дальше у нас есть ещё кнопка "Сохранить конфигурацию", "Обновить конфигурацию", служебные различные команды для работы с конфигурацией базы данных, которых мы в этом видео рассматривать не будем. В этом пункте меню есть режимы "Сохранить конфигурацию в файл" и "Сравнить, объединить с конфигурацией из файла". Вот запомните эти две команды, вы их скорее всего наиболее часто будете использовать в своей работе.
Давайте предварительно сделаем настройки для более удобной работы с конфигурацией. Перейдём в меню "Сервис", "Параметры". Меню "Сервис", "Параметры". Мы видим много-много закладок. Давайте перейдём на главную закладку для разработчика под названием "Модули". Здесь показываются настройки, как будут отображаться цвета в наших модулях программных, там, где мы будем писать код. Перейдём на вкладку "Тексты" и на всякий случай, давайте при перетаскивании текста, разрешать помещать курсор после концов строк. Для чего я запрещаю перетаскивание? Для того, чтобы случайно мышкой не зацепить кусок текста и не переместить его куда-то в другое место. Поскольку разработчики, они не таскают свои куски кода мышкой, но иногда бывает, что мышка наведена куда-то, курсор мышки наведён в какую-то часть текста, и его случайно цепляешь, и весь вот этот программный код он перемешивается, и потом приходится всё возвращать. Поэтому эту, этот флажок в "Перетаскивание текста" мы снимаем. Дальше снимаем флажок "Разрешать помещать курсор после концов строк". Это для того, чтобы после наших модулей, после наших операторов, после наших команд не оставались лишние пробелы, которые потом мешают навигации.
Перейдём на вкладку "Модули" и давайте здесь проверим, чтобы стояли цвета для идентификаторов. Найдём "Выделение текущего идентификатора" и установим здесь серый цвет, потому что по умолчанию здесь другой цвет стоит. Здесь у меня уже установлен, но вы можете поставить так же, как у меня, серый цвет 192, 192, 192. И ещё у нас есть "Выбранный идентификатор". Вы здесь тоже можете поставить "Выбранный идентификатор" оранжевым, а "Прочее" можно поставить серым, тоже 192, 192, 192. Шрифт Courier New, размер 10. Этот шрифт маловат, можно поставить, например, 11 или 12. Так для глазам будет проще, легче, и глаза будут меньше уставать. На этой вкладке "Поле автозамены" включить "С подсказкой" либо просто "Включить". Я всегда выбираю "Включить с подсказкой", иначе автозамена, автоподсказки не будут у вас работать. Это удобно, чтобы каждый раз не набирать команду полностью вручную, 1С будет вам её дописывать.
Итак, основные настройки мы сделали. Ещё можно перейти на вкладку "Группировка" и включить все флажки в колонке "Группировать". Так наш код будет выглядеть более компактно. Нажимаем "ОК".
Переходим непосредственно к программированию. Значит, что же такое программирование? А программирование - это написать программный код, соответственно, на программном языке. Программный язык у нас называется язык 1С. Программный код - это последовательность команд, которая поддерживает этот язык программирования. Язык программирования 1С поддерживает множество команд, которые мы, какую-то малую часть из них, рассмотрим сегодня в этом видео, для того чтобы вы поняли азы, а остальные команды вы уже дальше сами найдёте, изучите в процессе обучения.
Какие бывают команды? Первое - это переменные. Так называемые переменные мы рассмотрим немножко попозже, буквально через несколько минут. Что такое переменная? Операторы бывают. Операторы мы тоже сегодня рассмотрим. Бывают функции и процедуры. Их мы тоже затронем сегодня.
Есть такое понятие в 1С как "программный модуль". Модули - это место, где хранится программный код. Если щёлкнуть правой кнопкой по корню конфигурации, то мы увидим контекстное меню, в котором мы даже сразу можем понять, что такое "Модуль", "Открыть модуль управляемого приложения", "Сеанса" и так далее. Давайте откроем "Модуль управляемого приложения". Что же там находится? Как мы видим, здесь совершенно пусто, потому что программный модуль - это просто место, где мы можем писать код, но не обязательно там этот код будет находиться. А теперь давайте, может быть, найдём в другое место, где у нас может лежать программный код. Вот здесь, например, "Модуль объекта", "Приходная накладная". Здесь уже есть какой-то код и есть процедура "Обработка проведения". Давайте закроем этот модуль, мы его смотрели для примера.
Что же можно сделать в модуле? Это раз. Модуль - это место, где хранится программный код, то, соответственно, мы можем его туда поместить, этот программный код. Давайте напишем что-нибудь на языке 1С, чтобы уже скорее получить какой-то результат от нашего обучения. Есть команда. Введём команду "Сообщить" и напишем "Привет, мир!". Вот что же я сейчас сделал? С помощью этой команды, с помощью команды "Сообщить", я говорю интерпретатору 1С, что я хочу что-то вывести на экран для пользователя, чтобы он это увидел. Что он увидит? То, что он видит, я пишу вот с таких двойных кавычек. Кавычка двойная открывается, дальше я пишу сообщение, которое должен увидеть пользователь, и двойная кавычка закрывается. И всё, что между этими двойными кавычками, будет выведено на экран. После этого я должен поставить точку с запятой. После любого оператора.
Как же теперь нам запустить нашу команду в модуле, чтобы пользователь это увидел, чтобы мы это увидели? Для начала мы должны сохранить эту команду, сохранить наши изменения, которые мы сейчас сделали. Как это сделать? Мы можем перейти в меню "Файл" и нажать "Сохранить". Слева мы видим, что в конфигурации изменился заголовок, там появился восклицательный знак. Что это значит? Это значит, что мы внесли изменения в конфигурацию, мы эти изменения сохранили, но их не применили к рабочей базе. Мы не применили их к конфигурации базы данных, потому что у нас есть на самом деле две конфигурации: та конфигурация, в которой мы разрабатываем, и есть конфигурация рабочая, в которой уже пользователь работает. Как же нам применить изменения? Нажимаем либо F7 кнопку, либо переходим в меню "Конфигурация" и выбираем пункт "Обновить конфигурацию базы данных". Нажимаем. Восклицательный знак в заголовке исчез. Изменения применили.
Теперь, как же нам увидеть то, что мы запрограммировали? Можем нажать вот этот жёлтый значок с треугольником, значит, либо нажать кнопку F5, либо перейти в меню "Отладка", нажать "Отладка". Либо мы можем перейти в меню "Сервис" и вызвать "1С:Предприятие". Как правило, основной режим запуска "1С:Предприятие" - это через "Сервис" и "Запустить 1С:Предприятие", либо сочетание кнопок Ctrl+F5. Запускаем. Запустилось окно "1С:Предприятие", и внизу вывелось сообщение "Привет, мир!", что мы и хотели добиться. Итак, закрываем это окно.
Далее, давайте рассмотрим базовую конструкцию языка 1С, базовое понятие, которое называется "оператор". Итак, что такое операторы? Операторы - это конструкции языка, которые заложены в нём самом и позволяют создавать программы. Операторы есть в любом языке программирования, и если вы поймёте для себя, что такое оператор, то вы в каждом языке программирования уже сможете немного разбираться. Перейдём в нашу конфигурацию и посмотрим, что же такое оператор. Например, "Сообщить" - это и есть оператор, оператор, который занимается тем, что выводит какие-то сообщения. Оператор - это почти то же самое, что команда. Давайте не будем сейчас углубляться в дебри и будем считать, что оператор - это и есть разновидность команды.
Какие ещё бывают конструкции? Конструкция может быть следующая. Давайте перейдём к следующему разделу под названием "Переменная". Что такое переменная? Переменная - это именованный контейнер или хранилище для обращения к нему по имени. Переменная - это место хранения некоторых значений, каких-то любых значений. Переменная может называться любым словом, но есть правило именования переменных: название переменной не может содержать пробел и должна начинаться с буквы или с подчёркивания.
Давайте представим для лучшего понимания, что у нас есть много-много картонных ящиков, они разбросаны по нашей комнате. Это и есть наша переменные. На боку каждого картонного ящика мы напишем какое-то имя для того, чтобы другому человеку объяснить, о каком ящике идёт, потому что на вид они все одинаковые. Вместо того, чтобы показывать пальцем: "вот этот ящик открой" или "вот этот ящик открой", мы будем обращаться к ящикам по имени. Ну, присваиваем ящикам имя, пишем сбоку, и таким образом нам проще всего друг с другом. Вот мы сидим с вами, я могу назвать какое-то имя, и вы уже будете понимать, о каком ящике идёт речь. Точно так же интерпретатор 1С работает с переменными.
Я написал следующее: "ЗарплатаИванова = 50;". Что это такое? Я создал переменную под названием "ЗарплатаИванова". Интерпретатор 1С теперь будет понимать, что есть переменная, которая называется "ЗарплатаИванова". Дальше я поставил символ равенства. Символ равенства в 1С означает присваивание. То, что после этого символа равенства - это является выражением, которое мы должны присвоить нашей переменной. Справа я написал число 50 и по правилам синтаксиса поставил дальше точку с запятой, чтобы у нас не было никаких ошибок. Таким образом, я взял число 50 и положил его в переменную "ЗарплатаИванова". Это всё работает следующим образом: смотрите, слева направо находите первый символ равенства, и всё, что слева от этого символа, это будет названием переменной, а всё, что справа от этого символа, это будет выражением, которое хранится вот в этом картонном ящике под названием "ЗарплатаИванова".
Что же, например, будет, если интерпретатор встретит название вот этой переменной? Он найдёт ящик у себя где-то там под названием "ЗарплатаИванова", заглянет в него и увидит, что "ЗарплатаИванова" - это 50, ну, рублей, долларов там или чего-то там миллионов.
Пишем: "ЗарплатаПетрова = 100;". Этим оператором мы присвоили переменной под названием "ЗарплатаПетрова" значение 100. Теперь у нас есть две переменные: "ЗарплатаИванова" и "Зарплата Петрова".
"Сообщить(ЗарплатаИванова + ЗарплатаПетрова);". Что я сделал? Я определил переменную под именем "Результат". Что я поместил в эту переменную? Я взял переменную "ЗарплатаИванова" и взял переменную "Зарплата Петрова" и сложил их, то есть прибавил "ЗарплатаИванова" к "Зарплата Петрова". Но мы это делаем для понимания, что такое переменная. Дальше у меня идёт уже нам с вами известная команда, оператор "Сообщить", и в качестве параметра в эту команду я передаю "Результат", который мы посчитали выше. Что же будет у нас в переменной "Результат"? 1С увидит, что я определил переменную "Результат" и посмотрит: "Ага, нужно найти ЗарплатаИванова". Интерпретатор поднимется выше, найдёт переменную с именем "ЗарплатаИванова" и поймёт, что там лежит 50. Отлично. Интерпретатор нашёл значение 50. Дальше он смотрит: "Ага, плюс". Отлично. "ЗарплатаПетрова". Интерпретатор идёт вверх по коду и находит эту переменную под именем "ЗарплатаПетрова". А что в ней хранится в этом ящичке картонном? Цифра 100. Соответственно, "ЗарплатаИванова" 50 и "Зарплата Петрова" 100. Он берёт 50 и прибавляет 100. Соответственно, в переменную "Результат" помещается число 150, и это число далее выводится с помощью оператора "Сообщить".
Давайте проверим, так ли это. Нажмём Ctrl+F5. 1С говорит, что конфигурация изменена и не хочу ли я обновить её перед тем, как запустить. Соответственно, чтобы увидеть все изменения, я должен применить изменения. Давайте согласимся, нажмём "Да". Запускается конфигурация, и мы увидели. Теперь у нас есть два сообщения: "Привет, мир!" и "150". Что и требовалось доказать.
Ещё можно определить переменную. Переменную можно определить с помощью слова "Перем". Например, "Перем Результат;". Что мы сделали с помощью этой команды? С помощью команды "Перем" мы определили переменную "Результат". Давайте вот здесь удалим наши расчёты и сообщим пользователю, что такое переменная "Результат". При определении её таким образом, в ней не будет записано ничего. Для этого у 1С есть специальный тип под названием "Неопределено". При запуске 1С у нас ничего не будет выведено. Давайте запустим 1С и проверим. У нас есть переменная, но она не определена. Что же выведет 1С? Ничего не вывела. Давайте закроем её. Таким образом, мы уже научились двумя способами определять переменные: с помощью слова "Перем" и с помощью непосредственного объявления переменной.
Что же будет, если мы вообще не объявим переменную, но при этом попытаемся её вывести? Давайте нажмём Ctrl+F5 и запустим. Запускаем. Что же происходит? 1С говорит, что переменная не определена "Результат", и говорит, где эта ошибка. Ну, давайте попробуем проигнорировать и запустить. Что же будет? 1С говорит, что переменная не определена, и я не могу запуститься, предлагает завершить работу. Завершаем работу. Что мы поняли из текущей ошибки? Что переменная, перед тем как она будет использована в других расчётах, она должна быть определена любым нами известным способом, то есть либо со словом "Перем", либо с присваиванием. То есть, если мы присвоим какое-то значение, ошибки уже не будет. Пробуем запустить. Вот, ошибки нет, выводится 150.
Далее, давайте рассмотрим такую базовую вещь, как комментирование в модулях. Чтобы написать комментарий в модуле, мы должны написать двойной слэш. Он автоматически у нас подкрасится зелёным, если у нас соответствующие стандартные настройки. И дальше после этих двух слэшей мы пишем слова, которые хотим написать в комментарии. Вот я написал: "Это комментарий". Что это значит? И для чего это нужно? Для чего нужно комментирование в коде? Для того, чтобы разработчик при программировании мог объяснить другим людям, которые будут смотреть этот код, другим разработчикам на будущее. Кто-то в будущем посмотрит этот код и попытается понять, и чтобы ему было легче разобраться в этом коде, разработчик оставляет комментарий. Комментировать можно хоть каждую строку, хоть один комментарий на весь модуль.
Если нам нужно сделать несколько строк комментария, то мы должны открыть новую строку и добавить туда вторую строку. "Это вторая строка". То есть, если комментарий у нас очень длинный, и мы не хотим скроллить вправо этот экран, то мы вот таким образом добавляем ещё строк и снова вводим двойной слэш и снова пишем. Вот у нас есть три строки комментария.
Для чего ещё может понадобиться комментарий? Комментарии иногда используются для того, чтобы временно отключить код. Вот мы, например, хотим, чтобы сейчас у нас не выводилось сообщение "Привет, мир!". Мы, например, отлаживаем вот этот вот результат и хотим, чтобы писался только результат, а первое сообщение "Привет, мир!" мы хотим, чтобы не выводилось. И мы можем так называемую операцию закомментирования сделать. Пишем двойной слэш перед командой, подкрашивает в зелёный цвет, и всё, что после двойного слэша, превращается в комментарии. То есть комментарий, он не является оператором, не является выполняемыми командами. Давайте запустим и проверим, что же будет. Действительно, у нас теперь "Привет, мир!" не выводится, выводится только результат, который равен 150.
Для чего ещё нужны комментарии? Это для того, чтобы, если вы начали писать какой-то длинный программный код, то перед этим программным кодом вы можете написать комментарий. "Это обработка для расчёта зарплаты". И таким образом вы уже подсказываете тем людям, которые будут изучать код, который ниже этого комментария, о чём этот код, то есть для чего он писался. Также вы можете написать, например, номер задачи в трекере, в каком-нибудь, который у вас там существует на работе, в котором описываются все ваши задачи. Плановые задачи или текущие задачи, они обычно имеют какой-то либо номер, либо ссылку. Например, вы хотите указать, что номер задачи, например, 15.55. Таким образом, разработчик или аналитик или кто-то другой, заглянув в этот комментарий, сможет понять, что эта задача была реализована в рамках баг-трекера какого-нибудь под номером 1555. Там зарегистрированная ошибка была, например, или вам дали задание на разработку под номером 1555. Вот и описание можно найти будет там, потому что это описание зачастую нужно для понимания кода. Человек, который изучает код, заглянет в техническое задание, поймёт, о чём это было, и ему будет проще понять, что, что программист сделал здесь, и допустил ли он ошибки, и может быть, чего-то не учёл.
Так, мы рассмотрели комментарии. Давайте удалим это всё, что закомментировать быстро несколько строк и раскомментировать несколько строк. Выделяем строки и нажимаем Ctrl+/ (слэш). Сочетание клавиш Ctrl+слэш. Соответственно, все строки, которые были у нас выделены и которые содержат в себе операторы, команды, они автоматически перекрашиваются в зелёный цвет, и перед ними ставится двойной слэш. Зелёный цвет, повторюсь, он не обязательно будет зелёным, может быть вообще никакого цвета не быть, это зависит от настроек. "Сервис", "Параметры". Вот здесь в "Сервис", "Параметры" находится раскрашивание наших модулей. Вот "Комментарии", и вот видно, что здесь комментарии будут обычно подкрашивать зелёным. Как правило, всё так и будет в 99% случаев, потому что разработчики не меняют этот цвет комментария, он уже всем привычен, давно всем известен, что если встречается что-то зелёное, то глаз разработчика 1С, программиста 1С уже понимает, что это комментарий.
Как же убрать комментарий сразу с нескольких строк? Чтобы много раз не тыкать клавиатуру, то же самое: выделяем эти строки, которые были закомментированы, Ctrl+Shift+/ (слэш) либо "Текст", "Блок", "Удалить комментарий". Комментарий исчез.
Итак, переходим к следующему разделу нашего видео под названием "Оператор если", условный оператор. Что такое оператор условный? Что такое оператор "если"? Давайте представим себе богатырей на распутье, которые подъехали к перекрёстку и видят, значит, такой столбик, на котором есть таблички-указатели. То есть, туда пойдёшь - так-то будет, там сюда пойдёшь - так-то будет. Нужно сделать какой-то выбор, пойти по какому-то направлению. Тоже самое делает и 1С в случае появления оператора "если".
Давайте посмотрим, что можно сделать с помощью нашего вот этого оператора. Давайте всё удалим отсюда и напишем: "Если ЗарплатаИванова > ЗарплатаПетрова Тогда Сообщить("У Иванова больше");". Давайте сразу посмотрим, что будет делать 1С. Работа интерпретатора 1С она происходит сверху вниз. В модуле 1С идёт, идёт, видит присвоение, как мы уже разобрали, переменной "ЗарплатаИванова" значение 50. То есть, в коробочку, условную коробочку, картонную помещается число 50, и сбоку на коробочке пишется слово "ЗарплатаИванова". Таким образом, переменная "Иванова", "ЗарплатаИванова" проинициализирована значением 50. Дальше 1С идёт: "ЗарплатаПетрова = 100;". Переменная "ЗарплатаПетрова" проинициализирована значением 100. В этой условной коробочке лежит число 100, и на её боку написана "ЗарплатаИванова". Теперь 1С может манипулировать этими переменными, а мы можем помещать в эти переменные разные другие значения, либо оставить те же самые.
Значит, идём дальше: "Если ЗарплатаИванова > ЗарплатаПетрова Тогда". Что значит этот оператор? На самом деле, это не полный оператор. Полный оператор: "Если Тогда КонецЕсли". Ну, вот что означает конкретно эта строка: "Если ЗарплатаИванова > ЗарплатаПетрова". Что будет происходить в интерпретаторе 1С? А интерпретатор 1С посмотрит, что у нас лежит в ячейке под названием "ЗарплатаИванова", что лежит в ячейке под названием "ЗарплатаПетрова", и сравнит их значения. Причём сравниваться значения могут только одинакового типа. Одис не может сравнивать значения разного типа. То есть, например, если бы у нас здесь было не 100, а вот такая строка в кавычках, 1С бы не смогла её сравнить и выдала бы ошибку. Поэтому сравнивать нужно только значения одинакового типа. Что такое типы значений, мы рассмотрим сегодня в видео чуть-чуть попозже.
"ЗарплатаИванова = 50", "ЗарплатаПетрова = 100". Больше ли "ЗарплатаИванова" чем "ЗарплатаПетрова"? Нет. 1С значение "Ложь" - результат логических, так называемых булевых операций. Результат только два: либо "Истина", либо "Ложь". Всего два значения может принимать булев тип. Итак, в результате получим "Ложь". А если результат вычисления равен "Ложь", то вот это сообщение не будет выведено. 1С пойдёт дальше, в данном случае "КонецЕсли", и ничего выведено не будет.
Давайте попробуем расширить это: "Если ЗарплатаИванова < ЗарплатаПетрова Тогда". Что же будет у Иванова? Напишем: "Меньше". Данное условие отработает, вычислит, и в результате получится "Истина". Соответственно, если это "Истина", тогда всё, что после слова "Тогда" будет выполнено. И далее. Давайте напишем на всякий случай ещё "Иначе". Это для того, чтобы проверить все остальные условия. Если никакие из этих условий не выполнены, тогда 1С перейдёт к оператору "Иначе" и выполнит всё, что находится.
В этой ветке у Иванова равно. Таким образом, у нас оператор условный получился из трёх частей. Первое: проверяем, зарплата Иванова больше зарплаты Петрова? Второе: Иначе, если зарплата Иванова меньше зарплаты Петрова. Если ничего из этих условий не сработало, 1С переходит к оператору "Иначе", если он есть, потому что его может вот так вот не быть. Тогда в этом случае проверка условия завершится.
Давайте посмотрим, что выведет 1С. Уберём вот эти лишние. Запускаем 1С. Получаем: "у Иванова меньше". Действительно, да, у Иванова меньше. Мы видим, что после слова "тогда" и до следующего "иначе" у нас происходит вычисление, выполнение операторов, которые находятся между этими двумя словами.
Как ещё можно записать этот оператор "если"? Тогда есть более короткое выражение для этого. Давайте присвоить, например, напишем вот так:
[музыка]
Если, если зарплата Иванова больше зарплаты Петрова, выведем сообщение "больше". Иначе выведем сообщение "меньше или равно". Что я тут написал? Я инициализирую результ, присваиваю ей в зависимости от результата условия какую-то строку. Значит, строка это будет либо "больше", либо "меньше или равно". Это происходит следующим образом: 1С видит символ вопроса, она понимает, что это то же самое, что вот эта конструкция "если... конец если", но в более сокращённом варианте, в более упрощённом варианте и в более, так сказать, урезанном функционале. Видит символ вопроса, открывающую скобку и начиная с этой открывающей скобки и до первой запятой смотрит, какие тут есть условия и чему это всё равно. Зарплата Иванова больше, чем зарплата Петрова? У Иванова 50, а у Петрова 100. Условие не выполняется, поэтому 1С пропускает первую часть, ищет вторую запятую, и вот эту строку она присваивает в нашу переменную "результат". Давайте убедимся в этом. Сообщим "результат", выведем "результ" на экран. А вот это то, что сверху, пока за комментарием, "меньше или равно" вывела она нам. 1С действительно, да, зарплата Иванова либо меньше, либо равна.
В каких случаях использует эта сокращённая форма? Как мы видим, она более компактная, и именно для компактности её и используют, потому что вот такое громоздкое выражение на экране выглядит слишком, как сказать, ресурсоёмко, слишком много места занимает, и, возможно, программист не хочет перегружать экран множественными вот такими вот "если, если, если". Он хочет, чтобы это выглядело более компактно. И это же является ограничением. Вот эта компактность. Вот посмотрите, насколько наглядно, когда у нас много условий. Обычный оператор такой, в расширенной форме, мы всё видим. Мы каждое условие видим на своей строке. То это очень удобно наблюдать каждое условие и все операторы, которые выполняются в результате выполнения условия, на новой строке. То есть глазу приятно, и мозг лучше воспринимает такую информацию. А если мозг видит такой вот вопросик и открывающую скобку, выглядит удобно для простейших условий. Например, зарплата Иванова больше, чем зарплата Петрова, и всё. Вот это такое простое условие. И мы здесь не можем задать "Иначе если", "Иначе если", кроме. То есть, потому что вместо этого мы опять должны внутри будем писать такой вопросик, а потом ещё один вопросик такой, и это будет такая большая путаница. Поэтому такой компактный оператор, как вопрос с открывающей скобкой, рекомендуется писать для выполнения простейших условий. Первое время вообще не советую использовать. Пользуйтесь расширенной формой условного оператора "если".
Итак, мы с вами столкнулись с результатами вычисления логических операций. То есть вот здесь, когда мы вычисляли "зарплата Иванова больше, чем зарплата Петрова". А что будет, если мы выведем именно результат вычисления этого выражения? Давайте посмотрим, что выведет 1С. Она говорит: "Нет, существует так называемый булев тип переменных". Булев тип переменных, который может принимать значение либо "истина", либо "ложь". А "истина" - это что такое в русском языке? Это "да". "Ложь" - это "нет". Для программистов в коде используются вот эти слова "истина" и "ложь", а для пользователя всегда будет выводиться вместо "истина" слово "да", а вместо "ложь" - "нет". Пользователям, не программистам, привычнее.
Далее, давайте рассмотрим, какие бывают операции вообще сравнения. У нас их всего шесть: равно, больше, меньше, больше либо равно, меньше либо равно и не равно. Итак, первая строчка: мы проверяем, зарплата Иванова больше десяти. У Иванова больше. И если зарплата Иванова, например, меньше нуля. Нет. Давайте напишем: меньше 100. У Иванова меньше 100. Иначе, если у Иванова меньше либо равно 100. У Иванова больше либо равно 100. Например, сделаем. Нет, больше либо равно 10. Так, что там у нас? Больше, меньше, а равно, например, пять. И последнее: не равно нулю. Например, не равно нулю. Вот мы все операции сравнения с вами посмотрели: больше, меньше, либо равно, больше либо равно, равно и не равно.
Давайте посмотрим, что выведет 1С. "У Иванова больше десяти". Значит, что здесь произошло? 1С дошла до этой строчки: "зарплата Иванова больше десяти". 50 больше десяти, поэтому 1С выводит это сообщение: "у Иванова больше десяти" и завершает этот оператор, переходит вот сюда. Сюда переходим. А если, например, больше 100 поставить? Давайте посмотрим, что выведет. "У Иванова меньше 100". Значит, что произошло? Дошли до слова "если". "Зарплата Иванова больше 100"? Нет. Идём дальше. "Иначе, если зарплата Иванова меньше 100"? Да. Вот это условие уже истина. На экран выводится фраза "у Иванова меньше 100". Выполнятся вот это оператор условия. 1С игнорирует и переходит вот сюда, вот эту зелёную строчку, где у нас находится комментарий. Оператор завершается. Как мы видим, с помощью "если", "иначе если" мы можем производить различные условия, проверки условий, сравнения с чем-то, с чем-то. И в результате проверок этих условий какие-то производить действия. То есть здесь может быть вывод сообщения, запуск каких-то функций, присвоение, вычисления и так далее. Этот оператор очень часто используется в 1С и вообще во всех других языках.
Давайте посмотрим с вами на такую ситуацию. Например, напишем так: "результат равно зарплата Иванова равно зарплата Петрова". Как вы думаете, что вот вы видите сейчас? 1С: "Нет". Почему? Казалось бы, вот у нас два знака равно, и это немножко может путать начинающих программистов и того, кто первый раз это видит. На самом деле, в других языках вот этот, это равно, и вот это равно, они были бы разными. То есть такое не используется. Но в 1С приводит некоторые путаницы. Чтобы не было путаницы, делаете следующим образом. Значит, читаем сначала строки, ищем первый знак равенства. Это значит, что всё, что слева от этого знака равенства - это присвоение значения переменной по имени. То есть, вот видим слово "результат". В эту переменную по имени "результат" будет помещено значение, которое будет рассчитано путём вычисления значения, находящегося справа. А здесь может быть ещё один знак равно. И, ну, это уже 1С считает как логической операцией. Здесь он производит операцию сравнения. Здесь вот этот знак равенства означает операцию присвоения, а этот знак равенства означает уже операцию сравнения, логического. Давайте, например, возьмём это в скобки, чтобы было вот понятнее. То есть, всё, что вот я в скобках отметил в круглых - это операция сравнения. Всё очень просто. Всё, что слева от первого знака равенства - это присвоение, а всё, что справа - это вычисление. Вот на этом слайде я показал наглядно. Можете остановить видео и более подробно разобраться, что происходит.
Дарим. Операции в результате вычисления оператора "если" у нас возникает результат в виде булева. Зарплата Петрова. Тогда сообщить. Сообщить. Равно. Ну, допустим, мы хотим ещё какую-то проверку сделать здесь же. То есть, не только, например, сообщить, что равно, не только когда зарплата Иванова равна зарплате Петрова, но, допустим, проверить, чтобы зарплата Иванова была больше какого-то значения. Тогда мы напишем вот так: "и зарплата Иванова больше 10". Равно и больше. Также мы можем добавить ещё одно условие: "и зарплата Петрова больше 10". Таким образом, 1С посмотрит: "Ага, зарплата Иванова равна зарплате Петрова". Что в результате получится? Ложь. И здесь истина. То есть, у нас получается результат первого вычисления - ложь, результат второго - истина. Истина. Как понять, выведется ли у нас сообщение или не выведется? Для этого существуют следующие правила, которые показаны на этой схеме. Тоже можете приостановить видео, поставить на паузу и получше рассмотреть. Для логическая операция "и" результат будет истинной только когда все операторы будут равны истине. То есть, в результате вычисления нашего выражения у нас получится ложь, и ничего на экран не выведется, если хотя бы одно из этих выражений равно ложь. При слови "и" получится ложь. Давайте здесь вот немножко по-другому сделаем. Заменим зарплата Иванова, поставим, что она меньше, чем зарплата Петрова. Напишем: "больше". Получится, что все три условия у нас истинны. Зарплата Иванова меньше зарплаты Петрова? Да. Зарплата Иванова больше десяти? Да. И зарплата Петрова больше десяти? Равно да. То есть, все три истина. Как мы видим, истина и истина подаёт нам истину. У нас должно вывести сообщение. Давайте убедимся в этом. Да, больше [музыка] десяти.
Если же у нас логическая операция под названием "или", то здесь всё наоборот. Она всегда будет истина, кроме того случая, когда все результаты вычисления будут равны ложь. Давайте рассмотрим, что получится, когда будет оператор "или". Тоже больше, или больше десяти. Все три у нас истина, и поэтому выполняется оператор "сообщить". А давайте теперь попробуем сделать по-другому и применим логическую операцию "не". То есть, "не" - она инвертирующая, ну, превращает в ложь, как это часто бывает у нас в реальной жизни. Вот так сделаем. Перед каждым условием поставим "не" и посмотрим, что произойдёт. Ничего не вывелось на экран. Почему? Давайте разберёмся. 1С вычислила вот это выражение: "зарплата Иванова меньше, чем зарплата Петрова". Действительно, да. Да, истина получилась. Истина. Но мы должны её инвертировать, то есть слово "не" добавить. В результате получаем: ложь. Ложь. Дальше смотрим: "зарплата Иванова больше десяти"? Да. Добавляем "не", получаем ложь. То есть, сначала была истина, а если "не истина", то получаем ложь. Смотрим дальше: "зарплата Петрова больше систем". Больше. Преобразуем через "не", получаем тоже ложь. То есть, все три выражения у нас ложные. Что это значит? Дальше у нас идут команды под названием "или". Ложь или ложь или ложь. Поскольку у нас все выражения ложные, а для выполнения команды "сообщить" нам нужно, чтобы хотя бы одно из этих условий было истина, потому что мы используем операторы "если". Или. У нас ничего выполнено не будет. Смотрите, вот здесь у нас ложь, здесь у нас ложь, и здесь у нас ложь. Получаем: ложь или ложь или ложь. Получается так. Ну, когда 1С видит слово "ложь", она понимает, что сюда заходить нам не нужно. Хотя бы одно из них должно быть истинным для нашего случая, чтобы мы зашли вот в эту ветку. А поскольку у нас все три ложные выражения, соответственно, мы сюда в эту ветку не попадаем. Таким образом, мы с вами разобрали, что такое условный оператор, ветвление "если", что такое логическая операция. Логическая операция - это проверка какого-то выражения на то, что это является ли оно истинным, то есть логика, то есть "да" либо "нет", либо "истина", либо "ложь". Также мы рассмотрели с вами сложное условие с помощью логических операций "и", "или" или [музыка] "не".
Далее перейдём к рассмотрению типов данных. Это нужно нам для того, чтобы дальше двигаться дальше, понимать, какие операции можно делать с разными типами данных. Существуют в 1С несколько типов данных. Их довольно много. Есть примитивные типы данных, а есть сложные. Переменная от типа переменная зависит то, какие операции с переменной можно делать. Давайте наглядно продемонстрирую вам на слайде. Вот, например, если у нас две переменные имеют тип "число", то результат у нас тоже будет числом. А если две переменных имеют тип "строка", то и в результате получается тоже строка. Например, если сложить 1 + 2, и это числа, тогда мы получим число 3. А если сложить 1 + 2 как строки, то мы получим 1 и 2. То есть, как 12. Но это будет не число 12, это будет строка 1 2. Давайте посмотрим, как это выглядит в коде. "Зарплата Иванова", оставим "зарплата Петрова" и выведем результат сложения "зарплата Иванова плюс зарплата Петрова". У нас должна появиться цифра, цифра, цифра 150. Почему? Потому что "зарплата Иванова" имеет тип "число", и "зарплата Петрова" имеет тип тоже "число", и результат у нас получается тоже числом. Это вычисление произвело по арифметическим правилам.
Какие, давайте посмотрим, бывают у нас типы переменных? Примитивные типы данных - это у нас всего семь: это "булева", "строка", "число", "дата", "неопределено", "тип" и "нау". Давайте все их потихоньку рассматривать. Первое, мы рассмотрели - это "число". Теперь посмотрим, что такое "строка". Напишем: "строка 1 равно 1", "строка 2 равно 2" и сообщим, что у нас получится в результате вычисления. Как мы видим, переменную типом строки мы можем определить с помощью двойных кавычек. Всё, что находится в двойных кавычках, имеет тип "строка". В переменную под названием "строка 1" будет помещена строка "1". Давайте посмотрим, что выведется на экран. На экран выявилась строка "12". Как происходит сложение строк? Первая часть плюсовые ко второй просто как бы визуально можете себе представить, что вот у нас есть какой-то предмет, и справа к нему мы просто подставляем второй предмет, как вот два кубика рядом находящиеся. Добавляем. То есть, мы не по математическим правилам складываем их, а по предметным правилам. Есть одна строка, добавляется к другой справа.
Который мы уже с вами когда-то рассматривали - это "булева". Переменная "результат" помещаем значение "истина". И после этого переменная становится булева типа. Что у нас произойдёт, если вывести результат на экран? Давайте посмотрим. Да. Как мы уже с вами рассматривали немного выше, можно присвоить "истина" даже не просто так, например, с помощью выражения. Например, "зарплата Иванова больше, чем зарплата Петрова" и присвоить это в переменную "результат". Что у нас получится в результате? Запускаем снова. Нет. Соответственно, зарплата Иванова не больше зарплаты Петрова. У нас получилась "ложь". А "ложь" для того, кто смотрит, для пользователя, она у нас преобразуется в слово "нет". Далее мы рассмотрели примитивные типы данных: "булева", "строка" и "число".
Далее тип "дата". Тип "дата". Например, переменная "дата". Как можно присвоить переменной тип "дата"? Очень просто. Есть встроенная функция под названием "дата". Мы можем её задать вот так, например: 2024, 1. Что произойдёт? Здесь в переменную "дата" будет помещён результат вычисления вот этого выражения. А результат этого выражения имеет тип "дата". То есть, переменная "дата" у нас будет иметь тип "дата" и значение у неё будет 1 января 2024 года. Давайте убедимся в этом. Выведем на экран. Да, вот у нас получилось 2024 года. Значит, 0 часов, 0 минут, 0 секунд. Как ещё можно задать переменную? Переменной можно задать с помощью строкового, так называемого, литерала. Это пишется вот так: то есть, 2024 год, первый месяц и первый день. Давайте убедимся, что всё работает у нас правильно. Да, действительно, 1 января 2024 года. Чтобы задать минуты и секунды, здесь мы должны написать, например, 23 часа, там, например, 59 минут, 59 секунд. Тип "дата" в 1С имеет в своём составе дату и время.
Далее тип "неопределено". Что значит тип "неопределено"? В самом начале мы с вами смотрели, что переменную можно задать с помощью слова "перем". "Перем" ставится в начале переменная, какая-то переменная. Возвращаясь немного к тому, как задаются переменные, хочу напомнить вам, что по стандартам 1С названия переменных могут начинаться либо с буквы, либо с подчёркивания и не содержать в себе пробелы. То есть, не должно быть вот такого. И, кроме того, стандарт 1С подразумевает, что каждое слово в названии переменной должно начинаться с большой буквы. Это так называемый верблюжий стиль. "Переменная зарплата Сидорова". То есть, здесь нас два слова: "зарплата" и "Сидорова". Когда мы начинаем новое слово, мы должны начать его с большой буквы. И первое слово тоже назначать с большой буквы нужно. Если вы будете писать с маленькой буквы первое слово, то это будет раздражать других программистов, потому что все привыкли писать по стандартам вот таким, по верблюжьему, так сказать, style. Если в английский язык перейти. Далее мы определили переменную, и она не будет в себе содержать никакого типа и никакого значения. У неё будет тип "не определено". Что будет в результате того, если мы выведем эту переменную на экран? Нас ничего не вывело, потому что нечего выводить. Она не может вести слово "неопределено", потому что для пользователя нет такого понятия как "неопределено". Это только программистский. Мы тоже это не будем рассматривать.
Дальше у нас есть примитивный тип данных под названием "тип". Как бы это ни звучало странно. Давайте посмотрим, что с ним можно сделать и для чего он нужен. Следующее сообщение: "сообщить" вот такую команду попробуем дать 1С. Что я здесь написал? "Сообщить" - мы уже с вами знаем, что такое, это значит вывести сообщение для пользователя. Дальше "тип знач" - это встроенная функция, которая получает тип значения. Тип значения от переменной "зарплата Иванова". А откуда брать все эти функции и какие ещё функции есть в языке 1С, мы с вами рассмотрим чуть-чуть попозже. Сегодня. А мы получаем тип значения от переменной "зарплата Иванова". А этот тип, как уже знаем, является числом. Давайте посмотрим, что выведет 1С. "Число". То есть, 1С вывело тип значения. Если мы хотим получить тип, то мы вызываем функцию "тип значения". Для чего нужен этот примитивный тип под названием "тип"? Для того, чтобы сравнивать разные типы. Например, у нас есть переменная "фамилия сотрудника", равно "Иванов". И давайте попробуем сравнить, допустим, 1С у нас не знает, какой тип имеет "фамилия" и какой тип имеет "зарплата". И попробуем сравнить эти два типа. Это нам нужно будет для каких-то последующих вычислений. Например, ну, на практике, что может быть? Мы получили какие-то две переменные, мы их рассчитали, но судя по названию этих переменных, мы не знаем точно, какой в них содержится тип. И далее, в зависимости от типа, мы должны вызвать какую-то функцию или провести какой-то алгоритм, сделать какие-то вычисления. И вот, чтобы понять, к какому типу принадлежит наша переменная, мы можем использовать "тип". Вот: "нет", говорит "нет". То есть, что мы спросили? Является ли тип значения переменной "зарплаты Иванова" типу "фамилия сотрудника"? Нет, конечно, потому что "зарплата Иванова" у нас что? Число. А "фамилия сотрудника" - это у нас что? Строка. Соответственно, эти два типа не равны.
Также встречаются сложные типы данных, и некоторые из них мы с вами сейчас рассмотрим. Например, "массив" и "список значений". Что такое "массив"? Массив - это одна колонка Excel. В каждой ячейке содержится переменная. Все мы с вами знаем, что такое Excel и что такое ячейки. Вот представим себе одну колонку, в которую вписано много-много значений. В качестве примера, давайте сделаем следующее. Зададим переменную "массив". "Массив фамилий". "Массив фамилий равно массив". "Массив фамилий добавляем новый массив". "Добавляем сюда, например, Иванов". И добавим сюда "Петров". Вот таким образом. Что мы сделали? Мы инициализировали переменную под названием "массив фамилий" с помощью конструктора "новый массив". Теперь у 1С в памяти содержится некая вот эта коробочка, в которой ничего нет, на которой написано "массив фамилий", и 1С знает, что это не просто коробка, а в нём может содержаться много-много всего, потому что массив он у нас безразмерный. В 1С там может содержаться сколько угодно значений. И в этот, в эту коробку, далее мы начинаем добавлять потихоньку некоторые значения. То есть, добавляем туда фамилию "Иванова", добавляем туда фамилию "Петрова", и так далее. Можем добавлять их сколько угодно. Для чего используются массивы? Для того, чтобы, соответственно, на какое-то время хранить там какие-то значения.
Кроме типа "массив", у нас есть ещё какой тип? У нас есть ещё тип "список значений". Это то же самое, что и массив, только к каждой ячейке можно подписать комментарий. Давайте посмотрим на живом примере. "Список фамилий равно новый список значений". "Список фамилий добавить Иванов". И добавим ещё одно значение. Значит, что я сейчас сделал? Я создал переменную под названием "список фамилий". Эта переменная у нас является списком значений. То есть, у нас в этой картонной коробке лежит некая переменная, и мы говорим, что это список значений. А что такой список значений? Это некий список ячеек, и к каждой ячейке у нас какой-то комментарий добавлен. На самом деле, 1С для себя обычно не использует комментарии, а вот эти комментарии используются для интерактивного взаимодействия с пользователями. "Список фамилии добавили Иванов", "Петров". И как нам можно, например, показать пользователю этот список фамилий? Давайте ещё посмотрим: "показать выбор элемента". Значит, я 1С, чтобы она показала нам в виде меню выбор элемента из списка фамилий. Давайте запустим и посмотрим, что покажет 1С. Мы видим, что 1С предложила нам выбрать значение, и в качестве значения предлагает нам именно второй параметр, который мы задали в качестве представления, в качестве комментария. Давайте выберем любое значение. "Иванов". Всё, ничего не произошло, потому что алгоритм дальше мы не определяли. Закрываем. Во втором параметре списка содержится так называемое представление этого элемента. То есть, если мы будем обращаться по ключу "Иванов" в список значений, то 1С вместе с этим значением нам привяжет в памяти вот это представление этого значения. Повторюсь, что вот эти представления они нужны обычно в большей части, в подавляющей части программирования, именно для того, чтобы показать это пользователю. В редких каких-то случаях используется для других целей. Давайте посмотрим, что будет, если добавить ещё раз "Иванова" в список фамилий. Например, здесь напишем не "Иванов", а "Иванов, и". И уже "Иванов, например, ПП". Что покажет нам 1С? И 1С нам показала и "Иванова", и того, и другого. Что же будет, если мы, например, не будем задавать представление, а просто зам зададим значение? Давайте попробуем запустить и посмотрим, что будет. Соответственно, если у нас не задано представление, то 1С в качестве представления берёт значение. Всё просто. 1С не знает, что мы записали в комментарии, потому что комментарий пустой. Поэтому нужно вывести значение. Идём дальше.
Циклический оператор. 1С поддерживает три вида цикла: первые - это цикл по условию, второй - это цикл по счётчику, и третье - это цикл по коллекции. Давайте разберём сначала цикл по коллекции, потому что мы с вами уже как раз рассмотрели два новых типа переменных под названием "массив" и "список значений". А "массив" и "список значений" - это как раз являются коллекциями. Давайте попробуем вывести на экран список фамилий из массива. Напишем следующее: "Для каждого элемент массива из массив фамилий сообщить элемент массива фамилии". Что делает этот оператор? Этот оператор берёт массив фамилий, обходит каждый его элемент. То есть, у нас их тут два элемента: в первом содержится "Иванов", во втором "Петров". И для каждого этого элемента выполняет команду "сообщить". Давайте проверим. Действительно, у нас вывелось на экран два элемента: "Иванов" и "Петров". Вот таким простым способом можно обходить элементы массива. Точно так же можно обходить с помощью этого циклического оператора элементы списка значений, но тут есть небольшой нюанс. Давайте посмотрим, какой. И попробуем обойти список фамилий. Когда мы обходим список фамилий, как мы уже знаем, в списке значений у нас есть вот "Иванов" - первый параметр, второй - его представление. Вот тут "Иванов и". И мы с вами только что это рассмотрели. В каждом элементе будет содержаться вот эта фамилия "Иванов и". А вот в этом "Иванове" содержаться только "Иванов". А в качестве представления ничего не будет. Давайте посмотрим, что нам нужно вывести. Нам нужно в нашем случае мы выставляем "Ивана Ивановича". Здесь как будто ничего. Давайте посмотрим, что выведет 1С для наших представлений. В первом случае для первого элемента получился действительно "Иванов и". А в следующих случаях ничего нет, потому что представления у нас не заданы. В отличие от массива, мы должны здесь указать, что именно выводить: либо представление, либо значение. А если мы выведем просто "элемент списка фамилии", то давайте посмотрим, что выведет нам 1С. И 1С поступает мудро. Она, если задано представление, выводит представление. Если не задано представление, выводит значение. Но если мы хотим выводить прямо конкретно либо значение, либо представление, тогда мы должны здесь указать прямо чётко: либо "значение", либо "представление". Таким образом, мы рассмотрели цикл "для каждого", цикл обхода коллекции. Давайте теперь посмотрим, что такое цикл по условию. Пишется следующим образом: "пока цикл конец цикла". Это такой оператор, который будет проверять значение "истина" или "ложь", вот заданная вот здесь. "Пока счётчик, например, меньше двух". "Счётчик" сначала надо задать. [музыка] Си най создаёт мини с 1. Это сила 1 на бой создаёт. Что мы сейчас сделали? Для начала я присвоил ей значение ноль. Дальше я начал цикл. Цикл по условию. То есть, я буду говорить 1С, что пока счётчик у меня меньше двух, я должен выполнять все команды, которые находятся между словом "цикл" и словом "конец цикла". При первом проходе счётчик у нас чему равен? Ноль. Ноль меньше двух? Да, истина. Значит, мы входим в цикл и выполняем команду "сообщить". И чтобы цикл не стал бесконечным, мы должны счётчик увеличить на единицу. Иначе этот цикл превратится в бесконечный. "Счётчик присвоили значение счётчик плюс один". То есть, у нас он был ноль, теперь стал единицей. На следующем этапе мы проверяем: "счётчик меньше двух"? Да, у нас единица меньше по-прежнему двух. Мы опять выводим массив фамилии из массива фамилии, второй элемент, и опять счётчик.
увеличиваем на единицу. теперь счётчик нам у нас равен двум. проверяем счётчик меньше двух. нет, счётчик уже равен двум, поэтому мы выходим из цикла и идём дальше по коду.
ещё небольшое пояснение по команде "сообщить". в команду "сообщить" мы передаём параметр "массив фамилии" и в качестве вот такого параметра в квадратных скобках мы указываем номер нашего элемента. а нумерация в массиве начинается с нуля. вот "Иванов" будет иметь индекс ноль, а "Петров" будет иметь индекс один, потому что вся нумерация в списках 1С начинается с нуля. соответственно, из массива "фамилии" мы просим вытащить элемент с номером ноль. 1С смотрит, где у нас массив "фамилии" с индексом ноль. Ага, он говорит: "Ага, это Иванов у нас под индексом ноль". Окей, и выводит здесь "Иванова".
дальше, давайте попробуем убрать инкремент счётчика и посмотрим, что будет. 1С зависает, потому что мы вызвали так называемый бесконечный цикл. давайте завершим 1С принудительно через диспетчер задач либо через режим отладки. соответственно, это вот ошибочная ситуация, которую надо контролировать в процессе программирования, и все программисты должны очень внимательно относиться к этому циклу, потому что он может иногда впасть внезапно в бесконечный цикл. я такое встречал даже в типовой конфигурации.
итак, мы с вами рассмотрели цикл по условиям. идём дальше.
далее, давайте посмотрим, что такое цикл по счётчику. напишем следующий код: "для счётчик равно один по два цикл". и здесь выведем сообщение: "сообщение укажем массив фамилии счётчик". что мы здесь сделали? мы вызвали оператор "цикл по счётчику", и внутри этого оператора мы выводим сообщения, которые достают из массива "фамилии" элементы по номеру счётчика. не совсем правильно, номер счётчика минус один будет, потому что элементы у нас начинаются с нуля, а счётчик у нас начинается с единицы. вот этот момент важно учесть, и я специально здесь акцентирую.
то на второй итерации у нас будет ошибка. давайте попробуем вот вызвать ошибку в цикле: "индекс находится за пределами массива". когда счётчик будет равен двум, мы в массиве "фамилии" пытаемся найти этот элемент с индексом два, а его здесь нет, потому что у "Иванова" индекс ноль, у "Петрова" один, а элемента с номером два не существует. 1С выдаст ошибку, поэтому здесь счётчик мы должны минус один добавить, чтобы получить корректное значение. давайте проверим, что будет. вывелось "Иванов" и "Петров", что и требовалось получить.
ещё один вариант для понимания, что такое цикл по условию, я показываю на экране. мы берём имя переменной и пишем на каждой строке, что "имя переменной равно имя переменной плюс один" и так вот 10 раз. то есть мы хотим увеличивать имя переменной на единицу, на единицу, на единицу сколько-то раз, очень много раз. и чтобы не писать вот такие длинные-длинные куски кода, мы можем воспользоваться циклом по условию. и этот цикл будет выполняться, пока "имя переменной" будет меньше десяти. то есть мы пишем оператор "пока имя переменная меньше десяти" и в цикле присваиваем инкремент для этой переменной, то есть делаем плюс один вместо повторяющихся действий. то есть вот ещё одно применение цикла: не просто выводить что-то на экран, а делать какие-то повторяющиеся действия, вызывать какую-то функцию, вызывать какие-то обработки и так далее.
цикл по счётчику тоже самое иллюстрирует. мы можем задать имя переменной от одной до десяти и выводить эти переменные либо делать какие-то ещё функции, обработки автоматизировано, не выписывая код такими вот сложными способами, что до много-много раз повторять одно и то же. мы можем сделать это с помощью цикла по счётчику.
цикл по коллекции. вместо повторяющегося действия тоже пишем цикл, но он будет выводить, например, массива у нас, потому что цикл по коллекции работает только по коллекциям. это массив, список значений, соответственно, таблица значений или дерево значений.
[музыка]
дальше, давайте посмотрим, что такое процедуры и функции и зачем они нужны. мы с вами видим на экране, что у нас есть много кода, и если этого кода будет ещё больше, ещё больше и больше, больше, больше, он у нас займёт много-много места, и это будет не очень-то читаемо. кроме того, у нас есть, например, вот этот цикл, который мы хотим вызывать постоянно, много-много раз из разных мест программы. и чтобы избежать дублирования кода, мы с вами сделаем следующее: зададим процедуру под названием "суммирование". в этой процедуре мы будем производить суммирование двух чисел и выводить это на экран.
[музыка]
давайте попробуем воспользоваться этой функцией. суммируем зарплату Иванова и зарплату Петрова. вывелось число 150. мы уже с вами пытались суммировать это без помощи процедуры, функций. в этот раз я вызвал нашу новую процедуру, которую только что создали. в нашем случае это такой упрощённый пример. на самом деле, конечно, процедуры и функции используются для более сложных расчётов, когда у нас здесь есть много-много кода.
вот чем отличается процедура от функции. у нас есть процедуры, у нас есть функции, и процедура от функции отличается тем, что функция может просто возвращать значение, в отличие от процедуры. процедура не может вернуть значение.
давайте посмотрим, что же, в чём разница. назовём функцию "рассчитать сумму", и мы будем здесь не сообщать, а возвращать рассчитанное значение. давайте обратимся к этой функции и уже не будем вызывать процедуру, будем вызывать функцию и сразу сообщать её значение: "рассчитать сумму". что я здесь написал? я написал функцию, которая называется "рассчитать сумму". это я придумал сам это название. в качестве параметров я написал, что будет первое число и будет второе число. параметры перечисляются через запятую. и что делает эта функция? она с помощью ключевого слова "возврат" я возвращаю следующее значение, которое рассчитывается. мы берём число из первого параметра и берём число из второго параметра, суммируем их и передаём в то место, откуда мы вызвали эту функцию. где "сообщить"? мы вызываем эту функцию, передаём зарплату Иванова, зарплату Петрова, рассчитываем её внутри функции и возвращаем вот сюда, откуда вызывали, результат расчёта. то есть получится, что 150 мы вместо этой функции, как будто помещаем число 150. вот как будто здесь у нас будет 150. давайте в этом убедимся и выведем это на экран. на экране у нас 150.
что же такое функции, процедуры? давайте ещё раз закрепим. это способ объединить несколько строчек кода и назвать их каким-то словом, как и переменную. функция отличается от процедуры тем, что она может вернуть значение.
идём дальше. мы с вами только что посмотрели, как устроен программный модуль. он состоит из раздела объявления переменных, раздела процедур, функций и раздела основной программы. вот в чём мы можем убедиться. у нас сначала идёт объявление переменных, которые будут иметь значение "неопределено". дальше у нас пишутся процедуры, функции. когда этот блок процедур, функций у нас завершён, то есть у нас больше нет никаких функций, мы можем здесь уже писать блок основной программы. выполняться программный код 1С. сначала посмотрит, какие есть переменные, присвоит им значение "неопределено". потом посмотрит, какие есть процедуры и функции. она обработает их и проверит синтаксис, но выполнять их не будет. она пойдёт дальше вот в так называемое тело программы. а тело программы у нас вот эти как раз строчки, которые идут уже после всех процедур и функций.
мы не можем написать вот так. мы не можем процедуру поместить после основного кода. давайте убедимся в этом. попробуем сохранить. программа выдаёт ошибку, потому что говорит, что "определения процедуры, функции должны размещаться перед операторами тела модуля". окей, давайте это отменим, потому что это ошибка, программа не запустится. сначала идёт определение переменных, определение процедур, функций, и затем тело основной программы. при этом вот эти вот процедуры, функции, они могут вообще даже не выполняться. они могут быть просто написаны, и в итоге их никто никогда не вызовет, и программный код в них может никогда не выполниться, если мы их специально не вызовем. как мы видим здесь, мы вызываем функцию под названием "рассчитать сумму", и эта функция используется. а вот процедура "суммирования", получается, у нас не используется. такого не должно быть, это плохой код получается. если вы не используете какую-то процедуру или функцию, её не должно быть в этом модуле. вы её должны закомментировать, а лучше вообще удалить.
далее мы с вами рассмотрим, как работать со справкой. я сейчас много применял разных переменных, вызывал иногда встроенные функции, и хочу вам рассказать, откуда вы всё это можете самостоятельно узнать. большую часть вы можете подчеркнуть прямо из справки 1С в разделе "справка и содержание", "справка", "индекс справки" и "поиск по справке". также есть "синтаксис-помощник". "синтаксис-помощник" - это очень важный раздел, с которым программисты работают практически ежедневно, ежеминутно и ежечасно.
что же содержится в "синтаксис-помощнике"? содержание, индекс и поиск. обычно идёт поиск по индексу. например, мы хотим посмотреть, что же такое функция "сообщить". мы можем встать на кнопкой и сделать поиск по "синтаксис-помощнику". "синтаксис-помощник" нам говорит следующее, что какой синтаксис у этой команды. мы должны написать слово "сообщить", ввести текст сообщения и показать статус. текст сообщения - статус - это параметры. в первом параметре он является обязательным. здесь написано "текст сообщения" - обязательный. мы здесь как раз и пишем наш текст сообщения в виде зарплаты. а второй параметр в виде статуса, он необязательный, поэтому мы его здесь никогда с вами не указывали. но мы можем указать его, например, "статус сообщения важно". для необязательных параметров есть так называемое значение по умолчанию, которое 1С подставит в случае его отсутствия. значит, что мы ещё видим в "синтаксис-помощнике"? описание этой процедуры, команды. что делает эта непосредственно команда? что делает этот оператор? в данном случае выводит текст сообщения в окно сообщений. доступность. вам понадобится в те моменты, когда вы уже более глубоко начнёте проникать в программирование. доступность может быть на сервере или на тонком клиенте. это очень важно, потому что не все команды работают на тонком клиенте. если вы видите "тонкий клиент", значит, вы можете использовать вот в этом модуле управляемого приложения. а если будет написано "сервер", но не будет слова "тонкий клиент", то вот в нашем случае не сможем здесь ничего написать для серверных команд.
мы хотим, например, посмотреть, а что мы можем делать со строками 1С. и давайте поищем здесь. вот есть такое общее описание "встроенного языка", "примитивные типы", "строка". что такая строка? мы здесь можем почитать. давайте посмотрим, какие операторы, синтаксические конструкции. мы с вами видели наши циклы "если", "то", "иначе", и здесь ещё много разного интересного содержится.
давайте посмотрим, что содержится в "глобальном контексте". и вот то, что нам нужно. здесь "функции работы со значениями типа строка". раскроем и посмотрим, какие есть функции. давайте рассмотрим самое базовое. например, зададим две строки. значит, "фамилия равно Иванов", "имя равно Иван", "отчество отчество Иванович". и сейчас инициализируем три переменных: "фамилия", "имя" и "отчество". и мы хотим сделать ещё третью переменную, например, "фо", и она будет состоять у нас из фамилии, имени и отчества. как это можно сделать? можно просуммировать эти три переменные. давайте посмотрим, что выведет 1С. "Иванов Иван Иванович" без пробелов. то есть мы как задали, так нам и вывели. давайте тогда добавим пробелов сюда. вот. и давайте посмотрим, что получается в результате. "Иванов Иван Иванович". отлично, то, что и хотели.
так, допустим, теперь мы хотим только извлечь фамилию. для этого мы должны найти первый пробел. но, например, мы не знаем, у нас нет этих вот данных про фамилию, имя, отчество. у нас, например, есть вот целое "фо Иванов Иван Иванович", и из него мы хотим извлечь фамилию. а фамилию мы смотрим. Ага, нам надо найти первый пробел, и всё, что левее этого пробела, достать. это и будет наша фамилия. например, у нас такая структура, мы уверены, что это всё так. и давайте попробуем это сделать. у нас есть функция под названием "найти". в качестве параметров нам нужно подставить строку, подстроку поиска и направление поиска. в качестве строки мы будем использовать. давайте посмотрим. мы будем искать позицию и ищем пробел. "позиция пробела". давайте посмотрим, что нам выдаст 1С. "позиция пробела номер семь". отлично, мы уже знаем, что пробел находится в седьмой позиции, и нам нужно с первой по седьмую позицию вытащить строку. "фамилия равно". есть функция "лев", то есть "лево достать левую часть" какой-то строки. у нас есть пробел. мы знаем семь, но нам нужно всё без пробела, поэтому уменьшаем на единичку. "Иванов". отлично.
так, давайте теперь достанем имя из нашей "фо". для упрощения задачи, давайте сначала найдём имя отчества. имя отчества - это "Иван Иванович". мы "Иванова" уже нашли. давайте вытащим "Ивана Ивановича". есть функция "сред". в неё помещаем "фамилия", начальный номер - это у нас позиция пробела плюс один, и до конца. здесь количество символов мы можем не указывать. нам нужно строку до конца. здесь мы что сделали? вызвали функцию "сред". она из "фамилии", начиная с позиции пробела плюс один, вытащит всё, всё оставшееся. то есть найдёт пробел номер один, и вот здесь вот эту строку вытащит. давайте убедимся, что это так. "Иван Иванович". да, то, что и требовалось доказать.
а теперь давайте уже из этой подстроки вытаскивать имя. имя той же функцией "лев" достаём из "имя отчества". здесь нам нужна позиция пробела из "имя отчества". уже позиция пробела. таким образом, мы берём "имя отчества", вытаскиваем строку до позиции пробела минус один. и давайте посмотрим, что получается. "Иван". что и требовалось доказать.
теперь давайте вытащим оставшееся, то есть отчество. а что такое отчество? у нас здесь получается подстрока "Иван Иванович". вот здесь мы её определили, вытащили. значит, как же нам получить отчество? вот мы можем взять функцию "сред", как мы уже и делали. найти нам первый пробел, который там находится. вот у нас он, пробел плюс один, и до конца. и вызовем функцию "сообщить". покажем "отчество Иванович". отлично.
вот мы с вами посмотрели, как можно работать с функциями, которые относятся к типу "строка". какие ещё могут быть функции? у нас есть, например, функция, которая удаляет лишние пробелы. например, у нас есть вот такое выражение под названием "имя с пробелами". например, вот так вот "имя сигизмунд". мы тут каких-то пробелов у нас пользователь на вводил где-то там. вот мы попросили ввести имя, и вот как-то так вот ввёл эти все пробелы. как же нам сделать так, чтобы пробелов не было в итоговой строке, которую мы запишем в базу данных? мы можем здесь вот написать "заменить". и говорим, что у нас есть пробелы, и мы хотим убрать эти пробелы. таким образом, давайте посмотрим, что будет. в качестве имени с пробелами "сигизмунд" без пробелов. то есть вот эта функция "заменить" она берёт первый параметр и ищет в нём символы, которые мы указали во втором параметре, и заменяет их на символы из третьего параметра, то есть на пустую строку. то есть вот этот, например, находит пробел и меняет его на пустую строку, находит ещё пробел, ещё меняет его на пустую строку, и так далее, пока вот по всей строке пробегает, всё удаляет.
есть, например, ещё часто используемая функция "длина". "длина строки равно". смотрим, сколько у нас занимает итоговое имя уже без пробелов. и сообщим, сколько у нас символов в имени "сигизмунд". в имени с пробелами "девять". да, таким образом, вот в этом разделе, в этой ветке дерева "синтаксис-помощника" вы можете посмотреть, какие ещё есть функции для работы со строками. например, мы можем взять вот так и поместить процедуру, например, "процедура работа со строками". и вот так вот красиво у нас получится, что мы убрали это всё в процедуру. мы с вами настроили, что процедуры, функции можно сворачивать, и мы её, например, свернём, и будет вот так красиво. и вызовем. вот такая получается красота. в итоге всё перенесли в "работу со строками" и одним словом вызываем эту процедуру. а всё остальное мы не смотрим, чтобы отладка нам нас не напрягала при программировании.
давайте посмотрим, что будет. мы вызвали "работу со строками", и 1С поняла, что нам нужно вызвать эту процедуру, зашла в неё, выполнила весь код по порядку и вернулась туда, откуда её вызвали, пошла дальше. тут можно, кстати, два раза вызвать её. для чего нам нужны процедуры, функции? чтобы можно было много-много раз из разных мест вызывать. вот мы четыре раза вызовем один и тот же код. вот, пожалуйста, он четыре раза отработал. давайте это пока закомментируем.
и давайте попробуем посмотреть, какие есть функции для работы с типом "число". "число один равно 100". например, "число два равно 14.155". то есть число пи, например, нам нужно. как задаётся число? соответственно, с помощью чисел, да. то есть мы задали число и поместили в переменную "число один". и вот теперь там лежит число один. 1С понимает, что в этой ячейке, в этой картонной коробке внутри ящика находится число 100, и на боку написано "число". а в другом ящике с надписью "число" содержится 3.11. то есть это число с дробной частью. мы дробную часть отделяем с помощью точки. всегда. и в конце мы, конечно же, ставим всегда точку с запятой в конце любого оператора.
как же, например, получить нам целую часть из числа пи? есть и пишем число. таким образом, что мы сейчас на экране увидим? число. также можно округлить, например, с помощью функции "окр". мы можем число пи округлить. здесь написано, что параметр "число" обязательный. мы его как раз указали. "число пи". разрядность необязательная. по умолчанию значение ноль, то есть до целого числа округляет. давайте посмотрим, что выведет. вывело число три, по правилам округления, потому что у нас здесь один, один округляется до нуля.
далее, у нас есть ещё режим округления. "режим округления". давайте посмотрим, что тут такое. "режим округления". округлять полтора до единички или округлять полтора до двух? в разных ситуациях может потребоваться разная. давайте попробуем, допустим, полтора. как пять. давайте число пи у нас будет 3,5. давайте посмотрим. то есть мы 3 с половиной округлили до трёх. давайте теперь по-другому напишем. до двух. здесь три. округлили 3 с половиной до четырёх. давайте посмотрим, что по умолчанию. как округляет? округляет до четырёх. то есть вот это берётся режим округления необязательный, но он говорит, что по умолчанию полтора будет округлять до следующего числа целого.
всё это также можно на процедуру перенести. "1С сила 1". наш бой громовский код убрали в процедуры, функции и вызываем только две строчки: "работа со строками" и "работа с числами". запустили, всё отработало, всё на экране, всё компактно.
на этом сегодняшний урок закончен. жду вас на своём Telegram-канале под названием "фрилансер 1С". я на фрилансе уже больше лет, а в IT уже больше 30 лет, поэтому заходите, читайте, подписывайтесь. там только мои статьи. я не пишу при помощи чатов GPT и не использую разные ИИ для того, чтобы писать статьи. всё пишу самостоятельно, потому что у искусственного интеллекта нет того опыта, того чувственного опыта, тех эмоций, которые переживал я, и тех идей, которые вывел я для себя спустя 20 лет на фрилансе и 30 лет на IT в IT. найдите, подписывайтесь, ставьте лайки, пишите комментарии. пишите в комментариях, что было непонятно, что было понятно, что, может быть, ещё какие-то видео другие снять. пока-пока.
[музыка]
[аплодисменты]
[музыка]