Formula reference: functions and operators

Use this page to look up a function, an operator, or how a formula treats a blank field. Each entry shows what you type, what it does, and a before and after example. New to formulas? Start with What formulas are and when to use one. A formula reads fields from one record and gives back one answer. In a list filter, the answer must be true or false. In a list column, the answer is what each row shows. Formulas never change your data. In every table on this page, the quotes around text show exactly where it starts and ends, so you can see spaces. The quotes are not part of the value. Rows marked “same formula” use the formula from the row above.

Terms used on this page

Term	What it means
Record	One person or one company in MK. Each row in a list is a record.
Record type	A kind of data a record carries. A person can have several at once, such as the standard `person` record and a record that came from a connected system. A formula names the record type every time it reads a field.
Field	One piece of data on a record type, such as `title` on `person`.
Read	Fetching a field’s value into the formula, written $`record.field`.
Value	Whatever a read, a piece of typed text, a number, or a calculation gives back.
No value	A field with nothing stored in it. This also covers a field, or a whole record type, that the record does not have. Formulas write it as `null`.
Empty text	Text with no characters in it, written `''`. A form field a visitor left empty often arrives this way.
Spaces-only text	Text that contains only spaces, such as `' '`.
Blank	No value, empty text, or spaces-only text. This is exactly what `empty()` treats as nothing. The number `0` and the word `false` are not blank.
Filled	Not blank.
Counts as true / counts as false	How a formula reads a value that is not already true or false, in places that need a yes or no. It applies after `!`, around `&&` and `\|\|`, and before `?` in a choice. These values count as false: no value, empty text, `0`, and `false`. Every other value counts as true. That includes spaces-only text, `'0'`, `'false'`, `'no'`, and an empty list.
Condition	Anything that gives back true or false, such as a comparison or `empty()`.
Operator	A symbol that works on values, such as `==`, `&&`, or `+`.
Function and method	A named action. A function stands alone, such as `empty(…)`. A method follows a value after a dot, such as `.toLowerCase()`.
Fixed text	Text you type into the formula inside single quotes, such as `'Acme'`.

What counts as blank

Four checks ask “is there anything here?” in four different ways. They disagree on spaces-only text, 0, and false, so the check you pick matters.

Value stored in the field	`empty()` is	`exists()` is	Counts as true	`flag()` is	`=== null` is
No value	true	false	no	false	true
Empty text `''`	true	false	no	false	false
Spaces-only text `' '`	true	false	yes	false	false
Text `'a'`	false	true	yes	false	false
The number `0`	false	true	no	false	false
`false`	false	true	no	false	false
Text `'0'`	false	true	yes	false	false
Text `'false'`	false	true	yes	false	false
An empty list `[]`	false	true	yes	false	false
The number `5`	false	true	yes	false	false

How to choose:

Use empty() and exists() to ask whether a field has anything real in it. They treat spaces-only text as nothing, and 0 as something.
Use flag() to ask whether a field says yes. See Check for blank values below.
Use === null only to ask whether the field has no value at all. Empty text does not match.
Let a value count as true or false only when you want 0 and false treated as nothing, or when you are sure the field never holds spaces-only text.

Read a field

What you type	What it does	Example
$`record.field`	Reads a field. Start with the record type, then the field name.	$`person.title`
`$('record', 'field')`	Does the same thing. Use it only when a field name contains a period.	`$('lead', 'region.code')`

Field names must match exactly, including capitalization. A misspelled name reads as no value, and MK does not show an error. Always include the record type. A bare $`email` looks for a record type called “email” and finds nothing.

Values you can type

Kind	Example
Text	`'Acme'`
Number	`42` or `-1.5`
True or false	`true` or `false`
No value	`null`
List of values	`['ceo', 'cfo']`

Text and numbers mix in a few ways:

== treats a field holding the text 5 as equal to the number 5.
Math works on a field whose text looks like a number. If lead.score holds the text 5, then $`lead.score` + 1 gives 6.
Math on a field whose text is not a number fails with an error. If person.firstName holds Ann, then $`person.firstName` + 1 is rejected.

Compare values

What you type	What it does	Example
`==`	True when both sides are equal.	$`person.lifecycleStage` == 'customer'
`!=`	True when the sides are different.	$`person.consent` != 'unsubscribed'
`<` `<=` `>` `>=`	Compares numbers or text.	$`company.employeeCount` >= 500

