splitBy | MuleSoft Documentation
# splitBy
## splitBy(text: String, regex: Regex): Array<String>
Splits a string into a string array based on a value that matches part of that string. It filters out the matching part from the returned array.
This version of `splitBy` accepts a Java regular expression (regex) to match the input string. The regex can match any character in the input string. Note that `splitBy` performs the opposite operation of `joinBy`.
### Parameters
Name | Description  
---|---  
The input string to split.  
A Java regular expression used to split the string. If it does not match some part of the string, the function will return the original, unsplit string in the array.  
### Example
This example uses a Java regular expression to split an address block by the periods and forward slash in it. Notice that the regular expression goes between forward slashes.
#### Source
```
%dw 2.0
output application/json
---
"192.88.99.0/24" splitBy(/[.\/]/)
```

#### Output
```
["192", "88", "99", "0", "24"]
```

### Example
This example uses several regular expressions to split input strings. The first uses `/.b./` to split the string by `-b-`. The second uses `/\s/` to split by a space. The third example returns the original input string in an array (`[ "no match"]`) because the regex `/^s/` (for matching the first character if it is `s`) does not match the first character in the input string (`"no match"`). The fourth, which uses `/^n../`, matches the first characters in `"no match"`, so it returns `[ "", "match"]`. The last removes all numbers and capital letters from a string, leaving each of the lower case letters in the array. Notice that the separator is omitted from the output.
#### Source
```
%dw 2.0
output application/json
---
{ "splitters" : {
  "split1" : "a-b-c" splitBy(/.b./),
  "split2" : "hello world" splitBy(/\s/),
  "split3" : "no match" splitBy(/^s/),
  "split4" : "no match" splitBy(/^n../),
  "split5" : "a1b2c3d4A1B2C3D" splitBy(/[0-9A-Z]/)
 }
}
```

#### Output
```
{
 splitters: {
  split1: [ "a", "c" ],
  split2: [ "hello", "world" ],
  split3: [ "no match" ],
  split4: [ "", "match" ],
  split5: [ "a", "b", "c", "d" ]
 }
}
```

### Example
This example splits the number by `.` and applies the index selector `[0]` to the result of the splitBy function. The splitBy returns `["192", "88", "99", "0"]` so the index * selector `[0]` just returns the first element in the array ("192").
#### Source
```
%dw 2.0
output application/json
---
("192.88.99.0" splitBy("."))[0]
```

### Example
This example uses a Java regular expression to split a string by `.` at every point the input string matches the regex. Note that the regular expression does not consider the periods between the backticks ```.
#### Source
```
%dw 2.0
output application/json
---
'root.sources.data.`test.branch.BranchSource`.source.traits' splitBy(/[.](?=(?:[^`]*`[^`]*`)*[^`]*$)/)
```

#### Output
```
[
 "root",
 "sources",
 "data",
 "`test.branch.BranchSource`",
 "source",
 "traits"
]
```

## splitBy(text: String, separator: String): Array<String>
Splits a string into a string array based on a separating string that matches part of the input string. It also filters out the matching string from the returned array.
The separator can match any character in the input. Note that `splitBy` performs the opposite operation of `joinBy`.
### Parameters
Name | Description  
---|---  
The string to split.  
`separator` | A string used to separate the input string. If it does not match some part of the string, the function will return the original, unsplit string in the array.  
### Example
This example splits a string containing an IP address by its periods.
#### Source
```
%dw 2.0
output application/json
---
"192.88.99.0" splitBy(".")
```

#### Output
```
["192", "88", "99", "0"]
```

### Example
The first example (`splitter1`) uses a hyphen (`-`) in `"a-b-c"` to split the string. The second uses an empty string (`""`) to split each character (including the blank space) in the string. The third example splits based on a comma (`,`) in the input string. The last example does not split the input because the function is case sensitive, so the upper case `NO` does not match the lower case `no` in the input string. Notice that the separator is omitted from the output.
#### Source
```
%dw 2.0
output application/json
---
{ "splitters" : {
  "split1" : "a-b-c" splitBy("-"),
  "split2" : "hello world" splitBy(""),
  "split3" : "first,middle,last" splitBy(","),
  "split4" : "no split" splitBy("NO")
  }
}
```

#### Output
```
{
 splitters: {
  split1: [ "a","b","c" ],
  split2: [ "h","e","l","l","o","","w","o","r","l","d" ],
  split3: [ "first","middle","last"],
  split4: [ "no split"]
 }
}
```

## splitBy(text: Null, separator: Any)
Helper function that enables `splitBy` to work with a `null` value.
_Introduced in DataWeave version 2.4.0._