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.