> ## Documentation Index
> Fetch the complete documentation index at: https://help.teable.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Краткий справочник по функциям

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

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

## Числовые функции

Числовые функции выполняют математические операции, статистические вычисления и форматирование чисел.

| Название функции | Описание                                                                                                                    | Входные данные            | Результат | Пример                                              |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------- | ------------------------- | --------- | --------------------------------------------------- |
| SUM              | Складывает числа. Эквивалентно number1 + number2 + ...                                                                      | `number1, [number2, ...]` | Число     | `SUM(100, 200, 300) => 600`                         |
| AVERAGE          | Возвращает среднее значение чисел.                                                                                          | `number1, [number2, ...]` | Число     | `AVERAGE(100, 200, 300) => 200`                     |
| MAX              | Возвращает наибольшее из указанных чисел.                                                                                   | `number1, [number2, ...]` | Число     | `MAX(100, 200, 300) => 300`                         |
| MIN              | Возвращает наименьшее из указанных чисел.                                                                                   | `number1, [number2, ...]` | Число     | `MIN(100, 200, 300) => 100`                         |
| ROUND            | Округляет значение до количества знаков после запятой, указанного параметром «precision».                                   | `value, [precision]`      | Число     | `ROUND(1.99, 0) => 2` `ROUND(16.8, -1) => 20`       |
| ROUNDUP          | Всегда округляет от нуля.                                                                                                   | `value, [precision]`      | Число     | `ROUNDUP(1.1, 0) => 2` `ROUNDUP(-1.1, 0) => -2`     |
| ROUNDDOWN        | Всегда округляет к нулю.                                                                                                    | `value, [precision]`      | Число     | `ROUNDDOWN(1.9, 0) => 1` `ROUNDDOWN(-1.9, 0) => -1` |
| CEILING          | Возвращает ближайшее кратное целое, большее или равное значению.                                                            | `value, [significance]`   | Число     | `CEILING(2.49) => 3` `CEILING(2.49, 1) => 2.5`      |
| FLOOR            | Возвращает ближайшее кратное целое, меньшее или равное значению.                                                            | `value, [significance]`   | Число     | `FLOOR(2.49) => 2` `FLOOR(2.49, 1) => 2.4`          |
| EVEN             | Возвращает наименьшее чётное число, большее или равное указанному значению.                                                 | `value`                   | Число     | `EVEN(0.1) => 2` `EVEN(-0.1) => -2`                 |
| ODD              | Округляет положительные значения вверх до ближайшего нечётного числа, а отрицательные — вниз до ближайшего нечётного числа. | `value`                   | Число     | `ODD(0.1) => 1` `ODD(-0.1) => -1`                   |
| INT              | Возвращает целую часть числа.                                                                                               | `value`                   | Число     | `INT(1.9) => 1` `INT(-1.9) => -2`                   |
| ABS              | Возвращает абсолютное значение.                                                                                             | `value`                   | Число     | `ABS(-1) => 1`                                      |
| SQRT             | Возвращает квадратный корень из неотрицательного числа.                                                                     | `value`                   | Число     | `SQRT(4) => 2`                                      |
| POWER            | Возводит указанное основание в указанную степень.                                                                           | `base, exponent`          | Число     | `POWER(2, 2) => 4`                                  |
| EXP              | Возводит число Эйлера (e) в указанную степень.                                                                              | `value`                   | Число     | `EXP(0) => 1` `EXP(1) => 2.718`                     |
| LOG              | Вычисляет логарифм значения по указанному основанию. Если основание не указано, по умолчанию используется 10.               | `value, [base=10]`        | Число     | `LOG(100) => 2` `LOG(1024, 2) => 10`                |
| MOD              | Возвращает остаток от деления первого параметра на второй.                                                                  | `value, divisor`          | Число     | `MOD(9, 2) => 1` `MOD(9, 3) => 0`                   |
| VALUE            | Преобразует текстовую строку в число.                                                                                       | `text`                    | Число     | `VALUE("$1,000,000") => 1000000`                    |

## Текстовые функции

Текстовые функции объединяют, ищут, заменяют, извлекают и разделяют строки.

