Формулы BuildIn 2.0. Актуальный список 2025 • BuildIn-templates

Перед вами полный краткий справочник, или «шпаргалка», по формулам BuildIn. На этой странице вы найдёте от одного до нескольких примеров формул для каждой константы, оператора и функции, доступных в редакторе формул BuildIn.

Содержание

Термины формул BuildIn Встроенные модули Функции Переменные Советы по формулам

Эта шпаргалка создана в виде быстрых и простых в использовании ссылок.

Термины формул BuildIn

Вот некоторые из наиболее распространённых терминов, с которыми вы столкнётесь при работе с формулами BuildIn.

Свойство – прочие свойства, имеющиеся в вашей базе данных BuildIn. В новом редакторе формул ссылки на свойства отображаются в виде меток. Например, prop(«Number») теперь будет отображаться как Number. Вне нового редактора, как в данной документации, по-прежнему используется prop(«Number») – это сделано для того, чтобы можно было легко копировать и вставлять примеры в новый редактор.
Встроенные модули
- Операторы: символы, выполняющие операции с 1-3 операндами. Включают в себя математические операторы (например, add), логические операторы (например, not) и тернарный оператор (if).
- Логические значения: значения true и false.
Функции – заранее определённые формулы, которые можно использовать для быстрого выполнения сложных задач. Например, concat (объединение списков), или dateAdd (добавление x единиц времени к дате).

Аргументы – это принятые фрагменты данных, используемые внутри функций:

/* имя_функции(аргумент_1, аргумент_2,...) */

divide(10, 2) /* Результат: 5 */

/* Обратите внимание на то, что пробелы между аргументами необязательны, но запятые обязательны. */

join(["Я","Люблю", "BuildIn"], " ")
/* Результат: "Я люблю BuildIn" */

Формулами BuildIn поддерживается семь различных типов данных:

Строка – текстовое содержимое
Число – числовые символы, над которыми можно производить математические операции
Логические значения / Кнопка-флажок – значения true/false (истина/ложь)
Дата – объекты даты
Лицо – специальный объект данных для элементов, найденных в свойстве Person (Лицо)
Страница – специальный объект данных для элементов, найденных в свойстве Relation (Отношение)
Список – массив любых из вышеперечисленных типов данных

Встроенные модули

add (сложить)

Оператор add (+) позволяет:

Выполнять сложение чисел
Сцеплять («concatenate») строки, т.е. объединять их (что также можно выполнять с помощью join()).

Использование: + или add() → версия функции

2 + 5 /* Результат: 7 */

"Александр" + " Пушкин" /* Результат: "Александр Пушкин" */

add(4,7) /* Результат: 11 */

40.add(2) /* Результат: 42 */

subtract (вычесть)

Оператор subtract (–) позволяет вычесть одно число из другого и выдать их разницу.

Использование: - или subtract()

12 - 5 /* Результат: 7 */

subtract(5, 12) /* Результат: -7 */

47.subtract(5) /* Результат: 42 */

multiply (умножить)

Оператор multiply (*) позволяет перемножить два числа и получить их произведение.

Использование: * или multiply()

12 * 4 /* Результат: 48 */

multiply(12,-4) /* Результат: -48 */

21.multiply(2) /* Результат: 42 */

mod (остаток)

Оператор remainder (%) позволяет получить остаток после деления первого операнда на второй операнд.

Использование: % или mod()

19 % 12 /* Результат: 7 */

19 mod 12 /* Результат: 7 */

mod(-19, 12) /* Результат: -7 */

-19.mod(12) /* Результат: -7 */

pow (степень)

Оператор power (^) позволяет (также известный как оператор возведения в степень) позволяет возводить число в более высокую степень.

Использование: ^ или pow()

3 ^ 4 /* Результат: 81 */

pow(4,3) /* Результат: 64 */

4.pow(3) /* Результат: 64 */

2 ^ 2 ^ 3 /* Результат: 256 – подсчитывается как 2 ^ (2 ^ 3) */

divide (разделить)

Оператор pow (/) позволяет разделить два числа и получить их частное.

Использование: / или divide()

12 / 4 /* Результат: 3 */

divide(12, -4) /* Результат: -3 */

126.divide(3) /* Результат: 42 */

equal (равно)

Оператор equal (==) выдаёт значение true, если его операнды равны. Он действует с операндами всех типов данных – строками, числами, логическими значениями, датами и списками.

Использование: equal() или ==

1 == 1 /* Результат: true */

equal(1, 1) /* Результат: true */

1.equal(1) /* Результат: true */

1 == 2 /* Результат: false */

"1" == 1 /* Результат: false */

toNumber("1") == 1 /* Результат: true (для преобразования "1" в число используется функция toNumber */

2 ^ 2 == 4 /* Результат: true */

length("Monkey D. Luffy") == 15 /* Результат: true */

[1, 2] == [2, 1] /* Результат: false */

unequal (не равно)

Оператор unequal (!=) выдаёт значение true, если его операнды не равны. Он действует с операндами всех типов данных – строками, числами, логическими значениями, датами и массивами.

Использование: unequal() или !=

1 != 2 /* Результат: true */

1 != 1 /* Результат: false */

unequal("Кот","Собака") /* Результат: true */

