Bindings to the functions in RegExp.prototype
Provides bindings for JavaScript Regular Expressions
Melange provides a bit of syntax sugar for regex literals: [%re "/foo/g"] will evaluate to a t that can be passed around and used like usual.
Note: This is not an immutable API. A RegExp object with the global ("g") flag set will modify the lastIndex property when the RegExp object is used, and subsequent uses will continue the search from the previous lastIndex.
let maybeMatches = Js.String.exec ~str:"banana" [\[%re "/na+/g"\]]type t = Js.rethe RegExp object
val captures : result -> string Js.nullable arrayan array of the match and captures, the first is the full match and the remaining are the substring captures
val index : result -> int0-based index of the match in the input string
val input : result -> stringthe original input string
val fromString : string -> tConstructs a RegExp object (t) from a string
Regex literals ([%re "/.../"]) should generally be preferred, but fromString is very useful when you need to insert a string into a regex.
(* A function that extracts the content of the first element with the given tag *)
let contentOf tag xmlString =
Js.Re.fromString ("<" ^ tag ^ ">(.*?)<\\/" ^ tag ^">")
|> Js.Re.exec ~str:xmlString
|> function
| Some result -> Js.Nullable.toOption (Js.Re.captures result).(1)
| None -> Noneval fromStringWithFlags : string -> flags:string -> tConstructs a RegExp object (t) from a string with the given flags
See fromString
Valid flags:
| g | global | |
| i | ignore case | |
| m | multiline | |
| u | unicode | (es2015) |
| y | sticky | (es2015) |
val flags : t -> stringreturns the enabled flags as a string
val global : t -> boolreturns a bool indicating whether the global flag is set
val ignoreCase : t -> boolreturns a bool indicating whether the ignoreCase flag is set
val lastIndex : t -> intreturns the index where the next match will start its search
This property will be modified when the RegExp object is used, if the global ("g") flag is set.
(* Finds and prints successive matches *)
let re = [%re "/ab*/g"] in
let str = "abbcdefabh" in
let break = ref false in
while not !break do
match re |> Js.Re.exec ~str with
| None -> break := true
| Some result ->
Js.Nullable.iter (Js.Re.captures result).(0) ((fun match_ ->
let next = string_of_int (Js.Re.lastIndex re) in
Js.log ("Found " ^ match_ ^ ". Next match starts at " ^ next)))
doneval setLastIndex : t -> int -> unitsets the index at which the next match will start its search from
val multiline : t -> boolreturns a bool indicating whether the multiline flag is set
val source : t -> stringreturns the pattern as a string
val sticky : t -> boolreturns a bool indicating whether the sticky flag is set
val unicode : t -> boolreturns a bool indicating whether the unicode flag is set
executes a search on a given string using the given RegExp object
returns Some result if a match is found, None otherwise
(* Match "quick brown" followed by "jumps", ignoring characters in between
* Remember "brown" and "jumps"
* Ignore case
*)
let re = [%re "/quick\s(brown).+?(jumps)/ig"] in
let result = re |. Js.Re.exec ~str:"The Quick Brown Fox Jumps Over The Lazy Dog"val test : str:string -> t -> booltests whether the given RegExp object will match a given string
returns true if a match is found, false otherwise
(* A simple implementation of Js.String.startsWith *)
let str = "hello world!"
let startsWith target substring =
Js.Re.fromString ("^" ^ substring)
|. Js.Re.test ~str:target
let () = Js.log (str |. startsWith "hello") (* prints "true" *)