Funzioni elenco list-functions

differenceLists(listString,listString): listString

differenceLists(listInteger,listInteger): listInteger

differenceLists(listDecimal,listDecimal): listDecimal

differenceLists(listBoolean,listBoolean): listBoolean

differenceLists(listDuration,listDuration): listDuration

differenceLists(listDateTime,listDateTime): listDateTime

differenceLists(listDateTimeOnly,listDateTimeOnly): listDateTimeOnly

differenceLists(listDateOnly,listDateOnly): listDateOnly

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

Restituisce ['a','c'].

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

Restituisce ['a','b'].

differenceLists([], ['a'])

Restituisce [].

distinct(<listInteger>)

Restituisce un elenco di numeri interi.

distinct(<listDecimal>)

Restituisce un elenco di decimali.

distinct(<listString>)

Restituisce un elenco di stringhe.

distinct(<listDateTimeOnly>)

Restituisce un elenco di date senza considerare il fuso orario.

distinct(<listDateTime>)

Restituisce un elenco di date.

distinct(<listDateOnly>)

Restituisce un elenco di date.

distinct(<listBoolean>)

Restituisce un elenco di booleani.

distinct(<listDuration>)

Restituisce un elenco di durate.

distinct(<listObject>)

distinct(<listObject>,<string>)

Restituisce un elenco di oggetti.

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

Restituisce [10, 2].

distinctWithNull(<listInteger>)

Restituisce un elenco di numeri interi.

distinctWithNull(<listDecimal>)

Restituisce un elenco di decimali.

distinctWithNull(<listString>)

Restituisce un elenco di stringhe.

distinctWithNull(<listDateTimeOnly>)

Restituisce un elenco di date senza considerare il fuso orario.

distinctWithNull(<listDateTime>)

Restituisce un elenco di date.

distinctWithNull(<listDateOnly>)

Restituisce un elenco di date.

distinctWithNull(<listBoolean>)

Restituisce un elenco di booleani.

distinctWithNull(<listDuration>)

Restituisce un elenco di durate.

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

Restituisce [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)

Restituisce un oggetto listObject.

Ecco un esempio di payload passato in un evento in ingresso “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
}]

È possibile utilizzare la seguente espressione:

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

Restituisce un oggetto listObject contenente i due oggetti con “product2” e “product3” come id.

getListItem(<listInteger>,<index>)

Restituisce un numero intero.

getListItem(<listDecimal>,<index>)

Restituisce un valore decimale.

getListItem(<listString>,<index>)

Restituisce una stringa.

getListItem(<listDateTimeOnly>,<index>)

Restituisce un valore datetime senza considerare il fuso orario.

getListItem(<listDateTime>,<index>)

Restituisce un valore datetime.

getListItem(<listDateOnly>,<index>)

Restituisce un elenco di date.

getListItem(<listBoolean>,<index>)

Restituisce un valore booleano.

getListItem(<listDuration>,<index>)

Restituisce una durata.

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

Restituisce “2”

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

Restituisce “C”

Esempi con un campo evento “event.appVersion” con valore: “20.45.2.3434”

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

Restituisce ["20", "45", "2", "3434"]

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

Restituisce “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>)

Restituisce un valore booleano.

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

Restituisce true.

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

Restituisce false.

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

intersect(listString,listString): listString

intersect(listDecimal,listDecimal): listDecimal

intersect(listInteger,listInteger): listInteger

intersect(listDateTime,listDateTime): listDateTime

intersect(listDateTimeOnly,listDateTimeOnly): listDateTimeOnly

intersect(listDateOnly,listDateOnly): listDateOnly

intersect(listDuration,listDuration): listDuration

intersect(listBoolean,listBoolean): listBoolean

Restituisce un elenco.

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

Restituisce [“sport”, “news”]

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

Restituisce elementi comuni tra gli attributi del profilo e un elenco specifico di categorie.

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

Restituisce elementi comuni tra gli attributi del profilo e il campo evento specificato.

limit(<listString>,<integer>)

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

Restituisce un elenco di stringhe.

limit(<listInteger>,<integer>)

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

Restituisce un elenco di numeri interi.