| Название функции       | Описание                                                                                                                                                     | Входные данные                                     | Результат                 | Пример                                                           |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------- | ------------------------- | ---------------------------------------------------------------- |
| CONCATENATE            | Объединяет несколько параметров разных типов в одно текстовое значение.                                                                                      | `text1, [text2, ...]`                              | Текст                     | `CONCATENATE("Hello ", "Teable") => Hello Teable`                |
| FIND                   | Находит позицию подстроки в указанном тексте. Возвращает 0, если подстрока не найдена.                                                                       | `stringToFind, whereToSearch, [startFromPosition]` | Число                     | `FIND("Teable", "Hello Teable") => 7`                            |
| SEARCH                 | Находит позицию подстроки в указанном тексте. Возвращает пустое значение, если подстрока не найдена. Похожа на FIND, но возвращает пустое значение вместо 0. | `stringToFind, whereToSearch, [startFromPosition]` | Текст или пустое значение | `SEARCH("Teable", "Hello Teable") => 7`                          |
| MID                    | Извлекает указанное количество символов из текстовой строки, начиная с заданной позиции.                                                                     | `text, whereToStart, count`                        | Текст                     | `MID("Hello Teable", 6, 6) => "Teable"`                          |
| LEFT                   | Извлекает указанное количество символов с начала строки.                                                                                                     | `text, count`                                      | Текст                     | `LEFT("2023-09-06", 4) => "2023"`                                |
| RIGHT                  | Извлекает указанное количество символов с конца строки.                                                                                                      | `text, count`                                      | Текст                     | `RIGHT("2023-09-06", 5) => "09-06"`                              |
| REPLACE                | Заменяет указанное количество символов, начиная с заданной позиции, текстом замены.                                                                          | `text, whereToStart, count, replacement`           | Текст                     | `REPLACE("Hello Table", 7, 5, "Teable") => "Hello Teable"`       |
| REGEXP\_REPLACE        | Заменяет текстом замены все подстроки, соответствующие регулярному выражению.                                                                                | `text, regular_expression, replacement`            | Текст                     | `REGEXP_REPLACE("Hello Table", "H.* ", "") => "Teable"`          |
| SUBSTITUTE             | Заменяет старый текст новым. Можно указать индекс, чтобы заменить конкретное вхождение старого текста. Если индекс не указан, заменяются все вхождения.      | `text, oldText, newText, [index]`                  | Текст                     | `SUBSTITUTE("Hello Table", "Table", "Teable") => "Hello Teable"` |
| TEXTBEFORE             | Возвращает текст перед указанным разделителем.                                                                                                               | `text, delimiter`                                  | Текст                     | `TEXTBEFORE("20, 04, 79", ",") => "20"`                          |
| TEXTSPLIT              | Разделяет текст по указанному разделителю и возвращает несколько текстовых значений.                                                                         | `text, delimiter`                                  | Массив                    | `TEXTSPLIT("20, 04, 79", ",") => ["20", " 04", " 79"]`           |
| LOWER                  | Преобразует строку в нижний регистр.                                                                                                                         | `text`                                             | Текст                     | `LOWER("Hello Teable") => "hello teable"`                        |
| UPPER                  | Преобразует строку в верхний регистр.                                                                                                                        | `text`                                             | Текст                     | `UPPER("Hello Teable") => "HELLO TEABLE"`                        |
| REPT                   | Повторяет текст указанное количество раз.                                                                                                                    | `text, number`                                     | Текст                     | `REPT("Hello!", 3) => "Hello!Hello!Hello!"`                      |
| TRIM                   | Удаляет пробельные символы в начале и конце строки.                                                                                                          | `text`                                             | Текст                     | `TRIM(" Hello ") => "Hello"`                                     |
| LEN                    | Подсчитывает количество символов в строке.                                                                                                                   | `text`                                             | Число                     | `LEN("Hello") => 5`                                              |
| T                      | Возвращает параметр, если это текст; в противном случае возвращает пустое значение.                                                                          | `value`                                            | Текст или пустое значение | `T("Hello") => "Hello"` `T(100) => null`                         |
| ENCODE\_URL\_COMPONENT | Заменяет некоторые символы кодированными эквивалентами для создания URL или URI. Не кодирует: - \_ . \~                                                      | `value`                                            | Текст                     | `ENCODE_URL_COMPONENT("Hello Teable") => "Hello%20Teable"`       |

## Логические функции

Логические функции обрабатывают условия и логические операции, например `IF`, `AND` и `OR`.