"Кот".unequal("Собака") /* Результат: true */

"1" != 2 /* Результат: true */

2^3 != 10 /* Результат: true */

Greater than (больше)

Оператор «больше» (>) выдаёт значение true, если его левый операнд больше правого операнда. Он действует с операндами строк, чисел, дат и логических значений.

Использование: >

2 > 1 /* Результат: true *

42 > 50 /* Результат: false */

/* Логические значения приравнены к 1 (истина) и 0 (ложь) */
true > false /* Результат: true */

true > true /* Результат: false */

"ab" > "aa" /* Результат: true */

/* В случае дат, "меньше" приравнено к "до" */
now() > dateSubtract(now(), 1, "days") /* Результат: true */

Greater than or equal (больше или равно)

Операнд «больше или равно» (>=) выдаёт значение true, если его левый операнд больше правого операнда или равен ему. Он действует с операндами чисел, дат и логических значений.

Использование: >=

2 >= 1 /* Результат: true */

42 >= 42 /* Результат: true */

/* Логические значения приравнены к 1 (истина) и 0 (ложь) */
true >= false /* Результат: true */

true >= true /* Результат: true */

"aa" >= "aa" /* Результат: true */

/* В случае дат, "меньше" приравнено к "до" */
now() >= now() /* Результат: true */

Less than (меньше)

Оператор «меньше» (<) выдаёт значение true, если его левый операнд меньше правого операнда. Он действует с операндами чисел, дат и логических значений.

Использование: <

2 < 1 /* Результат: false */

42 < 50 /* Результат: true */

/* Логические значения приравнены к 1 (истина) и 0 (ложь) */
false < true /* Результат: true */

true < true /* Результат: false */

"ab" < "aa" /* Результат: false */

/* В случае дат, "меньше" приравнено к "до" */
now() < dateAdd(now(), 1, "months") /* Результат: true */

Less than or equal (меньше или равно)

Операнд «меньше или равно» (<=) выдаёт значение true, если его левый операнд меньше правого операнда или равен ему. Он действует с операндами чисел, дат и логических значений.

Использование: <=

2 <= 3 /* Результат: true */

42 <= 42 /* Результат: true */

/* Логические значения приравнены к 1 (истина) и 0 (ложь) */
false <= true /* Результат: true */

true <= true /* Результат: true */

"ab" <= "ac" /* Результат: true */

/* В случае дат, "меньше" приравнено к "до" */
now() <= now() /* Результат: true */

and (и)

Оператор and выдаёт значение true тогда и только тогда, когда оба его операнда имеют логическое значение true. В противном случае он выдаёт значение false. Он действует с логическими операндами.

Использование: and или &&

true and true /* Результат: true */

true and false /* Результат: false */

and(1 > 0, 0 < 4) /* Результат: true */

if(
	true and true,
	"Счастливый",
	"Грустный"
)
/* Результат: "Счастливый" */

if(
	true and false,
	"Счастливый",
	"Грустный"
)
/* Результат: "Грустный" */

if(
	5 > 4 and 1 < 3,
	true,
	false
) 
/* Результат: true */

if(
	length("Александр Пушкин") > 5
	and length("Александр Пушкин") < 100,
	true,
	false
)

/* Результат: true */

4 > 2 && 3 < 4 && 7 == 7 ? true: false /* Результат: true */

or (или)

Оператор or выдаёт значение true, если хотя бы один из его операндов имеет значение true. Он действует с логическими операндами.

Использование: or или ||

true or false /* Результат: true */

false or true /* Результат: true */

false or false /* Результат: false */

10 > 20 or "Кот" == "Кот" /* Результат: true */

10 > 20 || "Кот" == "Собака" || true /* Результат: true */

not (не)

Оператор not инвертирует (меняет на обратное) истинное значение логического значения / значения кнопки-флажка в формуле BuildIn. По-другому это можно выразить следующим образом: он выдаёт значение true только в том случае, если его операнд имеет значение false. Он действует с операндами логических значений.

Использование: not или !

not true /* Результат: false */

not(true) /* Результат: false */

not empty("Привет") /* Результат: true */

!empty("Привет") /* Результат: true */

not if(50 > 40, true, false) /* Результат: false */

true (истина)

Константа true представляет собой логический вывод true. Противоположной константой является false.

Подробнее о true

true /* Результат: true (Чекбокс не отмечен) */

true ? "😀" : "😭" /* Результат: "😀" */

false (ложь)

Константа false представляет логический вывод false. Противоположной константой является true.

Подробнее о false

false /* Результат: false (Чекбокс не отмечен) */

false ? "😀" : "😭" /* Результат: "😭" */

Функции

if (если)

Функция if() позволяет вносить в формулу BuildIn операторы if-then (если-то).

Подробнее о функции if()

Использование: if() или ?:

/* Синтаксис if() */
if(
	prop("Type") == "Млекопитающие",
	true,
	false
) /* Результат: true */

/* Синтаксис тернарной функции */
prop("Type") == "Млекопитающие" ? true: false /* Результат: true */

/* Вложенные операторы if() */
if(
	prop("Возраст") < 13,
	"Ребёнок",
	if(
		prop("Возраст") < 19,
		"Подросток",
		"Взрослый"
	)
)

