# 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 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 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:

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
``````{
{ "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, `1 >> ` 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, ` << 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, ` + 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 >>  },
{ "prepend-number" : 1 >>  },
{ "prepend-string" : "a" >>  },
{ "prepend-object" : { "a" : "b"} >>  },
{ "prepend-array" :  >> [2, 3] },
{ "prepend-binary" : (1 as Binary) >>  },
{ "prepend-date-time" : |23:57:59Z| >> [ |2017-10-01| ] },
// Array is on left side when appending.
{ "append-number" :  << 2 },
{ "append-string" :  << "a" },
{ "append-object" :  << { "a" : "b"} },
{ "append-array" : [1,2] << [1, 2, 3] },
{ "append-binary" :  << (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-+" :  + 2 },
{ "append-with-+" :  + 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] }
]
}``````