Re

t

RES
type t

The RegExp object.

result

RES
type result

The result of a executing a RegExp on a string.

captures

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

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

matches

RES
let matches: result => array<string>

Deprecated. Use captures instead. An array of the matches, the first is the full match and the remaining are the substring matches.

index

RES
let index: result => int

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

input

RES
let input: result => string

The original input string.

fromString

RES
let fromString: string => t

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.Re.captures(r)[1]
  | None => None
  }
}

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

fromStringWithFlags

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

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)

flags

RES
let flags: t => string

Returns the enabled flags as a string.

global

RES
let global: t => bool

Returns a bool indicating whether the global flag is set.

ignoreCase

RES
let ignoreCase: t => bool

Returns a bool indicating whether the ignoreCase flag is set.

lastIndex

RES
let 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.

RES
let re = %re("/ab*/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]->Js.Nullable.fromOption,
      (. match_) => {
        let next = Belt.Int.toString(Js.Re.lastIndex(re))
        let matchStr =
          match_->Js.Nullable.toOption->Belt.Option.getWithDefault("")
        Js.log("Found " ++ (matchStr ++ (". Next match starts at " ++ next)))
      },
    )
  | None => break := true
  }
}

setLastIndex

RES
let setLastIndex: (t, int) => unit

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

multiline

RES
let multiline: t => bool

Returns a bool indicating whether the multiline flag is set.

source

RES
let source: t => string

Returns the pattern as a string.

sticky

RES
let sticky: t => bool

Returns a bool indicating whether the sticky flag is set.

unicode

RES
let unicode: t => bool

Returns a bool indicating whether the unicode flag is set.

exec_

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

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")

exec

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

Deprecated. please use Js.Re.exec_ instead.

test_

RES
let test_: (t, string) => bool

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" */

test

RES
let test: (string, t) => bool

Deprecated. please use Js.Re.test_ instead.