ifs (несколько если)

Функция ifs() позволяет вносить несколько операторов else-if (ещё-если), не прибегая к вложенным операторам if.

ifs(true, 1, true, 2, 3) /* Результат: 1 */
true.ifs(1, true, 2, 3) /* Результат: 1 */

empty (пусто)

Функция empty() выдаёт значение true, если её аргумент пуст или имеет значение, приравненное к «пусто», включая 0, false и [].

empty("") /* Результат: true */

empty(0) /* Результат: true */

empty(false) /* Результат: true */

[].empty() /* Результат: true */

/* Допустим наличие строчки, в которой свойство Имя в настоящее время пусто */
empty(prop("Имя")) /* Результат: true */

/* Допустим наличие строчки, в которой свойство Имя содержит текст */
not empty(prop("Имя")) /* Результат: true */

/* Аналогичный результат может быть достигнут с помощью условных операторов (допустим, что свойство Имя в данной строке содержит текст) */
empty(prop("Имя")) ? false: true /* Результат: true */

length (длина)

Функция length() выдаёт число, соответствующее длине строки, числа или списка.

length("Александр Пушкин") /* Результат: 16 */

"Александр Пушкин".length() /* Результат: 16 */

length("Ялюблюипользуюсьnotion") /* Результат: 22 */

length("Doctor Doom") /* Результат: 11 */

["Luffy", "Zoro", "Nami", "Chopper"].length() /* Результат: 4 */

12345.length() /* Результат: 5 */

substring (подстрока)

Функция substring() позволяет «разрезать» строку и выдать её меньшую часть.

substring("Dangerfield",0,6) /* Результат: "Danger" */

"Dangerfield".substring(6) /* Результат: "field" */

substring("Monkey D. Luffy",0,6) /* Результат: "Monkey" */

substring("Monkey D. Luffy", 10, 15) /* Результат: "Luffy" */

substring("●●●●●●●●●●",0,6) + substring("○○○○○○○○○○",0,6) /* Результат: "●●●●●○○○○○" */

contains (содержит)

Функцией contains() проверяется, содержится ли в первом аргументе второй аргумент. Она действует только со строками (или вложенными функциями, выдающими строки).

contains("Monkey D. Luffy", "Luffy") /* Результат: true */

contains("Monkey D. Luffy", "keyLuf") /* Результат: false */

contains(true, "true") /* Результат: true */

contains(123, "123") /* Результат: true */

contains(now(), "Aug") /* Результат: true (если текущий месяц - август) */

contains([1, 2, 1], [1, 2]) /* Результат: true */

test (тест)

Функция test() позволяет проверить, содержит ли строка подстроку, или последнее является регулярным выражением. Если строка содержит подстроку, функция выдаёт значение true.

test("Monkey D. Luffy", "Luffy") /* Результат: true */

/* Функция test() чувствительна к регистру символов */
test("Monkey D. Luffy", "luffy") /* Результат: false */

/* Можно использовать квадратные скобки [], чтобы создать набор символов, каждый из которых будет считаться совпадением */
test("Monkey D. luffy", "[Ll]uffy") /* Результат: true */

/* Кроме того, с помощью круглых скобок () можно создать группу, а затем использовать оператор | (OR) */
test("Monkey D. luffy", "(L|l)uffy") /* Результат: true */

match (совпадение)

Функция match() выдаёт все совпадения регулярного выражения в виде списка.

match("Thomas 123 Frank 321", "\d+") /* Результат: ["123", "321"] */

"Thomas 123 Frank 321".match("\d+") /* Результат: ["123", "321"] */

replace (заменить)

Функция replace() ищет в строке шаблон (который может являться регулярным выражением) и заменяет первое найденное совпадение другой строкой.

replace("Pogo","Po","Dog") /* Результат: "Doggo" */

/* Совпадением считается первое найденное, если не указано иное */
replace("Dogs Dogs Dogs", "Dogs", "Cats") /* Результат: "Cats Dogs Dogs" */

/* $ сообщает механизму регулярных выражений "начать с конца строки и работать в обратном направлении" */
replace("Dogs Dogs Dogs", "Dogs$", "Cats") /* Результат: "Dogs Dogs Cats" */

/* Совпадения чувствительны к регистру символов */
replace("thomas", "t", "T") /* Результат: "Thomas" */

/* Можно использовать квадратные скобки [], чтобы создать набор символов, каждый из которых будет считаться совпадением */
replaceAll("thomas", "[Tt]homas", "Megatron") /* Результат: "Megatron" */

/* Кроме того, с помощью круглых скобок () можно создать группу, а затем использовать оператор | (OR) */
replaceAll("thomas", "(T|t)homas", "Megatron") /* Результат: "Megatron" */

/* Позволяет использовать метасимволы регулярных выражений, такие как "\\b" , который обозначает «границу слова». Без \\b, результат был бы: "Thwas is Sparta" */
replace("This is Sparta", "\\bis\\b", "was") /* Результат: "This was Sparta" */

replaceAll (заменить всё)

Функция replaceAll() ищет в строке шаблон (который может являться регулярным выражением) и заменяет ВСЕ найденные совпадения другой строкой.

Читать подробнее о функции

