Helper functions

Use the Helper functions within the personalization editor to define personalized content experiences with precision and efficiency by manipulating data, performing calculations, and formatting content. Explore and experiment with these functions, operators, and helpers to discover how they work together to help you craft tailored, data-driven journeys.

Aggregation functions

Use aggregation functions to group multiple values to form a single summary value. You can also use array and list functions to define interactions with arrays, lists, and strings easier.

average average

Use the average function to return the arithmetic mean of all the selected values within the array.

{%= average(array) %}

{%=average(orders.order.price)%}

count count

Use the count function to return the number of elements within the given array.

{%= count(array) %}

{%= count(orders) %}

max max

Use the max function to return the largest of all the selected values within the array.

{%= max(array) %}

{%=max(orders.order.price)%}

min min

Use the min function to return the smallest of all the selected values within the array.

{%= min(array) %}

{%=min(orders.order.price) %}

sum sum

Use the sum function to return the sum of all the selected values within the array.

{%= sum(array) %}

 {%=sum(orders.order.price)%}

Arithmetic functions maths

Use arithmetic functions to perform basic calculations on values.

add add

Use the + (addition) function to find the sum of two argument expressions.

{%= double + double %}

{%= product1.price + product2.price %}

multiply multiply

Use the * (multiplication) function to find the product of two argument expressions.

{%= double * double %}

{%= product.inventory * product.price %}

subtract substract

Use the - (subtraction) function to find the difference of two argument expressions.

{%= double - double %}

{%= product1.price - product2.price %}

divide divide

Use the / (division) function to find the quotient of two argument expressions.

{%= double / double %}

{%= totalProduct.price / totalProduct.sold %}

remainder remainder

Use the % (remainder) function to find the remainder after dividing the two argument expressions.

{%= double % double %}

{%= person.age % 5 = 0 %}

Arrays and list functions arrays

Use these functions to make interaction with arrays, lists, and strings easier.

countOnlyNull count-only-null

Use the countOnlyNull function to count the number of null values in a list.

{%= countOnlyNull(array) %}

{%= countOnlyNull([4,0,1,6,0,0]) %}

countWithNull count-with-null

Use the countWithNull function to count all the elements of a list including null values.

{%= countWithNull(array) %}

{%= countOnlyNull([4,0,1,6,0,0]) %}

distinct distinct

Use the distinct function to get values from an array or list with duplicate values removed.

{%= distinct(array) %}

{%= distinct(person.orders.storeId).count() > 1 %}

distinctCountWithNull distinct-count-with-null

Use the distinctCountWithNull function to count the number of different values in a list including the null values.

{%= distinctCountWithNull(array) %}

{%= distinctCountWithNull([10,2,10,null]) %}

head head

Use the head function to return the first item in an array or list.

{%= head(array) %}

{%= head(topN(orders,price, 5)) %}

topN first-n

The topN function sorts an array in descending order based on the given numerical expression and returns the first N items. If the array size is less than N, it returns the entire sorted array.

{%= topN(array, value, amount) %}

{%= topN(orders,price, 5) %}

in in

Use the in function to determine if an item is a member of an array or list.

{%= in(value, array) %}

{%= in (person.birthMonth, [3, 6, 9]) %}

includes includes

Use the includes function to determine if an array or list contains a given item.

{%= includes(array,item) %}

{%= includes(person.favoriteColors,"red") %}

intersects intersects

The intersects function is used to determine if two arrays or lists have at least one common member.

{%= intersects(array1, array2) %}

{%= intersects(person.favoriteColors,["red", "blue", "green"]) %}

bottomN last-n

The bottomN function sorts an array in ascending order based on the given numerical expression and returns the first N items. If the array size is less than N, it returns the entire sorted array.

{%= bottomN(array, value, amount) %}

{%= bottomN(orders,price, 5) %}

notIn notin

Use the notIn function to determine if an item is not a member of an array or list.

