«    DataWeave Operators    »

• Overview

DataWeave 1.0 supports several mathematical, equality, relational, logical, prepend, append, flow control, and scope operators. Here is the list :-

1.   map
2.   mapObject
3.   pluck
4.   filter
5.   remove
6.   and
7.   or
8.   is
9.   Concat
10.   contains
11.   coerce
12.   typeOf
13.   flatten
14.   sizeOf
15.   Array Push
16.   Remove from Array
17.   Remove Matching from Array
18.   Average of an Array
19.   reduce
20.   joinBy
21.   splitBy
22.   orderBy
23.   groupBy
24.   distinctBy
25.   zip
26.   unzip
27.   replace
28.   matches
29.   startsWith
30.   endsWith
31.   find
32.   match
33.   scan
34.   Similar
35.   upper
36.   lower
37.   camelize
38.   capitalize
39.   dasherize
40.   underscore
41.   pluralize
42.   singularize
43.   trim
44.   Sub String
45.   ordinalize
46.   Addition
47.   Substraction
48.   Multiply
49.   Division
50.   max
51.   min
52.   round
53.   sqrt
54.   pow
55.   ceil
56.   floor
57.   abs
58.   mod
59.   now
60.   Get Time Unit
61.   Shift Time Zone
62.   Append Time
63.   Append Time Zone
64.   Adding a Period of Time
65.   Subtracting a Period of Time
66.   Subtracting two Dates

• map

• Use map on an Array
  (':array', ':function') ⇒ :array
  Returns an array that is the result of applying a transformation function (lambda) to each of the elements. 
  The lambda is invoked with two parameters: index and the value. If these parameters are not named, the index is defined by default as $$ and the value as $.


• Use map on an Object
  
  (':object', ':function') ⇒ ':array'
  Returns an array with the values that result out of applying a transformation function (lambda) to each of the values in the object. 
  The keys of the original object are all ignored by this operation and the object is treated as an array.

• mapObject

(':object', ':function') ⇒ ':object'

Similar to map, but instead of processing only the values of an object, it processes both keys and values as a tuple. 

Also instead of returning an array with the results of processing these values through the lambda, it returns an object, which consists of a list of the key:value pairs that result from processing both key and value of the object through the lambda.

• pluck

(':object', ':function') ⇒ ':array'

pluck is useful for mapping an object into an array.

pluck is an alternate mapping mechanism to mapObject. 

Like mapObject, pluck executes a lambda over every key:value pair in its processed object as a tuple, but instead of returning an object, it returns an array, which may be built from either the values or the keys in the object.

• filter

• Use filter on an Array
  (':array', ':function') ⇒ ':array'
  Returns an array that is the result of applying a transformation function (lambda) to each of the elements. 
  The lambda is invoked with two parameters: index and the value. If these parameters are not named, the index is defined by default as $$ and the value as $.
  


• Use filter on an Object
  
  (':object', ':function') ⇒ ':object'
  Returns an object with the key:value pairs that pass the acceptance criteria defined in the lambda.
  If these parameters are not named, the index is defined by default as $$ and the value as $.
  

• Remove

• Use Remove on an Array
  (':array', ':name') ⇒ ':array'
  When running it on an array, it returns another array where the specified names are removed.
  


• Use Remove on an Object
  
  (':object', ':name') ⇒ ':object'
  When running it on an object, it returns another object where the specified keys are removed.
  


• Use Remove on Matching Key and Value
  
  (':object', ':object') ⇒ ':object'
  Works just like remove on objects, but only removes an element when there is a match of not just the key but of the key + value pair .
  It returns another object where the specified keys are removed.
  

• and

The expression and (in lower case) can be used to link multiple conditions

• or

The expression or (in lowercase) can be used to link multiple conditions.

Its use means that either one or all of the linked conditions must evaluate to true for the expression as a whole to evaluate to true. 

• is

(':any', condition) ⇒ ':boolean'

Evaluates if a condition validates to true and returns a boolean value.

• concat

The concat operator is defined using double plus signs. You must have spaces on both sides of them.

• Use concat on an Array
  (':array', ':array') ⇒ ':array'
  When using arrays, it returns the resulting array of concatenating two existing arrays.
  


• Use Concat on an String
  
  (':string', ':string') ⇒ ':string'
  Strings are treated as arrays of characters, so the operation works just the same with strings.
  


• Use concat on an Object
  
  (':object', ':object') ⇒ ':object'
  Returns the resulting object of concatenating two existing objects.
  

• contains

Evaluates if an array or list contains in at least one of its indexes a value that validates to true and returns a boolean value. 

• Use contains on an Array
  (':array', ':any') ⇒ ':boolean'
  We can evaluate if any value in an array matches a given condition:
  


