Versions Compared

Old Version 22

changes.mady.by.user Kalpana Malladi

Saved on

compared with

New Version 23

changes.mady.by.user Kalpana Malladi

Saved on

Key

  • This line was added.
  • This line was removed.
  • Formatting was changed.

In this article

Table of Contents
maxLevel2
excludeAdditional Resources|Related Links|Related Information

Overview

SnapLogic's expression language is a utility that is available to Snaps. Using the You can use expressions (Java script syntax, you can ) to access functions and properties to set field values dynamically. You can also use expression language to manipulate data. Learn  Learn more about Using Expressions.

Operators

Comparison Operators

Comparison operators (>, >=, <, <=, ==, !=) behave the same as JavaScript comparison operators except that strict equals (===) and strict not equals (!===) are not supported.

Arithmetic Operators

Arithmetic operators (+, -, *, /) operators behave the same as JavaScript arithmetic operators except that increment (++) and decrement (--) are not supported.

Note

All arithmetic operators return a floating point number. If an integer is desired, then the global function {{parseInt}} should be used to cast the arithmetic expression as an integer.

Example:
1/2 = .5
parseInt(1/2) = 0

In this section

Child pages (Children Display)


Logical Operators

Logical operators (&&, ||, !) behave the same as JavaScript logical operators. 

String Operators

String operators (+) behave the same as JavaScript string operators except that the shorthand assignment operator (+=) is not supported.

Spread Operators

The spread operator (...) makes it easier to build arrays, objects, and call functions where the list of arguments is built at runtime. For instance, while using in an array literal, the value on the right of the operator is inserted into the new array at that position. Similarly, in a function call, the array expands and is used as the arguments to the function. In an object literal, the right side of the operator is another object that has its keys added to the new object.

Examples:

To build a new array that is made up of another array surrounded by two elements:

Code Block
["header", ...$body, "footer"]

If you want to find the maximum value in an array of numbers:

Code Block
Math.max(...$numbers)


To create a new object with some fixed values and entries in the "$extra" object:


Code Block
{ first_name: $fname, last_name: $lname, ... $extra }


Special Operators

Info
panel
iconfalse

Conditional (Ternary)

The conditional operator (?) allows you to specify a value to use based on the result of an expression. The syntax is as follows:

Code Block
condition ? trueValue : falseValue

The condition expression will be evaluated and the trueValue will be the result of the expression if the condition evaluates to true, otherwise the falseValue will be the result.

Example:

Code Block
$text ==
 "NFL"
 ?
 "foo"
 :
 "bar"

Example:

Code Block
$counter > 1 ? ($counter < 3 ? 50 : 100) : -1
panel



Info
iconfalse

instanceof

The instanceof operator returns

The instanceof operator returns True if the given object is an instance of the given type. The syntax is as follows:

Code Block
object instanceof type


The possible values for the type are: Null, Boolean, String, Number, Object, Array, Date, LocalDate, DateTime, and LocalDateTime.

Example:

code


Info
iconfalse

$my_array

instanceof Array panel

instanceof Array


Info
iconfalse

match

The match operator allows you to conditionally evaluate one of a number of expressions based on whether an input value matches a given pattern.  See the match Control Flow Operator section to learn more.

Example:

paste-
Code Block
-macro
match $score {
    90..=100 => 'A',
    80..<90 => 'B',
    70..<80 => 'C',
    _ => 'F'
}
panel




Info
iconfalse

typeof

The typeof operator

The typeof operator returns the type of a value as a string. The syntax is as follows:

Code Block

typeof

 operand

The possible return values are: "boolean", "number", "string", "object", and "array".

panel

in

The in operator returns true if the property name or array index is in the given object or array. The syntax is as follows:

code
Info
language
icon
js
false

name|index

in

operand

Example:

code

'name'

in

$ 

$

Comments

You can add notes to your expressions using comments.

 A

A comment starts with '/*' and ends with '*/', for example:

Info
icon
code
false

/*

say

hello

*/

"Hello,

World!"

The comment will be ignored when evaluating the expression, it is only for the reader's benefit.

Operator Precedence

Operator
type
TypeIndividual
operators
Operators
member. []
call()
negation! -
multiply/divide* / %
addition/subtraction+ -
relational< <= > >=
equality== !=
logical-and&&
logical-or||
comma, 

Unsupported Operations

  • Assignment 
    • Creating variables and assigning values is not supported 
    • Example: var temp = 10
  • Short hand assignment
    • Example: count += 5
  • Strict equals
    • Example: first === last
  • Strict not equals
    • Example: first !== last
  • Increment
    • Example: count++
  • Decrement
    • Example: count--

Accessing Document Values

To access values in a document, JavaScript object accessors can be used.
For a given document data:

Info
icon
code
false

{

first

    first_name:

 "James",

last


    last_name:

 "Smith"


}

The expression $first_name would return the 'first_name' property which is James.

The 'first_name' property can also be accessed by using array notation $['first_name'].
 
JavaScript array accessors can be used also if the object is an array/list.
For a given document data:

[ 1, 2, 3]
 

$[1] would return the value 2.

More complex example:

code
Info
iconfalse

{

names:


    names: ["Joe",

 "Bob",

 "Fred"]


}

$names[2] would return the value Fred.

Arrow Functions

Custom expression language functions can be created using the arrow function syntax:

Code Block
// A function that takes multiple parameters:
(param1, param2, ..., paramN) => expression

// A function that takes a single parameter does not need parentheses:
(param) => expression
param => expression

// A function with no parameters requires parentheses:
() => expression

// Function parameters can also have default values
(param1 = defaultValue1, param2 = defaultValue2, ..., paramN = defaultValueN) => expression

These functions can be passed to other functions that accept callbacks, like Array.map() or Array.filter(), or they can be put into an expression library for use in any expression property in your pipelines.

Example

To multiply all numbers in an array by ten:
[1, 2, 3].map(x => x * 10)

Result:

  [10, 20, 30]
Panel
bgColor#ebf7e1
borderStylesolid

In this Section

Child pages (Children Display)depth2