{%= notIn(value, array) %}

{%= notIn(person.birthMonth ,[3, 6, 9]) %}

subsetOf subset

Use the subsetOf function to determine if a specific array (array A) is a subset of another array (array B). In other words, that all elements in array A are elements of array B.

{%= subsetOf(array1, array2) %}

{%= subsetOf(person.favoriteCities,person.visitedCities) %}

supersetOf superset

Use the supersetOf function to determine if a specific array (array A) is a superset of another array (array B). In other words, that array A contains all elements in array B.

{%= supersetOf(array1, array2) %}

{%= supersetOf(person.eatenFoods,["sushi", "pizza"]) %}

Date and time functions date-time

Use the date and time functions to perform date and time operations on values.

addDays add-days

The addDays function adjusts a given date by a specified number of days, using positive values to increment and negative values to decrement.

{%= addDays(date, number) %}

addHours add-hours

The addHours function adjusts a given date by a specified number of hours, using positive values to increment and negative values to decrement.

{%= addHours(date, number) %}

addMinutes add-minutes

The addMinutes function adjusts a given date by a specified number of minutes, using positive values to increment and negative values to decrement.

{%= addMinutes(date, number) %}

addMonths add-months

The addMonths function adjusts a given date by a specified number of months, using positive values to increment and negative values to decrement.

{%= addMonths(date, number) %}

addSeconds add-seconds

The addSeconds function adjusts a given date by a specified number of seconds, using positive values to increment and negative values to decrement.

{%= addSeconds(date, number) %}

addYears add-years

The addYears function adjusts a given date by a specified number of years, using positive values to increment and negative values to decrement.

{%= addYears(date, number) %}

age age

Use the age function to retrieve the age from a given date.

 {%= age(datetime) %}

ageInDays age-days

The ageInDays function calculates the number of days elapsed between the given date and the current date. It uses negative for future dates and positive for past dates.

{%= ageInDays(date) %}

ageInMonths age-months

The ageInMonths function calculates the number of months elapsed between the given date and the current date. It uses negative for future dates and positive for past dates.

{%= ageInMonths(date) %}

compareDates compare-dates

The compareDates function compares the first input date with the other. It returns 0 if date1 is equal to date2, -1 if date1 comes before date2, and 1 if date1 comes after date2.

{%= compareDates(date1, date2) %}

convertZonedDateTime convert-zoned-date-time

The convertZonedDateTime function converts a date-time to a given timezone.

{%= convertZonedDateTime(dateTime, timezone) %}

currentTimeInMillis current-time

Use the currentTimeInMillis function to retrieve current time in epoch milliseconds.

{%= currentTimeInMillis() %}

dateDiff date-diff

Use the dateDiff function to retrieve the difference between two dates in number of days.

{%= dateDiff(datetime,datetime) %}

dayOfMonth day-month

The dayOfMonth returns the number representing the day of the month.

{%= dayOfMonth(datetime) %}

DayOfWeek day-week

Use the dayOfWeek function to retrieve the day of week.

{%= dayOfWeek(datetime) %}

dayOfYear day-year

Use the dayOfYear function to retrieve the day of year.

{%= dayOfYear(datetime) %}

diffInSeconds diff-seconds

The diffInSeconds function returns the difference between two dates in terms of seconds.

{%= diffInSeconds(endDate, startDate) %}

extractHours extract-hours

The extractHours function extracts the hour component from a given timestamp.

{%= extractHours(date) %}

extractMinutes extract-minutes

The extractMinutes function extracts the minute component from a given timestamp.

{%= extractMinutes(date) %}

extractMonths extract-months

The extractMonth function extracts the month component from a given timestamp.

{%= extractMonths(date) %}

extractSeconds extract-seconds

The extractSeconds function extracts the second component from a given timestamp.

{%= extractSeconds(date) %}

formatDate format-date

Use the formatDate function to format a date time value. The format should be a valid Java DateTimeFormat pattern.

