In Java we can define capturing groups in regular expression. We can refer to these groups (if found) by the index from the group as defined in the regular expression. Instead of relying on the index of the group we can give a capturing group a name and use that name to reference the group. The format of the group name is ?<name>
as first element of the group definition. The name of the group can be used with the group
method of the Matcher
class. Also we can use the name when we want to reference the capturing group for example with the replaceAll
method of a Matcher
object. The format is ${name}
to reference the group by name. Finally we can use a named capturing group also as backreference in a regular expression using the syntax \k<name>
.
In the following example we define a regular expression with named groups and use them with several methods:
Continue reading →
In Clojure we can use several functions to see if at least one or all elements in a collection return true
or false
for a predicate. The function every?
only returns true
if the predicate function returns true
for all elements in the collection. To function not-every?
return true
if a predicate function return false
for all elements in a collection. The some
function is a bit different (notice there is no ?
) and returns the first logical true
value from the predicate function for the elements in the collection. So the return type of the predicate doesn’t have to be a Boolean
value and then the return type of some
is also not a Boolean
. If the predicate returns a Boolean
value we can use some
like a `any` function (any
is not part of Clojure). Clojure provides a not-any?
function that returns true
if the predicate function returns false
for one element in the collection and false
otherwise.
The following example uses the different functions on a vector with some cartoon names:
Continue reading →
To get the current Clojure version we must use the clojure-version
function. The function simply returns the Clojure version we are using from our code.
In the following example we simply check the result of clojure-version
and also define a function to get the Javaa version:
Continue reading →
The keep
function in Clojure invokes a function on each item in a collection and only returns non-nil results from the function invocation. The result of the keep
function is a lazy sequence.
The following example uses the keep
function, but also show what results would be when using map
function on the same collection with the same function argument:
Continue reading →
In Clojure we can use the clojure.string/split
function to split a string, based on a regular expression, into a vector with string values. Optionally we can also specify a limit on the maximum number of returned string values we want. If we want to split a string based on the newline characters we can use the function clojure.string/split-lines
that returns a vector where each element is a line from the original multi-line string.
The following example shows several usages of the split
and split-lines
functions:
Continue reading →
In Clojure we can use the rand-nth
function to get a single random element from a sequence. To get multiple items based on random probability for each item we use the function random-sample
. We must set the probability that determines for each item if it is in the result or not.
In the following example code we use rand-nth
function:
Continue reading →
We can search for a value in a string and replace it with another value using the clojure.string/replace
function. The first parameter is the original string value that we want to replace parts of. The second parameter can be a string value or regular expression. The last parameter is the replacement value that can be a string value or a function that returns a string value. The function itself gets either a string argument if the match has no nested groups (when match is a regular expression) or a vector with a complete match followed by the nested groups when the match has nested groups.
In the following example we several invocation of the clojure.string/replace
function with different arguments:
Continue reading →
We can use the flatten
function when we have a collection with nested sequential collections as elements and create a new sequence with the elements from all nested collections.
In the following example we use the flatten
function:
Continue reading →
In the clojure.set
namespace we can find the intersection
function. This functions accepts one or more sets as arguments and return a new set with all elements that are present in the sets that are passed as arguments to the intersection
function. The argument must be a set, so we need to convert other collection or seq values to a set first before we use it as an argument for the function.
In the following example we use one, two or three arguments for the intersection
function and also convert other types to a set to be used as argument:
Continue reading →
We can use the join
function from the clojure.string
namespace to join elements from a collection into a string. We can optionally specify a separator that is used to separate each element in the string output. The separator is not used after the last element of the collection. If we don’t specify a separator the elements are concatenated without separation. The string representation for each element in the collection is used in the joined end result.
In the following example code we see different usages of the join
function:
Continue reading →
In the clojure.string
namespace we can find several useful function for working with strings. If we want to trim a string we can choose for the trim
, trial
, trimr
and trim-newline
functions. To trim all characters before a string we must use the triml
function. To remove all space characters after a string we use trimr
. To remove space characters both before and after a string we can use the trim
function. Finally if we only want to remove the newline and/or return characters we use the trim-newline
function.
In the following example we use the different trim functions on strings:
Continue reading →
Groovy 3 adds the takeBetween
method to the String
class. With this method we can get all the characters that are enclosed by string values. We can specify one enclosed string value and then all text between the the first occurrence of the string and the second occurrence is returned. If multiple parts are enclosed by the string values we can also specify which occurrence we want. If the text is enclosed by different string values we can use a variant of takeBetween
that takes two string values to indicate the boundaries of the text we want. Also with two different enclosed string values we can use an argument to get the n-th occurrence of the string that is found.
Since Groovy 3 we can also use takeBefore
and takeAfter
to get the string before or after a given string value. All three methods will return an empty string if no text can be found.
In the following example we use the takeBefore
, takeAfter
and takeBetween
methods with different arguments:
Continue reading →