Базовый синтаксис

В этом разделе содержится описание основных элементов синтаксиса языка «1С:Элемент» с примерами. В конце каждого раздела находится ссылка на подробное описание соответствующей темы.

Комментарии

Используйте комментарии для добавления пояснений к коду. Язык «1С:Элемент» поддерживает однострочные (строчные) и многострочные (блочные) комментарии:

// Это строчный комментарий — игнорируется компилятором
метод Скрипт()
    /* Это блочный комментарий
       на нескольких строках */
    Консоль.Записать("Рабочий код!")
;

Вывод в стандартный поток вывода

Для вывода информации в стандартный поток вывода используйте метод Записать() типа Консоль:

метод Скрипт()
    Консоль.Записать("Привет ")
    Консоль.Записать("мир!")
;

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

• \н — перенос строки,
• \т — табуляция,
• \ — экранирующий символ.

метод Скрипт()
    // Новая строка и табуляция
    Консоль.Записать("Список:\н\т1. Первый\н\т2. Второй\н\т3. Третий")
    
    // Экранирование кавычек и обратных слэшей
    Консоль.Записать("Путь: C:\\\\Users\\\"Имя\"\\")
    Консоль.Записать("Он сказал: \"Привет!\"")
;

примечание

Подробнее о консоли.

Чтение из стандартного потока ввода

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

• СчитатьСимвол() — получает от пользователя один символ.
• СчитатьСтроку() — получает от пользователя несколько символов (строку).
• СчитатьЧисло() — получает от пользователя числовое значение. Формат ввода определяется локалью, которую использует консоль.
• СчитатьБулево() — запрашивает у пользователя значения типа Булево. Фактически, пользователю предлагается ввести какое-либо из значений: Истина, Ложь, True, False (при вводе учитывается регистр).
• СчитатьПароль() — считывает и возвращает из входящего потока пароль типа Строка. При вводе символов вывод в консоль не осуществляется.

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

метод Скрипт()
    пер ВашеСлово = Консоль.СчитатьСтроку("Введите любое слово: ")
    Консоль.Записать("Вы ввели слово: " + ВашеСлово)
;

примечание

Подробнее о консоли.

Переменные

Используйте переменные для временного хранения данных в программе. Переменные объявляются внутри тела метода с помощью модификаторов, после которых указывается имя переменной и, при необходимости, ее тип:

• пер — переменная, доступная для записи и чтения;
• знч — переменная, доступная только для чтения;
• исп — переменная, доступная только для чтения. При этом для закрытия используемого ресурса при выходе из области видимости для такой переменной вызывается метод Закрыть().

Объявить константу можно с помощью модификатора конст. Константу можно объявлять вне тела метода и нельзя изменять.

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

Пример использования модификаторов конст, пер и знч:

// Неизменяемое значение записывается в константу
конст ПИ = 3.14

метод АнализКруга(Р: Число)
    пер Радиус: Число
    Радиус = Р    
    знч Площадь = ПИ * Радиус * Радиус
    Площадь = 100 // Ошибка! Переменная Площадь доступна только для чтения
    Консоль.Записать("Площадь круга радиуса $Р равна $Площадь")
;

Пример использования модификатора исп:

// Откроет файл, выведет содержимое файла в консоль и после этого закроет файл
метод ПрочитатьФайл()
    исп ПотокЧтения = новый Файл("test.txt").ОткрытьПотокЧтения()
    Консоль.Записать(ПотокЧтения.ПрочитатьКакСтроку())
;

примечание

Подробнее об объявлении переменных.

Строковые шаблоны

Используйте строковые шаблоны для удобного форматирования строк с динамическими значениями. Строковые шаблоны используют интерполяцию для вставки значений переменных в строку. Для простых переменных применяйте $имя, для выражений — ${выражение}, для использования форматированного вывода — %имя:

метод Скрипт()
    пер ТекущееЧисло = 1000000
    // Интерполяция простой переменной
    пер Сообщение = "Число равно $ТекущееЧисло" // Число равно 1 000 000
    Консоль.Записать(Сообщение)
    
    ТекущееЧисло = 99999
    // Интерполяция выражения с вызовом метода
    пер НовоеСообщение = "${Сообщение.Заменить("равно", "было равно")}, но теперь равно %ТекущееЧисло"
    
    Консоль.Записать(НовоеСообщение) // Число было равно 1 000 000, но теперь равно 99999