limit(<listDecimal>,<integer>)

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

Restituisce un elenco di decimali.

limit(<listBoolean>,<integer>)

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

Restituisce un elenco di booleani.

limit(<listDateOnly>,<integer>)

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

Restituisce un elenco di date.

limit(<listDateTimeOnly>,<integer>)

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

Restituisce un elenco di date senza considerare il fuso orario.

limit(<listDateTime>,integer>)

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

Restituisce un elenco di date.

limit(<listDuration>,<integer>)

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

Restituisce un elenco di durate.

limit(<listObject>,<integer>)

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

Restituisce un elenco di oggetti.

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

Restituisce ["A","B","C"].

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

Restituisce ["C","D","E"].

listSize(<listInteger>)

listSize(<listDecimal>)

listSize(<listString>)

listSize(<listBoolean>)

listSize(<listDateTimeOnly>)

listSize(<listDateTime>)

listSize(<listDateOnly>)

listSize(<listDuration>)

Restituisce un numero intero.

listSize(<listObject>)

listSize([10,2,3])

Restituisce 3.

listSize(@event{my_event.productListItems})

Restituisce il numero di oggetti nella matrice di oggetti specificata (tipo listObject).

mergeLists(listString,listString,boolean): listString

mergeLists(listInteger,listInteger,boolean): listInteger

mergeLists(listDecimal,listDecimal,boolean): listDecimal

mergeLists(listBoolean,listBoolean,boolean): listBoolean

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)

Restituisce ['a','b','c'].

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