=== and !== work the same as == and !=. Text comparisons are case-sensitive, so 'VP' does not equal 'vp'. To ignore case, convert the field first, as in $`person.title`.toLowerCase() == 'vp'. A field with no value only equals another no value. So $`person.title` == '' is false when the title has no value. Use empty($person.title) to catch both. Before and after

Formula	Before	After
$`person.lifecycleStage` == 'customer'	`'customer'`	`true`
same formula	`'Customer'` (capital C)	`false`
same formula	`'lead'`	`false`
$`person.consent` != 'unsubscribed'	`'subscribed'`	`true`
same formula	`'unsubscribed'`	`false`
$`company.employeeCount` >= 500	`1200`	`true`
same formula	`80`	`false`
same formula	no value	`false`
$`person.title`.toLowerCase() == 'vp'	`'VP'`	`true`

In < and > comparisons, no value counts as 0. That makes $`company.employeeCount` < 500 true for a company with no employee count, and $`company.employeeCount` > 500 false. To leave those records out, check first: exists($`company.employeeCount`) && $`company.employeeCount` < 500.

Combine conditions

What you type	What it does	Example
`&&`	”And.” True when both sides are true.	$`person.title`.includes('VP') && exists($`person.email`)
`\|\|`	”Or.” True when either side is true.	empty($`person.phone`) \|\| empty($`person.email`)
`!`	”Not.” Flips true to false, and false to true.	!$`person.title`.includes('Intern')
`??`	Returns the first value that is not “no value.”	$`person.fullName` ?? $`person.firstName`

&& and || do not always give back true or false. They give back one of the two sides, chosen by whether it counts as true. 'a' && 'b' gives 'b'. '' || 'b' gives 'b'. In a filter, make both sides conditions, such as comparisons or empty(), so the answer is always true or false. || and ?? differ in what they skip:

|| skips anything that counts as false: no value, empty text, 0, and false. It does not skip spaces-only text.
?? skips only no value. It keeps empty text, spaces-only text, and 0.

Use ?? when 0 is a real answer. Use || when empty text should fall through. Neither one treats spaces-only text as nothing. To handle that, see Handle blank and messy values in formulas. When you mix && and || in one formula, add parentheses to show which goes first, as in (exists($`person.email`) || exists($`person.phone`)) && $`person.lifecycleStage` == 'lead'. Before and after

Formula	Before	After
$`person.title`.includes('VP') && exists($`person.email`)	Title `'VP of Marketing'`, has an email	`true`
same formula	Title `'VP of Marketing'`, no email	`false`
empty($`person.phone`) \|\| empty($`person.email`)	Phone `''`, email `'a@b.co'`	`true`
same formula	Phone `'555'`, email `'a@b.co'`	`false`
!$`person.title`.includes('Intern')	`'Marketing Intern'`	`false`
same formula	`'Director'`	`true`
$`person.fullName` ?? $`person.firstName`	Full name: no value. First name: `'Jordan'`	`'Jordan'`
same formula	Full name: `'Jordan Rivera'`. First name: `'Jordan'`	`'Jordan Rivera'`

Do math and join text

What you type	What it does	Example
`+`	Adds numbers, or joins text when one side of the `+` is text you typed.	$`person.firstName` + ' ' + $`person.lastName`
`-` `*` `/`	Subtracts, multiplies, divides.	$`company.annualRevenue` / 12

Before and after

Formula	Before	After
$`company.annualRevenue` / 12	`1200000`	`100000`
$`company.annualRevenue` - 50000	`1200000`	`1150000`
$`person.firstName` + ' ' + $`person.lastName`	First name `'Jordan'`, last name `'Rivera'`	`'Jordan Rivera'`

Three rules to know before you use + and math:

To join two fields, include some typed text between them, even if it is only a space. $`person.firstName` + $`person.lastName` tries to add the two fields as numbers and fails with an error. $`person.firstName` + ' ' + $`person.lastName` joins them.
When joining, a field with no value turns the whole result into no value. Empty text is fine. Handle blank and messy values in formulas shows the fix.
In math, no value counts as 0. $`company.annualRevenue` / 12 gives 0 for a company with no revenue. It does not give no value. Handle blank and messy values in formulas shows how to leave those rows empty.

Choose a value

What you type	What it does	Example
`condition ? a : b`	Returns `a` when the condition is true, otherwise `b`.	$`company.employeeCount` >= 1000 ? 'Enterprise' : 'Mid-market'

You can chain choices to sort records into more than two groups. MK checks them from left to right and stops at the first condition that is true:

$`company.employeeCount` >= 1000 ? 'Large' : $`company.employeeCount` >= 100 ? 'Medium' : 'Small'

