Module Js_re

Provides bindings for JavaScript Regular Expressions

Syntax sugar

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 ocntinue the search from the previous lastIndex.

let maybeMatches = "banana" |> Js.String.match_ [\[%re "/na+/g"\]]

@see <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp> JavaScript API reference on MDN

@see <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions> JavaScript Regular Expressions Guide on MDN

type t

the RegExp object

type result

the result of a executing a RegExp on a string

val captures : result -> string Js.nullable array

an array of the match and captures, the first is the full match and the remaining are the substring captures

val matches : result -> string array

an array of the matches, the first is the full match and the remaining are the substring matches *

  • deprecated

    Use captures instead.

val index : result -> int

0-based index of the match in the input string

val input : result -> string

the original input string

val fromString : string -> t

Constructs 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 xmlString
    |> function
      | Some result -> Js.Nullable.toOption (Js.Re.captures result).(1)
      | None -> None
val fromStringWithFlags : string -> flags:string -> t

Constructs 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 -> string

returns the enabled flags as a string

val global : t -> bool

returns a bool indicating whether the global flag is set

val ignoreCase : t -> bool

returns a bool indicating whether the ignoreCase flag is set

val lastIndex : t -> int

returns 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)))
done
val setLastIndex : t -> int -> unit

sets the index at which the next match will start its search from

val multiline : t -> bool

returns a bool indicating whether the multiline flag is set

val source : t -> string

returns the pattern as a string

val sticky : t -> bool

returns a bool indicating whether the sticky flag is set

val unicode : t -> bool

returns a bool indicating whether the unicode flag is set

val exec_ : t -> string -> result option

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_ "The Quick Brown Fox Jumps Over The Lazy Dog"
val exec : string -> t -> result option
  • deprecated

    please use exec_ instead

val test_ : t -> string -> bool

tests 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_ target

let () = Js.log (str |. startsWith "hello") (* prints "true" *)
val test : string -> t -> bool
  • deprecated

    please use test_ instead