# Синтаксис

## Общая информация о синтаксисе

Синтаксис может использоваться в следующих Слотах:

* Text: допустимо использование Выражение и Выражение с управляющей конструкцией в поле Text List
* Attachment: допустимо использование Выражение и Выражение с управляющей конструкцией в полях Source и Caption
* Slot Filling: допустимо использование Выражение и Выражение с управляющей конструкцией в поле Question
* button:  допустимо использование Выражение в поле Label
* condition: допустимо использование Выражение в поле Condition
* Timer: допустимо использование Выражение в поле If
* Memory: допустимо использование Выражение и Выражение с управляющей конструкцией в поле Value
* External Request: допустимо использование Выражение и Выражение с управляющей конструкцией в полях URL, Value на вкладке Headers и Query parameters, Data, поле Name на вкладке Response
* Incoming Request: допустимо использование Выражение и Выражение с управляющей конструкцией в поле Value
* Synonym: допустимо использование Выражение и Выражение с управляющей конструкцией в поле Source

\
Синтаксис Платформа использует синтаксис шаблонизатора Jinja:<https://jinja.palletsprojects.com/en/3.0.x/templates/>Шаблоны в синтаксисе делятся на 2 концепции:

1. Выражение. Заключаются в двойные фигурные скобки.
2. <https://jinja.palletsprojects.com/en/3.0.x/templates/#expressions>Примеры:
3. 1. {{ client\_message }}
   2. {{ number \* 10 }}
   3. {{ chat\_id == ‘abcde0123456789’ }}
   4. {{ uuid4() }}
   5. {{ some\_variable is defined }}
4. Выражение с управляющей конструкцией. Заключаются в фигурные скобки с символом %.<https://jinja.palletsprojects.com/en/3.0.x/templates/#list-of-control-structures>
5. Примеры:
6. 1. {% if client\_message == ‘привет’ %}Hi{% else %}Bye{% endif %}
   2. {% for number in \[1, 2, 3] %}{{ number }}{% endfor %}

