Js_re

Provide bindings to JS regular expressions (RegExp).

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.

t

The RegExp object.

type t

result

The result of a executing a RegExp on a string.

type result

captures

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

let captures: result => array<Js.nullable<string>>

matches

Deprecated. Use captures instead.

let matches: result => array<string>

index

0-based index of the match in the input string.

let index: result => int

input

The original input string.

let input: result => string

fromString

Constructs a RegExp object (Js.Re.t) from a string. Regex literals %re("/.../") should generally be preferred, but fromString is useful when you need to dynamically construct a regex using strings, exactly like when you do so in JavaScript.

RES
let firstReScriptFileExtension = (filename, content) => {
  let result = Js.Re.fromString(filename ++ "\.(res|resi)")->Js.Re.exec_(content)
  switch result {
  | Some(r) => Js.Nullable.toOption(Js.Re.captures(r)[1])
  | None => None
  }
}

// outputs "res"
firstReScriptFileExtension("School", "School.res School.resi Main.js School.bs.js")

let fromString: string => t

fromStringWithFlags

Constructs a RegExp object (Js.Re.t) from a string with the given flags. See Js.Re.fromString.

Valid flags:

• g global

• i ignore case

• m multiline

• u unicode (es2015)

• y sticky (es2015)

let fromStringWithFlags: (string, ~flags: string) => t

flags

Returns the enabled flags as a string.

let flags: t => string

global

Returns a bool indicating whether the global flag is set.

let global: t => bool

ignoreCase

Returns a bool indicating whether the ignoreCase flag is set.

let ignoreCase: t => bool

lastIndex

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.

RES
let re = %re("/ab*TODO/g")
let str = "abbcdefabh"

let break = ref(false)
while !break.contents {
  switch Js.Re.exec_(re, str) {
  | Some(result) => Js.Nullable.iter(Js.Re.captures(result)[0], (. match_) => {
      let next = Belt.Int.toString(Js.Re.lastIndex(re))
      Js.log("Found " ++ (match_ ++ (". Next match starts at " ++ next)))
    })
  | None => break := true
  }
}

See RegExp: lastIndex on MDN.

let lastIndex: t => int

setLastIndex

Sets the index at which the next match will start its search from.

let setLastIndex: (t, int) => unit

multiline

Returns a bool indicating whether the multiline flag is set.

let multiline: t => bool

source

Returns the pattern as a string.

let source: t => string

sticky

Returns a bool indicating whether the sticky flag is set.

let sticky: t => bool

unicode

Returns a bool indicating whether the unicode flag is set.

let unicode: t => bool

exec_

Executes a search on a given string using the given RegExp object. Returns Some(Js.Re.result) if a match is found, None otherwise.

RES
/* Match "quick brown" followed by "jumps", ignoring characters in between
 * Remember "brown" and "jumps"
 * Ignore case
 */

let re = %re("/quick\s(brown).+?(jumps)/ig")
let result = Js.Re.exec_(re, "The Quick Brown Fox Jumps Over The Lazy Dog")

See RegExp.prototype.exec() on MDN.

let exec_: (t, string) => option<result>

test_

Tests whether the given RegExp object will match a given string. Returns true if a match is found, false otherwise.

RES
/* A simple implementation of Js.String.startsWith */

let str = "hello world!"

let startsWith = (target, substring) =>
  Js.Re.fromString("^" ++ substring)->Js.Re.test_(target)

Js.log(str->startsWith("hello")) /* prints "true" */

See RegExp.prototype.test() on MDN.

let test_: (t, string) => bool