| Название функции | Описание                                                                                                                                                                                                         | Входные данные                                | Результат                                              | Пример                                                                      |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- | ------------------------------------------------------ | --------------------------------------------------------------------------- |
| IF               | Возвращает value1, если логический параметр истинен; в противном случае возвращает value2. Может использоваться для вложенных выражений IF и проверки пустых ячеек.                                              | `logical, value1, value2`                     | Строка \| Число \| Логическое значение \| Дата и время | `IF(2 > 1, "A", "B") => "A"` `IF(2 > 1, TRUE, FALSE) => TRUE`               |
| SWITCH           | Сопоставляет входное выражение с последовательностью значений и возвращает соответствующий результат. Может возвращать значение по умолчанию, если совпадение не найдено. Часто заменяет вложенные формулы IF(). | `expression, [pattern, result]..., [default]` | Строка \| Число \| Логическое значение \| Дата и время | `SWITCH("B", "A", "Value A", "B", "Value B", "Default Value") => "Value B"` |
| AND              | Возвращает true, если все параметры истинны; в противном случае возвращает false.                                                                                                                                | `logical1, [logical2, ...]`                   | Логическое значение                                    | `AND(1 < 2, 5 > 3) => true` `AND(1 < 2, 5 < 3) => false`                    |
| OR               | Возвращает true, если хотя бы один параметр истинен.                                                                                                                                                             | `logical1, [logical2, ...]`                   | Логическое значение                                    | `OR(1 < 2, 5 < 3) => true` `OR(1 > 2, 5 < 3) => false`                      |
| XOR              | Возвращает true, если истинно нечётное количество параметров.                                                                                                                                                    | `logical1, [logical2, ...]`                   | Логическое значение                                    | `XOR(1 < 2, 5 < 3, 8 < 10) => false` `XOR(1 > 2, 5 < 3, 8 < 10) => true`    |
| NOT              | Инвертирует логическое значение параметра.                                                                                                                                                                       | `boolean`                                     | Логическое значение                                    | `NOT(1 < 2) => false` `NOT(1 > 2) => true`                                  |
| BLANK            | Возвращает значение null. Также может использоваться для проверки пустого поля.                                                                                                                                  | `-`                                           | null                                                   | `BLANK() => null` `IF({Weight}=BLANK(), 1, 2) => 1`                         |
| ERROR            | Возвращает значение ошибки.                                                                                                                                                                                      | `message`                                     | Ошибка                                                 | `IF(2 > 3, "Yes", ERROR("Calculation")) => "#ERROR: Calculation"`           |
| IS\_ERROR        | Возвращает true, если выражение вызывает ошибку.                                                                                                                                                                 | `expr`                                        | Логическое значение                                    | `IS_ERROR(ERROR()) => true`                                                 |

## Функции даты

Функции даты обрабатывают и преобразуют значения даты и времени: получают текущую дату, вычисляют разницу между датами и сравнивают даты.

