Методы

Общая информация

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

Используемые определения

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

Определение метода

Место в исходном коде, где создан метод

Объявление метода

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

Тело метода

Инструкции, расположенные между объявлением метода и символом ;, описывающим завершение метода

Вызов метода

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

Определение параметров и передача аргументов

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

Возврат значения

Передача вызывающему программному коду какого-либо значения при завершении работы метода. Метод не обязательно должен возвращать какое-либо значение

Определение метода

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

метод имя-метода([параметр[, параметр[, ...]]])[: описание-типа]
    тело-метода 
   [возврат[ значение]]
;

Каждый параметр описывается следующим образом:

имя-параметра: тип-параметра[ = значение-по-умолчанию]

имя-параметра задает имя параметра в соответствии со стандартными правилами формирования имен.

тип-параметра указывает, соответственно, тип параметра (в том числе и составной).

Особенности передачи параметров

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

метод Скрипт()
    пер ДляТеста = 5
    Тестовый(ДляТеста)
    пер ПослеВызова = "ДляТеста = " + ДляТеста
;

метод Тестовый(Параметр1: Число)
    Параметр1 = 6
;

В данном примере значение переменной ДляТеста в методе Скрипт() будет равно 5 и до вызова метода Тестовый(), и после вызова этого метода. Такое поведение обеспечивает передача параметра "по значению".

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

метод Скрипт()
    пер ДляТеста = [1, 2]
    Тестовый(ДляТеста)
    пер ПослеВызова = "ДляТеста = " + ДляТеста
;

метод Тестовый(Параметр1: Массив<Число>)
    Параметр1.Очистить()
;

В этом примере до выполнения метода Тестовый() в массиве ДляТеста будет 2 значения: 1 и 2. После вызова метода Тестовый() в массиве не будет ни одного элемента. В то же время, если в методе Тестовый() мы попробуем присвоить параметру Параметр1 какое-либо значение, это не приведет к каким-либо изменениям аргумента (переменной ДляТеста).

Вызов метода с именованными параметрами

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

Перемножить(а = 2, б = 3)

Синтаксис:

ИмяМетода(ИмяПараметра1 = Значение, ИмяПараметра2 = Значение, ... , ИмяПараметраN = Значение).

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

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

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

  метод Разделить(а: Число, б: Число): Число
      возврат а / б
  ;
  
  // Вызовы ниже равносильны:
  Разделить(3, 2)
  Разделить(а = 3, б = 2)
  Разделить(б = 2, а = 3)

  Или:

  метод РассчитатьСебестоимость(Цена: Число, Наценка: Число, Налог: Число): Число
      возврат Цена - (Цена * Наценка / 100 + Цена * Налог / 100)
  ;
  
  // Позиционные параметры
  РассчитатьСебестоимость(1, 10, 100) // Результат: -0.1. Неправильно
  // Именованные параметры
  РассчитатьСебестоимость(Налог = 1, Наценка = 10, Цена = 100) // Результат: 89. Правильно

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

  // Сигнатура метода
  метод ОтправитьСообщение(Сообщение: Строка, УдалитьПробелы: Булево, ОтправитьБезУведомления: Булево)
  
  // Позиционные параметры
  ОтправитьСообщение(" Привет, мир! ", Истина, Ложь) // Непонятно
  // Именованные параметры
  ОтправитьСообщение(" Привет, мир! ", УдалитьПробелы = Истина, ОтправитьБезУведомления = Ложь) // Понятно

• Можно выборочно указывать только некоторые, наиболее важные для пользователя параметры. Это может быть особенно удобным, когда в методе используется много необязательных, "служебных" параметров. Для всех этих параметров просто будут использоваться значения по умолчанию, которые указываются при определении метода. Кроме того, для некоторых параметров уже могут быть указаны значения по умолчанию. Так, если для метода РассчитатьСебестоимость сделать значения по умолчанию: для наценки — 10 (%), а для налога — 1 (%), то можно передавать только значение цены. Сравните:

  метод РассчитатьСебестоимость(Налог: Число = 1, Наценка: Число = 10, Цена: Число): Число
      возврат Цена - (Цена * Наценка / 100 + Цена * Налог / 100)
  ;
  
  // Позиционные параметры
  РассчитатьСебестоимость(100) // Ошибка: Параметр "Цена" не имеет значения по умолчанию
  // Именованные параметры
  РассчитатьСебестоимость(Цена = 100) // Результат: 89. Правильно

Смешанная параметризация

При вызове метода можно смешивать позиционную и именованную формы параметризации. Например:

РассчитатьСебестоимость(Налог = 1, Наценка = 10, Цена = 100)
РассчитатьСебестоимость(1, 10, Цена = 100)

Разрешение неоднозначности

При разрешении неоднозначности действуют следующие правила:

Завершение метода и возвращаемое значение

Метод завершает свою работу после того, как завершается исполнение тела метода. Другим способом прервать исполнение метода является указание в необходимом месте метода ключевого слова возврат.

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

Повторное определение (перегрузка) методов

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

Рассмотрим примеры корректного и некорректного определения перегруженных методов:

1. метод Пример1(Параметр1: Строка|Число)
2. метод Пример1(Параметр1: Строка)
3. метод Пример1(Параметр1: Строка|Булево)

4. метод Пример2(Параметр1: Объект)
5. метод Пример2(Параметр1: Число)
6. метод Пример2(Параметр1: Число, Параметр2: неизвестно)

7. метод Пример3(Параметр1: Строка)
8. метод Пример3(Параметр1: Число)
9. метод Пример3(Параметр1: Строка, Параметр2: неизвестно = 22)

10. метод Пример4(Параметр1: Строка): Строка
11. метод Пример4(Параметр1: Число): Число
12. метод Пример4(Параметр1: Строка): Число

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

Метод Пример2() (строки 4, 5 и 6) можно описать, только исключив строку 5. Причиной является тот факт, что тип Объект является базовым для всех типов «1С:Исполнителя». В то же время объявление метода в строке 6 имеет другое количество параметров.

Метод Пример3() (строки 7, 8, 9) можно описать, только исключив строку 9. Причиной является то, что второй параметр имеет значение по умолчанию, а следовательно, если указан один параметр (первый), компилятор не будет понимать, какой из вариантов метода использовать.

Наконец, метод Пример4() (строки 10, 11, 12) может быть описан или строками 10 и 11 или строками 11 и 12. Причиной является тот факт, что перегруженные методы не могут отличаться только типом возвращаемого значения. Поэтому вариант со строками 10 и 12 отпадает.