replaceAll("Dogs Dogs Dogs", "Dogs", "Cats") /* Результат: "Cats Cats Cats" */

/* Совпадения чувствительны к регистру символов */
replaceAll("Dogs dogs Dogs", "Dogs", "Cats") /* Результат: "Cats dogs Cats" */

/* Можно использовать квадратные скобки [], чтобы создать набор символов, каждый из которых будет считаться совпадением */
replaceAll("Dogs dogs Dogs", "[Dd]ogs", "Cats") /* Результат: "Cats Cats Cats" */

/* Кроме того, с помощью круглых скобок () можно создать группу, а затем использовать оператор | (OR) */
replaceAll("Dogs dogs Dogs", "(D|d)ogs", "Cats") /* Результат: "Cats Cats Cats" */

/* Позволяет использовать метасимволы регулярных выражений, такие как "\\b" , который обозначает «границу слова». Без \\b, результат был бы: "Thwas was Sparta" */
replaceAll("This is Sparta","\bis\b","was") /* Результат: "This was Sparta" */

/* Функция replaceAll() была отличным способом подсчёта элементов в строке, но появление списков значительно упростило подсчёт. */

/* Первоначальная версия с функцией replaceAll */
length(replaceAll("Dog, Cat, Monkey, Bat, Gorilla", "[^,]" ,"")) + 1 /* Результат: 5 */

/* Использование вместо этого списка */
["Dog", "Cat", "Monkey", "Bat", "Gorilla"].length() /* Результат: 5 */

lower (нижний регистр)

Функция lower() преобразует регистр строки в нижний регистр.

lower("NOTIONBOX") /* Результат: "notionbox" */

"СЕРГЕЙ СОБОЛЕВСКИЙ".lower() /* Результат: "сергей соболевский" */

upper (верхний)

Функция upper() преобразует регистр строки в верхний.

upper("Сергей Соболевский") /* Результат: "СЕРГЕЙ СОБОЛЕВСКИЙ" */

"BuildInbox".upper() /* Результат: "NOTIONBOX" */

repeat (повторить)

Функция repeat() повторяет строку заданное количество раз.

"This is " + "very ".repeat(3).split(" ").join(", ") + " good."

link (ссылка)

Функцией link() создаётся ссылка из строки-названия и URL-адреса.

link("Сергей Соболевский", "https://ssobolevski.com") /* Результат: "Сергей Соболевский" (в виде ссылки) */

"BuildInbox".link("https://notionbox.ru")
/* Результат: "BuildInbox" (в виде ссылки) */

style (стиль)

Функция style() добавляет к строке форматирование. Можно добавить три уровня стиля:

Оформление текста: жирный («b«), подчёркивание («u«), курсив («i«), код («c«), зачёркивание («s«)
Цвет текста: «gray«(серый), «brown«(коричневый), «orange (оранжевый),»yellow«(жёлтый), «green (зелёный), «blue» (синий), «purple» (фиолетовый), «pink» (розовый), «red«(красный)
Цвет фона: «gray_background«, «brown_background«, «orange_background«, «yellow_background«, «green_background«,»blue_background«, «purple_background«, «pink_background«, «red_background«

style("BuildInbox", "b", "i", "gray", "red_background")
/* Результат: "BuildInbox" (текст: жирный, курсив, серый; красный фон) */

"Формулы BuildIn".style("c", "u", "red") /* Результат: "Формулы BuildIn" (со встроенным кодом, подчёркивание, красный текст) */

unstyle (отмена стиля)

Функция unstyle() удаляет форматирование строки. Можно указать стили, которые нужно удалить, или не указывать их, чтобы удалить все стили.

unstyle("*** BuildInbox***") /* Результат: "BuildInbox" */

"Формулы BuildIn".unstyle("u") /* Результат: "Формулы BuildIn" */

format (формат)

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

format(4) /* Результат: "4" */

4.format() /* Результат: "4" */

format(5 + 5) /* Результат: "10" */

format(true) /* Результат: "true" */

format(5 > 4) /* Результат: "true" */

format(now()) /* Результат: "June 20, 2022 2:23 PM" (меняется в зависимости от значения ()) */

"There are " + format(10) + " Straw Hat members."
/* Результат: "There are 10 Straw Hat members." */

prop("Relation").format() /* Результат: "Page 1 Name,Page 2 Name" */

Новое в Формулах 2.0: Числа, логические значения, даты и списки автоматически конвертируются в строки без необходимости использования функции format. При этом обратите внимание на то, что объекты дат и лиц отображаются в расширенном формате – серым цветом с символом @ в начале. Объекты страниц также отображаются в расширенном формате в виде встроенных ссылок на страницы со значками.

"There are " + 10 + " Straw Hat members."
/* Результат: "There are 10 Straw Hat members." */

"Сейчас " + now()
/* Результат: "Сейчас @September 7, 2024, 10:00 AM */

min (минимальное)

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

min(4, 1, 9, -3) /* Результат: -3 */

/* Допустим, что prop("Num") содержит 3 */
[prop("Num"), 13, 5].min() /* Результат: 3 */

/* Допустим, что prop("Num") пустое (не 0) */
min(prop("Num"), 13, 5) /* Результат: 5 */