Before and after

Formula	Before (employee count)	After
The three-group formula above	`1200`	`'Large'`
same formula	`250`	`'Medium'`
same formula	`40`	`'Small'`
$`company.employeeCount` >= 1000 ? 'Enterprise' : 'Mid-market'	`250`	`'Mid-market'`

Check for blank values

What you type	What it does	Example
`empty(a, b, …)`	True when every field listed is blank.	empty($`person.phone`)
`exists(a, b, …)`	True when every field listed is filled.	exists($`person.email`, $`person.firstName`)
`x === null`	True only when `x` has no value. Never gives back no value itself.	$`company.annualRevenue` === null
`flag(a)`	Reads a field as yes or no.	flag($`lead.opted_in`)

empty() and exists() always give back true or false. They never give back no value, and they never fail on a field that has nothing in it. flag() is for fields that spell out a yes or no in words, instead of holding a true or false value. It returns true for these values, in any capitalization: true, t, yes, y, on, and 1. It also returns true for the number 1. Everything else is false. That includes no value, empty text, 0, 2, no, maybe, and any word flag() does not recognize. Spaces are not removed, so ' yes ' is false. Without flag(), the text 'no' and the text 'false' both count as true, because they are not empty. Use flag() whenever a field holds words like these. Before and after

Formula	Before	After
empty($`person.phone`)	`' '` (spaces only)	`true`
same formula	`'+1 415 555 2671'`	`false`
exists($`person.email`, $`person.firstName`)	Email `'a@b.co'`, first name `'Jordan'`	`true`
same formula	Email `'a@b.co'`, first name `''`	`false`
$`company.annualRevenue` === null	No value	`true`
same formula	`0`	`false`
flag($`lead.opted_in`)	`'Yes'`	`true`
same formula	`'TRUE'`	`true`
same formula	`'y'`	`true`
same formula	`'1'`	`true`
same formula	`'no'`	`false`
same formula	`' yes '` (spaces around it)	`false`
same formula	`''`	`false`

Chain values together

Checks combine. You can test several fields at once with empty(a, b) and exists(a, b), pick the first filled value, and guard a field before you use it. Handle blank and messy values in formulas walks through each pattern with before and after tables.

Common patterns

Goal	Formula
Records with no email at all	empty($`person.email`)
Records with both an email and a phone	exists($`person.email`, $`person.phone`)
Records with an email or a phone	!empty($`person.email`, $`person.phone`)
Records missing a first name or a last name	!exists($`person.firstName`, $`person.lastName`)
Display name that never shows “null”	$`person.fullName`.trim() \|\| 'friend'
A yes or no field, safely	flag($`lead.opted_in`) ? 'Opted in' : 'Not opted in'
Email domain match, ignoring case, skipping empties	exists($`person.email`) && $`person.email`.toLowerCase().endsWith('@gmail.com')
Show a value only when there is one	empty($`person.title`) ? null : $`person.title`.toUpperCase()
Pull the domain out of an email (`'jordan@acme.com'` becomes `'acme.com'`)	$`person.email`.split('@')[1]
Strip dashes and spaces from a phone number (`'415 555-2671'` becomes `'4155552671'`)	$`person.phone`.replaceAll('-', '').replaceAll(' ', '')
Get a first name from a full name (`'Jordan Rivera'` becomes `'Jordan'`)	$`person.fullName`.split(' ')[0]

Work with text

Text functions go after a field or a piece of text, like $`person.email`.toLowerCase(). If the field has no value, the result is no value. That includes .length. A field with empty text has a length of 0.

What you type	What it does	Example
`.startsWith(text)`	True when the text begins with `text`.	$`person.email`.startsWith('info@')
`.endsWith(text)`	True when the text ends with `text`.	$`person.email`.endsWith('@acme.com')
`.includes(text)`	True when `text` appears anywhere inside.	$`person.title`.includes('Manager')
`.indexOf(text)`	Position where `text` first appears, counting from 0. Returns -1 when it does not appear.	$`person.email`.indexOf('@')
`.toLowerCase()` `.toUpperCase()`	Changes capitalization.	$`person.email`.toLowerCase()
`.trim()` `.trimStart()` `.trimEnd()`	Removes spaces from both ends, the start, or the end.	$`person.fullName`.trim()
`.replace(find, with)`	Replaces the first match.	$`person.phone`.replace('+1', '')
`.replaceAll(find, with)`	Replaces every match.	$`person.phone`.replaceAll('-', '')
`.padStart(length, text)` `.padEnd(length, text)`	Adds `text` to the start or end until the result reaches `length`.	$`lead.code`.padStart(8, '0')
`.repeat(count)`	Repeats the text.	`'-'.repeat(3)`
`.length`	Number of characters.	$`person.firstName`.length
`.charAt(n)` `.at(n)`	The character at position `n`, counting from 0.	$`person.firstName`.charAt(0)
`.substring(start, end)` `.slice(start, end)`	A piece of the text.	$`person.phone`.slice(0, 5)
`.split(separator)`	Breaks text into a list at each separator. Add `[0]`, `[1]`, and so on to pick one piece.	$`person.fullName`.split(' ')[0]