| Название функции | Описание                                                                                                                                                                         | Входные данные               | Результат           | Пример                                                                                                  |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------- |
| TODAY            | Возвращает текущую дату.                                                                                                                                                         | `-`                          | Дата и время        | `TODAY() => "2023-09-08 00:00"`                                                                         |
| NOW              | Возвращает текущие дату и время.                                                                                                                                                 | `-`                          | Дата и время        | `NOW() => "2023-09-08 16:50"`                                                                           |
| YEAR             | Возвращает четырёхзначный год даты.                                                                                                                                              | `date`                       | Число               | `YEAR("2023-09-08") => 2023`                                                                            |
| MONTH            | Возвращает месяц даты в виде числа от 1 (январь) до 12 (декабрь).                                                                                                                | `date`                       | Число               | `MONTH("2023-09-08") => 9`                                                                              |
| WEEKNUM          | Возвращает номер недели в году.                                                                                                                                                  | `date`                       | Число               | `WEEKNUM("2023-09-08") => 36`                                                                           |
| WEEKDAY          | Возвращает день недели в виде целого числа от 0 до 6. Можно передать второй параметр (`"Sunday"` или `"Monday"`), чтобы неделя начиналась с этого дня.                           | `date, [startDayOfWeek]`     | Число               | `WEEKDAY("2023-09-08", "Monday") => 5`                                                                  |
| DAY              | Возвращает день месяца в виде числа от 1 до 31.                                                                                                                                  | `date`                       | Число               | `DAY("2023-09-08") => 8`                                                                                |
| HOUR             | Возвращает час даты в виде числа от 0 (12:00am) до 23 (11:00pm).                                                                                                                 | `date`                       | Число               | `HOUR("2023-09-08 16:50") => 16`                                                                        |
| MINUTE           | Возвращает минуты даты в виде целого числа от 0 до 59.                                                                                                                           | `date`                       | Число               | `MINUTE("2023-09-08 16:50") => 50`                                                                      |
| SECOND           | Возвращает секунды даты в виде целого числа от 0 до 59.                                                                                                                          | `date`                       | Число               | `SECOND("2023-09-08 16:50:30") => 30`                                                                   |
| FROMNOW          | Вычисляет количество дней между текущей и другой датой.                                                                                                                          | `date, unit`                 | Число               | `FROMNOW({Date}, "day") => 25`                                                                          |
| TONOW            | Вычисляет количество дней между текущей и другой датой.                                                                                                                          | `date, unit`                 | Число               | `TONOW({Date}, "day") => 25`                                                                            |
| DATETIME\_DIFF   | Возвращает разницу между датами и временем в указанных единицах. По умолчанию используются секунды. (См. список обозначений единиц.)                                             | `date1, date2, [unit]`       | Число               | `DATETIME_DIFF("2022-08-01", "2023-09-08", "day") => 403`                                               |
| WORKDAY          | Возвращает рабочий день со смещением от начальной даты без учёта указанных праздников                                                                                            | `date, count, [holidayStr]`  | Дата и время        | `WORKDAY("2023-09-08", 200) => "2024-06-14 00:00:00"`                                                   |
| WORKDAY\_DIFF    | Возвращает количество рабочих дней между date1 и date2. Рабочие дни не включают выходные и необязательный список праздников в виде строки дат формата ISO, разделённых запятыми. | `date1, date2, [holidayStr]` | Число               | `WORKDAY_DIFF("2023-06-18", "2023-10-01") => 75`                                                        |
| IS\_SAME         | Сравнивает две даты с точностью до указанной единицы и определяет, совпадают ли они. Возвращает true при совпадении, иначе false.                                                | `date1, date2, [unit]`       | Логическое значение | `IS_SAME("2023-09-08", "2023-09-10") => false`                                                          |
| IS\_AFTER        | Определяет, следует ли date1 после date2. Возвращает true, если это так, иначе false.                                                                                            | `date1, date2, [unit]`       | Логическое значение | `IS_AFTER("2023-09-10", "2023-09-08") => true` `IS_AFTER("2023-09-10", "2023-09-08", "month") => false` |

## Функции массивов и другие функции

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

| Название функции | Описание                                                                                                                    | Входные данные          | Результат | Пример                                                                        |
| ---------------- | --------------------------------------------------------------------------------------------------------------------------- | ----------------------- | --------- | ----------------------------------------------------------------------------- |
| COUNTALL         | Возвращает количество всех элементов, включая текст и пустые значения.                                                      | `value1, [value2, ...]` | Число     | `COUNTALL(100, 200, "", "Teable", TRUE()) => 5`                               |
| COUNTA           | Возвращает количество непустых значений. Эта функция учитывает и числа, и текстовые значения.                               | `value1, [value2, ...]` | Число     | `COUNTA(100, 200, 300, "", "Teable", TRUE) => 4`                              |
| COUNT            | Возвращает количество числовых элементов.                                                                                   | `value1, [value2, ...]` | Число     | `COUNT(100, 200, 300, "", "Teable", TRUE) => 3`                               |
| ARRAY\_JOIN      | Объединяет массив элементов сводки в строку, используя разделитель.                                                         | `array, [separator]`    | Строка    | `ARRAY_JOIN(["Tom", "Jerry", "Mike"], "; ") => "Tom; Jerry; Mike"`            |
| ARRAY\_UNIQUE    | Возвращает только уникальные элементы массива.                                                                              | `array`                 | Массив    | `ARRAY_UNIQUE([1, 2, 3, 2, 1]) => [1, 2, 3]`                                  |
| ARRAY\_FLATTEN   | Делает массив плоским, удаляя вложенность. Все элементы становятся элементами одного массива.                               | `array`                 | Массив    | `ARRAY_FLATTEN([1, 2, " ", 3, true], ["ABC"]) => [1, 2, 3, " ", true, "ABC"]` |
| ARRAY\_COMPACT   | Удаляет из массива пустые строки и значения null. Сохраняет `false` и строки с одним или несколькими пробельными символами. | `array`                 | Массив    | `ARRAY_COMPACT([1, 2, 3, "", null, "ABC"]) => [1, 2, 3, "ABC"]`               |
| RECORD\_ID       | Возвращает идентификатор текущей записи.                                                                                    | `-`                     | Строка    | `RECORD_ID() => "recxxxxxx"`                                                  |
