API / Js / String

String

JavaScript String API

t

RESCRIPT
type t = string

make

RESCRIPT
let make: 'a => t

make(value) converts the given value to a string.

Examples

RESCRIPT
Js.String2.make(3.5) == "3.5" Js.String2.make([1, 2, 3]) == "1,2,3"

fromCharCode

RESCRIPT
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.

Examples

RESCRIPT
Js.String2.fromCharCode(65) == "A" Js.String2.fromCharCode(0x3c8) == `ψ` Js.String2.fromCharCode(0xd55c) == `한` Js.String2.fromCharCode(-64568) == `ψ`

fromCharCodeMany

RESCRIPT
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

RESCRIPT
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.

Examples

RESCRIPT
Js.String2.fromCodePoint(65) == "A" Js.String2.fromCodePoint(0x3c8) == `ψ` Js.String2.fromCodePoint(0xd55c) == `한` Js.String2.fromCodePoint(0x1f63a) == `😺`

fromCodePointMany

RESCRIPT
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.

Examples

RESCRIPT
Js.String2.fromCodePointMany([0xd55c, 0xae00, 0x1f63a]) == `한글😺`

length

RESCRIPT
let length: t => int

length(s) returns the length of the given string. See String.length on MDN.

Examples

RESCRIPT
Js.String2.length("abcd") == 4

get

RESCRIPT
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>.

Examples

RESCRIPT
Js.String2.get("Reason", 0) == "R" Js.String2.get("Reason", 4) == "o" Js.String2.get(`Rẽasöń`, 5) == `ń`

charAt

RESCRIPT
let charAt: (int, t) => t

charCodeAt

RESCRIPT
let charCodeAt: (int, t) => float

codePointAt

RESCRIPT
let codePointAt: (int, t) => option<int>

concat

RESCRIPT
let concat: (t, t) => t

concatMany

RESCRIPT
let concatMany: (array<t>, t) => t

endsWith

RESCRIPT
let endsWith: (t, t) => bool

endsWithFrom

RESCRIPT
let endsWithFrom: (t, int, t) => bool

includes

RESCRIPT
let includes: (t, t) => bool

includesFrom

RESCRIPT
let includesFrom: (t, int, t) => bool

indexOf

RESCRIPT
let indexOf: (t, t) => int

indexOfFrom

RESCRIPT
let indexOfFrom: (t, int, t) => int

lastIndexOf

RESCRIPT
let lastIndexOf: (t, t) => int

lastIndexOfFrom

RESCRIPT
let lastIndexOfFrom: (t, int, t) => int

localeCompare

RESCRIPT
let localeCompare: (t, t) => float

match_

RESCRIPT
let match_: (Js_re.t, t) => option<array<option<t>>>

normalize

RESCRIPT
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

RESCRIPT
let normalizeByForm: (t, t) => t

repeat

RESCRIPT
let repeat: (int, t) => t

replace

RESCRIPT
let replace: (t, t, t) => t

replaceByRe

RESCRIPT
let replaceByRe: (Js_re.t, t, t) => t

unsafeReplaceBy0

RESCRIPT
let unsafeReplaceBy0: (Js_re.t, (t, int, t) => t, t) => t

unsafeReplaceBy1

RESCRIPT
let unsafeReplaceBy1: (Js_re.t, (t, t, int, t) => t, t) => t

unsafeReplaceBy2

RESCRIPT
let unsafeReplaceBy2: (Js_re.t, (t, t, t, int, t) => t, t) => t

unsafeReplaceBy3

RESCRIPT
let unsafeReplaceBy3: (Js_re.t, (t, t, t, t, int, t) => t, t) => t
RESCRIPT
let search: (Js_re.t, t) => int

slice

RESCRIPT
let slice: (~from: int, ~to_: int, t) => t

sliceToEnd

RESCRIPT
let sliceToEnd: (~from: int, t) => t

split

RESCRIPT
let split: (t, t) => array<t>

splitAtMost

RESCRIPT
let splitAtMost: (t, ~limit: int, t) => array<t>

splitByRe

RESCRIPT
let splitByRe: (Js_re.t, t) => array<option<t>>

splitByReAtMost

RESCRIPT
let splitByReAtMost: (Js_re.t, ~limit: int, t) => array<option<t>>

startsWith

RESCRIPT
let startsWith: (t, t) => bool

startsWithFrom

RESCRIPT
let startsWithFrom: (t, int, t) => bool

substr

RESCRIPT
let substr: (~from: int, t) => t

substrAtMost

RESCRIPT
let substrAtMost: (~from: int, ~length: int, t) => t

substring

RESCRIPT
let substring: (~from: int, ~to_: int, t) => t

substringToEnd

RESCRIPT
let substringToEnd: (~from: int, t) => t

toLowerCase

RESCRIPT
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.

Examples

RESCRIPT
Js.String.toLowerCase("ABC") == "abc" Js.String.toLowerCase(`ΣΠ`) == `σπ` Js.String.toLowerCase(`ΠΣ`) == `πς`

toLocaleLowerCase

RESCRIPT
let toLocaleLowerCase: t => t

toLocaleLowerCase(str) converts str to lower case using the current locale.

See String.toLocaleLowerCase on MDN.

toUpperCase

RESCRIPT
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.

Examples

RESCRIPT
Js.String.toUpperCase("abc") == "ABC" Js.String.toUpperCase(`Straße`) == `STRASSE` Js.String.toUpperCase(`πς`) == `ΠΣ`

toLocaleUpperCase

RESCRIPT
let toLocaleUpperCase: t => t

toLocaleUpperCase(str) converts str to upper case using the current locale.

See String.to:LocaleUpperCase on MDN.

trim

RESCRIPT
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.

Examples

RESCRIPT
Js.String.trim(" abc def ") == "abc def" Js.String.trim("\n\r\t abc def \n\n\t\r ") == "abc def"

anchor

RESCRIPT
let anchor: (t, t) => t
RESCRIPT
let link: (t, t) => t

castToArrayLike

RESCRIPT
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()

Examples

RESCRIPT
let s = "abcde" let arr = Js.Array2.fromMap(Js.String.castToArrayLike(s), x => x) arr == ["a", "b", "c", "d", "e"]