Before and after

Formula	Before	After
$`person.email`.toLowerCase()	`'Firstname.Lastname@MyCompany.ai'`	`'firstname.lastname@mycompany.ai'`
$`person.email`.toUpperCase()	`'Firstname.Lastname@MyCompany.ai'`	`'FIRSTNAME.LASTNAME@MYCOMPANY.AI'`
$`person.title`.toUpperCase()	`'vp of marketing'`	`'VP OF MARKETING'`
$`person.fullName`.trim()	`' Jordan Rivera '`	`'Jordan Rivera'`
$`person.fullName`.trimStart()	`' Jordan Rivera '`	`'Jordan Rivera '`
$`person.fullName`.trimEnd()	`' Jordan Rivera '`	`' Jordan Rivera'`
$`person.phone`.replace('-', '')	`'415-555-2671'`	`'415555-2671'` (first dash only)
$`person.phone`.replaceAll('-', '')	`'415-555-2671'`	`'4155552671'`
$`person.phone`.replace('+1 ', '')	`'+1 415 555 2671'`	`'415 555 2671'`
$`person.phone`.replaceAll('-', '').replaceAll(' ', '')	`'415 555-2671'`	`'4155552671'`
$`lead.code`.padStart(8, '0')	`'42'`	`'00000042'`
$`lead.code`.padEnd(5, '*')	`'42'`	`'42***'`
`'-'.repeat(3)`	No field needed	`'---'`
$`person.firstName`.length	`'Jordan'`	`6`
$`person.firstName`.charAt(0)	`'Jordan'`	`'J'`
$`person.firstName`.at(1)	`'Jordan'`	`'o'`
$`person.phone`.slice(0, 5)	`'+14155552671'`	`'+1415'`
$`person.phone`.substring(2, 5)	`'+14155552671'`	`'415'`
$`person.fullName`.split(' ')[0]	`'Jordan Rivera'`	`'Jordan'`
$`person.fullName`.split(' ')[1]	`'Jordan Rivera'`	`'Rivera'`
$`person.email`.split('@')[1]	`'jordan@acme.com'`	`'acme.com'`
$`person.email`.startsWith('info@')	`'info@acme.com'`	`true`
same formula	`'jordan@acme.com'`	`false`
$`person.email`.endsWith('@acme.com')	`'jordan@acme.com'`	`true`
$`person.title`.includes('Manager')	`'Senior Manager, Demand Gen'`	`true`
same formula	`'Director'`	`false`
$`person.email`.indexOf('@')	`'jordan@acme.com'`	`6`
same formula	`'jordan.acme.com'`	`-1`
exists($`person.email`) && $`person.email`.toLowerCase().endsWith('@gmail.com')	`'Jordan@GMAIL.com'`	`true`

Some rules for replace, replaceAll, and split:

The text you search for must be typed in, and it cannot be empty. It cannot come from a field.
The replacement must be fixed text with no $ in it. To use a field as the replacement, write it as () => field, for example $`lead.template`.replace('{{name}}', () => $`person.firstName`).
Pattern matching (regular expressions) is not available.

Work with lists of values

A list can be one you type, like ['ceo', 'cfo'], or a field that holds several values, such as tags. In the functions that take e => …, e stands for each item in turn. You can name it anything, such as tag => ….

What you type	What it does	Example
`.includes(value)`	True when the list contains `value`.	['ceo', 'cfo', 'coo'].includes($`person.title`.toLowerCase())
`.map(e => …)`	Changes every item.	$`lead.tags`.map(e => e.toLowerCase())
`.filter(e => …)`	Keeps the items where the condition is true.	$`lead.scores`.filter(e => e > 50)
`.some(e => …)`	True when at least one item matches.	$`lead.tags`.some(e => e == 'vip')
`.every(e => …)`	True when every item matches.	$`lead.scores`.every(e => e > 0)
`.reduce((total, e) => …, start)`	Folds the list into one value. The starting value is required.	$`lead.scores`.reduce((total, e) => total + e, 0)
`.join(separator)`	Joins items into text. With no separator, uses a comma.	$`lead.tags`.join(', ')
`.length`	Number of items.	$`lead.tags`.length
`.at(n)` `.slice(start, end)`	One item, or a section of the list.	$`lead.tags`.at(0)
`.toSorted()` `.toReversed()`	Sorts low to high, or reverses the order.	$`lead.scores`.toSorted()
`[...a, ...b]`	Combines lists.	[...$`lead.tags`, 'new']

