%dw 2.0
output application/json
---
{ "math" : [
{ "2 + 2" : (2 + 2) },
{ "2 - 2" : (2 - 2) },
{ "2 * 2" : (2 * 2) },
{ "2 / 2" : (2 / 2) }
]
}
DataWeave Operators
DataWeave 2.1 is compatible with Mule 4.1. 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 version 2 supports several mathematical, equality, relational, logical, prepend, and append operators.
Mathematical Operators
DataWeave version 2 supports the most common mathematical operators:
Operator | Description |
---|---|
|
For addition |
|
For multiplication. |
|
For division. |
These examples use mathematical operators:
"math": [
{ "2 + 2": 4 },
{ "2 - 2": 0 },
{ "2 * 2": 4 },
{ "2 / 2": 1.0 }
]
}
Equality and Relational Operators
DataWeave version 2 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:
%dw 2.0
output application/json
---
{ "relational" : [
{ "1 < 1" : (1 < 1) },
{ "1 > 2" : (1 > 2) },
{ "1 <= 1" : (1 <= 1) },
{ "1 >= 1" : (1 >= 1) }
]
}
{ "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:
%dw 2.0
output application/dw
---
{ "equality" :
[
(1 == 1),
(1 == 2),
("true" == true),
("true" ~= true),
(['true'] ~= [true]),
('1' ~= 1)
]
}
{
equality: [ true, false, false, true, true, true ]
}
Logical Operators
The following logical operators are supported.
Operator | Description |
---|---|
|
Negates the result of the input. |
|
Returns |
|
Returns |
These examples show uses of these operators:
%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.
{
"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
.
%dw 2.0
output application/json
var orNot = if (1 + 1 == 4 or not 1 == 2) {"answer": "foo"}
else {"answer": "nope"}
var andNot = if (1 + 1 == 2 and not 1 == 2) {"answer": "bar"}
else {"answer": "nope"}
var notWithAndNot = if (not (1 + 1 == 2 and not 1 == 1)) {"answer": "foobar"}
else {"answer": "nope"}
---
{ "answers" :
[
orNot,
andNot,
notWithAndNot
]
}
{
"answers": [
{ "answer": "foo" },
{ "answer": "bar" },
{ "answer": "foobar" }
]
}
Prepend and Append Operators for Arrays
DataWeave version 2 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, |
|
Appends data on the right-hand side of the operator to items in the
array on the left-hand side. For example, |
|
Appends data on the right-hand side of the operator to items in the
array on the left-hand side. For example, |
These examples show uses of these 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 }
]
}
{
"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] }
]
}