The module dw::core::Array has several functions to create a new array by taking or dropping a number of elements of the source array. With the take function has as first input argument the original array and the second is a number indicating the number of items to take. For example [1, 2] take 1 will return [1]. Notice that we can use the functions also in the infix notation. The drop function works similarly, but will skip the number of items we define as second argument to the function. So [1, 2] drop 1 will return [2].
In the following example we use the take and drop function with several numbers to use or skip items from the original array:
Source
%dw 2.0
import take from dw::core::Arrays
var list = ['Simple', 'list', 'with', 5, 'items']
output application/json
---
{
// Return array with first element "Simple"
"take 1 item": list take 1,
// Return array with first 2 elements.
"take 2 items": list take 2,
// Empty list returned as we take 0 items.
"take 0 items": list take 0,
// Return array with all elements as 6 is larger
// than number of items in the list.
"take 6 items": list take 6
}
Output
{
"take 1 item": [
"Simple"
],
"take 2 items": [
"Simple",
"list"
],
"take 0 items": [
],
"take 6 items": [
"Simple",
"list",
"with",
5,
"items"
]
}
Source
%dw 2.0
import drop from dw::core::Arrays
var list = ['Simple', 'list', 'with', 5, 'items']
output application/json
---
{
// Return array where first element of original
// array is skipped.
"drop 1 item": list drop 1,
// Return array with elements from index 3.
"drop 3 items": list drop 3,
// Empty array returned as we drop all items.
"drop 5 items": list drop 5,
// Return empty array as 6 is larger than
// number of items in the list.
"drop 6 items": list drop 6,
// Range as array of numbers.
"drop from range": (0 to 10) drop 8
}
Output
{
"drop 1 item": [
"list",
"with",
5,
"items"
],
"drop 3 items": [
5,
"items"
],
"drop 5 items": [
],
"drop 6 items": [
],
"drop from range": [
8,
9,
10
]
}
We can also specify a condition using a predicate function to determine how many items to take or drop. In that case we use the takeWhile and dropWhile functions. Instead of specifying a number of items we use predicate function. The predicate function should return true or false. The function is applied to the items of the original array and as long as the return value is true it will be included in the resulting array with takeWhile or skipped with dropWhile.
In the next example we use both functions:
Source
%dw 2.0
import takeWhile, dropWhile from dw::core::Arrays
var list = (0 to 10)
var object = {
name: "mrhaki",
livesIn: "Tilburg",
worksAt: 'JDriven'
}
// Helper function to get key from object
// with only 1 key/value pair.
fun getKey(obj: Object): Key = keysOf(obj)[0]
output application/json
---
{
// Return array with first items smaller than 6.
take: list takeWhile ((item) -> item < 6),
// Once a false is returned for the condition
// no more items are processed.
// This time we use shorthand notation for the function argument.
irregularTake: [1, 5, 7, 2, 4, 6] takeWhile $ < 6,
// Return array where first items smaller than 6 are skipped.
drop: list dropWhile ((item) -> item < 6),
// With a bit of transformation we can also use the
// functions on objects.
// First we transform the object into an array,
// apply the function and transform to object again.
objectTake: object
pluck ((value, key) -> (key): value)
takeWhile ((item) -> sizeOf(getKey(item)) == 4)
reduce ((result, acc = {}) -> acc ++ result),
objectDrop: object
pluck ((value, key) -> (key): value)
dropWhile ((item) -> getKey(item) ~= "name")
reduce ((result, acc = {}) -> acc ++ result)
}
Output
{
"take": [
0,
1,
2,
3,
4,
5
],
"irregularTake": [
1,
5
],
"drop": [
6,
7,
8,
9,
10
],
"objectTake": {
"name": "mrhaki"
},
"objectDrop": {
"livesIn": "Tilburg",
"worksAt": "JDriven"
}
}
Written with DataWeave 2.4.
