Функции в скриптах Роутер ОС Микротик. Интересные решения и недокументированные возможности

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

В этой статье, не претендующей на полное руководство к разделу, мы рассмотрим одну из интересных и важных рубрик «скриптинга», а именно — функции.

Перед прочтением статьи, пользователям, начинающим изучать скрипты, рекомендую ознакомиться с официальным руководством Микротик по скриптам по ссылке выше, либо с его переводом (например, здесь). Следует знать типы переменных в скриптах Микротик, иметь понятие об областях видимости, окружении переменных и т.д… Также будет весьма полезна статья habr.com/ru/post/270719, в которой автор подробно разбирает типы переменных LUA Микротик и варианты их объявления и использования.

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

До версии Роутер ОС 6.2 функции в Микротик не были доступны напрямую, однако можно было использовать возможности команды :parse, как обходной способ для создания функций.

Например:

:global myFunc [:parse ":log info Goodbay!"];
$myFunc;

Или можно определить функцию из текста существующего скрипта:

# добавляем скрипт в репозиторий (если его там ещё нет)
/system script add name=myScript source=":put \"Hello world !\""

# парсим скрипт и присваиваем его текст переменной, исполняем код:
:local myFunc [:parse [/system script get myScript source]]
$myFunc

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

:local fnArray;
:foreach f in=[/system script find where name~"^Function.*"] do={:set fnArray ($fnArray.",".[/system script get $f name])};
:set fnArray [:toarray $fnArray];
:foreach f in=$fnArray do={:exec script=":global \"$f\" [:parse [/system script get $f source]]"; /log info ("Defined function ".$f);};

В этом скрипте, сначала производится поиск всех скриптов репозитория роутера, имена которых соответствуют требованиям поиска и заполнение ими переменной $fnArray. Затем переменная fnArray преобразуется в массив данных, а в последней строке пробегая по элементам массива циклом :foreach скрипты помещаются в переменные окружения и становятся функциями.

Позднее, начиная с версии 6.2, синтаксис был доработан и появилась возможность передачи функциям параметров, а также реализован возврат из функций. Соответствующие примеры приведены в официальном руководстве. Я же приведу здесь в качестве практического примера простую функцию FuncPing, позволяющую определить доступность устройства с указанным адресом в сети:

#------ FuncPing-------#
# Функция проверки доступности устройства в сети методом  пинга
# в именованном параметре PingAdr следует передать пингуемый IP-адрес
# при этом IP-адрес может быть "чистым"
#  или с указанием порта через двоеточие (при пинге функция отсекает порт)
#
# ответ функции возвращается в виде:
# "done" - устройство доступно в сети
# "ERROR: device not responded" - устройство не доступно

:global FuncPing do={
:local Hadr;
:if ([:find $PingAdr ":"]>0) do={:set Hadr [:pick $PingAdr 0 [:find $PingAdr ":"]];} else={
:set Hadr $PingAdr}
:local PingCount
:if ([:typeof $Count]="nothing") do={:set PingCount 3} else={:set PingCount $Count}
:local Result [/ping $Hadr count=$PingCount];
:local PingAnswer;
:local MainIfInetOk false;
:set MainIfInetOk ((3*$Result) >= (2 * $PingCount))
:put "MainIfInetOk=$MainIfInetOk"
if (!$MainIfInetOk) do={:set PingAnswer "ERROR: device not responded"}
if ($MainIfInetOk) do={:set PingAnswer "done"}
:return $PingAnswer;
}

:log info [$FuncPing PingAdr="192.168.0.7" Count=5]

В данном случае функция декларируется как глобальная переменная в окружении FuncPing, которой присваивается код функции, помещенный между do={}.

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

В функциях Микротик можно передавать параметры двух типов: позиционные и именованные, а также их сочетание.

В примере, приведенном выше, осуществляется передача именованных параметров-аргументов PingAdr, который должен содержать адрес пингуемого функцией устройства в сети, и Count, содержащего количество «пингов» для проверки. В случае передачи функции именованных параметров, их положение в строке вызова не имеет значения (можно менять местами).
Обратите внимание на строку кода функции:

:if ([:typeof $Count]="nothing") do={:set PingCount 3} else={:set PingCount $Count}

Здесь осуществляется проверка параметра Count (число пингов). Если $Count=«nothing» (т.е. не был задан), устанавливается значение $PingCount=3, если же $Count передан в функцию, то $PingCount принимает значение $Count.

Когда нам нужно определить доступность устройства в сети, вызываем функцию FuncPing, определенную как глобальная переменная, не забыв предварительно продекларировать (объявить) её в коде своего скрипта, иначе он не сможет её выполнить. Чтобы функция была исполнена следует подставить символ «$» перед её именем, для наглядности вся конструкция может быть заключена в квадратные скобки (не обязательно), дополнительно обозначающие необходимость исполнить действие внутри:

:global FuncPing
:local Result [$FuncPing PingAdr=«192.168.0.1» PingCount=5]
:put $Result

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

Пока, всё изложенное выше, общеизвестно, и лишь уточняет некоторые детали. Пойдём дальше в нашем изучении функций. Следует понимать, что функция в скриптах Микротик «с точки зрения» скриптового языка по конструкции напоминает ни что иное как массив. Такая конструкция удобна как для передачи параметров, так и для возврата результатов.
Это положение может быть доказано, например, следующим. Я условно называю это выражением function knows its name (функция знает своё имя).

Заключается этот эффект в том, что вне зависимости передавали ли функции аргументы или нет (в том числе строковые, позиционные или смешанные), при вызове функции всегда имеется параметр $0, который содержит имя нашей функции (вероятно он служит как какой-то внутренний указатель в скриптах Микротик).

Таким образом, получается, что функция – это смешанный массив, содержащий как позиционные ($0), так и именованные аргументы (ключевые и/или нумерованные элементы массива – аргументы функции).

«Узнать своё имя» функция может следующим образом (берем $0 и отсекаем у него первый символ, это всегда «$»):

:global FuncName do={:return [:pick $0 1 [:len $0]]}
:log info [$FuncName]

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

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

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

Наглядно проиллюстрировать «ошибку третьего вызова» можно следующим образом:

[$FuncPing PingAdr=«192.168.0.1» PingCount=5]
[$FuncPing PingAdr=«192.168.0.7» PingCount=2]

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

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

$FuncPing PingAdr=«192.168.0.1» PingCount=5
$FuncPing PingAdr=«192.168.0.7» PingCount=2

либо как-то блокировать лишний вызов … но как это сделать?

К счастью, как оказалось, ошибочный третий вызов функции производится без передачи функции параметра $0 (имени функции). Да, да по какой-то причине при этом ошибочном вызове $0 пуст. Это позволяет реализовать программную страховку от ошибочного выполнения внутри самой функции. Сделаем это так, допустим есть функция:

:global myFunc do={:log info "Hello world !"}

Если мы попросим выполнить её дважды:

[$myFunc]; [$myFunc]

Как мы уже выяснили она будет выполнена трижды.

Добавление в функцию проверки на наличие имени в $0 устраняет проблему:

:global myFunc do={
:if ([$len $0]!=0) do={
:log info "Hello world !"}
}

Если имеется проверка на $0, то при ошибочном третьем запуске тело кода функции будет просто проигнорировано (не будет исполнено). Эта проверка осуществляется строкой проверки на условие :if ([$len $0]!=0) do={ }.

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

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

Обработка ошибок организуется командами do { контролируемое действие } on-error={ действие при ошибке }. В обработчик ошибок имеет смысл «заворачивать» команды, при исполнении которых есть риск ошибочного завершения, например действие команд :fetch, :resolve и т.п… Всё это справедливо и для функций. Внутри функций, я также делаю проверки на корректность переданных аргументов.

