Operatori operators

Esistono due tipi di operatori: operatori unari e operatori binari. Sono disponibili operatori unari di sinistra e operatori unari di destra.

// left-hand unary operators
// <operator> <operand>
// operand is an expression
not (@event{LobbyBeacon.endUserIDs._experience.emailid.id}=="example@adobe.com")

// right-hand unary operators
// <operator> <operand>
// operand is an expression
@event{LobbyBeacon.endUserIDs._experience.emailid.id} is not null

// binary operators
// <operand1> <operator> <operand2>
// operand is an expression
(@event{LobbyBeacon.endUserIDs._experience.emailid.id}=="example1@adobe.com") or (@event{LobbyBeacon.endUserIDs._experience.emailid.id}=="example2@adobe.com")

Note importanti important-notes

  • Quando si utilizza una moltiplicazione (*), entrambi i campi dell’operazione devono avere lo stesso tipo, intero o decimale. Esempio:

    • l’esempio seguente è corretto: 3.0 * 4.0
    • 3 * 4.0 genererà un errore
  • Quando si utilizza l’operatore +, l’espressione deve essere racchiusa tra parentesi. Esempio:

    • toDateTimeOnly(toDateTime((currentTimeInMillis()) + 1)) è corretto
    • toDateTimeOnly(toDateTime(currentTimeInMillis() + 1)) genererà un errore

Logico logical

e

<expression1> and <expression2>

Sia <espressione1> che <espressione2> devono essere booleani. Il risultato è booleano.

Esempio:

3.14 > 2 and 3.15 < 1

oppure

<expression1> or <expression2>

Sia <espressione1> che <espressione2> devono essere booleani. Il risultato è booleano.

Esempio:

3.14 > 2 or 3.15 < 1

non

not <expression>

<espressione> deve essere booleano. Il risultato è booleano.

Esempio:

not 3.15 < 1

Confronto comparison

è nullo

<expression> is null

Il risultato è booleano.

Nullo significa che l’espressione non ha un valore valutato.

Esempio:

@event{BarBeacon.location} is null

non è nullo

<expression> is not null

Il risultato è booleano.

Nullo significa che l’espressione non ha un valore valutato.

Esempio:

@event{BarBeacon.location} is not null

ha valore null

<expression> has null

<espressione> deve essere un elenco. Il risultato è booleano.

Utile per identificare che un elenco contiene almeno un valore null.

Esempio:

["foo", "bar", null] has null

Restituisce true

["foo", "bar", ""] has null

Restituisce false perché “” non è considerato nullo.

==

<expression1> == <expression2>
NOTE
Per <expression1> e <expression2> non è disponibile alcun controllo del tipo di dati.

Esempio:

3.14 == 42
"foo" == "bar"

!=

<expression1> != <expression2>
NOTE
Per <expression1> e <expression2> non è disponibile alcun controllo del tipo di dati.

Il risultato è booleano.

Esempio:

3.14 != 42
"foo" != "bar"

>

<expression1> > <expression2>

Datetime può essere confrontato con Datetime.

Datetimeonly può essere confrontato con Datetimeonly.

Sia il numero intero che il numero decimale possono essere confrontati con il numero intero o il numero decimale.

Qualsiasi altra combinazione è vietata.

Il risultato è booleano.

Esempio:

3.14 > 42

>=

<expression1> >= <expression2>

Datetime può essere confrontato con Datetime.

Datetimeonly può essere confrontato con Datetimeonly.

Sia il numero intero che il numero decimale possono essere confrontati con il numero intero o il numero decimale.

Qualsiasi altra combinazione è vietata.

Il risultato è booleano.

Esempio:

42 >= 3.14

<

<expression1> < <expression2>

Datetime può essere confrontato con Datetime.

Datetimeonly può essere confrontato con Datetimeonly.

Sia il numero intero che il numero decimale possono essere confrontati con il numero intero o il numero decimale.

Qualsiasi altra combinazione è vietata.

Il risultato è booleano.

Esempio:

42 < 3.14

<=

<expression1> <= <expression2>

Datetime può essere confrontato con Datetime.

Datetimeonly può essere confrontato con Datetimeonly.

Sia il numero intero che il numero decimale possono essere confrontati con il numero intero o il numero decimale.

Qualsiasi altra combinazione è vietata.

Il risultato è booleano.

Esempio:

42 <= 3.14

Aritmetica arithmetic

+

<expression1> + <expression2>

Entrambe le espressioni devono essere numeriche (numero intero o decimale).

Il risultato è anche numerico.

Esempio:

1 + 2

Restituisce 3

-

<expression1> - <expression2>

Entrambe le espressioni devono essere numeriche (numero intero o decimale).

Il risultato è anche numerico.

Esempio:

2 - 1

Restituisce 1

/

<expression1> / <expression2>

Entrambe le espressioni devono essere numeriche (numero intero o decimale).