;

примечание

Подробнее про интерполяцию строк.

Методы

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

Метод с двумя параметрами типа Число и возвращаемым значением типа Число:

метод Сумма(А: Число, Б: Число): Число
    возврат А + Б
;

метод Скрипт()
    пер Число = Сумма(3, 5)
    Консоль.Записать("Сумма 3 и 5 равна $Число")
;

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

метод ВывестиСумму(А: Число, Б: Число)
    Консоль.Записать("Сумма $А и $Б равна ${А + Б}")
;

// Метод не возвращает значения, «ничто» используется только для улучшения читаемости 
метод ВывестиРазность(А: Число, Б: Число): ничто
    Консоль.Записать("Разность $А и $Б равна ${А - Б}")
;

метод Скрипт()
    ВывестиСумму(-1, 8)
    ВывестиРазность(10, 5)
;

примечание

Подробнее о методах.

Подробнее о ключевом слове ничто.

Импорт

Используйте директиву #требуется для подключения внешних скриптов. Объявляйте все зависимости в начале файла до любого исполняемого кода. Указывайте пути к подключаемым скриптам относительно текущего файла или используйте абсолютные системные пути.

// Подключение скрипта с использованием относительного пути
#требуется ./Логирование.sbsl 

// Импорт скрипта с использованием абсолютного пути
#требуется C:\test\Фигура.sbsl

метод Скрипт()
    пер Фигура = новый Фигура.Прямоугольник(10, 5)
    Консоль.Записать("Площадь фигуры: ${Фигура.Х * Фигура.У}")
    Логирование.ЗаписатьЛог()
;

примечание

Подробнее о модульной разработке.

Условная инструкция «если»

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

метод ЭтоЧетыре(А: Число): Строка
    если А == 4
        возврат "Верно!"
    ;
    возврат "Не верно!"
;

метод Скрипт()
    пер Число = Консоль.СчитатьЧисло("Сколько будет 2+2?\н")
    Консоль.Записать(ЭтоЧетыре(Число))
;

Используйте блок иначе для указания действий, если значение условия — Ложь:

метод Максимум(А: Число, Б: Число): Число
    если А > Б
        возврат А
    иначе
        возврат Б
    ;
;

метод Скрипт()
    Консоль.Записать("Максимум 0 и 42 равен " + Максимум(0, 42))
;

Инструкция если поддерживает любой уровень вложенности и любые инструкции языка:

метод ВДиапазоне(А: Число): Строка 
    если А == 0
        возврат "А равно 0"
    иначе если А < 10
        возврат "А меньше 10"
    иначе если А >= 10 и А < 15
        возврат "А больше или равно 10, но меньше 15"
    иначе
        возврат "А строго больше 15"
    ;
;

метод Скрипт()
    пер Число = Консоль.СчитатьЧисло("Введите число: ")
    Консоль.Записать(ВДиапазоне(Число))
;

Для работы с несколькими логическими выражениями используйте логические операторы или/и/не (подробнее), а также тернарный оператор ?: (подробнее):

метод ПроверитьТреугольник(А: Число, Б: Число, В: Число)
    пер Условие1 = (А + Б) > В
    пер Условие2 = (А + В) > Б
    пер Условие3 = (Б + В) > А
    
    если Условие1 и Условие2 и Условие3
        // Тернарный оператор для определения типа треугольника
        пер Тип = (А == Б и Б == В) ? "равносторонний" : 
                 (А == Б или А == В или Б == В) ? "равнобедренный" : "разносторонний"
        Консоль.Записать("Можно построить ${Тип} треугольник")
    иначе если (А + Б == В) или (А + В == Б) или (Б + В == А)
        Консоль.Записать("Точки лежат на одной прямой")
    иначе если не (А > 0 и Б > 0 и В > 0)
        Консоль.Записать("Некорректный ввод. Все стороны должны быть > 0")
    иначе
        Консоль.Записать("Треугольник нельзя построить" + 
                         (А > Б + В ? " (сторона А слишком велика)" : ""))
    ;
;