• Use contains on an String
  
  (':string', ':regex') ⇒ ':boolean'
  can also use contains to evaluate a substring from a larger string:
  

• coerce

Check the type coercion table to see what conversions between what types are allowed in DataWeave.

• Coerce to string
  (':any', ':type') ⇒ ':string'
  Any simple types can be coerced to string. If formatting is required (such as for a number or date) the format schema property can be used.
  


• Coerce to number
  
  (':string', ':type') ⇒ ':number'
  A string can be coerced to number. If the given number has a specific format the schema property can be used.
  


• Coerce a date to number
  
  (':time', ':type') ⇒ ':number'
  When coercing a date to a number, there is an extra parameter you can add – 'unit' – to specify what unit of time to use,
  


• Coerce to date
  
  (':string', ':type')/(':number', ':type') ⇒ ':date'
  Date types can be coerced from string or number.
  


• Coerce to Object
  
  (':any', ':type') ⇒ ':object'
  We can coerce our input into a custom object type of whatever class you want.
  

• typeOf

(':any') ⇒ ':type'

Returns the type of a provided element (eg: '":string"' , '":number"' )

• flatten

(':array') ⇒ ':array'

If you have an array of arrays, this function can flatten it into a single simple array.

• sizeOf

(':array')/(':string')/(':object') ⇒ ':number'

Returns the number of elements in an array (or anything that can be converted to an array such as a string).

• Array Push