{%= formatDate(datetime, format) %}

{%= formatDate(profile.timeSeriesEvents._mobile.hotelBookingDetails.bookingDate, "MM/dd/YY") %}

Pattern characters pattern-characters

Some pattern letters may look similar, but represent different concepts.

Format date with locale support format-date-locale

You can use the formatDate function to format a date time value into its corresponding language sensitive representation, such as for a desired locale. The format should be a valid Java DateTimeFormat pattern.

{%= formatDate(datetime, format, locale) %}

{%= formatDate(profile.timeSeriesEvents._mobile.hotelBookingDetails.bookingDate, "MM/dd/YY", "fr_FR") %}

getCurrentZonedDateTime get-current-zoned-date-time

The getCurrentZonedDateTime function returns the current date and time with time zone information.

{%= getCurrentZonedDateTime() %}

diffInHours hours-difference

The diffInHours function returns the difference between two dates in terms of hours.

{%= diffInHours(endDate, startDate) %}

diffInMinutes diff-minutes

The diffInMinutes function returns the difference between two dates in terms of minutes.

{%= diffInMinutes(endDate, startDate) %}

diffInMonths months-difference

The diffInMonths function returns the difference between two dates in terms of months.

{%= diffInMonths(endDate, startDate) %}

setDays set-days

Use the setDays function to set the day of the month for the given date-time.

{%= setDays(datetime, day) %}

setHours set-hours

Use the setHours function to set the hour of the date-time.

{%= setHours(datetime, hour) %}

toDateTime string-to-date-time

The toDateTime function converts string to date. It returns the epoch date as output for invalid input.

{%= toDateTime(string, string) %}

toUTC to-utc

Use the toUTC function to convert a datetime to UTC.

{%= toUTC(datetime) %}

truncateToStartOfDay truncate-day

Use the truncateToStartOfDay function to modify a given date-time by setting it to the start of the day with time at 00:00.

{%= truncateToStartOfDay(date) %}

truncateToStartOfQuarter truncate-quarter

Use the truncateToStartOfQuarter function is used to truncate a date-time to the first day of its quarter (such as January 1, April 1, July 1, October 1) at 00:00.

{%= truncateToStartOfQuarter(dateTime) %}

truncateToStartOfWeek truncate-week

The truncateToStartOfWeek function modifies a given date-time by setting it to the start of the week (Monday at 00:00).

{%= truncateToStartOfWeek(dateTime) %}

truncateToStartOfYear truncate-year

Use the truncateToStartOfYear function to modify a given date-time by truncating it to the first day of the year (January 1) at 00:00.

{%= truncateToStartOfYear(dateTime) %}

weekOfYear week-of-year

Use the weekOfYear function to retrieve the week of the year.

{%= weekOfYear(datetime) %}

diffInYears diff-years

Use the diffInYears function to return the difference between two dates in terms of years.

{%= diffInYears(endDate, startDate) %}: int

Operator functions operators

Use the Boolean and comparison functions to perform logical evaluations.

and and

The and function is used to create a logical conjunction.

{%= query1 and query2 %}

{%= profile.homeAddress.country = "France" and profile.person.birthYear = 1985 %}

or or

The or function is used to create a logical disjunction.

{%= query1 or query2 %}

{%= profile.homeAddress.country = "France" or profile.person.birthYear = 1985 %}

equals operator-equals

The = (equals) function checks whether one value or expression is equal to another value or expression.

{%= expression = value %}

{%= profile.homeAddress.country = "France" %}

not equal notequal

The != (not equal) function checks whether one value or expression is not equal to another value or expression.

{%= expression != value %}

{%= profile.homeAddress.country != "France" %}

greater than greaterthan

Use the > (greater than) function to check if the first value is greater than the second value.

{%= expression1 > expression2 %}

{%= profile.person.birthYear > 1970 %}

greater than or equal to greaterthanorequal