метод Скрипт()
    ПроверитьТреугольник(3, 4, 5)   // Можно построить разносторонний треугольник
    ПроверитьТреугольник(5, 5, 5)   // Можно построить равносторонний треугольник
    ПроверитьТреугольник(5, 5, 8)   // Можно построить равнобедренный треугольник
    ПроверитьТреугольник(1, 1, 2)   // Точки лежат на одной прямой
    ПроверитьТреугольник(10, 2, 3)  // Треугольник нельзя построить (сторона А слишком велика)
;

примечание

Подробнее об инструкции если.

Цикл «для»

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

Используйте цикл для из для последовательного обхода всех элементов коллекции:

метод Скрипт()
    пер Элементы = ["яблоко", "банан", "киви"]
    для Элемент из Элементы
        // Выведет в консоль каждый элемент коллекции
        Консоль.Записать(Элемент)
    ;
;

Используйте цикл для по для обхода коллекции с указанием диапазона индексов и шага:

метод Кварталы()
    пер Месяцы = ["январь", "февраль", "март", "апрель", "май", "июнь", 
                    "июль", "август", "сентябрь", "октябрь", "ноябрь", "декабрь"]
    
    для Кв = 0 по Месяцы.Размер()-1 шаг 3
        Консоль.Записать("Квартал ${Кв/3+1}: ${Месяцы[Кв]}, ${Месяцы[Кв+1]}, ${Месяцы[Кв+2]}")
    ;
;

примечание

Подробнее о цикле для из.

Подробнее о цикле для по.

Цикл «пока»

Используйте цикл пока для выполнения цикла, пока выполняется условие.

метод УгадайЧисло()
    пер СекретноеЧисло = 42
    пер Попытка = 0
    пер Попытки = 0
    
    Консоль.Записать("Угадайте число от 1 до 100!")
    пока Попытка != СекретноеЧисло
        Попытки += 1
        Попытка = Консоль.СчитатьЧисло()
        
        если Попытка < СекретноеЧисло
            Консоль.Записать("Слишком мало! Попробуйте еще:")
        иначе если Попытка > СекретноеЧисло
            Консоль.Записать("Слишком много! Попробуйте еще:")
        ;
    ;
    Консоль.Записать("Поздравляем! Вы угадали число ${СекретноеЧисло}. Попыток: ${Попытки}")
;

примечание

Подробнее о цикле пока.

Управление циклами

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

Используйте ключевое слово прервать для досрочного выхода из цикла:

метод НайтиПервоеОтрицательное(Числа: Массив<Число>)
    для Индекс = 0 по Числа.Размер() - 1
        если Числа[Индекс] < 0
            Консоль.Записать("Первое отрицательное: ${Числа[Индекс]} на позиции ${Индекс+1}")
            // Цикл прервется после нахождения первого отрицательного числа
            прервать
        ;
    ;
;

метод Скрипт()
    пер Данные = [8, 5, 12, -3, 7, -1, 4]
    НайтиПервоеОтрицательное(Данные)  // Найдет -3 на позиции 4
;

Используйте ключевое слово продолжить для пропуска текущей итерации:

метод ВывестиНечетные(Числа: Массив<Число>)
    для Число из Числа
        если Число % 2 == 0
            продолжить  // Пропускаем четные числа
        ;
        Консоль.Записать("Нечетное: ${Число}")
    ;
;

метод Скрипт()
    пер Данные = [1, 2, 3, 4, 5, 6]
    ВывестиНечетные(Данные)
;

примечание

Подробнее о ключевых словах циклов.

Инструкция «выбор»

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

метод ВремяГода(Месяц: Число): Строка
    выбор Месяц
    когда 12, 1, 2
        возврат "Зима"
    когда 3, 4, 5
        возврат "Весна"
    когда 6, 7, 8 
        возврат "Лето"
    когда 9, 10, 11 
        возврат "Осень"
    иначе 
        возврат "Неверный месяц"
    ;
;

метод Скрипт()
    Консоль.Записать("Январь: " + ВремяГода(1))      // Зима
    Консоль.Записать("Апрель: " + ВремяГода(4))      // Весна
    Консоль.Записать("Сентябрь: " + ВремяГода(9))    // Осень
;

примечание

Подробнее об инструкции выбор.

Области видимости

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

Примеры областей видимости переменных внутри метода:

