# DataWeave Operators

 Standard Support for Mule 4.1 ended on November 2, 2020, and this version of Mule will reach its End of Life on November 2, 2022, when Extended Support ends. Deployments of new applications to CloudHub that use this version of Mule are no longer allowed. Only in-place updates to applications are permitted. MuleSoft recommends that you upgrade to the latest version of Mule 4 that is in Standard Support so that your applications run with the latest fixes and security enhancements.

DataWeave 2.0 supports several mathematical, equality, relational, logical, prepend, and append operators.

## Mathematical Operators

DataWeave 2.0 supports the most common mathematical operators:

Operator Description

+

*

For multiplication.

/

For division.

These examples use mathematical operators:

Source
%dw 2.0
output application/json
---
{ "math" : [
{ "2 + 2" : (2 + 2) },
{ "2 - 2" : (2 - 2) },
{ "2 * 2" : (2 * 2) },
{ "2 / 2" : (2 / 2) }
]
}
Output
"math": [
{ "2 + 2": 4 },
{ "2 - 2": 0 },
{ "2 * 2": 4 },
{ "2 / 2": 1.0 }
]
}

Note that several DataWeave functions operate on numbers, for example: sum, mod (for modulo), and avg (for average).

## Equality and Relational Operators

DataWeave 2.0 supports the following equality and relational operators:

Operator Description

<

For less than.

>

For greater than.

<=

For less than or equal to.

>=

For greater than or equal to.

==

For equal to.

~=

Equality operator that tries to coerce one value to the type of the other when the types are different.

Note that you can negate these operators by using the logical operator, not.

These examples use relational operators:

Source
%dw 2.0
output application/json
---
{ "relational" : [
{ "1 < 1" : (1 < 1) },
{ "1 > 2" : (1 > 2) },
{ "1 <= 1" : (1 <= 1) },
{ "1 >= 1" : (1 >= 1) }
]
}
Output
{ "relational": [
{ "(1 < 1)": false },
{ "(1 > 2)": false },
{ "(1 <= 1)": true },
{ "(1 >= 1)": true }
]
}

Note that if the operands of the relational operator belong to different types, DataWeave coerces the right-side operand to the type of the left-side operand. For example, in the expression "123" > 12 DataWeave coerces 12 (a Number type) to "12" (a String type) and compares each String value lexicographically. In the expression 123 > "12", DataWeave coerces the String value "12" to the Number value 12 and compares the numbers.

These examples use equality operators:

Source
%dw 2.0
output application/dw
---
{ "equality" :
[
(1 == 1),
(1 == 2),
("true" == true),
("true" ~= true),
(['true'] ~= [true]),
('1' ~= 1)
]
}
Output
{
equality: [ true, false, false, true, true, true ]
}

## Logical Operators

The following logical operators are supported.

Operator Description

not

Negates the result of the input.

and

Returns true if the result of all inputs is true, false if not.

or

Returns true if the result of any input is true, false if not.

These examples show uses of these operators:

Source
%dw 2.0
output application/json
var myArray = [1,2,3,4,5]
var myMap = myArray map not ((\$ mod 2) == 0)
---
{
"not" : [
"notTrue" : not true,
"notFalse" : not false,
"myMapWithNot" : myMap
],
"and" : [
"andTrueFalse" : true and false,
"andIsTrue" : (1 + 1 == 2) and (2 + 2 == 4),
"andIsFalse" : (1 + 1 == 2) and (2 + 2 == 2)
],
"or" : [
"orTrueFalse" : true or false,
"orIsTrue" : (1 + 1 == 2) or (2 + 2 == 2),
"orIsFalse" : (1 + 1 == 1) or (2 + 2 == 2)
]
}

Note that myMap iterates through the items in a list (myArray) and determines whether the modulo (mod) expression does not evaluate to 0 when applied to each given item.

Output
{
"not": [
{ "notTrue": false },
{ "notFalse": true },
{ "myMapWithNot": [ true, false, true, false, true ] }
],
"and": [
{ "andTrueFalse": false },
{ "andIsTrue": true },
{ "andIsFalse": false }
],
"or": [
{ "orTrueFalse": true },
{ "orIsTrue": true },
{ "orIsFalse": false }
]
}