Before and after

Formula	Before	After
['ceo', 'cfo', 'coo'].includes($`person.title`.toLowerCase())	Title `'CFO'`	`true`
same formula	Title `'Director'`	`false`
$`lead.tags`.map(e => e.toLowerCase())	`['VIP', 'Webinar']`	`['vip', 'webinar']`
$`lead.scores`.filter(e => e > 50)	`[20, 60, 90]`	`[60, 90]`
$`lead.tags`.some(e => e == 'vip')	`['lead', 'vip']`	`true`
same formula	`['lead']`	`false`
$`lead.scores`.every(e => e > 0)	`[20, 60, 90]`	`true`
same formula	`[20, 0, 90]`	`false`
$`lead.scores`.reduce((total, e) => total + e, 0)	`[20, 60, 90]`	`170`
$`lead.tags`.join(', ')	`['vip', 'webinar']`	`'vip, webinar'`
$`lead.tags`.join()	`['vip', 'webinar']`	`'vip,webinar'`
$`lead.tags`.length	`['vip', 'webinar']`	`2`
$`lead.tags`.at(0)	`['vip', 'webinar']`	`'vip'`
$`lead.tags`.slice(1)	`['vip', 'webinar', 'q4']`	`['webinar', 'q4']`
$`lead.scores`.toSorted()	`[10, 2, 1]`	`[1, 2, 10]`
$`lead.scores`.toReversed()	`[20, 60, 90]`	`[90, 60, 20]`
[...$`lead.tags`, 'new']	`['vip']`	`['vip', 'new']`

Some behaviors to know:

.includes on a typed list works as “is one of.” It follows the same matching as ==, so ['1'].includes(1) is true.
.toSorted() sorts numbers by value, so [10, 2, 1] becomes [1, 2, 10]. It always sorts low to high, and items with no value go last.
A list function used on something that is not a list gives no value instead of an error.
A function inside e => … can read fields, but cannot use the e of an outer function.

Other forms

What you type	What it does	Example
`({ name: value })`	Returns several named values at once. Wrap it in parentheses. Used in advanced setups.	({ name: $`person.fullName`, adult: true })

Before and after

Formula	Before	After
({ name: $`person.fullName`, adult: true })	`'Jordan Rivera'`	`{ name: 'Jordan Rivera', adult: true }`

What formulas can’t do

MK checks a formula when you enter it. If it uses something outside what this page describes, MK rejects it and points to the spot, like this:

Formula: cannot use "%" operator (line 1, column 6)

These are not available:

Remainder (%), bitwise operators, and optional chaining (?.)
Regular expressions
Assigning values, or writing more than one statement
Functions or text and list methods not listed on this page
Fields chosen by another field, such as a[$`b`]
Reading another record, such as a person’s company, from a list formula. A list formula reads the record in each row.
split(id, salt), a function used to divide people into test groups in content routing. It does not work in list filters or columns.

If a formula you expect to work is rejected, or gives an answer that this page does not explain, contact allGood support. Include the formula, the record you tested it on, and the full error message or the unexpected result.

Marketing Kernel

Platform

Enterprise

Settings

Formula reference: functions and operators

Terms used on this page

What counts as blank

Read a field

Values you can type

Compare values

Combine conditions

Do math and join text

Choose a value

Check for blank values

Chain values together

Common patterns

Work with text

Work with lists of values

Other forms

What formulas can’t do

​Terms used on this page

​What counts as blank

​Read a field

​Values you can type

​Compare values

​Combine conditions

​Do math and join text

​Choose a value

​Check for blank values

​Chain values together

​Common patterns

​Work with text

​Work with lists of values

​Other forms

​What formulas can’t do

​Related articles

Terms used on this page

What counts as blank

Read a field

Values you can type

Compare values

Combine conditions

Do math and join text

Choose a value

Check for blank values

Chain values together

Common patterns

Work with text

Work with lists of values

Other forms

What formulas can’t do

Related articles