Перед вами полный краткий справочник, или «шпаргалка», по формулам Notion. На этой странице вы найдёте от одного до нескольких примеров формул для каждой константы, оператора и функции, доступных в редакторе формул Notion.
Эта шпаргалка создана в виде быстрых и простых в использовании ссылок.
Термины формул Notion
Вот некоторые из наиболее распространённых терминов, с которыми вы столкнётесь при работе с формулами Notion.
- Свойство – прочие свойства, имеющиеся в вашей базе данных Notion. В новом редакторе формул ссылки на свойства отображаются в виде меток. Например, prop(«Number») теперь будет отображаться как Number. Вне нового редактора, как в данной документации, по-прежнему используется prop(«Number») – это сделано для того, чтобы можно было легко копировать и вставлять примеры в новый редактор.
- Встроенные модули
- Операторы: символы, выполняющие операции с 1-3 операндами. Включают в себя математические операторы (например, add), логические операторы (например, not) и тернарный оператор (if).
- Функции – заранее определённые формулы, которые можно использовать для быстрого выполнения сложных задач. Например, concat (объединение списков), или dateAdd (добавление x единиц времени к дате).
Аргументы – это принятые фрагменты данных, используемые внутри функций:
/* имя_функции(аргумент_1, аргумент_2,...) */
divide(10, 2) /* Результат: 5 */
/* Обратите внимание на то, что пробелы между аргументами необязательны, но запятые обязательны. */
join(["Я","Люблю", "Notion"], " ")
/* Результат: "Я люблю Notion" */Формулами Notion поддерживается семь различных типов данных:
- Строка – текстовое содержимое
- Число – числовые символы, над которыми можно производить математические операции
- Логические значения / Кнопка-флажок – значения 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 инвертирует (меняет на обратное) истинное значение логического значения / значения кнопки-флажка в формуле Notion. По-другому это можно выразить следующим образом: он выдаёт значение 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 ? "😀" : "😭" /* Результат: "😀" */false (ложь)
Константа false представляет логический вывод false. Противоположной константой является true.
false /* Результат: false (Чекбокс не отмечен) */
false ? "😀" : "😭" /* Результат: "😭" */Функции
if (если)
Функция if() позволяет вносить в формулу Notion операторы if-then (если-то).
Использование: 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("Сергей Соболевский") /* Результат: "СЕРГЕЙ СОБОЛЕВСКИЙ" */
"Notionbox".upper() /* Результат: "NOTIONBOX" */repeat (повторить)
Функция repeat() повторяет строку заданное количество раз.
"This is " + "very ".repeat(3).split(" ").join(", ") + " good."link (ссылка)
Функцией link() создаётся ссылка из строки-названия и URL-адреса.
link("Сергей Соболевский", "https://ssobolevski.com") /* Результат: "Сергей Соболевский" (в виде ссылки) */
"Notionbox".link("https://notionbox.ru")
/* Результат: "Notionbox" (в виде ссылки) */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("Notionbox", "b", "i", "gray", "red_background")
/* Результат: "Notionbox" (текст: жирный, курсив, серый; красный фон) */
"Формулы Notion".style("c", "u", "red") /* Результат: "Формулы Notion" (со встроенным кодом, подчёркивание, красный текст) */unstyle (отмена стиля)
Функция unstyle() удаляет форматирование строки. Можно указать стили, которые нужно удалить, или не указывать их, чтобы удалить все стили.
unstyle("*** Notionbox***") /* Результат: "Notionbox" */
"Формулы Notion".unstyle("u") /* Результат: "Формулы Notion" */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(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(now()) /* Результат: 25 (Когда текущее время было 11:25) */
/* Допустим наличие свойства под названием Date с текущей датой June 24, 2024 11:29 AM */
prop("Date").minute() /* Результат: 29 */hour (час)
Функция hour() выдаёт целое число от 0 до 23, соответствующее часу её аргумента даты.
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(now()) /* Результат: 5 (когда now() = June 24, 2024) */
/* Допустим наличие свойства под названием Date с текущей датой June 1, 2024 */
prop("Date").day() /* Результат: 3 */date (дата)
Функция date() выдаёт целое число от 1 до 31, соответствующее дню месяца её аргумента даты.
date(now()) /* Результат: 24 (когда now() = June 24, 2024) */
/* Допустим наличие свойства под названием Date с текущей датой June 1, 2024 11:29 AM */
prop("Date").date() /* Результат: 1 */month (месяц)
Функция month() выдаёт целое число от 0 до 11, соответствующее месяцу её аргумента даты.
month(now()) /* Результат: 5 (когда now() = June 24, 2024) */
/* Допустим наличие свойства под названием Date с текущей датой January 1, 2024 */
prop("Date").month() /* Результат: 0 */year (год)
Функция year() выдаёт целое число, соответствующее году её аргумента даты.
year(now()) /* Результат: 2024 (Когда now() = June 24, 2024) */
/* Допустим наличие свойства под названием Date с текущей датой June 24, 2024 */
prop("Date").year() /* Результат: 2024dateAdd (добавить к дате)
Функция dateAdd() действует с аргументом даты и добавляет к нему число, выдавая новую дату.
Для этого требуется указать три аргумента в следующем порядке:
- Дата (должна быть действительным типом данных «дата»)
- Число
- Единица измерения
Принятые единицы измерения:
- «годы»
- «кварталы»
- «месяцы»
- «недели»
- «дни»
- «часы»
- «минуты»
- «секунды»
- «миллисекунды»
/* Допустим наличие свойства под названием "Date" с текущей датой June 1, 2024 */
dateAdd(prop("Date"),3,"months") /* Результат: September 1, 2024 */
prop("Date").dateAdd(5,"days") /* Результат: June 6, 2024 */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") /* Результат: -6dateRange (диапазон дат)
Функция 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 в дату.
/* Notion выражает эту дату в местном часовом поясе, поэтому она может выглядеть иначе, если вы попробуете использование этой формулы. */
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(["Павел", "Лиза", "Наташа", "Андрей"], ", ")
/* Вывод: Павел, Лиза, Наташа, Андрей */
[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. (Это можно сделать, когда курсор находится в любом месте строки кода.)
- Добавляйте комментарии, окружив текст знаками
/**/, например:/*Это не появится в результате формулы. */
Выдача пустых/нулевых значений в формулах Notion
Выдать пустую строку:
""Выдать пустое число:
toNumber("")Выдать пустую дату:
fromTimestamp(toNumber(""))Выдать пустой список:
[]Выдать пустое логическое значение:
1 > 2 ? true : ""