В качестве примера демонстрации обработки ошибок, приведу «старую» свою функцию FuncMail, написанную ещё в 2017 году, и служащую для отправки сообщений на почту. Функция имеет два именованных параметра: Mailtext (должен содержать текст пересылаемого сообщения) и Email (должен содержать адрес получателя):

#------------- FuncMail-----------------#
#    Функция отправки почты 
#    by Sergej Serkov 24.12.17
#---------------------------------------#

# Применение:

# [$FuncMail Email="user@mail.ru" Mailtext="test letter"]

# В качестве параметра функции в Mailtext нужно передать текст сообщения на почту
# отправка почты идет на ящик, указанный в параметре Email
# для корректной работы функции почтовый сервис Router OS /tool email должен быть настроен верно по умолчанию

:global FuncMail do={
:local smtpserv [:resolve [/tool e-mail get address]];
:local Eaccount [/tool e-mail get user];
:local pass [/tool e-mail get password];
:local Eport [/tool e-mail get port];
:local Etls "yes"; # если не используется установить в "no"
:if (([:len $Email]!=0) and ([:len $Mailtext]!=0)) do={
:log info " "; :log warning "FuncMail start mail sending ... to e-mail: $Email";
do {[/tool e-mail send from="<$Eaccount>" to=$Email server=$smtpserv \
 port=$Eport user=$Eaccount password=$pass start-tls=$Etls subject=("from FuncMail Router $[/system identity get name]") \
 body=$Mailtext;];
              } on-error={:log info ""; :log error ("Call ERROR function $0 ERROR e-mail send"); 
                                                                                      :return "ERROR: <$0 e-mail send>"}
:log warning "Mail send"; :log info " "; :return "OK: <mail send>"
} else={:log error ("Call ERROR function $0 Email or Mailtext parametrs no defined"); :return ("ERROR: $0 < necessary parameters are not set >")}
}

:log info [$FuncMail Mailtext="Привет !" Email="user@mail.ru"]

Заметьте, обработка ошибок сделана для команды отправки почты /tool e-mail send, но не сделана для :resolve smtp сервера (для данного примера). Также сделана обработка ошибки при вызове функции без параметров:

:if  (([:len $Email]!=0) and ([:len $Mailtext!]=0)) do={} else={:log error ("Call ERROR function $0 Email or Mailtext parametrs no defined"); :return ("ERROR: $0 < necessary parameters are not set >")}

Возврат из функции не всегда нужен, однако функции тем и хороши, что могут посредством переменных различных типов возвращать результаты своей работы. При этом можно возвращать из функций «логические» (булевые) переменные, такие как «thrue» и «false», числовые и строковые переменные, переменные других типов (при необходимости), а также массивы данных. Возврат из функции прекращает её работу и осуществляется командой :return.

Например:

:global cuDte do={:return ([/system clock get date]." ".[/system clock get time]);}
:log info [$cuDte]

В этом примере функция возвратит полученные конкатенацией системные дату и время в виде единой строки. А в примере ниже возврат осуществляется в виде массива элементов (первый элемент дата, второй – время)

:global cuDte do={:return [:toarray {[/system clock get date]; [/system clock get time]}] }
:local DateTime [$cuDte]
:log info $DateTime
:log info [:typeof $DateTime]