/* Другие типы данных должны быть преобразованы в числа. Здесь для преобразования false в число (0) используется функция toNumber */
min(3, 8, toNumber(false)) /* Результат: 0 */

max (максимальное)

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

max(3, 5, 4) /* Результат: 5 */

/* Допустим, что prop("Num") содержит 20. */
[prop("Num"), 13, 5].max() /* Результат: 20 */

/* Допустим, что prop("Num") пустое (не 0) */
max(prop("Num"), 13, 5) /* Результат: 13 */

/* Другие типы данных должны быть преобразованы в числа. Здесь для преобразования true и "3" в числа используется функция toNumber. */
max(1, toNumber(true), toNumber("3") ,9) /* Результат: 9 */

sum (сумма)

Функция sum() складывает свои аргументы и выдаёт результат. Обратите внимание на то, что данная функция работает с обычными числами, списком чисел и даже с несколькими списками чисел.

Подробнее о функции Sum

sum(1, 2, 3) /* Результат: 5 */

[4, 5, 6].sum() /* Результат: 15 */

sum([7, 8], [9]) /* Результат: 24 */

abs (абсолютное значение)

Функция abs() вычисляет абсолютное значение (модуль) числа.

abs(-42) /* Результат: 42 */

42.abs() /* Результат: 42 */

round (округлить)

Функция round() округляет свой аргумент до ближайшего целого (целого числа).

round(4.5) /* Результат: 5 */

4.49.round() /* Результат: 4 */

round(-4.49) /* Результат: -4 */

round(-4.5) /* Результат: -4 */

round(-4.51) /* Результат: -5 */

/* Округление до двух десятичных знаков */
round(4.158015 * 100) / 100 /* Результат: 4.16 */

/* Округление до трёх десятичных знаков */
round(5145.018394 * 10000)/10000 /* Результат: 5145.0184 */

ceil (верхняя целая часть числа)

Функция ceil() выдаёт наименьшее целое число, которое больше или равно её аргументу.

ceil(4.2) /* Результат: 5 */

3.845.ceil() /* Результат: 4 */

ceil(4) /* Результат: 4 */

/* Вычисление сдачи при округлённой оплате. Допустим, что prop("Subtotal") равно $5.34 */
ceil(prop("Subtotal")) - prop("Subtotal") /* Результат: $0.66 */

floor (нижняя целая часть числа)

Функция floor() выдаёт наибольшее целое число, которое меньше или равно её аргументу.

floor(4.2) /* Результат: 4 */

3.845.floor() /* Результат: 3 */

floor(4) /* Результат: 4 */

sqrt (квадратный корень)

Функция sqrt() выдаёт квадратный корень своего аргумента. Функция sqrt() действует только с числами.

sqrt(16) /* Результат: 4 */

100.sqrt() /* Результат: 10 */

sqrt(73-3^2) /* Результат: 8 */

cbrt (кубический корень)

Функция cbrt() выдаёт кубический корень своего аргумента. Функция cbrt() действует только с числами.

cbrt(8) /* Результат: 2 */

64.cbrt() /* Результат: 4 */

/* Общая площадь поверхности куба объёмом 300 м³ по формуле 6a², где a = длина ребра */
6 * cbrt(300) ^ 2 /* Результат: 268.88428479343 */

exp (показатель степени)

Функция exp() позволяет возвести число Эйлера e (основание натурального логарифма) в более высокую степень и получить результат, где аргументом является показатель степени (экспонент) e.

exp(2) /* Результат: 7.389056098931 */

5.exp() /* Результат: 148.413159102577 */

e ^ 5 /* Результат: 148.413159102577 */

exp(ln(5)) /* Результат: 5 */

ln(exp(5)) /* Результат: 5 */

ln (натуральный логарифм)

Функция ln() выдаёт натуральный логарифм числа.

ln(20) /* Результат: 2.995732273554 */

e.ln() /* Результат: 1 */

log10 (логарифм по основанию 10)

Функция log10() выдаёт логарифм числа по основанию 10.

log2(64) /* Результат: 6 */

2.log2() /* Результат: 1 */

sign (знак)

Функция sign() выдаёт знак своего аргумента. Она указывает на то, является ли её аргумент положительным, отрицательным или нулевым.

sign(-5) /* Результат: -1 */

5.sign() /* Результат: 1 */

sign(0) /* Результат: 0 */

sign(+"-1") /* Результат: -1 */

pi (Пи)

Математическая константа пи (π) равна (примерно) 3,1415926559.

pi() /* Результат: 3.14159265359 */

pi() * 10 ^ 2 /* Результат: 314.159265358979 */

е

Математическая константа e известна как число Эйлера и приблизительно равна 2,718281828459045.

e() /* Результат: 2.718281828459 */

500 * e() ^ (0.3 * 10) /* Результат: 10042.768461593832 */

toNumber (в число)

Функция toNumber() преобразует свой аргумент в число, если это возможно. Она полезна для преобразования в числа строк, логических значений и дат.

toNumber("42") /* Результат: 42 */

"42".toNumber() /* Результат: 42 */

toNumber(true) /* Результат: 1 */

false.toNumber() /* Результат: 0 */

toNumber(5 > 3) /* Результат: 1 */