Restituisce ['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>)

Restituisce una stringa.

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

Restituisce “Hello World”.

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

Restituisce ““Hello”,“World””.

sort(<listInteger>,<boolean>)

Restituisce un elenco di numeri interi.

sort(<listDecimal>,<boolean>)

Restituisce un elenco di decimali.

sort(<listString>,<boolean>)

Restituisce un elenco di stringhe.

sort(<listDateTimeOnly>,<boolean>)

Restituisce un elenco di date senza considerare il fuso orario.

sort(<listDateTime>,<boolean>)

Restituisce un elenco di date.

sort(<listDateOnly>,<boolean>)

Restituisce un elenco di date.

sort(<listBoolean>,<boolean>)

Restituisce un elenco di booleani.

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

Restituisce un elenco di oggetti.

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

Restituisce ["A","B","C"].

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

Restituisce [3, 2, 1].

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

Restituisce l’oggetto listObject ordinato in base all’attributo SKU (ordine crescente)

Questa sezione contiene informazioni strutturate che supportano l’interpretazione, il recupero e la risposta alle domande relative a questo argomento.

Per una comprensione completa, queste informazioni devono essere unite alla documentazione su questa pagina. Nessuna delle due origini è progettata per essere indipendente; la pagina descrive la funzione, mentre questa sezione fornisce un contesto aggiuntivo che aiuta a non ambiguare la terminologia, le finalità, l’applicabilità e i vincoli.

• TL;DR: In questa pagina sono documentate tutte le funzioni di elenco disponibili nelle espressioni di percorso AJO, con informazioni su come filtrare, ordinare, deduplicare, controllare l’appartenenza, limitare, serializzare, unire, sottrarre e trovare intersezioni di elenchi e array.

Intenti:

• Rimuovere i valori duplicati da un elenco utilizzando distinct (ignorando i valori Null) o distinctWithNull (mantenendo i valori Null)
• Filtrare un listObject per restituire solo oggetti che corrispondono a valori chiave specifici utilizzando filter
• Recuperare un elemento in un indice specifico da un elenco utilizzando getListItem
• Verificare se esiste un valore in un elenco utilizzando in
• Trovare elementi comuni tra due elenchi utilizzando intersect
• Combinare due elenchi, con o senza deduplicazione, utilizzando mergeLists
• Sottrarre un elenco da un altro (impostare la differenza) utilizzando differenceLists
• Restituire il primo o l’ultimo N elementi di un elenco utilizzando limit
• Contare il numero totale di elementi in un elenco utilizzando listSize
• Convertire un elenco in una stringa delimitata utilizzando serializeList
• Ordinare un elenco in ordine crescente o decrescente utilizzando sort

Glossario:

• listObject: un elenco di oggetti complessi che devono essere un riferimento di campo; non può contenere oggetti Null (specifici del prodotto)
• keyAttributeName: parametro di stringa facoltativo utilizzato con distinct, filter e sort per identificare l’attributo di oggetto da utilizzare per la deduplicazione, il filtraggio o l’ordinamento di (specifico per prodotto)
• intersect: un’operazione set restituisce solo gli elementi presenti in entrambi gli elenchi di input
• mergeLists: un’operazione set che restituisce l’unione (deduplicata) o la concatenazione (con duplicati) di due elenchi, a seconda del parametro di deduplicate (specifico per prodotto)
• differenceLists: un’operazione set che restituisce gli elementi del primo elenco non presenti nel secondo elenco (specifico per prodotto)

Guardrail:

• distinctWithNull non supporta il tipo di parametro <listObject>
• filter richiede che il parametro listObject sia un riferimento di campo, non un valore letterale in linea
• listSize in un listObject richiede che l’elenco sia un riferimento di campo; un listObject non può contenere oggetti null
• serializeList non supporta il tipo listObject
• mergeLists e differenceLists supportano solo i tipi di elenchi scalari (string, integer, decimal, boolean, dateTimeOnly, dateOnly, duration); listObject non è supportato
• Il parametro deduplicate di mergeLists deve essere un valore letterale true/false, non un’espressione booleana dinamica
• differenceLists deduplica sempre il risultato; non è possibile mantenere duplicati

Terminologia:

• Nome canonico: Funzioni elenco — Acronimo: none — Varianti: funzioni raccolta, funzioni matrice
• Sinonimi: “listSize” = “count list elements”; “serializeList” = “join list to string”
• Non confondere: “distinct” (ignora i valori Null) ≠ “distinctWithNull” (mantiene null come valore distinto)
• Non confondere: “limit” con il terzo parametro true (restituisce i primi N elementi) ≠ “limit” con false (restituisce gli ultimi N elementi)
• Non confondere: “intersect” (elementi comuni tra due elenchi) ≠ “filter” (elementi che corrispondono a valori chiave specifici)
• Non confondere: “mergeLists” (combina due elenchi, unione o concatenazione) ≠ “differenceLists” (sottrae un elenco da un altro) ≠ “intersect” (solo elementi comuni)

Domande frequenti:

• D: come è possibile ottenere i primi 3 elementi di un elenco? — Utilizzare limit(myList, 3) o limit(myList, 3, true); per impostazione predefinita vengono restituiti i primi elementi.
• D: come è possibile ottenere gli ultimi 3 elementi di un elenco? — Utilizza limit(myList, 3, false).
• Q: Qual è la differenza tra distinct e distinctWithNull? — distinct ignora i valori Null e li esclude dal risultato; distinctWithNull tratta i valori Null come valori distinti e include una voce Null se sono presenti valori Null.
• Q: è possibile filtrare un elenco di stringhe con filter? — No, filter funziona solo su listObject; per gli elenchi scalari utilizza in o distinct per la deduplicazione.
• D: come posso verificare se un valore è presente in un elenco? — Utilizzare in(value, myList), che restituisce true se il valore si trova nell’elenco.
• Q: è possibile ordinare un listObject in base a un attributo specifico? — Sì, utilizza sort(@event{...}, "attributeName", true) dove il secondo parametro è il nome dell’attributo e il terzo è la direzione di ordinamento (true = ascending).
• D: come si combinano due elenchi e si rimuovono i duplicati? — Utilizza mergeLists(list1, list2, true).
• D: come si combinano due elenchi mantenendo valori duplicati? — Utilizza mergeLists(list1, list2, false).
• D: come è possibile trovare gli elementi di un elenco che non si trovano in un altro? — Utilizzare differenceLists(list1, list2), che restituisce gli elementi di list1 non presenti in list2.
• Q: Qual è la differenza tra intersect e differenceLists? — intersect restituisce elementi comuni a entrambi gli elenchi; differenceLists restituisce elementi del primo elenco assenti dal secondo elenco.