По индексам массива можно получить каждый (нужный) элементы массива (помним, что индекс первого элемента массива равен 0, второго 1 и т.д…

:log info ($DateTime->0)
:log info ($DateTime->1)

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

Когда надобность в функции отпадает её можно удалить. Локальные функции не требуют удаления, так как удаляются системой при выходе скрипта из области видимости (либо по завершению работы). Функции, объявленные как глобальные переменные могут быть удалены из окружения присвоением пустого значения командой :set.

:set cuDte

или

:set сuDte (:nothing);

Формально можно также удалить переменную из окружения системной командой удаления:

/system script environment remove [find name="cuDte"]

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

:global cuDte []

Также напомню важную рекомендацию из официальной документации Wiki по скриптам относительно функций, которую следует всегда иметь ввиду:

«Если функция содержит глобально определённую переменную с именем совпадающим с именем передаваемого именного параметра, то глобально определённая переменная будет проигнорирована для совместимости со старыми версиями. Эта возможность может быть изменена в будущих версиях. Избегайте использование параметров с теми же именами, что и глобальные переменные.»

Пример:

        :global my2 "123"
        :global myFunc do={ :global my2; :put $my2; :set my2 "lala"; :put $my2 }
        $myFunc my2=1234
        :put «global value $my2»

Вывод:
1234
lala
global value 123

Любая функция может в свою очередь вызывать другие функции. Чтобы это работало, вызываемые функции должны быть продекларированы в коде той функции, которая их вызывает (пример из Wiki):

        :global funcA do={ :return 5 }
        :global funcB do={ 
          :global funcA;
          :return ([$funcA] + 4)
        }
        :put [$funcB]

Вывод:
9

В Роутер ОС Микротик поддерживается рекурсивный вызов функций. То есть функция может вызывать саму себя! Это бывает нужно в случаях, когда необходимо повторять ту или иную часть кода с различными значениями входных параметров. Рекурсивные функции фактически формируют циклы и наиболее эффективны при обработке сложных данных, которые слишком сложны, чтобы пройтись по ним с помощью обычных циклов языка, задаваемых командами :for, :foreach или :while. Для работы рекурсии в теле функции она должна декларировать сама себя.

Простой пример рекурсивного вызова функции:

:global CountDown do={
:global CountDown;
:if ($1>0) do={:log warning $1; :set $1 ($1-1);[$CountDown $1];}
:return "end"
}

:log info [$CountDown 5]

Вывод:

5
4
3
2
1
end

Заметьте, что обращаемся мы к функции один раз (:log info [$CountDown 5]), а выполняет она сама себя пока не исчерпает данные по условию (6 раз).

При наличии сложных данных рекурсивные функции работают эффективнее и быстрее циклов, при простых – наоборот. С рекурсивными функциями следует быть осторожными, так как при неправильном рекурсивном вызове может получится формирование бесконечного цикла и, как следствие, переполнение стека данными с аварийным завершением работы (чаще всего происходит перезагрузка роутера, как при исполнении /system reboot).

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

Автором был создан великолепный парсер данных из формата JSON в многомерный ассоциативный массив. В функции $fJParsePrint, из набора парсера, можно видеть в коде функции рекурсивный вызов, который передает внутрь функции текущий уровень вложения и элемент-подмассив, таким образом осуществляется обход всего дерева массивов в переменной $JParseOut (подробнее в статье).

В той же статье можно видеть недокументированную команду :any, ювелирно использованную автором парсера для исключение повторного развертывания функций при вызове, что ускоряет работу системы. При объявлении каждой из функций сначала производится проверка на её «не пустость» командой :any. Если переменная (она же функция) пуста – требуется её определение (наполнение кодом), если же не пуста, соответственно она уже содержит код и её переопределение не требуется. В качестве примера короткой, но мощной функции, для демонстрации работы :any, в указанной статье можно видеть функцию fByteToEscapeChar, «налету» преобразующей позиционный параметр $1 (байтовое число) в строковый символ, т.е. осуществляющей преобразование кода ASCII в символ.

:global fByteToEscapeChar
:if (!any $fByteToEscapeChar) do={ :global fByteToEscapeChar do={
  :return [[:parse "(\"\\$[:pick "0123456789ABCDEF" (($1 >> 4) & 0xF)]$[:pick "0123456789ABCDEF" ($1 & 0xF)]\")"]]
}}

От себя добавлю интересную находку. Когда я проверил какой тип у параметра функции $0, то получил вот что:

:global myFunc do={:log info $0; log info [:typeof $0]}
$myFunc

Вывод:
$myFunc
lookup

То есть параметр $0 (тот, что содержит имя функции как мы выяснили выше) имеет некий тип «lookup», о котором нет ни слова в официальном руководстве Рос Микротик! Запомним это и посмотрим как это можно использовать (будет обсуждено далее).

Одним из интересных разделов в теме функции Роутер Ос является создание функций в массиве. Да, да, такое возможно! Действительно, раз функции можно создавать внутри переменных, почему нельзя было бы определять функции, как элементы массива?
Не скрою, данная идея не моя и была случайно почерпнута в одном из топиков официального форума Микротик здесь.
При этом по данной теме очень мало информации и примеров.

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

Мы уже знаем, что функция knows its name (знает своё имя). Наглядный пример ниже демонстрирует как имя функции и параметр $1 формируют предложение:

:global hello
:set hello do={:log info ("$[pick $0 1 [:len $0]]". " $1")}
$hello world

Вывод:
hello world

Функцию массив можно задать следующим образом. Сначала создаём пустой массив:

:global fnArray [:toarray ""]

Затем, наполняем его функциями, индексированными, например, по ключевым элементам:

:global fnArray [toarray ""]
:set ($fnArray->"hello") do={:log info "hello $1 "}
:set ($fnArray->"good by") do={:log info "good by $1 "}

Вызовем первую функцию:

[($fnArray->"hello") world]

Вывод:
hello

Функция должна была вывести hello world, а вместо этого выводит hello. Почему так происходит?
Всё дело в том, что параметр world, передается функции не как первый позиционный параметр $1, а как нулевой — $0, а параметр $1 получается нами вовсе не определен.

Правильно будет написать так:

:set ($fnArray->"hello") do={:log info "hello $0 "}
[($fnArray->"hello") world]

Тогда world становится $0 параметром и функция выводит:

hello world

Далее цитирую источник:
" … С несколькими параметрами то, что было бы $2 в функции с глобальной областью действия, равно $1, когда функция определена в массиве. По сути, является ли первый аргумент $0 или $1, зависит от того, где он находится. Даже примешивание именованного параметра все еще работает, позиционные аргументы просто сдвигаются на единицу, а аргументы ключ=значение работают везде, как обычно.

Возможно, что это ошибка, но более тонкая. Но я вижу логику: функция массива больше похожа на анонимную функцию — это термины CS, а глобальная функция — это команда (команды имеют имя, имя — это аргумент), поэтому первый аргумент, известный функции, всегда равен $0, что может быть его имя, если таковое имеется…

… Таким образом используйте $0, когда функция определена в массиве."

В заключение этого небольшого обзора по функциям скриптов Микротик в качестве бонуса, приведу свою универсальную функцию массив, FuncAS (Function Active Sender), осуществляющую отправку сообщений в мессенджер Телеграмм, в виде SMS через модем роутера, SMS через API сервиса sms.ru, SMS через шлюз устройств Laurent5G, Netping и на почту.

Функция FuncAS представляет собой смешанный массив, имеющий девять элементов: $0, translite, telegram, sms, smsAPI, smsLT, smsNP, email, all. Элемент all стоит последним и производит вызов всех элементов, отправляя сообщения сразу на все «пункты приема». Благодаря работе над этой функцией, выяснилась ещё одна интересная особенность функций, определенных как массив. Если вызвать не один из элементов такой функции, а как обычно функцию «целиком» (без ключей) будет произведено выполнение последнего элемента массива-функции. Этой особенностью я и воспользовался разместив на последнем месте элемент с ключом «all». Заметьте, что элемент функции «translate» не является компонентом отправки, как другие элементы, а используется частью из них для транслитерации русскоязычных сообщений как подпрограмма.

Функция полностью корректно работает при отправке сообщений на английском языке и/или русском языке с аргументом «translite» и, с учётом ограничения длины сообщения, поддерживает спец. символы \$@!#%'()*+,-./:;<=>?[]^_`{|}~ Для Телеграмм, API sms.ru и большинства почтовых клиентов (проверено для mail.ru, yandex.ru и gmail.com) есть поддержка национального (русского) текста. Для Телеграмм (опционально при указании $1=«translite») и отправке SMS через модемы, работает транслитерация русских символов в латинские. В работе функции использованы, написанные мной ранее конвертеры строки (приведены и описаны в статьях Хабра habr.com/ru/post/518534 и habr.com/ru/post/519406).
Функция поддерживает отправку сообщений через модем, подключенный к роутеру (usb или pci-e), а также через многофункциональные интернет-контроллеры компаний KernelChip (Laurent-5G) и Алентис-Электроникс (устройства Netping, имеющие модем).
Для работы функции на роутере должны быть сконфигурированы /tool sms и /tool e-mail. При использовании ключа «telegram» должны быть определены global Emoji (Emoji роутера, по желанию), заданы ID Вашего Телеграм-бота и чата (глобальные переменные botID и myChatID). При использовании сервиса sms.ru (ключ «smsAPI») должна быть определена global apikey (ключ аккаунта пользователя на sms.ru). При пересылке сообщения через модем модуля Laurent-5G (ключ smsLT) должны быть определены глобальные переменный Ladr (адрес Laurent-5G в локальной сети) и Lpassword (пароль для авторизации при http get-запросах к модулю). При использовании ключа «smsNP» должны быть определены global NPadr (адрес шлюза Netping в сети), NPuser (login), NPpass (пароль) авторизации.

Выбор номера телефона получателя при всех вариантах отправок sms осуществляется в порядке $1 (из параметра функции) -> $ADMINPHONE (global var) -> first [/tool sms get allowed-number] по алгоритму «если не указан, то следующий». Для smsLT вместо $ADMINPHONE номер телефона берется из первой ячейки базы данных телефонных номеров модуля. Номера телефонов следует указывать в международном формате (+7десятизначный номер), поддерживается отправка sms только по России (+7). Выбор почтового адреса получателя при отправке e-mail осуществляется аналогично в порядке $1 -> $ADMINMAIL (global var).

Ещё раз обратим внимание, что в отличие от обычных функций, которые в $0 хранят своё имя, первый параметр функции массива будет $0, второй $1 и т.д...., что учитывается в коде элементов функции. Вызов функции без ключа, в виде [$FuncAS «you mesage»] вызывает последовательную работу всех элементов функции и равноценен записи [($FuncAS->«all») «you mesage»].


Основные аспекты работы функции отмечены в комментариях к коду. Функция объединяет шесть вариантов отправки сообщений посредством различных служб и устройств и способна работать как частично (отправляя сообщение по какому-либо одному каналу) так и полностью по всем последовательно. Служит наглядным примером того, как можно создавать функции в массивах. Вероятно, можно такое проделать и в многомерном массиве, однако ввиду усложнений синтаксиса вряд ли это необходимо.
Из вышесказанного следует также, что в функции-массиве можно разместить как «подфункции» так и данные.
Обратите внимание на последнюю часть функции под ключом ($FuncAS->«all»). Помня про lookup мы проверяем откуда вызвана данная часть функции: как элемент массива по ключу «all» или как обычная целая функция $FuncAS в этой строке кода:

 :if ([:typeof $0]="lookup") do={:set $0 $1; :if ((any $2) && ($2="translite")) do={:set $1 $2}}

Если функция вызвана без ключа, то осуществляется «передвижка» аргументов: $1 «передвигается» в $0, а $2, когда это нужно для работы блока транслитерации, становится $1.

Разумеется можно «разобрать» функцию массив на более привычные нам, отдельные функции, и использовать каждую со своим именем, однако объединение в функцию-массив тематически однообразных подфункций представляется удобным и логичным решением.
С 2017 года мной были созданы и собраны около 200 функций самого разного назначения, многие из которых ежедневно помогают мне в работе над скриптами Роутер ОС. Конечной целью было бы создание сайта-библиотеки скриптов и функций, которым могли бы пользоваться все желающие. В настоящее время можно обсуждать всё, что связано со скриптовыми функциями на русскоязычном форуме Микротик по ссылке.

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

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

© Серков Сергей Владимирович 2022 (Sertik)