now().toNumber() /* Результат: 1655757000000 (меняется в зависимости от значения now()) */

now (сейчас)

Функция now() выдаёт текущую дату и время местного часового пояса. Функция now() не действует с аргументами.

now() /* Результат: June 23, 2024 12:30 (на момент написания) */

minute (минута)

Функция minute() выдаёт целое число от 0 до 59, соответствующее минуте её аргумента даты.

Подробнее о minute

minute(now()) /* Результат: 25 (Когда текущее время было 11:25) */

/* Допустим наличие свойства под названием Date с текущей датой June 24, 2024 11:29 AM */
prop("Date").minute() /* Результат: 29 */

hour (час)

Функция hour() выдаёт целое число от 0 до 23, соответствующее часу её аргумента даты.

Подробнее о hour

hour(now()) /* Результат: 11 (Когда текущее время было 11:25) */

/* Допустим наличие свойства под названием Date с текущей датой June 24, 2024 11:29 AM */
prop("Date").hour() /* Результат: 11 */

day (день)

Функция day() выдаёт целое число от 0 до 6, соответствующее дню недели её аргумента даты:

0 = воскресенье
1 = понедельник
2 = вторник
3 = среда
4 = четверг
5 = пятница
6 = суббота

Подробнее о day

day(now()) /* Результат: 5 (когда now() = June 24, 2024) */

/* Допустим наличие свойства под названием Date с текущей датой June 1, 2024 */
prop("Date").day() /* Результат: 3 */

date (дата)

Функция date() выдаёт целое число от 1 до 31, соответствующее дню месяца её аргумента даты.

Подробнее о date

date(now()) /* Результат: 24 (когда now() = June 24, 2024) */

/* Допустим наличие свойства под названием Date с текущей датой June 1, 2024 11:29 AM */
prop("Date").date() /* Результат: 1 */

month (месяц)

Функция month() выдаёт целое число от 0 до 11, соответствующее месяцу её аргумента даты.

Подробнее о month

month(now()) /* Результат: 5 (когда now() = June 24, 2024) */

/* Допустим наличие свойства под названием Date с текущей датой January 1, 2024 */
prop("Date").month() /* Результат: 0 */

year (год)

Функция year() выдаёт целое число, соответствующее году её аргумента даты.

Подробнее о year

year(now()) /* Результат: 2024 (Когда now() = June 24, 2024) */

/* Допустим наличие свойства под названием Date с текущей датой June 24, 2024 */
prop("Date").year() /* Результат: 2024

dateAdd (добавить к дате)

Функция dateAdd() действует с аргументом даты и добавляет к нему число, выдавая новую дату.

Для этого требуется указать три аргумента в следующем порядке:

Дата (должна быть действительным типом данных «дата»)
Число
Единица измерения

Принятые единицы измерения:

«годы»
«кварталы»
«месяцы»
«недели»
«дни»
«часы»
«минуты»
«секунды»
«миллисекунды»

/* Допустим наличие свойства под названием "Date" с текущей датой June 1, 2024 */
dateAdd(prop("Date"),3,"months") /* Результат: September 1, 2024 */

prop("Date").dateAdd(5,"days") /* Результат: June 6, 2024 */

dateSubtract (вычесть из даты)

Функция dateSubtract() действует с аргументом даты и вычитает из него число, выдавая новую дату.

Для этого требуется указать три аргумента в следующем порядке:

Дата (должна быть действительным типом данных «дата»)
Число
Единица измерения

Принятые единицы измерения:

«годы»
«кварталы»
«месяцы»
«недели»
«дни»
«часы»
«минуты»
«секунды»
«миллисекунды»

Подробнее о dateSubtract()

/* Допустим наличие свойства под названием "Date" с текущей датой June 1, 2024 */
dateSubtract(prop("Date"),3,"months") /* Результат: March 1, 2024 */

prop("Date").dateSubtract(5,"days") /* Результат: May 27, 2024 */

dateBetween (дата между)

Функция dateBetween() выдаёт промежуток времени между двумя датами на основе указанной единицы измерения времени.

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

Дата 1 (должна быть типом данных «дата»)
Дата 2 (должна быть типом данных «дата»)
Единица измерения

Принятые единицы измерения:

«годы»
«кварталы»
«месяцы»
«недели»
«дни»
«часы»
«минуты»
«секунды»
«миллисекунды»

/* Допустим, что now() == June 23, 2024 и Date == June 1, 2024 */
dateBetween(now(),prop("Date"),"days") /* Результат: 22 */

/* Допустим, что now() == June 23, 2024 и Date == June 30, 2024 */
now().dateBetween(prop("Date"),"days") /* Результат: -6

dateRange (диапазон дат)

Функция dateRange()

/* Допустим Start Date == June 23, 2024 и End Date == June 30, 2024 */
dateRange(prop("Start Date"), prop("End Date"))
/* Результат: June 23, 2024 → June 30, 2024 */

prop("Start Date").dateRange(prop("End Date"))
/* Результат: June 23, 2024 → June 30, 2024 */

dateStart (начальная дата)

Функция dateStart() выдаёт значение начальной даты диапазона дат. Она действует с одним аргументом даты. Примечание: Данная функция ранее называлась start (более не действует).