(:array', ':any') ⇒ ':array'

Pushes a new element to the end of an array.

• Remove from Array

(:array', ':any') ⇒ ':array'

Removes an element from an array when it matches the specified value.

If multiple elements in the array match the value, they will all be removed.

• Remove Matching from Array

(':array', ':array') ⇒ ':array'

Removes a set of elements from an array when an element in the base array matches one of the values in the substracted array.

If multiple elements in the array match the value, they will all be removed.

• Average of an Array

(':array') ⇒ ':number'

Creates an average of all the values in an array and outputs a single number.

The array must of course contain only numerical value in it.

• reduce

(':array', ':function') ⇒ ':any'

Apply a reduction to the array using just two parameters: the accumulator ($$), and the value ($).

By default, the accumulator starts at the first value of the array.

In some cases, you may not want to use the first element of the array as an accumulator.

To set the accumulator to something else, you must define this in a lambda.

• joinBy

(':array', ':string') ⇒ ':string'

Merges an array into a single string value, using the provided string as a separator between elements.

By default, the accumulator starts at the first value of the array.

• splitBy

(':string', ':string')/(':string', ':regex') ⇒ ':array'

Performs the opposite operation as Join By.

It splits a string into an array of separate elements, looking for instances of the provided string and using it as a separator.

• orderBy

(':array', ':function')/(':object', ':function') ⇒ ':array'/':object'

Returns the provided array (or object) ordered according to the value returned by the lambda.

The lambda is invoked with two parameters: index and the value.

If these parameters are not named, the index is defined by default as $$ and the value as $.

• groupBy

(':array', ':function') ⇒ ':object'

Partitions an array into a Object that contains Arrays, according to the discriminator lambda we define.

The lambda is invoked with two parameters: index and the value.

If these parameters are not named, the index is defined by default as $$ and the value as $.

• distinctBy

(':array', ':function') ⇒ ':array'

Returns only unique values from an array that may have duplicates.

The lambda is invoked with two parameters: index and the value.

If these parameters are not named, the index is defined by default as $$ and the value as $.

• zip

(':array', ':array') ⇒ ':array'

Given two or more separate lists, the zip function can be used to merge them together into a single list of consecutive n-tuples.

the zip function interdigitates each element from each input list, one element at a time.

• unzip

(':array') ⇒ ':array'

Performs the opposite function of zip arrays.

the zip function interdigitates each element from each input list, one element at a time.

Given a single array where each index contains an array with two elements, it outputs two separate arrays.

• replace

(':string', ':regex', ':function') ⇒ ':string'

Replaces a section of a string for another, in accordance to a regular expression, and returns a modified string.

• matches

(':string', ':regex') ⇒ ':boolean'

Matches a string against a regular expression, and returns true or false.

• startsWith

(':string', ':string') ⇒ ':boolean'

Returns true or false depending on if a string starts with a provided substring.

• endsWith

(':string', ':string') ⇒ ':boolean'

Returns true or false depending on if a string ends with a provided substring.

• find

(':string', ':string')/.(':string', ':regex') ⇒ ':array'

It returns the index position within the string at which a match was matched.

If found in multiple parts of the string, it returns an array with the various index positions at which it was found

• match

(':string', ':regex') ⇒ ':array'

Match a string against a regular expression.

Match returns an array that contains the entire matching expression, followed by all of the capture groups that match the provided regex.

It can be applied to the result of any evaluated expression, and can return any evaluated expression.

• scan

(':string', ':regex') ⇒ ':array'

Returns an array with all of the matches in the given string.

Each match is returned as an array that contains the complete match, as well as any capture groups there may be in your regular expression.

• Similar

(':any', ':any') ⇒ ':boolean'

Evaluates if two values are similar, regardless of their type.

For example, the string "1234" and the number 1234 aren’t equal, but they are recognised as similar.

• upper

(':string') ⇒ ':string'

Returns the provided string in uppercase characters.

• lower

(':string') ⇒ ':string'

Returns the provided string in lowercase characters.

• camelize

(':string') ⇒ ':string'

Returns the provided string in camel case.

All underscores are deleted, including any underscores at the beginning of the string.

• capitalize

(':string') ⇒ ':string'

Returns the provided string with every word starting with a capital letter and no underscores.

It also replaces underscores with spaces and puts a space before each capitalized word.

• dasherize

(':string') ⇒ ':string'

Returns the provided string with every word separated by a dash.

• underscore

(':string') ⇒ ':string'

Returns the provided string with every word separated by an underscore.

• pluralize

(':string') ⇒ ':string'

Returns the provided string transformed into its plural form.

• singularize

(':string') ⇒ ':string'

Returns the provided string transformed into its plural form.

• trim

(':string') ⇒ ':string'

Removes any excess spaces at the start and end of a string.

• Sub String

(':string') ⇒ ':string'

Extracts a set of characters out of a string, based on the position that the first and last character of the desired substring occupy in the character array.

If we use negative numbers, you can also inverse the order in which characters are set.

• ordinalize

(':number') ⇒ ':string'

Returns the provided numbers set as ordinals.

• Addition

• Substraction

• Multiply

• Division

• max

(':array')/(':object') ⇒ ':number'

Returns the highest number in an array or object.

• min

(':array')/(':object') ⇒ ':number'

Returns the lowest number in an array or object.

• round

(':number') ⇒ ':number'

Rounds the value of a number to the nearest integer.

• sqrt

(':number') ⇒ ':number'

Returns the square root of the provided number.

• pow

(':number', ':number') ⇒ ':number'

Returns the result of the first number a to the power of the number following the pow operator.

• ceil

(':number') ⇒ ':number'

Rounds a number upwards, returning the first full number above than the one provided.

• floor

(':number') ⇒ ':number'

Rounds a number downwards, returning the first full number below than the one provided.

• abs

(':number') ⇒ ':number'

Returns the absolute value of a number.

• mod

(':number', ':number') ⇒ ':number'

Returns the remainder after division of the first number by the second one

• now

Returns a datetime object with the current date and time.

• Get Time Unit

(':date')/(':time')/(':localtime')/(':datetime')/(':localdatetime')/(':period') ⇒ (':date')/(':time')/(':localtime')/(':period')

We can extract a particular time unit from any date related type as shown below:

• Shift Time Zone

(':datetime', ':timezone') ⇒ ':datetime'

Shift a date time to the specified timezone.

• Append Time

(':date', ':time')/(':date', ':localtime')/(':time', ':date')/(':localtime', ':date') ⇒ (':localtime')/(':datetime')/(':localdatetime')

• Append Time Zone

(':datetime', ':timezone')/(':time', ':timezone')/(':localtime', ':timezone')/(':localdatetime', ':timezone') ⇒ (':localtime')/(':localdatetime')

Appends a time zone to a date type value.

• Adding a Period of Time

(':time', ':period')/(':datetime', ':period')/(':localtime', ':period')/(':localdatetime', ':period') ⇒ (':date')/(':time')/(':localtime')/(':datetime')/(':localdatetime')

Add or subtract a period of time from a given date or time type object.

• Subtracting a Period of Time

(':time', ':period')/(':datetime', ':period')/(':localtime', ':period')/(':localdatetime', ':period') ⇒ (':date')/(':time')/(':localtime')/(':datetime')/(':localdatetime')

The same logically applies to subtracting time periods from a date or time type object.

• Subtracting two Dates

(':date', ':date')/(':datetime', ':datetime')/('#:time', ':time')/(':localtime', ':localtime')/(':localdatetime', ':localdatetime') ⇒ ':period'

When subtracting one date or time type object from another, what we logically get is the difference between these times expressed as a time period.

• Code Reference

Click here to download "DataWeave Operators" project from Git

If you got some knowledge about DataWeave Operators, please follow with me in next topic to understand about API-led Architecture.

Comments

Submit comment