метод ДемонстрацияОбластиВидимости()
    // Область видимости метода
    пер ГлобальнаяПеременная = "Доступна везде в методе"
    
    // Область видимости цикла
    для Индекс = 1 по 10
        пер ЛокальнаяВЦикле = "Доступна только внутри цикла"
        Консоль.Записать("Цикл: ${Индекс}, ${ЛокальнаяВЦикле}")
        
        // Область видимости условия
        если Индекс % 2 == 0
            пер ЛокальнаяВУсловии = "Доступна только в этом условии"
            Консоль.Записать("Четное: ${ЛокальнаяВУсловии}")
        иначе
            Консоль.Записать("Нечетное")
        ;
    ;
    
    // Доступ к этим переменным вызовет ошибку:
    ЛокальнаяВЦикле = "Изменить значение!"
    ЛокальнаяВУсловии = "Изменить значение!"
;

примечание

Подробнее об области видимости.

Коллекции

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

Перебор элементов коллекции с помощью цикла для:

метод Скрипт()
    пер Фрукты = ["яблоко", "банан", "киви"]
    для Фрукт из Фрукты
        // Выведет в консоль каждый элемент коллекции
        Консоль.Записать(Фрукт)
    ;
;

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

метод Скрипт()
    пер Фрукты = ["айва", "банан", "апельсин", "яблоко", "киви", "ананас"]
    пер Результат = Фрукты
        .Фильтровать(Элемент -> Элемент.НачинаетсяС("а"))
        .СортироватьПо(Элемент -> Элемент.Длина())
        .Преобразовать(Элемент -> Элемент.ВВерхнийРегистр())
    // Отфильтрует элементы, которые начинаются с буквы «а»
    // по возрастанию длины слова в верхнем регистре
    Консоль.Записать(Результат) // [АЙВА, АНАНАС, АПЕЛЬСИН]
;

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

метод АнализироватьМассив()
    пер Числа = [15, 3, 42, 8, 27]
    
    // Проверка на пустоту
    если Числа.Пусто()
        Консоль.Записать("Массив пуст!")
        возврат
    ;
    
    Консоль.Записать("Исходный массив: ${Числа}")
    
    // Проверка наличия элемента
    пер Искомое = 8
    если Числа.Содержит(Искомое)
        Консоль.Записать("Найдено число: ${Искомое}")
    ;
    
    // Сортировка и базовый анализ
    пер Отсортированные = Числа.Сортировать()
    Консоль.Записать("Отсортировано: ${Отсортированные}")
    
    // Расчет характеристик
    пер Размер = Отсортированные.Размер()
    пер Мин = Отсортированные[0]
    пер Макс = Отсортированные[Размер - 1]
    пер Среднее = Отсортированные.Сумма() / Размер
    
    Консоль.Записать("Размер: ${Размер}, Мин: ${Мин}, Макс: ${Макс}, Среднее: ${Среднее}")
    
    // Фильтрация по условию
    пер Четные = Отсортированные.Фильтровать(Ч -> Ч % 2 == 0)
    Консоль.Записать("Четные числа: ${Четные}")
;

метод Скрипт()
    АнализироватьМассив()
;

примечание

Подробнее о коллекциях.

Структуры

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

структура Прямоугольник
    // Публичные поля только для чтения
    обз знч Х: Число
    обз знч У: Число
    
    // Метод экземпляра
    метод Площадь(): Число
        возврат Х * У
    ;
;

метод Скрипт()
    // Создание экземпляра через конструктор
    пер Фигура = новый Прямоугольник(1, 2)
    Консоль.Записать("Прямоугольник со сторонами (${Фигура.Х}, ${Фигура.У}) имеет площадь ${Фигура.Площадь()}")
;

примечание

Подробнее о структурах.

Перечисления

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

перечисление ОперационныеСистемы
    Linux,
    macOS,
    Windows умолчание  // Значение, используемое по умолчанию
;

метод Скрипт()
    // Объявление переменной типа перечисления
    пер ИспользуемаяОС: ОперационныеСистемы
    
    // Присвоение конкретного значения из перечисления
    ИспользуемаяОС = ОперационныеСистемы.Windows
    
    // Преобразование значения перечисления в строку
    Консоль.Записать("Используемая ОС: " + ИспользуемаяОС)
;

примечание

Подробнее о перечислениях.

Создание экземпляров типов