Use the >= (greater than or equal to) function to check if the first value is greater than or equal to the second value.

{%= expression1 >= expression2 %}

{%= profile.person.birthYear >= 1970 %}

less than lessthan

Use the < (less than) comparison function to check if the first value is less than the second value.

{%= expression1 < expression2 %}

{%= profile.person.birthYear < 2000 %}

less than or equal to lessthanorequal

Use the <= (less than or equal to) comparison function to check if the first value is less than or equal to the second value.

{%= expression1 <= expression2 %}

{%= profile.person.birthYear <= 2000 %}

Dynamic functions dynamic-helpers

Use the dynamic helper functions to use conditional evaluations, iteration, and variable assignments for dynamic personalization.

Default Fallback Value default-value

The Default Fallback Value helper is used to return a default fallback value if an attribute is empty or null. This mechanism works for Profile attributes and Journey events.

Hello {%=profile.personalEmail.name.firstName ?: "there" %}!

if (conditions) if-function

The if helper is used to define a conditional block.
If the expression evaluation returns true, the block is rendered otherwise it is skipped.

{%#if contains(account.accountOrganization.primaryEmailDomain, ".edu")%}
<a href="https://www.adobe.com/academia">Check out this link</a>

{
    {
        {%#if condition1%} element_1
        {%else if condition2%} element_2
        {%else%} default_element
        {%/if%}
    }
}

unless unless

Use the unless helper is to define a conditional block. By opposition to the if helper, if the expression evaluation returns false, the block is rendered.

{%#unless unlessCondition%} element_1 {%else%} default_element {%/unless%}

{%#unless endsWith(account.accountOrganization.primaryEmailDomain}, ".edu")%}
Some Normal Content
{%else%}
Some edu specific content
{%/unless%}

each each

Use the each helper to iterate over an array.

The helper structure is {{#each ArrayName}} YourContent {{/each}}

You can use the keyword this inside the block to refer to the individual array items. Use {{@index}} to render the index of the array’s element.

{{#each profile.productsInCart}}
    <li>{{this.name}}</li>
{{/each}}

{{#each profile.homeAddress.city}}
  {{@index}} : {{this}}<br>
{{/each}}

{{#each profile.products as |product|}}
    <li>{{product.productName}} {{product.productRating}}</li>
{{/each}}

with with

Use the with helper to change the evaluation token of template-part.

{{#with profile.person.name}}
{{this.firstName}} {{this.lastName}}
{{/with}}

{{#with profile.person.name as |name|}}
 Hi {{name.firstName}} {{name.lastName}}!
 Checkout our trending products for today!
{{/with}}

let let

The let function allows an expression to be stored as a variable to be used later in a query.

{% let variable = expression %} {{variable}}

{% let sum = 0%}
    {{#each profile.productsInCart as |p|}}
        {%#if p.price>100 and p.price<1000%}
            {%let sum = sum + p.price %}
        {%/if%}
    {{/each}}
{{sum}}

Execution metadata execution-metadata

Use the executionMetadata to capture and store custom key-value pairs dynamically into the message execution context.

With this function, you can append contextual information to any native action from your campaigns or journeys. Use it to export real-time delivery contextual data to external systems for various purposes, such as tracking, analytics, personalization and downstream processing.

For example, you can use the executionMetadata helper to append a specific ID to each delivery sent to each profile. This information is generated during runtime and the enriched execution metadata can then be exported for downstream reconciliation with an external reporting platform.

{{executionMetadata key="your_key" value="your_value"}}

"_experience": {
  "customerJourneyManagement": {
    "messageExecution": {
      "metadata": {
        "your_key": "your_value"
      }
    }
  }
}

{{executionMetadata key="firstName" value=profile.person.name.firstName}}

{
  "key": "firstName",
  "value": "Alex"
}

Map functions maps

Use map functions in personalization to make interaction with maps easier.

get get

Use the get function to retrieve the value of a map for a given key.

{%= get(map, string) %}

{%= get(identityMap,"example@example.com") %}

keys keys

Use the keys function to retrieve all the keys for a given map.

{%= keys(map) %}

{%= keys(identityMap) %}

values values

The values function is used to retrieve all the values of a given map.

{%= values(map) %}

{%= values(identityMap) %}

Math functions math

Learn how to use Math functions in the personalization editor.

absolute absolute

Use the absolute function to convert a number to its absolute value.

{%= absolute(int) %}: int

formatNumber format-number

Use the formatNumber function to format any number into its language-sensitive representation.

It accepts a number and a string representing the locale, and returns a formatted string of the number in the desired locale.

{%= formatNumber(number/double,string) %}: string

{%= formatNumber(123456.789, "ar_EG") %}

random random

Use the random function to return a random value between 0 and 1.

{%= random() %}: double

roundDown round-down

Use the roundDown function to round a number down.

{%= roundDown(double) %}: double

roundUp round-up

Use the roundUp function to round a number up.

{%= roundUp(double) %}: double

toHexString to-hex-string

The toHexString function converts any number into its hexadecimal string.

{%= toHexString(number) %}: string

{%= toHexString(158) %}

toInt to-int

Use the toInt function to convert types (number, double, integer, long, float, short, byte, boolean, string) to an integer.

{%= toInt(<valueToConvert>) %}: integer

{%= toInt(42.6) %}: integer

toPercentage to-percentage

Use the toPercentage function to convert a number to percentage.

{%= toPercentage(double) %}: string

toPrecision to-precision

Use the toPrecision function to convert a number to required precision.

{%= toPrecision(double,int) %}: string

toString to-string

The toString function converts any number into its string representation.

{%= toString(string) %}: string

{%= toString(12) %}

Object functions objects

Object functions to query object properties or attributes.

isNull isNull

The isNull function determines if an object reference does not exist.

{%= isNull(object) %}

{%= isNull(person.homeAddress) %}

isNotNull isNotNull

The isNotNull function determines if an object reference exists.

{%= isNotNull(object) %}

{%= isNotNull(person.homeAddress) %}

String functions string-functions

Learn how to use String functions in the personalization editor.

camelCase camelCase

The camelCase function capitalizes the first letter of each word of a string.

{%= camelCase(string)%}

{%= camelCase(profile.homeAddress.street) %}

charCodeAt char-code-at

The charCodeAt function returns ASCII value of a character, like the charCodeAt function in JavaScript. It takes a string and an integer (defining the position of a character) as input arguments and returns its corresponding ASCII value.

{%= charCodeAt(string,int) %}: int

{%= charCodeAt("some", 1)%}

concat concate

The concat function combines two strings into one.

{%= concat(string,string) %}

{%= concat(profile.homeAddress.city,profile.homeAddress.country) %}

contains contains

Use the contains function to determine if a string contains a specified substring.

{%= contains(STRING_1, STRING_2, CASE_SENSITIVE) %}

doesNotContain doesNotContain

Use the doesNotContain function to determine if a string does not contain a specified substring.

{%= doesNotContain(STRING_1, STRING_2, CASE_SENSITIVE)%}

{%= doesNotContain(profile.person.emailAddress,"2010@gm")%}

doesNotEndWith doesNotEndWith

Use the doesNotEndWith function to determine if a string does not end with a specified substring.

{%= doesNotEndWith(STRING_1, STRING_2, CASE_SENSITIVE)%}

doesNotEndWith(person.emailAddress,".com")

doesNotStartWith doesNotStartWith

Use the doesNotStartWith function to determine if a string does not start with a specified substring.

{%= doesNotStartWith(STRING_1, STRING_2, CASE_SENSITIVE)%}

{%= doesNotStartWith(person.name,"Joe")%}

encode64 encode64

Use the encode64 function to encode a string to preserve Personal Information (PI), such as to be included in a URL.

{%= encode64(string) %}

endsWith endsWith

Use the endsWith function to determine if a string ends with a specified substring.

{%= endsWith(STRING_1, STRING_2, CASE_SENSITIVE) %}

{%= endsWith(person.emailAddress,".com") %}

equals equals

Use the equals function to determine if a string is equal to the specified string, with case sensitivity.

{%= equals(STRING_1, STRING_2) %}

{%=equals(profile.person.name,"John") %}

equalsIgnoreCase equalsIgnoreCase

Use the equalsIgnoreCase function to determine if a string is equal to the specified string, without case sensitivity.

{%= equalsIgnoreCase(STRING_1, STRING_2) %}

{%= equalsIgnoreCase(profile.person.name,"John") %}

extractEmailDomain extractEmailDomain

Use the extractEmailDomain function to extract the domain of an email address.

{%= extractEmailDomain(string) %}

{%= extractEmailDomain(profile.personalEmail.address) %}

formatCurrency format-currency

Use the formatCurrency function to convert any number into its corresponding language-sensitive currency representation depending on the locale passed as a string in the second argument.

{%= formatCurrency(number/double,string) %}: string

{%= formatCurrency(56L,"en_GB") %}

getUrlHost get-url-host

Use the getUrlHost function to retrieve the hostname of a URL.

{%= getUrlHost(string) %}: string

{%= getUrlHost("https://www.myurl.com/contact") %}

getUrlPath get-url-path

Use the getUrlPath function to retrieve the path after the domain name of a URL.

{%= getUrlPath(string) %}: string

{%= getUrlPath("https://www.myurl.com/contact.html") %}

getUrlProtocol get-url-protocol

Use the getUrlProtocol function to retrieve the protocol of a URL.

{%= getUrlProtocol(string) %}: string

{%= getUrlProtocol("https://www.myurl.com/contact.html") %}

indexOf index-of

Use the indexOf function to return the position (in the first argument) of the first occurrence of the second parameter. Returns -1 if there is no match.

{%= indexOf(STRING_1, STRING_2) %}: integer

{%= indexOf("hello world","world" ) %}

isEmpty isEmpty

Use the isEmpty function to determine if a string is empty.

{%= isEmpty(string) %}

{%= isEmpty(profile.mobilePhone.number) %}

isNotEmpty is-not-empty

Use the isNotEmpty function to determine if a string is not empty.

{= isNotEmpty(string) %}: boolean

{%= isNotEmpty(profile.mobilePhone.number) %}

lastIndexOf last-index-of

Use the lastIndexOf function to return the position (in the first argument) of the last occurrence of the second parameter. Returns -1 if there is no match.

{= lastIndexOf(STRING_1, STRING_2) %}: integer

{%= lastIndexOf("hello world","o" ) %}

leftTrim leftTrim

Use the leftTrim function to remove white spaces from beginning of a string.

{%= leftTrim(string) %}

length length

Use the length function to get the number of characters in a string or an expression.

{%= length(string) %}

{%= length(profile.homeAddress.city) %}

like like

Use the like function to determine if a string matches a specified pattern.

{%= like(STRING_1, STRING_2) %}

{%= like(profile.homeAddress.city, "%es%")%}

lowerCase lower

Use the lowerCase function to convert a string to lower case letters.

{%= lowerCase(string) %}

{%= lowerCase(profile.person.name.firstName) %}

matches matches

Use the matches function to determine if a string matches a specific regular expression. For more information about matching patterns in regular expressions, refer to the Oracle documentation.

{%= matches(STRING_1, STRING_2) %}

{%= matches(person.name.,"(?i)^John") %}

mask mask

Use the mask function to replace a part of a string with “X” characters.

{%= mask(string,integer,integer) %}

{%= mask("123456789",1,2) %}

md5 md5

Use the md5 function to calculate and return the md5 hash of a string.

{%= md5(string) %}: string

{%= md5("hello world") %}

notEqualTo notEqualTo

Use the notEqualTo function to determine if a string is not equal to the specified string.

{%= notEqualTo(STRING_1, STRING_2) %}

{%= notEqualTo(profile.person.name,"John") %}

notEqualWithIgnoreCase not-equal-with-ignore-case

Use the notEqualWithIgnoreCase function to compare two strings ignoring case.

{= notEqualWithIgnoreCase(STRING_1,STRING_2) %}: boolean

{%= notEqualTo(profile.person.name,"john") %}

regexGroup regexGroup

Use the regexGroup function to extract specific information, based on the regular expression provided.

{%= regexGroup(STRING, EXPRESSION, GROUP) %}

{%= regexGroup(emailAddress,"@(\\w+)", 1) %}

replace replace

Use the replace function to replace a given substring in a string with another substring.

{%= replace(STRING_1,STRING_2,STRING_3) %}:string

{%= replace("Hello John, here is your monthly newsletter!","John","Mark") %}

replaceAll replaceAll

Use the replaceAll function to replace all substrings of a text that matches the regex expression with the specified literal replacement string. Regex has special handling of \ and + and all regex expressions follow the PQL escaping strategy. The replacement proceeds from the beginning of the string to the end, for example, replacing aa with b in the string aaa results in ba rather than ab.

{%= replaceAll(string,string,string) %}

rightTrim rightTrim

The rightTrim function removes white spaces from end of a string.

{%= rightTrim(string) %}

sha256 sha256

The sha256 function calculates and returns the sha256 hash of a string.

{%= sha256(string) %} : string

{%= sha256("Eliechxh")%}

split split

Use the split function to split a string by a given character.

{%= split(string,string) %}

startsWith startsWith

Use the startsWith function to determine if a string starts with a specified substring.

{%= startsWith(STRING_1, STRING_2, CASE_SENSITIVE) %}

{%= startsWith(person.name,"Joe") %}

stringToDate string-to-date

The stringToDate function converts a string value into a date-time value. It takes two arguments: string representation of a date-time and string representation of the formatter.

{= stringToDate("date-time value","formatter" %}

{= stringToDate("2023-01-10 23:13:26", "yyyy-MM-dd HH:mm:ss") %}

string_to_integer string-to-integer

Use the string_to_integer function to convert a string value into an integer value.

{= string_to_integer(string) %}: int

stringToNumber string-to-number

Use the stringToNumber function to convert a string into number. It returns the same string as output for invalid input.

{%= stringToNumber(string) %}: double

substr sub-string

Use the substr function to return the sub-string of the string expression between the beginning index and the ending index.

{= substr(string, integer, integer) %}: string

titleCase titleCase

Use the titleCase function to capitalize first letters of each words of a string.

{%= titleCase(string) %}

{%= titleCase(profile.person.location.Street) %}

toBool to-bool

Use the toBool function to convert an argument value into a boolean value, depending on its type.

{= toBool(string) %}: boolean

toDateTime to-date-time

Use the toDateTime function to convert string to date. It returns the epoch date as output for invalid input.

{%= toDateTime(string, string) %}: date-time

toDateTimeOnly to-date-time-only

Use the toDateTimeOnly function to convert an argument value into a date time only value. It returns the epoch date as output for invalid input. This function accepts string, date, long, and integer field types.

{%= toDateTimeOnly(string/date/long/int) %}: date-time

trim trim

The trim function removes all white spaces from the beginning and at the end of a string.

{%= trim(string) %}

upperCase upper

The upperCase function converts a string to upper case letters.

{%= upperCase(string) %}

{%= upperCase(profile.person.name.lastName) %}

urlDecode url-decode

Use the urlDecode function to decode a url encoded string.

{%= urlDecode(string) %}: string

urlEncode url-encode

Use the urlEncode function to encode a string as a URL.

{%= urlEncode(string) %}: string