/* Допустим наличие свойства "Date" со значением строчки June 23, 2024 → June 27, 2024 */
start(prop("Date")) /* Результат: June 23, 2024 */

prop("Date").start() /* Результат: June 23, 2024 */

dateEnd (конечная дата)

Функция dateEnd() выдаёт значение конечной даты диапазона дат. Она действует с одним аргументом даты. Примечание: Данная функция ранее называлась end (более не действует).

/* Допустим наличие свойства "Date" со значением строчки June 23, 2024 → June 27, 2024 */
end(prop("Date")) /* Результат: June 27, 2024 */

prop("Date").end() /* Результат: June 27, 2024 */

timestamp (временная метка)

Функция timestamp() преобразует аргумент даты в соответствующую ему временную метку Unix (также известную как время Unix или время эпохи), представляющую собой число.

timestamp(now()) /* Результат: 1656012120000 (меняется в зависимости от значения now()) */

now().timestamp() /* Результат: 1656012120000 (меняется в зависимости от значения now()) */

fromTimestamp (из временной метки)

Функция fromTimestamp() преобразует временную метку Unix в дату.

/* BuildIn выражает эту дату в местном часовом поясе, поэтому она может выглядеть иначе, если вы попробуете использование этой формулы. */
fromTimestamp(1656012840000) /* Результат: June 23, 2024 7:34 (UTC) */

1656012840000.fromTimestamp() /* Результат: June 23, 2024 7:34 (UTC) */

formatDate (формат даты)

Функция formatDate() форматирует дату как строку, используя стандартный формат времени «Moment».

formatDate(now(), "MMMM DD YYYY") /* Результат: June 24 2024 */

now().formatDate("dddd, MMMM DD, YYYY hh:mm A zz")
/* Результат: Friday, June 24, 2024 10:45 AM MDT */

formatDate(now(), "[Month of] MMMM, YYYY") /* Результат: Month of June, 2024 */

parseDate (преобразовать дату)

Функция parseDate преобразует строку в формате «ISO 1860» («YYYY-MM-DDT00:00Z») в объект даты.

parseDate("2024-08-16") /* Результат: August 16, 2024 */

"2015-10-21T16:08".parseDate() /* Результат: October 21, 2015 4:08 PM */

parseDate("2024") /* Результат: January 1, 2024 */

parseDate("2024-02") /* Результат: February 1, 2024 */

name (имя)

Функция name() выдаёт имя типа данных «лицо».

name(prop("Created By")) /* Результат: "Сергей Соболевский" */

prop("Created By").name() /* Результат: "Сергей Соболевский" */

email (электронная почта)

Функция email() выдаёт адрес электронной почты типа данных «лицо».

email(prop("Created By")) /* Результат: notionbox@gmail.com */

prop("Created By").email() /* Результат: notionbox@gmail.com */

at (в)

Функция at() выдаёт значение, найденное в указанном месте списка. Индексация начинается с нуля, поэтому 0 выдаёт первый элемент.

at(["Luffy", "Zoro", "Nami", "Chopper"], 1) /* Результат: "Zoro" */

[3, 2, 7, 5].at(0) /* Результат: 3 */

[prop("Date"), now().dateAdd(1, "days"), now()].at(2)
/* Результат: August 16, 2024 4:19 PM */

first (первый)

Функция first() выдаёт первый элемент списка.

first([1, 2, 3]) /* Результат: 1 */

[1, 2, 3].first() /* Результат: 1 */

last (последний)

Функция last() выдаёт последний элемент списка.

last([1, 2, 3]) /* Результат: 3 */

[1, 2, 3].last() /* Результат: 3 */

slice (разрезать)

Функция slice() позволяет «разрезать» список и выдать список меньшего размера.

slice(["Luffy", "Zoro", "Nami", "Chopper"], 1, 3) /* Результат: ["Zoro", "Nami"] */

["Luffy", "Zoro", "Nami", "Chopper"].slice(2) /* Результат: ["Nami", "Chopper"] */

concat (объединить)

Функция concat() «сцепляет» (т.е. объединяет) свои аргументы, разделённые запятыми. Она действует с одним или несколькими аргументами списка и выдаёт объединённый список из списков верхнего уровня.

concat(["Roronoa"],["Zoro"]) /* Результат: ["Roronoa", "Zoro"] */

[["Roronoa"],["Zoro"]].concat() /* Результат: ["Roronoa", "Zoro"] */

concat(["Luffy", "Zoro", ["Nami", "Chopper"]], ["Robin"])
/* Результат: ["Luffy", "Zoro", ["Nami", "Chopper"], "Robin"] */

sort (упорядочить)

Функция sort()

sort([3, 1, 2]) /* Результат: [1, 2, 3] */

[3, 1, 2].sort() /* Результат: [1, 2, 3] */

reverse (обратный порядок)

Функция reverse()

reverse(["Luffy", "Zoro", "Nami"]) /* Результат: ["Nami", "Zoro", "Luffy"] */

join (соединить)

Функция join() вставляет свой последний аргумент между всеми дополнительными аргументами, выдавая строку. Она действует только с аргументами списка.

Подробнее о функции Join

join(["Павел", "Лиза", "Наташа", "Андрей"], ", ")
/* Вывод: Павел, Лиза, Наташа, Андрей */