Создавайте экземпляры типов с помощью конструкторов или литералов. Для вызова конструктора используйте ключевое слово новый:

структура Книга
    обз знч Название: Строка
    обз знч Год: Число
    обз знч Жанры: Массив<Строка>
;

метод Скрипт()
    // Создание экземпляров типов
    пер Книги = <Книга>[
        новый Книга("Программирование", 2023, <Строка>["Техническая"]),
        новый Книга("История искусств", 2020, <Строка>["Искусство", "Образование"])
    ]
    
    Консоль.Записать("Каталог книг:")
    для Книга из Книги
        Консоль.Записать(" - %{Книга.Название} (%{Книга.Год})")
    ;
;

примечание

Подробнее о ключевом слове новый.

Обнуляемые значения и проверки на «Неопределено»

Используйте обнуляемые типы для безопасной работы с потенциально отсутствующими значениями. Явно помечайте такие типы суффиксом ? и всегда проверяйте значение на равенство Неопределено перед использованием:

метод ПолучитьНомерМесяца(Название: Строка): Число?
    пер Месяцы = ["январь", "февраль", "март", "апрель", 
                "май", "июнь", "июль", "август",
                "сентябрь", "октябрь", "ноябрь", "декабрь"]
    
    // Нормализация ввода
    пер Нормализованный = Название.ВНижнийРегистр()
    
    // Поиск номера месяца в массиве
    для Индекс = 0 по Месяцы.Размер()-1
        если Месяцы[Индекс] == Нормализованный
            возврат Индекс + 1  // Возвращаем найденный номер месяца
        ;
    ;
    
    возврат Неопределено  // Месяц не найден
;

метод ОпределитьВремяГода(Месяц: Строка): Строка
    
    пер НомерМесяца: Число? = ПолучитьНомерМесяца(Месяц)
    
    если НомерМесяца == Неопределено
        возврат "${Месяц} — неверное название месяца!"
    ;
    
    выбор НомерМесяца
    когда 12, 1, 2
        возврат "Зима"
    когда 3, 4, 5 
        возврат "Весна"
    когда 6, 7, 8 
        возврат "Лето"
    когда 9, 10, 11 
        возврат "Осень"
    иначе 
        возврат "Ошибка: недопустимый номер месяца"
    ;
;

метод Скрипт()
    Консоль.Записать(ОпределитьВремяГода("апрель"))    // Весна
    Консоль.Записать(ОпределитьВремяГода("Декабрь"))   // Зима
    Консоль.Записать(ОпределитьВремяГода("июль"))      // Лето
    Консоль.Записать(ОпределитьВремяГода("Сентябрь"))  // Осень
    Консоль.Записать(ОпределитьВремяГода("Лето"))      // Лето — неверное название месяца!
;

Используйте специальные операции доступа при работе с типом Неопределено:

• ! — настойчивая операция,
• ?. — операция безопасного доступа,
• ?? — значение по умолчанию.

метод Скрипт()
    пер Заказ1: Число? = 1200
    пер Заказ2: Число? = Неопределено
    
    пер СтатусЗаказа1 = Заказ1 > 1000 ? "Крупный заказ!" : "Обычный заказ"
    
    // Настойчивая операция: гарантия что Заказ1 != Неопределено
    пер НомерЗаказа = "ORD-" + Заказ1!.ВСтроку()  // "ORD-1200"
    
    // Безопасный доступ: обработка возможного отсутствия заказа с использованием значения по умолчанию
    пер СуммаЗаказа2 = Заказ2?.ВСтроку() ?? "Заказ не оформлен"
    
    Консоль.Записать("Заказ ${НомерЗаказа}: ${СтатусЗаказа1}")
    Консоль.Записать("Статус второго заказа: ${СуммаЗаказа2}")
    
    // Расчет скидки
    пер СкидкаВПроцентах: Число? = 15
    // Если значение СкидкаВПроцентах не определено, то используется значение по умолчанию
    пер ЦенаСоСкидкой = Заказ1 * (100 - (СкидкаВПроцентах ?? 5)) / 100
    Консоль.Записать("Цена со скидкой ${СкидкаВПроцентах ?? 5}%: ${ЦенаСоСкидкой} руб")
;

примечание

Подробнее о типе Неопределено.

Проверки соответствия типов

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

