Js_string
JavaScript String API
t
type t = string
make
let make: 'a => t
make(value) converts the given value to a string.
RESJs.String2.make(3.5) == "3.5"
Js.String2.make([1, 2, 3]) == "1,2,3"
fromCharCode
let fromCharCode: int => t
fromCharCode(n) creates a string containing the character corresponding to that number; n ranges from 0 to 65535.
If out of range, the lower 16 bits of the value are used. Thus, fromCharCode(0x1F63A) gives the same result as fromCharCode(0xF63A). See String.fromCharCode on MDN.
RESJs.String2.fromCharCode(65) == "A"
Js.String2.fromCharCode(0x3c8) == `ψ`
Js.String2.fromCharCode(0xd55c) == `한`
Js.String2.fromCharCode(-64568) == `ψ`
fromCharCodeMany
let fromCharCodeMany: array<int> => t
fromCharCodeMany([n1, n2, n3]) creates a string from the characters
corresponding to the given numbers, using the same rules as fromCharCode. See
String.fromCharCode
on MDN.
fromCodePoint
let fromCodePoint: int => t
fromCodePoint(n) creates a string containing the character corresponding to
that numeric code point. If the number is not a valid code point, it raises
RangeError.Thus, fromCodePoint(0x1F63A) will produce a correct value,
unlike fromCharCode(0x1F63A), and fromCodePoint(-5) will raise a
RangeError.
See String.fromCodePoint
on MDN.
RESJs.String2.fromCodePoint(65) == "A"
Js.String2.fromCodePoint(0x3c8) == `ψ`
Js.String2.fromCodePoint(0xd55c) == `한`
Js.String2.fromCodePoint(0x1f63a) == `😺`
fromCodePointMany
let fromCodePointMany: array<int> => t
fromCodePointMany([n1, n2, n3]) creates a string from the characters
corresponding to the given code point numbers, using the same rules as
fromCodePoint.
See String.fromCodePoint
on MDN.
RESJs.String2.fromCodePointMany([0xd55c, 0xae00, 0x1f63a]) == `한글😺`
length
let length: t => int
length(s) returns the length of the given string. See
String.length
on MDN.
RESJs.String2.length("abcd") == 4
get
let get: (t, int) => t
get(s, n) returns as a string the character at the given index number. If
n is out of range, this function returns undefined, so at some point this
function may be modified to return option(string).
RESJs.String2.get("Reason", 0) == "R"
Js.String2.get("Reason", 4) == "o"
Js.String2.get(`Rẽasöń`, 5) == `ń`
charAt
let charAt: (int, t) => t
charCodeAt
let charCodeAt: (int, t) => float
codePointAt
let codePointAt: (int, t) => option<int>
concat
let concat: (t, t) => t
concatMany
let concatMany: (array<t>, t) => t
endsWith
let endsWith: (t, t) => bool
endsWithFrom
let endsWithFrom: (t, int, t) => bool
includes
let includes: (t, t) => bool
includesFrom
let includesFrom: (t, int, t) => bool
indexOf
let indexOf: (t, t) => int
indexOfFrom
let indexOfFrom: (t, int, t) => int
lastIndexOf
let lastIndexOf: (t, t) => int
lastIndexOfFrom
let lastIndexOfFrom: (t, int, t) => int
localeCompare
let localeCompare: (t, t) => float
match_
let match_: (Js_re.t, t) => option<array<option<t>>>
normalize
let normalize: t => t
normalize(str) returns the normalized Unicode string using Normalization Form
Canonical (NFC) Composition. Consider the character ã, which can be represented
as the single codepoint \u00e3 or the combination of a lower case letter A
\u0061 and a combining tilde \u0303. Normalization ensures that both can be
stored in an equivalent binary representation.
See String.normalize
on MDN.
See also Unicode technical report #15 for details.
normalizeByForm
let normalizeByForm: (t, t) => t
repeat
let repeat: (int, t) => t
replace
let replace: (t, t, t) => t
replaceByRe
let replaceByRe: (Js_re.t, t, t) => t
unsafeReplaceBy0
let unsafeReplaceBy0: (Js_re.t, (t, int, t) => t, t) => t
unsafeReplaceBy1
let unsafeReplaceBy1: (Js_re.t, (t, t, int, t) => t, t) => t
unsafeReplaceBy2
let unsafeReplaceBy2: (Js_re.t, (t, t, t, int, t) => t, t) => t
unsafeReplaceBy3
let unsafeReplaceBy3: (Js_re.t, (t, t, t, t, int, t) => t, t) => t
search
let search: (Js_re.t, t) => int
slice
let slice: (~from: int, ~to_: int, t) => t
sliceToEnd
let sliceToEnd: (~from: int, t) => t
split
let split: (t, t) => array<t>
splitAtMost
let splitAtMost: (t, ~limit: int, t) => array<t>
splitByRe
let splitByRe: (Js_re.t, t) => array<option<t>>
splitByReAtMost
let splitByReAtMost: (Js_re.t, ~limit: int, t) => array<option<t>>
startsWith
let startsWith: (t, t) => bool
startsWithFrom
let startsWithFrom: (t, int, t) => bool
substr
let substr: (~from: int, t) => t
substrAtMost
let substrAtMost: (~from: int, ~length: int, t) => t
substring
let substring: (~from: int, ~to_: int, t) => t
substringToEnd
let substringToEnd: (~from: int, t) => t
toLowerCase
let toLowerCase: t => t
toLowerCase(str) converts str to lower case using the locale-insensitive
case mappings in the Unicode Character Database. Notice that the conversion can
give different results depending upon context, for example with the Greek
letter sigma, which has two different lower case forms; one when it is the last
character in a string and another when it is not.
See String.toLowerCase
on MDN.
RESJs.String.toLowerCase("ABC") == "abc"
Js.String.toLowerCase(`ΣΠ`) == `σπ`
Js.String.toLowerCase(`ΠΣ`) == `πς`
toLocaleLowerCase
let toLocaleLowerCase: t => t
toLocaleLowerCase(str) converts str to lower case using the current locale.
See String.toLocaleLowerCase
on MDN.
toUpperCase
let toUpperCase: t => t
toUpperCase(str) converts str to upper case using the locale-insensitive
case mappings in the Unicode Character Database. Notice that the conversion can
expand the number of letters in the result; for example the German ß
capitalizes to two Ses in a row.
See String.toUpperCase
on MDN.
RESJs.String.toUpperCase("abc") == "ABC"
Js.String.toUpperCase(`Straße`) == `STRASSE`
Js.String.toUpperCase(`πς`) == `ΠΣ`
toLocaleUpperCase
let toLocaleUpperCase: t => t
toLocaleUpperCase(str) converts str to upper case using the current locale.
See String.to:LocaleUpperCase
on MDN.
trim
let trim: t => t
trim(str) returns a string that is str with whitespace stripped from both
ends. Internal whitespace is not removed.
See String.trim
on MDN.
RESJs.String.trim(" abc def ") == "abc def"
Js.String.trim("\n\r\t abc def \n\n\t\r ") == "abc def"
anchor
let anchor: (t, t) => t
link
let link: (t, t) => t
castToArrayLike
let castToArrayLike: t => Js_array2.array_like<t>
Casts its argument to an array_like entity that can be processed by functions
such as Js.Array2.fromMap()
RESlet s = "abcde"
let arr = Js.Array2.fromMap(Js.String.castToArrayLike(s), x => x)
arr == ["a", "b", "c", "d", "e"]