| Тип данных          | Memory                                                                                                                                                                              | Примеры вывода в текстовом слоте                                                                                                                            | Примечание                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |                          |
| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ |
| Строки              | <ul><li>{{ 'string' }}</li><li>{{ "string" }}</li><li>Пустая строка: {{ '' }} или {{ "" }}</li></ul>                                                                                | <p>string<br>Пустая строка выводится в виде отсутcтвия значения</p>                                                                                         | <p>Если строка обрамлена двойными кавычками и внутри строки присутствует символ двойных кавычек в качестве знака препинания, то символ кавычек внутри строки необходимо экранировать символом \ для прохождения Валидация сценария и корректного отображения. Пример:<br>{{ "кинотеатр "Победа" " }}<br>Если строка обрамлена одинарными кавычками и внутри строки присутствует символ одинарных кавычек в качестве знака препинания, то символ кавычек внутри строки необходимо экранировать символом \ для прохождения Валидация сценария и корректного отображения. Пример:<br>{{ 'I've made an order' }}<br>В случаях, когда строка обрамлена двойными кавычками и внутри строки присутствует символ одинарных кавычек, либо если строка обрамлена одинарными кавычками и внутри строки присутствует символ двойных кавычек, экранирование не требуется.</p> |                          |
| Числа               | <ul><li>{{ 5 }}</li><li>{{ 42.23 }}</li></ul>                                                                                                                                       | <ul><li>5</li><li>42.23</li></ul>                                                                                                                           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                          |
| Булевы              | <ul><li>{{ true }}</li><li>{{ false }}</li></ul>                                                                                                                                    | <ul><li>True</li><li>False</li></ul>                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                          |
| Отсутствие значения | {{ None }}                                                                                                                                                                          | Выводится в виде отсутcтвия значения                                                                                                                        |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |                          |
| Объекты             | {{ {"one": 1, "two": 2, "colors": \["red", "green", "blue"]} }}                                                                                                                     | {"one": 1, "two": 2, "colors": \["red", "green", "blue"]}                                                                                                   | В Платформа доступны Зарезервированные методы объектов: Зарезервированные методы объектов                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |                          |
| Массивы             | <ul><li>Чисел: \[1, 2, 3, 4, 5]</li><li>Строк: \["one", "two", "three"]</li><li>Массивов: \[\["one", "two", "three"], \["cat", "dog", "bird"], \["green", "blue", "red"]]</li></ul> | <ul><li>\[1, 2, 3, 4, 5]</li><li>\["one", "two", "three"]</li><li>\[\['one', 'two', 'three'], \['cat', 'dog', 'bird'], \['green', 'blue', 'red']]</li></ul> | <ul><li>Через точку (.) происходит обращение к элементам массивов;</li><li>Обращение к соответствующему номеру элемента массива происходит с помощью чисел. Нумерация элементов массива начинается с нуля, поэтому обращение к первому элементу массива обозначается как 0.</li><li>Примеры: {{ array.0 }}</li></ul>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |                          |
| Даты                | <p>Привести данные к формату даты возможно только с помощью фильтра string\_to\_time<br>Пример: {{ "2000-06-15 18:50:47"                                                            | string\_to\_time("%Y-%m-%d %H:%M:%S") }}<br>Подробнее: Преобразование строки в дату</p>                                                                     | 2000-06-15 18:50:47                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | Часовой пояс не хранится |

| Метод      | Доступность в Платформе | Смысл                                    | Как использовать    | Пример                   |                                                            |
| ---------- | ----------------------- | ---------------------------------------- | ------------------- | ------------------------ | ---------------------------------------------------------- |
| items      | Да                      | Возвращает пары "ключ-значение" словаря. | {{ data.items() }}  | <ul><li>{{ data.items()  | list }}</li><li>Результат: \[('a', 1), ('b', 2)]</li></ul> |
| keys       | Да                      | Возвращает ключи словаря                 | {{ data.keys() }}   | <ul><li>{{ data.keys()   | list }}</li><li>Результат: \['a', 'b']</li></ul>           |
| values     | Да                      | Возвращает значения словаря              | {{ data.values() }} | <ul><li>{{ data.values() | list }}</li><li>Результат: \[1, 2]</li></ul>               |
| clear      | Нет                     |                                          |                     |                          |                                                            |
| copy       | Нет                     |                                          |                     |                          |                                                            |
| fromkeys   | Нет                     |                                          |                     |                          |                                                            |
| get        | Нет                     |                                          |                     |                          |                                                            |
| pop        | Нет                     |                                          |                     |                          |                                                            |
| popitem    | Нет                     |                                          |                     |                          |                                                            |
| setdefault | Нет                     |                                          |                     |                          |                                                            |
| update     | Нет                     |                                          |                     |                          |                                                            |

> Важно: при парсинге Входящий запрос, ответа на Внешний запрос или на Notification обращение к ключу объекта, если его имя совпадает с именем Зарезервированные методы объектов происходит через квадратные скобки и кавычки.\
> Пример: {{ data\["keys"] }}

## Выражения

| Оператор        | Обозначение                                                                     | Область применения                                                                                                    | Как использовать                                                                                                                                                                                                                                                                                                                           | Пример                                                                                                                                                                                                                                                                                                                                                        |
| --------------- | ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Строка          | "string"                                                                        | <ul><li>Объявление строки</li><li>Объявление пустой строки</li></ul>                                                  | <p>Объявление строки</p><ul><li>Пустая строка</li><li>{{ '' }} или {{ "" }}</li><li>Непустая строка</li><li>{{ 'str' }} или {{ "str" }}</li></ul><p>Обращение к символам строкиstr == {{ 'string' }}{{ str\[0] }} = s{{ str\[1] }} = t...Срез строкиstr == {{ 'string' }}{{ str\[:2] }} = st{{ str\[2:] }} = ring{{ str\[2:5] }} = rin</p> | <ul><li>{{ 'Hello World' }}</li><li>Результат: Hello World.</li><li>{{ "Hello World" }}</li><li>Результат: Hello World.</li><li>{{ 'Hello World'\[1] }}</li><li>Результат: e.</li><li>{{ 'Hello World'\[:5] }}</li><li>Результат: Hello.</li><li>{{ 'Hello World'\[5:] }}</li><li>Результат: World.</li></ul>                                                 |
| Целое число     | <ul><li>42</li><li>123\_456</li></ul>                                           | Объявление целого числа                                                                                               | {{ num }}                                                                                                                                                                                                                                                                                                                                  | <ul><li>{{ 123 }}</li><li>Результат: 123.</li><li>{{ 1\_2\_3 }}</li><li>Результат: 123.</li></ul>                                                                                                                                                                                                                                                             |
| Число с точкой  | <ul><li>42.23</li><li>42.1e2</li><li>123\_456.789</li></ul>                     | Объявление вещественного числа                                                                                        | {{ num }}                                                                                                                                                                                                                                                                                                                                  | <ul><li>{{ 42.23 }}</li><li>Результат: 42.23.</li><li>{{ 42.1e2 }}</li><li>Результат: 4210.0.</li><li>{{ 4\_2.23 }}</li><li>Результат: 42.23.</li></ul>                                                                                                                                                                                                       |
| Списки          | \['list', 'of', 'objects']                                                      | <ul><li>Объявление списка с произвольными типами объектов</li><li>Обращение к элементу из списка</li></ul><p><br></p> | <p>Объявление списка</p><ul><li>Пустой список</li><li>{{ \[] }}</li><li>Список чисел</li><li>{{ \[num1, num2, ...] }}</li><li>Список строк</li><li>{{ \['str1','str2', ...] }}{{ \["str1","str2", ...] }}</li></ul><p>Обращение к элементам спискаlist = {{ \[A, B, ...] }}{{ list\[0] }} = A{{ list\[1] }} = B...</p>                     | <ul><li>{{ \[1, 2, 3] }}</li><li>Результат: \[1, 2, 3].</li><li>{{ \['one', 'two'] }}</li><li>Результат: \['one', 'two'].</li><li>{{ \['one', 'two'] }}\[0]</li><li>Результат: one.</li></ul>                                                                                                                                                                 |
| Словари         | {'dict': 'of', 'key': 'and', 'value': 'pairs'}                                  | <ul><li>Объявление словаря</li><li>Обращение к элементу из словаря</li></ul>                                          | Объявление словаря{{ { key1:val1, key2:val2, ... } }}Обращение к элементам словаряdict = {{ { key1:val1, key2:val2, ... } }}{{ dict\[key1] }} = val1{{ dict\[key2] }} = val2...                                                                                                                                                            | <ul><li>{{ {1:'A', 2:'B', 3:'C'} }}</li><li>Результат: {1: 'A', 2: 'B', 3: 'C'}.</li><li>{{ {1:'A', 2:'B', 3:'C'}\[1] }}</li><li>Результат: A.</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'} }}</li><li>Результат: {'one': 'A', 'two': 'B', 'three': 'C'}.</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}\['three'] }}</li><li>Результат: C.</li></ul> |
| Массивы         | {{ \[{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}] }} | <ul><li>Объявление массива данных</li><li>Обращение к элементу из массива</li></ul>                                   | Объявление массива{{ \[{'id': id1, 'value': val1 }, {'id': id2, 'value': val2 }, ...] }}Обращение к элементам массиваarray = {{ \[{'id': id1, 'value': val1 }, {'id': id2, 'value': val2 }, ...] }}{{ array\[0] }} = {'id': id1, 'value': val1 }...                                                                                        | <ul><li>{{ \[{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}] }}</li><li>Результат: \[{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}].</li><li>{{ \[{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}] \[0] }}</li><li>Результат: {'id': 3, 'name': 'O'}.</li></ul>                       |
| Булевы значения | <ul><li>true</li><li>false</li></ul>                                            | Выражения и булевы переменные                                                                                         | <ul><li>{{ true }}</li><li>{{ false }}</li></ul>                                                                                                                                                                                                                                                                                           | <ul><li>{{ А == true }}</li><li>Результат: True, если булева переменная A истинна.</li><li>{{ (A == B) == true }}</li><li>Результат: True, если выражение (A == B) истинно.</li></ul>                                                                                                                                                                         |

| Оператор                                                            | Обозначение | Область применения                                                                                                                                                                                                    | Как использовать                                                                                                                                             | Пример                                                                                                                                                                                                                                  |
| ------------------------------------------------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Сложение                                                            | +           | <ul><li>Сложение целых и вещественных чисел</li><li>Конкатенация строк</li><li>Объединение элементов массивов в один массив</li></ul>                                                                                 | <ul><li>{{ num1 + num2 + ... }}</li><li>{{ 'str1' + 'str2' + ... }}</li><li>{{ "str1" + "str2" + ... }}</li><li>{{ mas1 + mas2 + ... }}</li></ul><p><br></p> | <ul><li>{{ 1 + 2 + 3 }}</li><li>Результат: 6.</li><li>{{ 'a' + 'b' + 'c' }}</li><li>Результат: abc.</li><li>{{ 0.5 + 1.5 }}</li><li>Результат: 2.0.</li><li>{{ \[0,1,2] + \[3,4,5] }}</li><li>Результат: \[0, 1, 2, 3, 4, 5].</li></ul> |
| Вычитание                                                           | -           | Вычитание целых и вещественных чисел                                                                                                                                                                                  | {{ num1 - num2 - num3 - ... }}                                                                                                                               | <ul><li>{{ 4 - 2 - 1 }}</li><li>Результат: 1.</li><li>{{ 0.5 - 1.5 }}</li><li>Результат: -1.0.</li></ul>                                                                                                                                |
| Деление                                                             | /           | Деление целых и вещественных чисел                                                                                                                                                                                    | {{ num1 / num2 / num3 / ... }}                                                                                                                               | <ul><li>{{ 1 / 2 }}</li><li>Результат: 0.5.</li><li>{{ -1.5 / 0.5 }}</li><li>Результат: -3.0.</li><li>{{ 6 / 3 / 2 }}</li><li>Результат: 1.0.</li></ul>                                                                                 |
| Деление, при котором будет возвращена только целая часть результата | //          | Деление целых и вещественных чиселОграничения:Оператор //  возвращает целое число только при делении целых чисел. Если одним из операндов является вещественное число, то результатом также будет вещественное число. | {{ num1 // num2 // num3 // ... }}                                                                                                                            | <ul><li>{{ 6 // 3 // 2 }}</li><li>Результат: 1.</li><li>{{ 1.5 // 0.5 }}</li><li>Результат: 3.0.</li></ul>                                                                                                                              |
| Вычисление остатка от деления                                       | %           | Вычисление остатка от деления целых и вещественных чисел                                                                                                                                                              | {{ num1 % num2 }}                                                                                                                                            | <ul><li>{{ 6 % 4 }}</li><li>Результат: 2.</li><li>{{ 1.5 % 0.5 }}</li><li>Результат: 0.0.</li></ul>                                                                                                                                     |
| Умножение                                                           | \*          | Умножение целых и вещественных чисел                                                                                                                                                                                  | {{ num1 \* num2 \* num3 \* ... }}                                                                                                                            | <ul><li>{{ -1.5 \* -0.5 }}</li><li>Результат: 0.75.</li><li>{{ -2 \* 3 \* 4 }}</li><li>Результат: -24.</li></ul>                                                                                                                        |

Ограничения:

* Максимальное число (по модулю), которое можно использовать в арифметических операциях — 4294967296 . Если использовать большие числа, то будет ошибка (в memory в переменную сохранится False, например).
* Если складывать строки / массивы, то максимально допустимая длина строки / массива — 1000 . При попытке сложения/конкатенации строк/массивов, дающих результат длиннее 1000 символов, в Контекстная переменная error записывается значение “Addition of objects with length greater than 1000 is not allowed”.
* Для конкатенации строк/массивов, дающих результат длиннее 1000 символов, можно использовать запись {{ string\_1 }}{{ string\_2 }}.

| Оператор                                               | Обозначение | Область применения                      | Как использовать | Пример                                                                                                                                                                                                                                                             |
| ------------------------------------------------------ | ----------- | --------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Проверка равенства                                     | ==          | Любые контекстные переменные и значения | {{ A == B }}     | <ul><li>{{ A == B }}</li><li>Результат: True, если переменная A равна переменной B.</li><li>{{ A == 1 }}</li><li>Результат: True, если переменная A равна 1.</li><li>{{ A == 'один' }}</li><li>Результат: True, если переменная A равна 'один'.</li></ul>          |
| Проверка неравенства                                   | !=          | Любые контекстные переменные и значения | {{ A != B }}     | <ul><li>{{ A != B }}</li><li>Результат: True, если переменная A не равна переменной B.</li><li>{{ A != 1 }}</li><li>Результат: True, если переменная A не равна 1.</li><li>{{ A != 'один' }}</li><li>Результат: True, если переменная A не равна 'один'.</li></ul> |
| Проверка, что первый операнд больше второго            | >           | Числовые переменные и числа             | {{ A > B }}      | <ul><li>{{ A > B }}</li><li>Результат: True, если переменная A больше переменной B.</li><li>{{ A > 1 }}</li><li>Результат: True, если переменная A больше 1.</li></ul>                                                                                             |
| Проверка, что первый операнд больше либо равен второго | >=          | Числовые переменные и числа             | {{ A >= B }}     | <ul><li>{{ A >= B }}</li><li>Результат: True, если переменная A больше или равна переменной B.</li><li>{{ A >= 1 }}</li><li>Результат: True, если переменная A больше или равна 1.</li></ul>                                                                       |
| Проверка, что первый операнд меньше второго            | <           | Числовые переменные и числа             | {{ A < B }}      | <ul><li>{{ A < B }}</li><li>Результат: True, если переменная A меньше переменной B.</li><li>{{ A < 1 }}</li><li>Результат: True, если переменная A меньше 1.</li></ul>                                                                                             |
| Проверка, что первый операнд меньше либо равен второго | <=          | Числовые переменные и числа             | {{ A <= B }}     | <ul><li>{{ A <= B }}</li><li>Результат: True, если переменная A меньше или равна переменной B.</li><li>{{ A <= 1 }}</li><li>Результат: True, если переменная A меньше или равна 1.</li></ul>                                                                       |

| Оператор                         | Обозначение | Область применения            | Как использовать | Пример                                                                                                                                                                    |
| -------------------------------- | ----------- | ----------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| “И”                              | and         | Выражения и булевы переменные | {{ A and B }}    | <ul><li>{{ A and B }}</li><li>Результат: True, если если обе булевы переменные A и B истинны.</li></ul>                                                                   |
| "ИЛИ”                            | or          | Выражения и булевы переменные | {{ A or B }}     | <ul><li>{{ A or B }}</li><li>Результат: True, если если одна из булевых переменных A и B истинны.</li></ul>                                                               |
| "НЕ”                             | not         | Выражения и булевы переменные | {{ not A }}      | <ul><li>{{ not A }}</li><li>Результат: True, если если булева переменная A ложна.</li><li>{{ not A == 1 }}</li><li>Результат: False, если переменная A равна 1.</li></ul> |
| Скобки для группировки выражения | (expr)      | Выражения и булевы переменные | {{ (A) }}        | <ul><li>{{ (A > 0) and (A < 10) }}</li><li>Результат: True, если переменная A больше 0 и меньше 10.</li></ul>                                                             |

| Оператор                                         | Обозначение | Область применения                 | Как использовать                                                                                                                                                                                                                                   | Пример                                                                                                                                                                                                                                                       |
| ------------------------------------------------ | ----------- | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Поиск первого операнда во втором                 | in          | Контекстные переменные и выражения | <ul><li>Строка</li><li>{{ 's' in 'str' }}</li><li>Список чисел</li><li>{{ num in \[num1,num2,...] }}</li><li>Список строк</li><li>{{ 'str' in \['str1','str2',...] }}</li><li>Словарь</li><li>{{ key in { key1:val1, key2:val2, ... } }}</li></ul> | <ul><li>{{ 'A' in 'ABC' }}</li><li>Результат: True.</li><li>{{ 1 in \[1,2,3] }}</li><li>Результат: True.</li><li>{{ 'ABC' in \['ABC','DEF','GHI'] }}</li><li>Результат: True.</li><li>{{ 1 in {1: 'A', 2: 'B', 3: 'C'} }}</li><li>Результат: True.</li></ul> |
| Проверка операнда на свойство                    | is          | Тесты                              | {{ A is B }}                                                                                                                                                                                                                                       | Описано в таблице: Проверки значений переменных                                                                                                                                                                                                              |
| Применяет фильтр по отношению к операнду         | \|          | Фильтры                            | {{ A\|B }}                                                                                                                                                                                                                                         | Описано в таблице: Фильтры синтаксиса                                                                                                                                                                                                                        |
| Приведение операндов к строкам и их конкатенация | \~          | Контекстные переменные и строки    | <ul><li>{{ "string" \~ var }}</li><li>{{ var \~ "string" }}</li></ul>                                                                                                                                                                              | {{ "Hello " \~ name \~ "!" }}Результат: Hello John! (если переменная name содержит значение John).                                                                                                                                                           |
| Получение артибута объекта                       | . / \[]     | Любые контекстные переменные       | <ul><li>{{ A.B }}</li><li>{{ A\['B'] }}</li></ul>                                                                                                                                                                                                  | <ul><li>{{ \['A','B','C'].0 }}</li><li>Результат: A.</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}\['two'] }}</li><li>Результат: B.</li></ul>                                                                                                            |

