목록 함수 list-functions

differenceLists(listString,listString): listString

differenceLists(listInteger,listInteger): list정수

differenceLists(listDecimal,listDecimal): listDecimal

differenceLists(listBoolean,listBoolean): list부울

differenceLists(listDuration,listDuration): listDuration

differenceLists(listDateTime,listDateTime): listDateTime

differenceLists(listDateTimeOnly,listDateTimeOnly): listDateTimeOnly

differenceLists(listDateOnly,listDateOnly): listDateOnly

differenceLists(['a','b','c'], ['b'])

['a','c']을(를) 반환합니다

differenceLists(['a','a','b'], [])

['a','b']을(를) 반환합니다

differenceLists([], ['a'])

[]을(를) 반환합니다

distinct(<listInteger>)

정수 목록을 반환합니다.

distinct(<listDecimal>)

소수점 목록을 반환합니다.

distinct(<listString>)

문자열 목록을 반환합니다.

distinct(<listDateTimeOnly>)

시간대를 고려하지 않고 날짜/시간 목록을 반환합니다.

distinct(<listDateTime>)

날짜/시간 목록을 반환합니다.

distinct(<listDateOnly>)

날짜 목록을 반환합니다.

distinct(<listBoolean>)

부울 목록을 반환합니다.

distinct(<listDuration>)

기간 목록을 반환합니다.

distinct(<listObject>)

distinct(<listObject>,<string>)

개체 목록을 반환합니다.

distinct([10,2,10,null])

[10, 2]을(를) 반환합니다

distinctWithNull(<listInteger>)

정수 목록을 반환합니다.

distinctWithNull(<listDecimal>)

소수점 목록을 반환합니다.

distinctWithNull(<listString>)

문자열 목록을 반환합니다.

distinctWithNull(<listDateTimeOnly>)

시간대를 고려하지 않고 날짜/시간 목록을 반환합니다.

distinctWithNull(<listDateTime>)

날짜/시간 목록을 반환합니다.

distinctWithNull(<listDateOnly>)

날짜 목록을 반환합니다.

distinctWithNull(<listBoolean>)

부울 목록을 반환합니다.

distinctWithNull(<listDuration>)

기간 목록을 반환합니다.

distinctWithNull([10,2,10,null])

[10, 2, null] 반환

filter(listObject, string, listString)

filter(listObject, string, listInteger)

filter(listObject, string, listDecimal)

filter(listObject, string, listDateTime)

filter(listObject, string, listDateTimeOnly)

filter(listObject, string, listDateOnly)

filter(listObject, string, listDuration)

filter(listObject, string, listBoolean)

listObject를 반환합니다.

다음은 수신 이벤트 "myevent"에서 전달된 페이로드의 예입니다.

"productListItems": [{
   "id": "product1",
   "name": "the product 1",
   "price": 20
},{
   "id": "product2",
   "name": "the product 2",
   "price": 30
},{
   "id": "product3",
   "name": "the product 3",
   "price": 50
}]

다음 표현식을 사용할 수 있습니다.

filter(
 @event{myevent.productListItems},
 "id",
 ["product2", "product3", "product4"]
)

id로 “product2” 및 "product3"을 사용하는 두 개체가 포함된 listObject를 반환합니다.

getListItem(<listInteger>,<index>)

정수 반환.

getListItem(<listDecimal>,<index>)

십진수를 반환합니다.

getListItem(<listString>,<index>)

문자열을 반환합니다.

getListItem(<listDateTimeOnly>,<index>)

시간대를 고려하지 않고 날짜/시간을 반환합니다.

getListItem(<listDateTime>,<index>)

날짜/시간을 반환합니다.

getListItem(<listDateOnly>,<index>)

날짜 목록을 반환합니다.

getListItem(<listBoolean>,<index>)

부울 반환.

getListItem(<listDuration>,<index>)

기간을 반환합니다.

getListItem([10, 2, 3], 1)

“2” 반환

getListItem(["A", "B", "C"], 2)

“C” 반환

값이 "20.45.2.3434"인 이벤트 필드 'event.appVersion’이 있는 예

split(@event{event.appVersion}, "\\.")

["20", "45", "2", "3434"] 반환

getListItem(split(@event{event.appVersion}, "\\."), 0)

“20” 반환

in(<integer>,<listInteger>)

in(<decimal>,<listDecimal>)

in(<string>,<listString>)

in(<boolean>,<listBoolean>)

in(<dateTimeOnly>,<listDateTimeOnly>)

in(<dateTime>,<listDateTime>)

in(<dateOnly>,<listDateOnly>)

in(<duration>,<listDuration>)

부울 반환.

in(4,[4,5,3,4])

true를 반환합니다.

in(8,[4,5,3,4])

false를 반환합니다.