Note that not works in expressions such as not (true), but not(true) (without the space) does not work.

You can use logical operators together. The next example uses or not as defined in the orNot expression, uses and not in andNot, and uses not and and not in notWithAndNot.

Example: Using Logical Operators Together
%dw 2.0
output application/json
var orNot = if (1 + 1 == 4 or not 1 == 2) {"answer": "foo"}
var andNot = if (1 + 1 == 2 and not 1 == 2) {"answer": "bar"}
var notWithAndNot = if (not (1 + 1 == 2 and not 1 == 1)) {"answer": "foobar"}
---
[
orNot,
andNot,
notWithAndNot
]
}
Output
{
]
}

## Prepend and Append Operators for Arrays

DataWeave 2.0 supports operators for appending and prepending items within an array.

Operator Description

>>

Prepends data on the left-hand side of the operator to items in the array on the right-hand side. For example, 1 >> [2] results in [ 1, 2 ], prepending 1 to 2 in the array.

<<

Appends data on the right-hand side of the operator to items in the array on the left-hand side. For example, [1] << 2 results in [ 1, 2 ], appending 2 to 1 in the array.

+

Appends data on the right-hand side of the operator to items in the array on the left-hand side. For example, [1] + 2 results in [ 1, 2 ], appending 2 to 1 in the array. The array is always on the left-hand side of the operator.

These examples show uses of these operators:

Example: Using Prepend and Append Operators
%dw 2.0
output application/json
---
{
"prepend-append" : [
// Array on right side when prepending.
{ "prepend" : 1 >> [2] },
{ "prepend-number" : 1 >> [1] },
{ "prepend-string" : "a" >> [1] },
{ "prepend-object" : { "a" : "b"} >> [1] },
{ "prepend-array" : [1] >> [2, 3] },
{ "prepend-binary" : (1 as Binary) >> [1] },
{ "prepend-date-time" : |23:57:59Z| >> [ |2017-10-01| ] },
// Array is on left side when appending.
{ "append-number" : [1] << 2 },
{ "append-string" : [1] << "a" },
{ "append-object" : [1] << { "a" : "b"} },
{ "append-array" : [1,2] << [1, 2, 3] },
{ "append-binary" : [1] << (1 as Binary) },
{ "append-date-time" : [ |2017-10-01| ] << |23:57:59Z| },
{ "append-object-to-array" : [1,2] << {"a" : "b"} },
{ "append-array-to-array1" : ["a","b"] << ["c","d"] },
{ "append-array-to-array2" : [["a","b"],["c","d"]] << ["e","f"] },
// + always appends within the array
{ "append-with-+" : [1] + 2 },
{ "append-with-+" : [2] + 1 }
]
}
Output
{
"prepend-append": [
{ "prepend": [ 1, 2 ] },
{ "prepend-number": [ 1, 1 ] },
{ "prepend-string": [ "a", 1 ] },
{ "prepend-array": [ [ 1 ], 2, 3 ] },
{ "prepend-object": [ { "a": "b" }, 1 ] },
{ "prepend-binary": [ "\u0001", 1 ] },
{ "prepend-date-time": [ "23:57:59Z", "2017-10-01" ] },
{ "append-number": [ 1, 2 ] },
{ "append-string": [ 1, "a" ] },
{ "append-object": [ 1, { "a": "b" } ] },
{ "append-array": [ 1, 2, [ 1, 2, 3 ] ] },
{ "append-binary": [ 1, "\u0001" ] },
{ "append-date-time": [ "2017-10-01", "23:57:59Z" ] },
{ "append-object-to-array": [ 1, 2, { "a": "b" } ] },
{ "append-array-to-array1": [ "a", "b", ["c","d"] ] },
{ "append-array-to-array2": [ ["a","b"], ["c","d"], ["e","f"] ] },
{ "append-with-+": [ 1, 2] },
{ "append-with-+": [ 2, 1] }
]
}