### Проверки значений переменных

| Тест                                                                                                         | Обозначение | Как использовать                                                                                                                                                                                                                     | Пример                                                                                                                                                                                                                                                                                                                                                           |
| ------------------------------------------------------------------------------------------------------------ | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Проверка, что переменная существует в контексте                                                              | defined     | {{ A is defined }}                                                                                                                                                                                                                   | <ul><li>{{ A is defined }}, A существует</li><li>Результат: True.</li><li>{{ A is defined }}, A не существует</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                |
| Проверка, что переменная не существует в контексте                                                           | undefined   | {{ A is undefined }}                                                                                                                                                                                                                 | <ul><li>{{ A is undefined }}, A существует</li><li>Результат: False.</li><li>{{ A is undefined }}, A не существует</li><li>Результат: True.</li></ul>                                                                                                                                                                                                            |
| Проверка на соответствие регулярному выражению                                                               | match       | {{ A is match ... }}                                                                                                                                                                                                                 | <p>{{ A is match("\[regular\_expression]") }}<br>Результат:</p><ul><li>True, если A соответствует регулярному выражению;</li><li>False, если A НЕ соответствует регулярному выражению;</li><li>False, если A имеет не строковый формат;</li><li>False, если регулярное выражение прописано некорректно</li></ul><p>Важно: проверка чувствительна к регистру.</p> |
| Проверка, что объект является числом                                                                         | number      | {{ A is number }}                                                                                                                                                                                                                    | <ul><li>{{ 5 is number }}</li><li>Результат: True.</li><li>{{ 'five' is number }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                            |
| Проверка, что объект является четным числом                                                                  | even        | {{ A is even }}                                                                                                                                                                                                                      | <ul><li>{{ 22 is even }}</li><li>Результат: True.</li><li>{{ 11 is even }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                                   |
| Проверка, что объект является нечетным числом                                                                | odd         | {{ A is odd }}                                                                                                                                                                                                                       | <ul><li>{{ 46 is odd }}</li><li>Результат: False.</li><li>{{ 15 is odd }}</li><li>Результат: True.</li></ul>                                                                                                                                                                                                                                                     |
| Проверка, что объект является целым числом                                                                   | integer     | {{ A is integer }}                                                                                                                                                                                                                   | <ul><li>{{ 1012 is integer }}</li><li>Результат: True.</li><li>{{ 10.12 is integer }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                        |
| Проверка, что объект является вещественным числом                                                            | float       | {{ A is float }}                                                                                                                                                                                                                     | <ul><li>{{ 3.55 is float }}</li><li>Результат: True.</li><li>{{ 35 is float }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                               |
| Проверка, что объект делится нацело на число                                                                 | divisibleby | <p>{{ A is divisibleby(B) }}Важно:</p><ul><li>Если A = True, а B = 1, то вернется True, т.к True это 1, а 1 делится на 1.</li><li>Если A = False, то вернется True, т.к False это 0, а 0 делится на любое число (кроме 0).</li></ul> | <ul><li>{{ 4 is divisibleby(2) }}</li><li>Результат: True.</li><li>{{ 6 is divisibleby(5) }}</li><li>Результат: False.</li><li>{{ 5 is divisibleby(0) }}</li><li>Результат: False.</li><li>{{ true is divisibleby(1) }}</li><li>Результат: True.</li><li>{{ false is divisibleby(10) }}</li><li>Результат: True.</li></ul>                                       |
| Проверка, что объект является строкой                                                                        | string      | {{ A is string }}                                                                                                                                                                                                                    | <ul><li>{{ 'one' is string }}</li><li>Результат: True.</li><li>{{ 1 is string }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                             |
| Проверка, что строка находится в нижнем регистре                                                             | lower       | {{ A is lower }}                                                                                                                                                                                                                     | <ul><li>{{ 'hello' is lower }}</li><li>Результат: True.</li><li>{{ 'Hello' is lower }}</li><li>Результат: False.</li><li>{{ 'HELLO' is lower }}</li><li>Результат: False.</li></ul>                                                                                                                                                                              |
| Проверка, что строка находится в верхнем регистре                                                            | upper       | {{ A is upper }}                                                                                                                                                                                                                     | <ul><li>{{ 'BYE' is upper }}</li><li>Результат: True.</li><li>{{ 'Bye' is upper }}</li><li>Результат: False.</li><li>{{ 'bye' is upper }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                    |
| Проверка, что объект является словарем                                                                       | mapping     | {{ A is mapping }}                                                                                                                                                                                                                   | <ul><li>{{ {1:'A', 2:'B', 3:'C'} is mapping }}</li><li>Результат: True.</li><li>{{ \[1, 2, 3] is mapping }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                  |
| Проверка, что объект является последовательностью (строкой, списком или словарем)                            | sequence    | {{ A is sequence }}                                                                                                                                                                                                                  | <ul><li>{{ '12345' is sequence }}</li><li>Результат: True.</li><li>{{ \[1, 2, 3] is sequence }}</li><li>Результат: True.</li><li>{{ {1:'A', 2:'B', 3:'C'} is sequence }}</li><li>Результат: True.</li><li>{{ 12345 is sequence }}</li><li>Результат: False.</li></ul>                                                                                            |
| Проверка, что объект является булевым                                                                        | boolean     | {{ A is boolean }}                                                                                                                                                                                                                   | <ul><li>{{ A is boolean }}, A = true</li><li>Результат: True.</li><li>{{ A is boolean }}, A = 4</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                              |
| Проверка, что объект является истинным                                                                       | true        | {{ A is true }}                                                                                                                                                                                                                      | <ul><li>{{ A is true }}, A = true</li><li>Результат: True.</li><li>{{ A is true }}, A = 1</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                    |
| Проверка, что объект является ложным                                                                         | false       | {{ A is false }}                                                                                                                                                                                                                     | <ul><li>{{ A is false }}, A = false</li><li>Результат: True.</li><li>{{ A is false }}, A = 2</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                 |
| Проверка, что у объекта отсутствует значение (значение None или Null (преобразуется при парсинге ER в None)) | none        | {{ A is none }}                                                                                                                                                                                                                      | <ul><li>{{ A is none }}, A = none</li><li>Результат: True.</li><li>{{ A is none }}, A = ''</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                   |
| Проверка равенства (эквивалентно оператору ==)                                                               | eq          | {{ A is eq B }}                                                                                                                                                                                                                      | <ul><li>{{ 123 is eq 123 }}</li><li>Результат: True.</li><li>{{ 'abc' is eq 'ABC' }}</li><li>Результат: False.</li><li>{{ 456 is eq '456' }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                 |
| Проверка неравенства (эквивалентно оператору !=)                                                             | ne          | {{ A is ne B }}                                                                                                                                                                                                                      | <ul><li>{{ 123 is ne 124 }}</li><li>Результат: True.</li><li>{{ 'D' is ne 'D' }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                             |
| Проверка, что первый операнд больше второго (эквивалентно оператору >)                                       | gt          | {{ A is gt B }}                                                                                                                                                                                                                      | <ul><li>{{ 5 is gt 3 }}</li><li>Результат: True.</li><li>{{ (-1.12) is gt 1.13 }}</li><li>Результат: False.</li><li>{{ '5a' is gt '33' }}</li><li>Результат: True.</li><li>{{ '222' is gt '33' }}</li><li>Результат: False.</li></ul>                                                                                                                            |
| Проверка, что первый операнд больше либо равен второго (эквивалентно оператору >=)                           | ge          | {{ A is ge B }}                                                                                                                                                                                                                      | <ul><li>{{ 12.12 is ge 12.1199 }}</li><li>Результат: True.</li><li>{{ 15 is ge 15 }}</li><li>Результат: True.</li><li>{{ 0 is ge (-15) }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                    |
| Проверка, что первый операнд меньше второго (эквивалентно оператору <)                                       | lt          | {{ A is lt B }}                                                                                                                                                                                                                      | <ul><li>{{ 0.001 is lt 1 }}</li><li>Результат: True.</li><li>{{ (-1) is lt (-1.5) }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                                                                         |
| Проверка, что первый операнд меньше либо равен второго (эквивалентно оператору <=)                           | le          | {{ A is le B }}                                                                                                                                                                                                                      | <ul><li>{{ 21 is le 22 }}</li><li>Результат: True.</li><li>{{ (-1.11) is le (-1.11) }}</li><li>Результат: True.</li><li>{{ (1) is le (-12) }}</li><li>Результат: False.</li></ul>                                                                                                                                                                                |
| Поиск первого операнда во втором                                                                             | in          | {{ A in B }}                                                                                                                                                                                                                         | Описано в таблице: Поиск первого операнда во втором                                                                                                                                                                                                                                                                                                              |

### Фильтры синтаксиса

<table><thead><tr><th>Фильтр</th><th>Обозначение</th><th>Как использовать</th><th>Пример</th></tr></thead><tbody><tr><td>Добавление дефолтного значения</td><td>default</td><td><ul><li>{{ A|default(B) }}</li><li>Значение B будет использоваться только в случае, если переменной A нет в контексте.</li><li>{{ A|default(B,true) }}</li><li>Значение B будет использоваться в случаях, если переменной A нет в контексте или если значение переменной A приводится к False (0, пустая строка, пустой массив, пустой список).</li></ul></td><td><ul><li>{{ A|default('A is not defined') }}, A = 1</li><li>Результат: 1.</li><li>{{ A|default('A is not defined') }}, A не существует</li><li>Результат: A is not defined.</li><li>{{ A|default('A is empty', true) }}, A = ''</li><li>Результат: A is empty.</li><li>{{ A|default('A is not defined', true) }},</li><li>A не существуетРезультат: A is not defined.</li></ul></td></tr><tr><td>Преобразование в целое число</td><td>int</td><td>{{ A|int }}</td><td><ul><li>{{ 2.53|int }}</li><li>Результат: 2.</li><li>{{ '-15'|int }}</li><li>Результат: -15.</li><li>{{ '12abc'|int }}</li><li>Результат: 0.</li></ul></td></tr><tr><td>Преобразование в вещественное число</td><td>float</td><td>{{ A|float }}</td><td><ul><li>{{ 2|float }}</li><li>Результат: 2.0.</li><li>{{ '-122'|float }}</li><li>Результат: -122.0.</li><li>{{ '1a'|float }}</li><li>Результат: 0.0.</li></ul></td></tr><tr><td>Возвращение абсолютного значения числа</td><td>abs</td><td>{{ A|abs }}Ограничения: работает только с целыми и вещественными числами.</td><td><ul><li>{{ -1|abs }}</li><li>Результат: 1.</li><li>{{ -0.1111|abs }}</li><li>Результат: 0.1111.</li></ul></td></tr><tr><td>Округление числа</td><td>round</td><td><ul><li>{{ A|round }}</li><li>Округление до целой части.</li><li>{{ A|round(B, C) }}</li><li>B - число знаков после запятой.C - тип округления:common - округление в большую или меньшую сторону.ceil - округление в большую сторону.floor - округление в меньшую сторону.</li></ul></td><td><ul><li>{{ 42.12345|round }}</li><li>Результат: 42.0.</li><li>{{ -1.538675|round(3,'common') }}</li><li>Результат: -1.539.</li><li>{{ 0.5712|round(2, 'ceil') }}</li><li>Результат: 0.58.</li><li>{{ 121.67354|round(3, 'floor') }}</li><li>Результат: 121.673.</li><li>{{ 0.11111|round|int }}</li><li>Результат: 0.</li></ul></td></tr><tr><td>Преобразование в строку</td><td>string</td><td>{{ A|string }}</td><td><ul><li>{{ 12345|string }}</li><li>Результат: 12345.</li><li>{{ [1,2,3,4,5]|string }}</li><li>Результат: [1, 2, 3, 4, 5] (весь список является строкой).</li><li>{{ {1: 'A', 2: 'B', 3: 'C'}|string }}</li><li>Результат: {1: 'A', 2: 'B', 3: 'C'} (весь словарь является строкой).</li></ul></td></tr><tr><td>Преобразование в список</td><td>list</td><td>{{ A|list }}</td><td><ul><li>{{ 'abcdefg'|list }}</li><li>Результат: ['a', 'b', 'c', 'd', 'e', 'f', 'g'].</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}|list }}</li><li>Результат: ['one', 'two', 'three'].</li><li>{{ 12345|list }}</li><li>Результат: False.</li></ul></td></tr><tr><td>Преобразование в нижний регистр</td><td>lower</td><td>{{ A|lower }}</td><td><ul><li>{{ 'AbcDefg'|lower }}</li><li>Результат: abcdefg.</li><li>{{ ['A','B','C']|lower }}</li><li>Результат: ['a', 'b', 'c'].</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}|lower }}</li><li>Результат: {'one': 'a', 'two': 'b', 'three': 'c'}.</li></ul></td></tr><tr><td>Преобразование в верхний регистр</td><td>upper</td><td>{{ A|upper }}</td><td><ul><li>{{ 'AbcDefg'|upper }}</li><li>Результат: ABCDEFG.</li><li>{{ ['a','b','c']|upper }}</li><li>Результат: ['A', 'B', 'C'].</li><li>{{ {'one': 'a', 'two': 'b', 'three': 'c'}|upper }}</li><li>Результат: {'ONE': 'A', 'TWO': 'B', 'THREE': 'C'}.</li></ul></td></tr><tr><td>Приведение первой буквы в строке к верхнему регистру</td><td>capitalize</td><td>{{ A|capitalize }}Ограничения: работает только со строками.</td><td><ul><li>{{ 'abc'|capitalize }}</li><li>Результат: Abc.</li></ul></td></tr><tr><td>Преобразование в заглавный регистр (т.е. слова будут начинаться с прописных букв, все остальные символы будут строчными)</td><td>title</td><td>{{ A|title }}Важно: элементы списка и словаря приводятся к нижнему регистру.</td><td><ul><li>{{ 'hello'|title }}</li><li>Результат: Hello.</li><li>{{ 'hELLO'|title }}</li><li>Результат: Hello.</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}|title }}</li><li>Результат: {'one': 'a', 'two': 'b', 'three': 'c'}.</li></ul></td></tr><tr><td>Первый элемент последовательности (строки, списка или словаря)</td><td>first</td><td>{{ A|first }}</td><td><ul><li>{{ '12345'|first }}</li><li>Результат: 1.</li><li>{{ [1, 2, 3]|first }}</li><li>Результат: 1.</li><li>{{ {1:'A', 2:'B', 3:'C'}|first }}</li><li>Результат: 1.</li><li>{{ 12345|first }}</li><li>Результат: False.</li></ul></td></tr><tr><td>Последний элемент последовательности (строки, списка или словаря)</td><td>last</td><td>{{ A|last }}</td><td><ul><li>{{ '12345'|last }}</li><li>Результат: 5.</li><li>{{ [1, 2, 3]|last }}</li><li>Результат: 3.</li><li>{{ {1:'A', 2:'B', 3:'C'}|last }}</li><li>Результат: 3.</li><li>{{ 12345|last }}</li><li>Результат: False.</li></ul></td></tr><tr><td>Число элементов в последовательности (строке, списке или словаре)</td><td>length</td><td>{{ A|length }}</td><td><ul><li>{{ 'abcdefg'|length }}</li><li>Результат: 7.</li><li>{{ [1, 2, 3]|length }}</li><li>Результат: 3.</li><li>{{ {1:'A'}|length }}</li><li>Результат: 1.</li><li>{{ 111|length }}</li><li>Результат: False.</li></ul></td></tr><tr><td>Сумма элементов последовательности</td><td>sum</td><td>{{ A|sum }}Важно: если последовательность пустая, то возвращается 0.</td><td><ul><li>{{ [1,2,3,4,5]|sum }}</li><li>Результат: 15.</li><li>{{ {1: 'A', 2: 'B', 3: 'C'}|sum }}</li><li>Результат: 6.</li><li>{{ ''|sum }}</li><li>Результат: 0.</li></ul></td></tr><tr><td>Получение наименьшего значения элемента последовательности</td><td>min</td><td>{{ A|min }}</td><td><ul><li>{{ [1, 0.001, -1]|min }}</li><li>Результат: -1.</li><li>{{ ['1', '0.001', '-1']|min }}</li><li>Результат: -1.</li><li>{{ ['b', 'f', 'a']|min }}</li><li>Результат: a.</li><li>{{ {'1': 'A', '2': 'B', '3': 'C'}|min }}</li><li>Результат: 1.</li></ul></td></tr><tr><td>Получение наибольшего значения элемента последовательности</td><td>max</td><td>{{ A|max }}</td><td><ul><li>{{ [1, 0.001, -1]|max }}</li><li>Результат: 1.</li><li>{{ ['1', '0.001', '-1']|max }}</li><li>Результат: 1.</li><li>{{ ['b', 'f', 'a']|max }}</li><li>Результат: f.</li><li>{{ {'1': 'A', '2': 'B', '3': 'C'}|max }}</li><li>Результат: 3.</li></ul></td></tr><tr><td>Получение случайного элемента</td><td>random</td><td>{{ A|random }}Ограничения: работает только со списками и массивами.</td><td><ul><li>{{ [-22, 4.110263, 353, 124]|random }}</li><li>Результат: 4.110263.</li><li>{{ ['-22', '4.110263', '353', '124']|random }}</li><li>Результат: -22.</li><li>{{ ['apple', 'orange', 'banana']|random }}</li><li>Результат: banana.</li></ul></td></tr><tr><td>Замена элемента последовательности</td><td>replace</td><td>{{ A|replace }}</td><td><ul><li>{{ "Hello World"|replace("Hello", "Goodbye") }}</li><li>Результат: Goodbye World.</li><li>{{ ['A','B','C']|replace('A', 'D') }}</li><li>Результат: ['D', 'B', 'C'].</li></ul></td></tr><tr><td>Переворачивание последовательности</td><td>reverse</td><td>{{ A|reverse }}Важно: чтобы перевернуть список или словарь, нужно добавить |list для преобразования результата в список, иначе переменная будет пустой.</td><td><ul><li>{{ 'abcdefg'|reverse }}</li><li>Результат: gfedcba.</li><li>{{ '12345'|reverse }}</li><li>Результат: 54321.</li><li>{{ ['a', 'b', 'c']|reverse|list }}</li><li>Результат: ['c', 'b', 'a'].</li><li>{{ {'1': 'A', '2': 'B', '3': 'C'}|reverse|list }}</li><li>Результат: ['3', '2', '1'].</li></ul></td></tr><tr><td>Добавление разделителя элементов последовательности (строки, списка или словаря)</td><td>join</td><td><ul><li>{{ A|join }}</li><li>{{ A|join(B) }}</li></ul></td><td><ul><li>{{ '123'|join(',') }}</li><li>Результат: (1, 2, 3).</li><li>{{ [1, 2, 3]|join }}</li><li>Результат: 123.</li><li>{{ {'one': 'A', 'two': 'B', 'three': 'C'}|join('!') }}</li><li>Результат: one!two!three.</li><li>{{ {1:'A', 2:'B', 3:'C'}.values()|join(", ") }}</li><li>Результат: A, B, C.</li><li>{{ {1:'A', 2:'B', 3:'C'}.keys()|join("!")|list }}</li><li>Результат: ['1', '!', '2', '!', '3'].</li></ul></td></tr><tr><td>Преобразование последовательности в уникальный список</td><td>unique</td><td>{{ A|unique|list }}Ограничения: работает только с добавлением |list.</td><td><ul><li>{{ 'abcab'|unique|list }}</li><li>Результат: gfedcba.</li><li>{{ '12345'|reverse }}</li><li>Результат: 54321.</li><li>{{ ['a', 'b', 'c']|reverse|list }}</li><li>Результат: ['c', 'b', 'a'].</li><li>{{ {'1': 'A', '2': 'B', '3': 'C'}|reverse|list }}</li><li>Результат: ['3', '2', '1'].</li></ul></td></tr><tr><td>Сортировка последовательности</td><td>sort</td><td><ul><li>{{ A|sort }}</li><li>{{ A|sort(r, c, a) }}</li></ul><p>r(reverse) - сортировка по убыванию, а не по возрастанию.c(case_sensitive) - сортировка верхнего и нижнего регистров отдельно.a(attribute) - значение или ключ для сортировки.</p></td><td><ul><li>{{ [1,4,3,2,5]|sort }}</li><li>Результат: [1, 2, 3, 4, 5].</li><li>{{ ['b','a','c']|sort(reverse=true) }}</li><li>Результат: ['c', 'b', 'a'].</li><li>{{ [{'id': 3, 'name': 'O'}, {'id': 1, 'name': 'E'}, {'id': 2, 'name': 'S'}]|sort(attribute='name') }}</li><li>Результат: [{'id': 1, 'name': 'E'}, {'id': 3, 'name': 'O'}, {'id': 2, 'name': 'S'}].</li><li>{{ {4: 'c', 2: 'a', 3: 'b', 1:'d'}.values()|sort }}</li><li>Результат: ['a', 'b', 'c', 'd'].</li><li>{{ {4: 'c', 2: 'a', 3: 'b', 1:'d'}.keys()|sort }}</li><li>Результат: [1, 2, 3, 4].</li></ul></td></tr><tr><td>Сортировка словаря по ключу или значению</td><td>dictsort</td><td><ul><li>{{ A|dictsort }}</li><li>{{ A|dictsort(by='key' }}</li><li>{{ A|dictsort(by='value' }}</li></ul><p>Важно: словарь по умолчанию превращается в строку.</p></td><td><ul><li>{% for key, value in {"c": 1, "a": 4, "b": 2, "d": 3}|dictsort %} {{ key }}: {{ value }} {% endfor %}</li><li>Результат: aaa: 4 b: 2 c: 1 d: 3.</li><li>{% for key, value in {"c": 1, "a": 4, "b": 2, "d": 3}|dictsort(by="key") %} {{ key }}: {{ value }} {% endfor %}</li><li>Результат: a: 4 b: 2 c: 1 d: 3.</li><li>{{ {4: 'c', 2: 'a', 3: 'b', 1:'d'}|dictsort(by='value')|list }}</li><li>Результат: [(2, 'a'), (3, 'b'), (4, 'c'), (1, 'd')].</li></ul><p><br></p></td></tr><tr><td>Фильтрация по атрибуту</td><td>map</td><td>{{ A|map(attribute='B')|map(attribute='C'|...|list }}Важно: если объект является массивом, то результат необходимо преобразовать в список.</td><td><ul><li>{{ [{'name': 'Anna', 'number': '123'}, {'name': 'Olga', 'number': '456'}, {'name': 'Evgeniya', 'number': '789'}]| map(attribute='name')|list }}</li><li>Результат: ['Anna', 'Olga', 'Evgeniya'].</li></ul></td></tr><tr><td>Группировка по числу элементов в цикле</td><td>batch</td><td><ul><li>{{ A|batch(l) }}</li><li>{{ A|batch(l, f) }}</li></ul><p>l(linecount) - число групп, на которые будет разбит объект.f(fill_with) - значение, которое используется для заполнения отсутсвующих элементов.</p></td><td><ul><li>{% for row in ['A','B','C']|batch(5, 'D') %}{{ row }}{% endfor %}</li><li>Результат: ['A', 'B', 'C', 'D', 'D'].</li><li>{% for row in [1, 2, 3, 4]|batch(2) %}</li><li>{% for i in row %}{{ i }}{% endfor %}{% endfor %}Результат:1234.</li></ul></td></tr><tr><td>Преобразование в список списков</td><td>slice</td><td><ul><li>{{ A|slice(s) }}</li><li>{{ A|slice(s, f) }}</li></ul><p>s(slices) - число списков, на которые будет разбит объект.f(fill_with) - значение, которое используется для заполнения отсутсвующих элементов.</p></td><td><ul><li>{{ [1, 2, 3, 4, 5]|slice(2)|list }}</li><li>Результат: [[1, 2, 3], [4, 5]].</li><li>{{ 'abc'|slice(5, 'd')|list }}</li><li>Результат: [['a'], ['b'], ['c'], ['d'], ['d']].</li></ul></td></tr><tr><td>Группировка по атрибуту</td><td>groupby</td><td><ul><li>{{ A|groupby(a) }}</li><li>{{ A|groupby(a, d) }}</li></ul><p>a(attribute) - атрибут.d(default) - значение по умолчанию, использующееся, если объект в списке не имеет данного атрибута.</p></td><td><ul><li>items = [ {"name": "james",  "type": "green"}, {"name": "john", "type": "blue"}, {"name": "jim", "type": "blue"}, {"name": "jessie", "type": "green"} ]</li></ul><pre><code>{% for type, items in items|groupby('type') %}{{ type }}:{% for item in items %}{{ item.name }} {% endfor %}{% endfor %}
</code></pre><p>Результат: blue: john jim green: james jessie.</p></td></tr><tr><td>Удаление элементов последовательности, которые не соответствуют тесту</td><td>select</td><td>{{ A|select(B,C)|list }}B - тест из таблицы Проверки значений переменных.C - аргумент, который передается в тест B.</td><td><ul><li>{{ [1, 2, 3, 4, 5]|select('odd')|list }}</li><li>Результат: [1, 3, 5] (нечетные числа).</li><li>{{ [1, 2, 3, 4, 5]|select('gt', 3)|list }}</li><li>Результат: [4, 5] (числа, которые больше 3).</li></ul></td></tr><tr><td>Удаление элементов последовательности, которые не соответствуют тесту по атрибуту</td><td>selectattr</td><td>{{ A|selectattr(B,C,D)|list }}B - атрибут, который необходимо достать из последовательности.C - тест из таблицы Проверки значений переменных.D - аргумент, который передается в тест С.</td><td><ul><li>users = [ {"name": "james",  "email": "james@james.com", "password": "123"}, {"name": "john", "email": "john@john.com"}, {"name": "jim", "email": "jim@jim.com"}, {"name": "jessie", "email": "jessie@jessie.com", "password": "123"} ] .</li><li>{{ users|selectattr('password','undefined')| map(attribute='email')|list }}{{ email }}Результат: ['john@john.com', 'jim@jim.com'].</li><li>table = [['685697115', 'evpolyntseva', 'Новосибирск'], ['658795243', 'Iourigaha', 'Москва'], ['683128920', 'jarondara', 'Казань'], ['630685929', 'blarar', 'Москва']] .</li><li>{{ table_all|selectattr(2, 'eq', "Москва")|map(attribute=1)|list }}Результат: ['Iourigaha', 'blarar'].</li></ul></td></tr><tr><td>Удаление элементов последовательности, которые соответствуют тесту</td><td>reject</td><td>{{ A|reject(B,C)|list }}B - тест из таблицы Проверки значений переменных .C - аргумент, который передается в тест B.</td><td><ul><li>{{ [1, 2, 3, 4, 5]|reject('odd')|list }}</li><li>Результат: [2, 4] (не нечетные числа).</li><li>{{ [1, 2, 3, 4, 5]|reject('gt', 3)|list }}</li><li>Результат: [1, 2, 3] (числа, которые не больше 3).</li></ul></td></tr><tr><td>Удаление элементов последовательности, которые соответствуют тесту по атрибуту</td><td>rejectattr</td><td>{{ A|rejectattr(B)|list }}B - атрибут, который необходимо достать из последовательности.C - тест из таблицы Проверки значений переменных .D - аргумент, который передается в тест С.</td><td><ul><li>table = [['685697115', 'evpolyntseva', 'Новосибирск'], ['658795243', 'Iourigaha', 'Москва'], ['683128920', 'jarondara', 'Казань'], ['630685929', 'blarar', 'Москва']] .</li><li>{{ table|selectattr(2, 'eq', "Москва")|map(attribute=1)|list }}Результат: ['evpolyntseva', 'jarondara'].</li></ul></td></tr><tr><td>Удаление символов в начале и конце строки</td><td>trim</td><td><ul><li>{{ A|trim }}</li><li>{{ A|trim(c) }}</li></ul><p>c(chars) - символ или строка, которые будут удалены. По умолчанию пробел.</p></td><td><ul><li>{{ ' a '|trim }}</li><li>Результат: a.</li><li>{{ 'bbbсbb'|trim('b') }}</li><li>Результат: c.</li></ul></td></tr><tr><td>Усечение строки</td><td>truncate</td><td><ul><li>{{ A|truncate(len) }}</li><li>{{ A|truncate(len,k,e,l) }}</li></ul><p>len(length) - длина урезанной строки. По умолчанию 255.k(killwords) - True или False. True указывается если нужно обрезать строку по длине, False если нужно отбросить последнее обрезаемое слово.e(end) - знак на месте усечения. По умолчанию многоточие.l(leeway) - предел превышения длины.</p></td><td><ul><li>{{ 'foo bar baz qux'|truncate(9) }}</li><li>Результат: foo... .</li><li>{{ 'foo bar baz qux'|truncate(9, True) }}</li><li>Результат: foo ba... .</li><li>{{ 'foo bar baz qux'|truncate(11, False, '', 0) }}</li><li>Результат: foo bar.</li></ul></td></tr><tr><td>Подсчет слов</td><td>wordcount</td><td>{{ A|wordcount }}</td><td><ul><li>{{ 'Hello World!'|wordcount }}</li><li>Результат: 2.</li><li>{{ ['a a a','b','c']|wordcount }}</li><li>Результат: 5.</li><li>{{ {'one': 'a', 'two': 'b b b', 'three': 'c'}|wordcount }}</li><li>Результат: 8.</li></ul></td></tr><tr><td>Форматирование числа в размер файла</td><td>filesizeformat</td><td>{{ A|filesizeformat }}</td><td><ul><li>{{ 100000 | filesizeformat }}</li><li>Результат: 100.0 kB.</li><li>{{ 25000000 | filesizeformat }}</li><li>Результат: 25.0 MB.</li></ul></td></tr><tr><td>Кодирование в URL</td><td>urlencode</td><td>{{ A|urlencode }}Важно: работает только со строками и словарями.</td><td><ul><li>{{ 'привет'|urlencode }}</li><li>Результат: %D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82.</li><li>{{ {"aaa": "привет", "bbb": 1}|urlencode }}</li><li>Результат: aaa=%D0%BF%D1%80%D0%B8%D0%B2%D0%B5%D1%82&#x26;bbb=1.</li></ul></td></tr><tr><td>Преобразование строки в дату</td><td>string_to_time</td><td>{{ "2000-06-15 18:50:47" | string_to_time("%Y-%m-%d %H:%M:%S") }}<br>После string_to_time в скобках указывается необходимый формат даты. Подробнее: <a href="https://docs.python.org/3/library/datetime.html?highlight=datetime#strftime-and-strptime-format-codes">https://docs.python.org/3/library/datetime.html?highlight=datetime#strftime-and-strptime-format-codes</a></td><td>{{ "2000-06-15 18:50:47" | string_to_time("%Y-%m-%d %H:%M:%S") }}<br>Результат: 2000-06-15 18:50:47 (тип данных — дата)</td></tr><tr><td>Преобразование даты в строку</td><td>time_to_string</td><td>{{ "2000-06-15 18:50:47" | time_to_string("%Y-%m-%d %H:%M:%S") }}<br>После time_to_string в скобках указывается необходимый формат даты. Подробнее: <a href="https://docs.python.org/3/library/datetime.html?highlight=datetime#strftime-and-strptime-format-codes">https://docs.python.org/3/library/datetime.html?highlight=datetime#strftime-and-strptime-format-codes</a></td><td>{{ "2000-06-15 18:50:47" | time_to_string("%Y-%m-%d %H:%M:%S") }}<br>Результат: 2000-06-15 18:50:47 (тип данных — строка)</td></tr></tbody></table>

## Выражения с управляющими конструкциями

| Оператор                                             | Обозначение     | Область применения           | Как использовать                                                                                                                                                                                                         | Пример                                                                |
| ---------------------------------------------------- | --------------- | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------- |
| Пройти циклом по каждому элементу последовательности | for, in, endfor | Любые контекстные переменные | {% for A in B %}{{ ... }}{% endfor %}Важно: цикл может быть максимум двойной вложенности.Внутри циклов можно использовать дополнительные переменные для проверки значений: <https://coda.io/d/\\_d\\_pM7PjYCmj#\\_tuYU1> | {% for number in \[1, 2, 3] %}{{ number }}{% endfor %}Результат: 123. |

<table><thead><tr><th>Переменная</th><th>Обозначение</th><th>Как использовать</th><th>Пример</th></tr></thead><tbody><tr><td>Номер итерации с начала цикла (1 проиндексирована)</td><td>loop.index</td><td>{{ loop.index }}</td><td><pre><code>{% for i in [{'name': 'Молоко', 'quantity': '1'}, {'name': 'Яблоки', 'quantity': '4'}, {'name': 'Печенье', 'quantity': '1'}] %}{{ loop.index }}{{ ') ' }}{{ i.name }} {{ i.quantity }} {% endfor %}
</code></pre><p>Результат:1) Молоко 12) Яблоки 43) Печенье 1</p></td></tr><tr><td>Номер итерации с начала цикла (0 проиндексирован)</td><td>loop.index0</td><td>{{ loop.index0 }}</td><td><pre><code>{% for i in ['A','B','C'] %}{{ loop.index0 }}{{ ': ' }}{{ i }}{% endfor %}
</code></pre><p>Результат:0: A1: B2: C.</p></td></tr><tr><td>Номер итерации с конца цикла (1 проиндексирована)</td><td>loop.revindex</td><td>{{ loop.revindex }}</td><td><p>dict = {{ {'one': 'A', 'two': 'B', 'three': 'C'} }}</p><pre><code>{% for i in dict %}{{ loop.revindex }}{{ ': ' }}{{ i }}{{ ' is ' }}{{ dict[i] }}{% endfor %}
</code></pre><p>Результат:3: one is A2: two is B1: three is C.</p></td></tr><tr><td>Номер итерации с конца цикла (0 проиндексирован)</td><td>loop.revindex0</td><td>{{ loop.revindex0 }}</td><td><pre><code>{% for i in ['apple','orange','cherry'] %}{{ loop.revindex0 }}{{ ' | ' }}{{ i }}{% endfor %}
</code></pre><p>Результат:2 | apple1 | orange0 | cherry.</p></td></tr><tr><td>Истина, если первая итерация</td><td>loop.first</td><td>{{ loop.first }}</td><td><pre><code>{% for i in ['a','b','c','d','e'] %}{% if loop.first == true %}{{ i }}{{ ' is first' }}{% endif %}{% endfor %}
</code></pre><p>Результат: a is first.</p></td></tr><tr><td>Истина, если последняя итерация</td><td>loop.last</td><td>{{ loop.last }}</td><td><pre><code>{% for i in ['a','b','c','d','e'] %}{% if loop.last == true %}{{ i }}{{ ' is last' }}{% endif %}{% endfor %}
</code></pre><p>Результат: e is last.</p></td></tr><tr><td>Количество элементов в последовательности</td><td>loop.length</td><td>{{ loop.length }}</td><td><pre><code>{% for i in ['a','b','c','d','e'] %}{% if loop.last == true %}{{ 'длина: '}}{{ loop.length }}{% endif %}{% endfor %}
</code></pre><p>Результат: длина: 5.</p></td></tr><tr><td>Циклическое перемещение внутри объекта</td><td>loop.cycle</td><td>{{ loop.cycle }}</td><td><p>dict = {{ {'one': 'A', 'two': 'B', 'three': 'C'} }}</p><pre><code>{% for i in dict %}{{ loop.cycle }}{{ dict[i] }}{% endfor %}
</code></pre><p>Результат: >A>B>C.</p></td></tr><tr><td>Глубина рекурсивного цикла (начиная с уровня 1)</td><td>loop.depth</td><td>{{ loop.depth }}</td><td><pre><code>{% for i in [1,2,3] %}{% if loop.last == true %}{{ 'глубина: '}}{{ loop.depth }}{% endif %}{% endfor %}
</code></pre><p>Результат: глубина: 1.</p></td></tr><tr><td>Глубина рекурсивного цикла (начиная с уровня 0)</td><td>loop.depth0</td><td>{{ loop.depth0 }}</td><td><pre><code>{% for i in [1,2,3] %}{% if loop.last == true %}{{ 'глубина: '}}{{ loop.depth0 }}{% endif %}{% endfor %}
</code></pre><p>Результат: глубина: 0.</p></td></tr><tr><td>Получение значения из предыдущей интерации цикла</td><td>loop.previtem</td><td>{{ loop.previtem }}Важно: элемент не определен, если итерация является первой.</td><td><pre><code>{% for i in [1,2,3] %}{% if loop.first == false %}{{ 'предыдущий элемент: '}}{{ loop.previtem }}{% endif %}{% endfor %}
</code></pre><p>Результат:предыдущий элемент: 1предыдущий элемент: 2.</p></td></tr><tr><td>Получение значения из следующей интерации цикла</td><td>loop.nextitem</td><td>{{ loop.nextitem }}Важно: элемент не определен, если итерация является последней.</td><td><pre><code>{% for i in [1,2,3] %}{% if loop.last == false %}{{ 'следующий элемент: '}}{{ loop.nextitem }}{% endif %}{% endfor %}
</code></pre><p>Результат:следующий элемент: 2следующий элемент: 3.</p></td></tr><tr><td>Проверка изменялось ли значение переменной</td><td>loop.changed(val)</td><td>{{ loop.changed(A) }}</td><td><p>mass = [{'k': 3, 'v': 2}, {'k': 2, 'v': 3}, {'k': 2, 'v': 2}]</p><pre><code>{% for row in mass %}{% if loop.changed(row.k) == true %}{{ row.k }}{% endif %}{% endfor %}
</code></pre><p>Результат:32.</p></td></tr></tbody></table>

<table><thead><tr><th>Оператор</th><th>Обозначение</th><th>Область применения</th><th>Как использовать</th><th>Пример</th></tr></thead><tbody><tr><td>Условные конструкции</td><td>if, elif, else, endif</td><td>Любые контекстные переменные</td><td>Для более больших условий, нежели if-выражения, например, для слота Text:{% if ... %}A{% else %}B{% endif %}Могут использоваться elif и else.</td><td><pre><code>{% if current_time > 18 %}Добрый вечер!{% else %}Добрый день!{% endif %}
</code></pre><p>Результат: ‘Добрый вечер!’, если переменная current_time содержит значение более 18.‘Добрый день!’, если переменная current_time содержит значение менее либо равное 18.<br></p></td></tr></tbody></table>

<br>

<table><thead><tr><th>Оператор</th><th>Обозначение</th><th>Область применения</th><th>Как использовать</th><th>Пример</th></tr></thead><tbody><tr><td>Применяет фильтр по отношению к блоку данных шаблона</td><td>filter, endfilter</td><td>Любые контекстные переменные</td><td>Аналогично выражениям с использованием фильтров, только для более больших условий{% filter &#x3C;фильтр> %}  TEXT{% endfilter %}Фильтры: https://coda.io/d/_d_pM7PjYCmj#_tuKuk</td><td><pre><code>{% filter upper %}    This text becomes uppercase{% endfilter %}
</code></pre><p>Результат: THIS TEXT BECOMES UPPERCASE.</p></td></tr></tbody></table>

<table><thead><tr><th>Оператор</th><th>Обозначение</th><th>Область применения</th><th>Как использовать</th><th>Пример</th></tr></thead><tbody><tr><td>Присваивает значение операнду</td><td>set</td><td>Любые контекстные переменные</td><td><ul><li>{% set A = B%}</li></ul></td><td><pre><code>{% set x = 'apples' if age is even else 'oranges' %}{{ x }}
</code></pre><p>Результат: ‘apples’, если переменная age содержит четное число.‘oranges’, если переменная age содержит нечетное число.</p></td></tr></tbody></table>

## Ошибки при рендеринге Шаблонов

При Обучение Агента в процессе Валидация сценария проверяется правильность используемых в Слотах Выражение и Выражение с управляющей конструкцией. При обнаружении ошибок появится предупреждение:\
![image.png](https://codahosted.io/docs/_pM7PjYCmj/blobs/bl-9pME_AbZcQ/96a98d3db218ff2fd1dae769e1d362417d9f2e398050a3ac40d467c0cc31ab5fbabc867a350469b4ab8a8762c38c6e0df0a473dcaa4affb86132b3e26784e47f0b0216f3199fdcabaa7421a2e19c076b359fc78ad6018f48eaaa3c341dfba727f0852535)

Формат текста предупреждения:

```
Invalid template syntax:Slot <id проблемного слота>. Error “<описание ошибки>” in expression “<проблемное выражение>”
```

Пример:

```
Invalid template syntax:Slot 8848840. Error “unexpected char '@' at 3” in expression “{{ @foo }}”
```

Расшифровка ошибки: в Слоте 8848840 обнаружена ошибка — лишний символ '@' с порядковым номером 3 в выражении {{ @foo }}.

> Важно: отсчет порядковых номеров символов в проблемном выражении начинается с 0.

<br>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://chatme-ai-4.gitbook.io/docs/proekty-na-platforme/proekt-i-ego-soderzhimoe/agenty-na-platforme/sintaksis.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.