[1, 2, 3, 4].join("-") /* Вывод: "1-2-3-4" */

/* Используйте "\n" для добавления переносов строк */
join(["Павел", "Лиза", "Наташа", "Андрей"], "\n")
/* Вывод:
Павел
Лиза
Наташа
Андрей */

split (отделить)

Функция split()

split("Luffy,Zoro,Nami", ",") /* Результат: ["Luffy", "Zoro", "Nami"] */

"Luffy,Zoro,Nami".split(",") /* Результат: ["Luffy", "Zoro", "Nami"] */

unique (уникальное)

Функция unique()

unique([1, 1, 2]) /* Результат: [1, 2] */

[1, 1, 2].unique() /* Результат: [1, 2] */

includes (включает в себя)

Функция includes() проверяет, содержится ли в первом аргументе второй аргумент. Она действует только со списком в качестве первого аргумента и со строкой в качестве второго. Она выдаёт истинное значение только в том случае, если строка соответствует элементу полного списка.

includes(["Luffy", "Zoro", "Nami", "Chopper"], "Luf") /* Результат: false */

["Luffy", "Zoro", "Nami", "Chopper"].includes("Luf") /* Результат: false */

includes(["Luffy", "Zoro", "Nami", "Chopper"], "Luffy") /* Результат: true */

[123, 456].includes(123) /* Результат: true */

includes([123, 456], "123") /* Результат: false */

[true, false, true].includes(true) /* Результат: true */

includes([now(), now().dateAdd(1, "days")], now()) /* Результат: true */

[[1, 2], 1].includes([1, 2]) /* Результат: true */

find (найти)

Функция find() выдаёт первый элемент списка, для которого условие является истинным.

find(["a", "b", "c"], current == "b") /* Результат: "b" */

["a", "b", "c"].find(current == "b") /* Результат: "b" */

findIndex (найти указатель)

Функция findIndex() выдаёт указатель первого элемента списка, для которого условие является истинным. Индексация начинается с нуля, поэтому для первого элемента выдаётся 0.

filter (отфильтровать)

Функция filter() выдаёт значения списка, для которых условие является истинным.

filter([1, 2, 3], current > 1) /* Результат: [2, 3] */

[1, 2, 3].filter(current > 1) /* Результат: [2, 3] */

some (любой)

Функция some() выдаёт значение true, если любой элемент списка удовлетворяет заданному условию, и значение false в противном случае.

some([1, 2, 3], current == 2) /* Результат: true */

[1, 2, 3].some(current == 2) /* Результат: true */

every (каждый)

Функция every() выдаёт значение true, если каждый элемент списка удовлетворяет заданному условию, и значение false в противном случае.

every([1, 2, 3], current > 0) /* Результат: true */

[1, 2, 3].every(current > 0) /* Результат: true */

map (проецировать)

Функция map()

map([1, 2, 3], current + 1) /* Результат: [2, 3, 4] */

[1, 2, 3].map(current + 1) /* Результат: [2, 3, 4] */

flat (сжать)

Функция flat() объединяет несколько списков в один.

flat([[1, 2], [3, 4]]) /* Результат: [1, 2, 3, 4] */

[[1, 2], [3, 4]].flat() /* Результат: [1, 2, 3, 4] */

id (идентификатор)

Функция id() выдаёт идентификатор страницы текущей строчки, представляющий собой уникальную строку. Функция id() не действует с аргументами.

/* Page URL: <https://nboxru.notion.site/nboxru/45c0add874a642fe85f3642bc28d6f9b> */
id() /* Результат: 45c0add874a642fe85f3642bc28d6f9b */

prop("Relation").first().id() /* Результат: 45c0add874a642fe85f3642bc28d6f9b */

let (разрешить)

Функция let()

let(person, "Luffy", "Hello, " + name + "!")
/* Результат: "Hello, Luffy!" */

person.let("Luffy", "Hello, " + name + "!")
/* Результат: "Hello, Luffy!" */

lets (разрешить)

Функция lets()

lets(a, "Hello,", b, "Luffy!", a + " " + b) /* Результат: "Hello, Luffy!" */

a.lets("Hello,", b, "Luffy!", a + " " + b) /* Результат: "Hello, Luffy!" */

Переменные

current (текущее)

Встроенная переменная current выдаёт значение текущего элемента функции списка.

map([1, 2, 3], current + 1) /* Результат: [2, 3, 4] */

[1, 2, 3].map(current + 1) /* Результат: [2, 3, 4] */

index (указатель)

Встроенная переменная index выдаёт указатель текущего элемента функции списка. Индексация начинается с нуля.

map([1, 2, 3], current + index) /* Результат: [1, 3, 5] */

[1, 2, 3].map(current + index) /* Результат: [1, 3, 5] */

Советы по формулам

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

Работа с редактором формул

Новый редактор формул упрощает редактирование: теперь доступны новые строки кода, отступы и комментарии!

Новая строка кода создаётся нажатием клавиш cmd/ctrl + Enter.
Отступ добавляется нажатием клавиши Tab. (Это можно сделать, когда курсор находится в любом месте строки кода.)
Добавляйте комментарии, окружив текст знаками /* */, например: /* Это не появится в результате формулы. */