метод ПолучитьДлинуСтроки(Объект: Объект): Число?
    если Объект это Строка
        пер СтроковоеЗначение = Объект как Строка
        возврат СтроковоеЗначение.Длина()
    ;
    возврат Неопределено
;

метод Скрипт()
    пер ТестоваяСтрока = "Тестовая строка"
    пер ТестовоеЧисло = 1000
    пер Результат1 = ПолучитьДлинуСтроки(ТестоваяСтрока) ?? "Не строка"
    пер Результат2 = ПолучитьДлинуСтроки(ТестовоеЧисло) ?? "Не строка"
    Консоль.Записать("Длина '${ТестоваяСтрока}': ${Результат1}")
    Консоль.Записать("Длина '${ТестовоеЧисло}': ${Результат2}")
;

Используйте операцию это для проверки параметризованных типов коллекций:

метод ПримерСМассивами()
    ПроверитьМассив(<Число>[1, 2, 3])
    ПроверитьМассив(<Строка>["а", "б", "в"])
    ПроверитьМассив(<Объект>[1, Истина])
;

метод ПроверитьМассив(Массив: Объект)
    если Массив это Массив<Число>
        Консоль.Записать("Массив чисел")
    иначе если Массив это Массив<Строка>
        Консоль.Записать("Массив строк")
    иначе
        Консоль.Записать("Другой массив")
    ;
;

метод Скрипт()
    ПримерСМассивами()
;

примечание

Подробнее об операции это.

Приведение типов

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

метод Скрипт()
    пер ПеременнаяА: Строка|Число = ""
    пер ПеременнаяБ: Строка|Число|Булево = 0
    пер ПеременнаяВ: неизвестно
    
    ПеременнаяВ = ПеременнаяБ как Число
    ПеременнаяА = ПеременнаяБ как Строка|Число
    
    ОбработатьОбъект("текст")
    ОбработатьОбъект(42)
    ОбработатьОбъект(Истина)
;

метод ОбработатьОбъект(Параметр: Объект)
    если Параметр это Строка
        ОбработатьСтроку(Параметр как Строка)
    иначе если Параметр это Число
        ОбработатьЧисло(Параметр как Число)
    иначе если Параметр это Булево
        ОбработатьБулево(Параметр как Булево)
    ;
;

метод ОбработатьСтроку(Текст: Строка)
    Консоль.Записать("Получена строка: ${Текст}")
;

метод ОбработатьЧисло(ЧислоДляОбработки: Число)
    Консоль.Записать("Получено число: ${ЧислоДляОбработки}")
;

метод ОбработатьБулево(Флаг: Булево)
    Консоль.Записать("Получен флаг: ${Флаг}")
;

Для приведения типов используйте стандартные методы и конструкторы этих типов:

метод Скрипт()
    // Преобразование строки в число
    пер ЧисловаяСтрока = "42"
    пер ЧислоИзСтроки = новый Число(ЧисловаяСтрока)
    Консоль.Записать("Число из строки: ${ЧислоИзСтроки}")
    
    // Преобразование числа в строку
    пер ПростоеЧисло = 3.14
    пер СтрокаИзЧисла = ПростоеЧисло.ВСтроку()
    Консоль.Записать("Строка из числа: ${СтрокаИзЧисла}")
    
    // Преобразование булева значения
    пер ЛогическийФлаг = Истина
    пер СтрокаИзБулева = ЛогическийФлаг.ВСтроку()
    Консоль.Записать("Строка из флага: ${СтрокаИзБулева}")
    
    // Комбинированное преобразование
    пер СуммаКакСтрока = (ЧислоИзСтроки + ПростоеЧисло).ВСтроку()
    Консоль.Записать("Сумма как строка: ${СуммаКакСтрока}")
;

примечание

Подробнее об операции как.

Лямбда-выражения

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

метод Скрипт()
    // Простые математические операции
    пер Умножить = (А: Число, Б: Число) -> А * Б
    пер Разделить = (А: Число, Б: Число) -> А / Б
    
    Консоль.Записать("5 * 3 = ${Умножить(5, 3)}")  // 15
    Консоль.Записать("10 / 2 = ${Разделить(10, 2)}")  // 5
    
    // Проверка условий
    пер Четное = (Условие: Число) -> Условие % 2 == 0
    Консоль.Записать("8 четное? ${Четное(8)}")  // Да
    Консоль.Записать("7 четное? ${Четное(7)}")  // Нет
    
    // Работа со строками
    пер Приветствие = (Имя: Строка) -> "Привет, $Имя!"
    Консоль.Записать(Приветствие("Анна"))  // Привет, Анна!