Il risultato è anche numerico.

<espressione2> non deve essere uguale a 0 (restituisce 0).

Esempio:

4 / 2

Restituisce 2

*

<expression1> * <expression2>

Entrambe le espressioni devono essere numeriche (numero intero o decimale).

Il risultato è anche numerico.

Esempio:

3 * 4

Restituisce 12

%

<expression1> % <expression2>

Entrambe le espressioni devono essere numeriche (numero intero o decimale).

Il risultato è anche numerico.

Esempio:

3 % 2

Restituisce 1.

Matematica math

è numerico

<expression> is numeric

Il tipo dell’espressione è numero intero o decimale.

Esempio:

@ is numeric

è un numero intero

<expression> is integer

Il tipo dell’espressione è un numero intero.

Esempio:

@ is integer

è decimale

<expression> is decimal

Il tipo dell’espressione è decimal.

Esempio:

@ is decimal

Stringa string

+

<string> + <expression>
<expression> + <string>

Concatena due espressioni.

Un’espressione deve essere una stringa concatenata.

Esempio:

"the current time is " + (now())

Restituisce “l’ora corrente è 2023-09-23T09:30:06.693Z”

(now()) + " is the current time"

Restituisce “2023-09-23T09:30:06.693Z è l’ora corrente”

"a" + "b" + "c" + 1234

Restituisce “abc1234”.

Data date

+

<expression> + <duration>

Aggiungere una durata a un valore dateTime, dateTimeOnly o duration.

Esempio:

(toDateTime("2023-12-03T15:15:30Z")) + (toDuration("PT15M"))

Restituisce un valore dateTime 2023-12-03T15:30:30Z

(toDateTimeOnly("2023-12-03T15:15:30")) + (toDuration("PT15M"))

Restituisce un valore dateTimeOnly 2023-12-03T15:30:30

(now()) + (toDuration("PT1H"))

Restituisce un valore dateTime (con fuso orario UTC) un’ora dopo rispetto all’ora corrente

(toDuration("PT1H")) + (toDuration("PT1H"))

Restituisce un valore duration PT2H

AI Knowledge Reference

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 is a complete reference of operators available in the Journey advanced expression editor, covering logical (and, or, not), comparison (==, !=, >, >=, <, <=, is null, is not null, has null), arithmetic (+, -, /, *, %), math type-check (is numeric, is integer, is decimal), string concatenation, and date arithmetic operators.

Intents:

  • Combine boolean conditions using logical operators and, or, and not
  • Check whether a field or expression value is null or not null using is null / is not null
  • Detect null values within a list using the has null operator
  • Compare numeric, datetime, and datetimeonly values using >, >=, <, <=, ==, and !=
  • Perform arithmetic on numeric values using +, -, /, *, and %
  • Add a duration to a dateTime, dateTimeOnly, or duration value using the + operator

Glossary:

  • Unary operator: An operator applied to a single operand; can be left-hand (e.g. not) or right-hand (e.g. is null) (product-specific)
  • Binary operator: An operator applied between two operands (e.g. and, ==, +) (product-specific)
  • has null: A right-hand unary operator that returns true if a list contains at least one null element (product-specific)
  • is numeric / is integer / is decimal: Type-check operators that return a boolean based on the numeric subtype of the expression (product-specific)

Guardrails:

  • When using multiplication (*), both operands must be the same numeric type (both integer or both decimal) — mixing types causes an error
  • When using the + operator for date arithmetic, the expression must be wrapped in parentheses to avoid parsing errors
  • Comparison operators (>, >=, <, <=) are only valid between compatible types: Datetime with Datetime, DatetimeOnly with DatetimeOnly, or numeric with numeric — any other combination is forbidden
  • An empty string "" is not considered null — has null returns false for a list containing ""
  • The == and != operators perform no data type control between operands

Terminology:

  • Canonical name: Operators — Acronym: none — variants: expression operators, journey operators
  • Synonyms: and = “logical AND”; or = “logical OR”; not = “logical NOT”; % = “modulo”
  • Do not confuse: is null (expression has no evaluated value) ≠ == null (not a valid syntax); has null (list contains null) ≠ is null (expression itself is null)

FAQ:

  • Q: Can I multiply an integer by a decimal directly? — No; both operands of * must be the same type. Use 3.0 * 4.0 (both decimal) or 3 * 4 (both integer).
  • Q: How do I add 15 minutes to a dateTime? — Use (toDateTime("...")) + (toDuration("PT15M")).
  • Q: What is the difference between is null and has null?is null checks whether a single expression has no evaluated value; has null checks whether a list contains at least one null element.
  • Q: Does "" has null return true? — No; an empty string is not considered null, so the result is false.
  • Q: Why does 3 * 4.0 cause an error? — The * operator requires both operands to be the same numeric type; mixing integer and decimal is not allowed.
recommendation-more-help
journey-optimizer-help