in(#{ExperiencePlatform.ProfileFieldGroup.profile.person.gender}, ["male"])

intersect(listString,listString): listString

intersect(listDecimal,listDecimal): listDecimal

intersect(listInteger,listInteger): list정수

intersect(listDateTime,listDateTime): listDateTime

intersect(listDateTimeOnly,listDateTimeOnly): listDateTimeOnly

intersect(listDateOnly,listDateOnly): listDateOnly

intersect(listDuration,listDuration): listDuration

intersect(listBoolean,listBoolean): list부울

목록을 반환합니다.

intersect(
    ["sports", "news", "documentary"],
    ["sports", "movies", "documentary"]
)

[“sports”, “news”] 반환

intersect(
    #{ExperienceDataPlatform.profile.interests},
    ["sports", "documentary"]
)

프로필 속성과 지정된 범주 목록 간의 공통 항목을 반환합니다.

intersect(
    #{ExperienceDataPlatform.profile.interests},
        @event{myEvent.sport_interests}
)

프로필 속성과 지정된 이벤트 필드 간의 공통 항목을 반환합니다.

limit(<listString>,<integer>)

limit(<listString>,<integer>,<boolean>)

문자열 목록을 반환합니다.

limit(<listInteger>,<integer>)

limit(<listInteger>,<integer>,<boolean>)

정수 목록을 반환합니다.

limit(<listDecimal>,<integer>)

limit(<listDecimal>,<integer>,<boolean>)

소수점 목록을 반환합니다.

limit(<listBoolean>,<integer>)

limit(<listBoolean>,<integer>,<boolean>)

부울 목록을 반환합니다.

limit(<listDateOnly>,<integer>)

limit(<listDateOnly>,<integer>,<boolean>)

날짜 목록을 반환합니다.

limit(<listDateTimeOnly>,<integer>)

limit(<listDateTimeOnly>,<integer>,<boolean>)

시간대를 고려하지 않고 날짜/시간 목록을 반환합니다.

limit(<listDateTime>,integer>)

limit(<listDateTime>,<integer>,<boolean>)

날짜/시간 목록을 반환합니다.

limit(<listDuration>,<integer>)

limit(<listDuration>,<integer>,<boolean>)

기간 목록을 반환합니다.

limit(<listObject>,<integer>)

limit(<listObject>,<integer>,<boolean>)

개체 목록을 반환합니다.

limit(["A", "B", "C", "D", "E"], 3)

["A","B","C"]을(를) 반환합니다

limit(["A", "B", "C", "D", "E"], 3, false)

["C","D","E"]을(를) 반환합니다

listSize(<listInteger>)

listSize(<listDecimal>)

listSize(<listString>)

listSize(<listBoolean>)

listSize(<listDateTimeOnly>)

listSize(<listDateTime>)

listSize(<listDateOnly>)

listSize(<listDuration>)

정수를 반환합니다.

listSize(<listObject>)

listSize([10,2,3])

3을 반환합니다.

listSize(@event{my_event.productListItems})

지정된 개체 배열(listObject 형식)에 있는 개체 수를 반환합니다.

mergeLists(listString,listString,boolean): listString

mergeLists(listInteger,listInteger,boolean): list정수

mergeLists(listDecimal,listDecimal,boolean): listDecimal

mergeLists(listBoolean,listBoolean,boolean): list부울

mergeLists(listDuration,listDuration,boolean): listDuration

mergeLists(listDateTime,listDateTime,boolean): listDateTime

mergeLists(listDateTimeOnly,listDateTimeOnly,boolean): listDateTimeOnly

mergeLists(listDateOnly,listDateOnly,boolean): listDateOnly

mergeLists(['a','b'], ['b','c'], true)

['a','b','c']을(를) 반환합니다

mergeLists(['a','b'], ['b','c'], false)

['a','b','b','c']을(를) 반환합니다

serializeList(<listInteger>,<string>,<boolean>)

serializeList(<listDecimal>,<string>,<boolean>)

serializeList(<listString>,<string>,<boolean>)

serializeList(<listBoolean>,<string>,<boolean>)

serializeList(<listDateTimeOnly>,<string>,<boolean>)

serializeList(<listDateTime>,<string>,<boolean>)

serializeList(<listDateOnly>,<string>,<boolean>)

serializeList(<listDuration>,<string>,<boolean>)

문자열을 반환합니다.

serializeList(["Hello","World"], " ", false)

"Hello World"를 반환합니다.

serializeList(["Hello", "World"], ",", true)

"“Hello”,“World”"를 반환합니다.

sort(<listInteger>,<boolean>)

정수 목록을 반환합니다.

sort(<listDecimal>,<boolean>)

소수점 목록을 반환합니다.

sort(<listString>,<boolean>)

문자열 목록을 반환합니다.

sort(<listDateTimeOnly>,<boolean>)

시간대를 고려하지 않고 날짜/시간 목록을 반환합니다.

sort(<listDateTime>,<boolean>)

날짜/시간 목록을 반환합니다.

sort(<listDateOnly>,<boolean>)

날짜 목록을 반환합니다.

sort(<listBoolean>,<boolean>)

부울 목록을 반환합니다.

sort(<listObject>,<string>,<boolean>)

개체 목록을 반환합니다.

sort(["A", "C", "B"], true)

["A","B","C"]을(를) 반환합니다

sort([1, 3, 2], false)

[3, 2, 1]을(를) 반환합니다

sort(@event{my_event.productListItems}, "SKU", true)

SKU 속성으로 정렬된 listObject 반환(오름차순)

This section contains structured knowledge intended to support interpretation, retrieval, and question answering related to this topic.

For complete understanding, this information should be combined with the documentation on this page. Neither source is intended to stand alone; the page describes the feature, while this section provides additional context that helps disambiguate terminology, intent, applicability, and constraints.

• TL;DR: This page documents all list functions available in AJO journey expressions, covering how to filter, sort, deduplicate, check membership, limit, serialize, merge, subtract, and find intersections of lists and arrays.

Intents:

• Remove duplicate values from a list using distinct (ignoring nulls) or distinctWithNull (preserving nulls)
• Filter a listObject to return only objects matching specific key values using filter
• Retrieve an element at a specific index from a list using getListItem
• Check whether a value exists in a list using in
• Find common elements between two lists using intersect
• Combine two lists, with or without deduplication, using mergeLists
• Subtract one list from another (set difference) using differenceLists
• Return the first or last N elements of a list using limit
• Count the total number of elements in a list using listSize
• Convert a list to a delimited string using serializeList
• Sort a list in ascending or descending order using sort

Glossary:

• listObject: A list of complex objects that must be a field reference; cannot contain null objects (product-specific)
• keyAttributeName: An optional string parameter used with distinct, filter, and sort to identify which object attribute to use for deduplication, filtering, or sorting (product-specific)
• intersect: A set operation returning only the elements present in both input lists
• mergeLists: A set operation returning the union (deduplicated) or concatenation (with duplicates) of two lists, depending on the deduplicate parameter (product-specific)
• differenceLists: A set operation returning the items of the first list that are not present in the second list (product-specific)

Guardrails:

• distinctWithNull does not support the <listObject> parameter type
• filter requires the listObject parameter to be a field reference, not an inline literal
• listSize on a listObject requires the list to be a field reference; a listObject cannot contain null objects
• serializeList does not support the listObject type
• mergeLists and differenceLists only support scalar list types (string, integer, decimal, boolean, dateTime, dateTimeOnly, dateOnly, duration); listObject is not supported
• mergeLists’s deduplicate parameter must be a literal true/false, not a dynamic boolean expression
• differenceLists always deduplicates its result; there is no option to keep duplicates

Terminology:

• Canonical name: List functions — Acronym: none — variants: collection functions, array functions
• Synonyms: “listSize” = “count list elements”; “serializeList” = “join list to string”
• Do not confuse: “distinct” (ignores nulls) ≠ “distinctWithNull” (preserves null as a distinct value)
• Do not confuse: “limit” with third parameter true (returns first N items) ≠ “limit” with false (returns last N items)
• Do not confuse: “intersect” (common elements between two lists) ≠ “filter” (elements matching specific key values)
• Do not confuse: “mergeLists” (combines two lists, union or concatenation) ≠ “differenceLists” (subtracts one list from another) ≠ “intersect” (common elements only)

FAQ:

• Q: How do I get the first 3 items of a list? — Use limit(myList, 3) or limit(myList, 3, true); the default is to return the first items.
• Q: How do I get the last 3 items of a list? — Use limit(myList, 3, false).
• Q: What is the difference between distinct and distinctWithNull? — distinct ignores null values and excludes them from the result; distinctWithNull treats null as a distinct value and includes one null entry if any nulls are present.
• Q: Can I filter a list of strings with filter? — No, filter only works on listObject; for scalar lists use in or distinct for deduplication.
• Q: How do I check if a value is in a list? — Use in(value, myList), which returns true if the value is found in the list.
• Q: Can I sort a listObject by a specific attribute? — Yes, use sort(@event{...}, "attributeName", true) where the second parameter is the attribute name and the third is the sort direction (true = ascending).
• Q: How do I combine two lists and remove duplicates? — Use mergeLists(list1, list2, true).
• Q: How do I combine two lists but keep duplicate values? — Use mergeLists(list1, list2, false).
• Q: How do I find the items in one list that are not in another? — Use differenceLists(list1, list2), which returns the items of list1 not present in list2.
• Q: What is the difference between intersect and differenceLists? — intersect returns items common to both lists; differenceLists returns items in the first list that are absent from the second list.