;

примечание

Подробнее о лямбда-выражениях.

Исключения

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

Используйте стандартные исключения при работе с базовыми типами:

метод ПолучитьЭлемент(Массив: Массив<Число>, Индекс: Число): Число
    если Индекс < 0 или Индекс >= Массив.Размер()
        выбросить новый ИсключениеИндексВнеГраниц(
            "Индекс ${Индекс} вне диапазона [0, ${Массив.Размер() - 1}]"
        )
    ;
    возврат Массив[Индекс]
;

метод Скрипт()
    пер Числа = [10, 20, 30, 40]
    пер Результат: Число? = Неопределено
    
    попытка
        // Попытка получить элемент
        Результат = ПолучитьЭлемент(Числа, 2)  // Корректный индекс
        Консоль.Записать("Значение элемента: ${Результат}")
        
        // Теперь попробуем неверный индекс
        Результат = ПолучитьЭлемент(Числа, 5)
        Консоль.Записать("Этот код не выполнится")
    поймать Искл: ИсключениеИндексВнеГраниц
        Консоль.Записать("${Искл.Описание}. Массив: ${Числа}")
    вконце
        // Этот блок выполнится в любом случае
        знч Сообщение = (Результат == Неопределено) ? "нет" : "${Результат}"
        Консоль.Записать("Обработка завершена. Последний результат: $Сообщение")
    ;
;

Используйте пользовательские исключения, чтобы определить собственные типы ошибок:

исключение ОшибкаПроверкиДанных
    обз пер КодОшибки: Число
;

метод ПроверитьEmail(Почта: Строка)
    если не Почта.Содержит("@")
        выбросить новый ОшибкаПроверкиДанных (
            Описание = "Ошибка проверки данных",
            КодОшибки = 1001)
    ;
;

метод Скрипт()
    попытка
        ПроверитьEmail("user.example.com")  // Нет @
    поймать Искл: ОшибкаПроверкиДанных
        Консоль.Записать("Ошибка! Код: ${Искл.КодОшибки}, Описание: ${Искл.Описание}.")
    ;
;

примечание

Подробнее об исключениях.

Аннотации

Аннотации добавляют метаданные к элементам кода и влияют на их поведение. Используйте @ИмяАннотации перед объявлением элемента для применения аннотации.

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

Скрипт Константы.sbsl с описанием константы, которая видна в других скриптах:

Константы.sbsl

@Глобально
конст КГ_В_ПУДЕ = 16.38

В скрипте Скрипт.sbsl можно использовать константу из скрипта Константы.sbsl с аннотацией @Глобально:

Скрипт.sbsl

#требуется Константы.sbsl

@Локально
метод ПереводВКилограммы(Пуды: Число): Число
    возврат Пуды * Константы.КГ_В_ПУДЕ
;

@Локально
метод ПереводВПуды(Килограммы: Число): Число
    возврат Килограммы / Константы.КГ_В_ПУДЕ
;

метод Скрипт()
    // Демонстрация работы с константой
    Консоль.Записать("В одном пуде: ${Константы.КГ_В_ПУДЕ} кг")
    
    // Конвертация пудов в килограммы
    пер Пуды = 10
    Консоль.Записать("${Пуды} пудов = ${ПереводВКилограммы(Пуды)} кг")
    
    // Конвертация килограммов в пуды
    пер Кг = 100
    Консоль.Записать("${Кг} кг = ${ПереводВПуды(Кг)} пудов")

;

Используйте аннотацию @ПроверятьИспользованиеЗначения для проверки использования возвращаемого значения:

@ПроверятьИспользованиеЗначения
метод СгенерироватьЧисло(): Число
    возврат 42
;

метод Скрипт()
    // Ошибка компиляции: возвращаемое значение не используется
    СгенерироватьЧисло()
    
    // Правильное использование - значение присваивается
    пер Число = СгенерироватьЧисло()
    
    // Или сразу используется
    Консоль.Записать(Число)
;

примечание

Подробнее об аннотациях.