The string library provides generic functions to manipulate strings, such as
to extract substrings or match patterns. You can access the string library by
the global `Library.string` library.

## String Patterns

A **string pattern** is a combination of characters that you can use with
`Library.string.match()`, `Library.string.gmatch()`, and other functions to
find a piece, or substring, of a longer string.

### Direct Matches

You can use direct matches in a Lua function like `Library.string.match()`,
except for [magic characters](#magic-character). For example, these commands
look for the word **Roblox** within a string:

```lua
local match1 = string.match("Welcome to Roblox!", "Roblox")
local match2 = string.match("Welcome to my awesome game!", "Roblox")
print(match1) -- Roblox
print(match2) -- nil
```

Notice that the first string has a match, so `Roblox` outputs to the Output
window, but the second string doesn't have a match, so `nil` outputs to the
Output window.

### Character Classes

Character classes are essential for more advanced string searches. You can use
them to search for something that isn't necessarily character-specific but
fits within a known category (class), including **letters**, **digits**,
**spaces**, **punctuation**, and more.

The following table shows the official character classes for Lua string
patterns:

<table>
  <thead>
    <th>Class</th>
    <th>Represents</th>
    <th>Example Match</th>
  </thead>
  <tbody>
    <tr>
      <td><code>.</code></td>
      <td>Any character</td>
      <td><code>32kasGJ1%fTlk?@94</code></td>
    </tr>
    <tr>
      <td><code>%a</code></td>
      <td>An uppercase or lowercase letter</td>
      <td><code>aBcDeFgHiJkLmNoPqRsTuVwXyZ</code></td>
    </tr>
    <tr>
      <td><code>%l</code></td>
      <td>A lowercase letter</td>
      <td><code>abcdefghijklmnopqrstuvwxyz</code></td>
    </tr>
    <tr>
      <td><code>%u</code></td>
      <td>An uppercase letter</td>
      <td><code>ABCDEFGHIJKLMNOPQRSTUVWXYZ</code></td>
    </tr>
    <tr>
      <td><code>%d</code></td>
      <td>Any digit (number)</td>
      <td><code>0123456789</code></td>
    </tr>
    <tr>
      <td><code>%p</code></td>
      <td>Any punctuation character</td>
      <td><code>!@#;,.</code></td>
    </tr>
    <tr>
      <td><code>%w</code></td>
      <td>An alphanumeric character (either a letter <b>or</b> a number)</td>
      <td><code>aBcDeFgHiJkLmNoPqRsTuVwXyZ0123456789</code></td>
    </tr>
    <tr>
      <td><code>%s</code></td>
      <td>A space or whitespace character</td>
      <td><code>&nbsp;</code>, <code>\n</code>, and <code>\r</code></td>
    </tr>
    <tr>
      <td><code>%c</code></td>
      <td>A special <a href="https://wikipedia.org/wiki/Control_character">control character</a></td>
      <td></td>
    </tr>
    <tr>
      <td><code>%x</code></td>
      <td>A hexadecimal character</td>
      <td><code>0123456789ABCDEF</code></td>
    </tr>
    <tr>
      <td><code>%z</code></td>
      <td>The NULL character (<code>\0</code>)</td>
      <td></td>
    </tr>
  </tbody>
</table>

For single-letter character classes such as `%a` and `%s`, the corresponding
uppercase letter represents the "opposite" of the class. For instance, `%p`
represents a punctuation character while `%P` represents all characters except
punctuation.

### Magic Characters

There are 12 "magic characters" which are reserved for special purposes in
patterns:

<table>
  <tbody>
    <tr>
      <td><code>$</code></td>
      <td><code>%</code></td>
      <td><code>^</code></td>
      <td><code>*</code></td>
      <td><code>(</code></td>
      <td><code>)</code></td>
    </tr>
    <tr>
      <td><code>.</code></td>
      <td><code>[</code></td>
      <td><code>]</code></td>
      <td><code>+</code></td>
      <td><code>-</code></td>
      <td><code>?</code></td>
    </tr>
  </tbody>
</table>

You can escape and search for magic characters using the `%` symbol. For
example, to search for **roblox.com**, escape the `.` (period) symbol by
preceding it with a `%` as in `%.`.

```lua
-- Incorrect: "roblox.com" matches "roblox#com" because the period is interpreted as "any character"
local match1 = string.match("What is roblox#com?", "roblox.com")
-- Correct: Escape the period with % so it is interpreted as a literal period character
local match2 = string.match("I love roblox.com!", "roblox%.com")
print(match1) -- roblox#com
print(match2) -- roblox.com
```

### Anchors

You can search for a pattern at the beginning or end of a string by using the
`^` and `$` symbols.

```lua
-- Using ^ to match the beginning of a string
local start1 = string.match("first second third", "^first")  -- Matches because "first" is at the beginning
local start2 = string.match("third second first", "^first")  -- Doesn't match because "first" isn't at the beginning
print(start1) -- first
print(start2) -- nil

-- Using $ to match the end of a string
local end1 = string.match("first second third", "third$")  -- Matches because "third" is at the end
local end2 = string.match("third second first", "third$")  -- Doesn't match because "third" isn't at the end
print(end1) -- third
print(end2) -- nil
```

You can also use both `^` and `$` together to ensure a pattern matches only
the full string and not just some portion of it.

```lua
-- Using both ^ and $ to match across a full string
local match1 = string.match("Roblox", "^Roblox$")  -- Matches because "Roblox" is the entire string (equality)
local match2 = string.match("I play Roblox", "^Roblox$")  -- Doesn't match because "Roblox" isn't at the beginning AND end
local match3 = string.match("I play Roblox", "Roblox")  -- Matches because "Roblox" is contained within "I play Roblox"
print(match1) -- Roblox
print(match2) -- nil
print(match3) -- Roblox
```

### Class Modifiers

By itself, a character class only matches **one** character in a string. For
instance, the following pattern (`"%d"`) starts reading the string from left
to right, finds the **first** digit (`2`), and stops.

```lua
local match = string.match("The Cloud Kingdom has 25 power gems", "%d")
print(match) -- 2
```

You can use **modifiers** with any character class to control the result:

<table>
  <thead>
    <th>Quantifier</th>
    <th>Meaning</th>
  </thead>
  <tbody>
    <tr>
      <td><code>+</code></td>
      <td>Match 1 or more of the preceding character class</td>
    </tr>
    <tr>
      <td><code>-</code></td>
      <td>Match as few of the preceding character class as possible</td>
    </tr>
    <tr>
      <td><code>*</code></td>
      <td>Match 0 or more of the preceding character class</td>
    </tr>
    <tr>
      <td><code>?</code></td>
      <td>Match 1 or less of the preceding character class</td>
    </tr>
    <tr>
      <td><code>%n</code></td>
      <td>For <code>n</code> between <b>1</b> and <b>9</b>, matches a substring equal to the <code>n</code>-th captured string.</td>
    </tr>
    <tr>
      <td><code>%bxy</code></td>
      <td>The balanced capture matching <code>x</code>, <code>y</code>, and everything between (for example, <code>%b()</code> matches a pair of parentheses and everything between them)</td>
    </tr>
  </tbody>
</table>

Adding a modifier to the same pattern (`"%d+"` instead of `"%d"`), outputs
`25` instead of `2`:

```lua
local match1 = string.match("The Cloud Kingdom has 25 power gems", "%d")
print(match1) -- 2
local match2 = string.match("The Cloud Kingdom has 25 power gems", "%d+")
print(match2) -- 25
```

### Class Sets

**Sets** should be used when a single character class can't do the whole job.
For instance, you might want to match both lowercase letters (`%l`) **and**
punctuation characters (`%p`) using a single pattern.

Sets are defined by brackets `[]` around them. In the following example,
notice the difference between using a set (`"[%l%p]+"`) and **not** using a
set (`"%l%p+"`).

```
local match1 = string.match("Hello!!! I am another string.", "[%l%p]+")  -- Set
local match2 = string.match("Hello!!! I am another string.", "%l%p+")    -- Non-set
print(match1) -- ello!!!
print(match2) -- o!!!
```

The first command (set) tells Lua to find both lowercase characters and
punctuation. With the `+` quantifier added after the entire set, it finds
**all** of those characters (`ello!!!`), stopping when it reaches the space.

In the second command (non-set), the `+` quantifier only applies to the `%p`
class before it, so Lua grabs only the first lowercase character (`o`) before
the series of punctuation (`!!!`).

Like character classes, sets can be "opposites" of themselves. This is done by
adding a `^` character at the beginning of the set, directly after the opening
`[`. For instance, `"[%p%s]+"` represents both punctuation and spaces, while
`"[^%p%s]+"` represents all characters **except** punctuation and spaces.

Sets also support **ranges** which let you find an entire range of matches
between a starting and ending character. This is an advanced feature which is
outlined in more detail on the
[Lua 5.1 Manual](https://www.lua.org/manual/5.1/manual.html#5.4.1).

### String Captures

String **captures** are sub-patterns within a pattern. These are enclosed in
parentheses `()` and are used to get (capture) matching substrings and save
them to variables. For example, the following pattern contains two captures,
`(%a+)` and `(%d+)`, which return two substrings upon a successful match.

```lua
local pattern = "(%a+)%s?=%s?(%d+)"

local key1, val1 = string.match("TwentyOne = 21", pattern)
print(key1, val1) -- TwentyOne 21

local key2, val2 = string.match("TwoThousand= 2000", pattern)
print(key2, val2) -- TwoThousand 2000

local key3, val3 = string.match("OneMillion=1000000", pattern)
print(key3, val3) -- OneMillion 1000000
```

In the previous pattern, the `?` quantifier that follows both of the `%s`
classes is a safe addition because it makes the space on either side of the
`=` sign optional. That means the match succeeds if one (or both) spaces are
missing around the equal sign.

String captures can also be **nested** as the following example:

```lua
local places = "The Cloud Kingdom is heavenly, The Forest Kingdom is peaceful"
local pattern = "(The%s(%a+%sKingdom)[%w%s]+)"

for description, kingdom in string.gmatch(places, pattern) do
  print(description)
  print(kingdom)
end
--[[Expected Output:
The Cloud Kingdom is heavenly
Cloud Kingdom
The Forest Kingdom is peaceful
Forest Kingdom
]]
```

This pattern search works as follows:

The `Library.string.gmatch()` iterator looks for a match on the entire
"description" pattern defined by the outer pair of parentheses. This stops at
the first comma and captures the following:

<table>
    <thead>
        <tr>
            <th width="8%">#</th>
            <th width="42%">Pattern</th>
            <th>Capture</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><b>1</b></td>
            <td><code>(The%s(%a+%sKingdom)[%w%s]+)</code></td>
            <td>The Cloud Kingdom is heavenly</td>
        </tr>
    </tbody>
</table>

Using its successful first capture, the iterator then looks for a match on the
"kingdom" pattern defined by the inner pair of parentheses. This nested
pattern simply captures the following:

<table>
    <thead>
        <tr>
            <th width="8%">#</th>
            <th width="42%">Pattern</th>
            <th>Capture</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><b>2</b></td>
            <td><code>(%a+%sKingdom)</code></td>
            <td>Cloud Kingdom</td>
        </tr>
    </tbody>
</table>

The iterator then backs out and continues searching the full string, capturing
the following:

<table>
    <thead>
        <tr>
            <th width="8%">#</th>
            <th width="42%">Pattern</th>
            <th>Capture</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><b>3</b></td>
            <td><code>(The%s(%a+%sKingdom)[%w%s]+)</code></td>
            <td>The Forest Kingdom is peaceful</td>
        </tr>
        <tr>
            <td><b>4</b></td>
            <td><code>(%a+%sKingdom)</code></td>
            <td>Forest Kingdom</td>
        </tr>
    </tbody>
</table>


Returns the internal numerical codes of the characters
`s[i], s[i+1], ..., s[j]`. The default value for `i` is 1; the default
value for `j` is `i`. These indices are corrected following the same rules
of function string.sub.


string.byte

Receives zero or more integers and returns a string with length equal to
the number of arguments that has each character has the internal numerical
code equal to its corresponding argument.


string.char

Looks for the first match of pattern in the string `s`. If it finds a
match, then it returns the indices of `s` where the occurrence starts and
ends; otherwise, it returns nil. A third, optional numerical argument init
specifies where to start the search; its default value is 1 and can be
negative. A value of true as a fourth, optional argument plain turns off
the pattern matching facilities, so the function does a plain "find
substring" operation, with no characters in the pattern being considered
"magic". Note that if _plain_ is given, then _init_ must be given as well.


string.find

pattern

init

plain

Looks for the first match of pattern in the string `s` and returns the
indices of `s` where the occurrence starts and ends.


Returns a formatted version of its variable number of arguments following
the description given in its first argument, which must be a string.

You can convert variables into user-friendly strings of text using the
`Library.string.format()` function. The function requires the following
format:

`%[flags][width].[precision][specifier]`.

#### Specifiers

The most important part of string formatting is the **specifiers**.

<table>
  <thead>
    <tr>
      <th>Specifier</th>
      <th>Accepts</th>
      <th>Outputs</th>
      <th>Example Output</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><b>c</b></td>
      <td>integer</td>
      <td></td>
      <td>3</td>
    </tr>
    <tr>
      <td><b>d</b> or <b>i</b></td>
      <td>integer</td>
      <td>Decimal representation.</td>
      <td> 321 </td>
    </tr>
    <tr>
      <td><b>e</b> or <b>E</b></td>
      <td>float</td>
      <td>Scientific notation using <b>e</b> or <b>E</b>.</td>
      <td>3.296e2<br>3.296E2</td>
    </tr>
    <tr>
      <td><b>f</b></td>
      <td>float</td>
      <td></td>
      <td>3231.1231</td>
    </tr>
    <tr>
      <td><b>g</b> or <b>G</b></td>
      <td>float</td>
      <td>The shorter of <b>e</b>/<b>E</b> and <b>f</b>.</td>
      <td>3E14<br>3e14</td>
    </tr>
    <tr>
      <td><b>o</b></td>
      <td>integer</td>
      <td>Octal representation.</td>
      <td>610</td>
    </tr>
    <tr>
      <td><b>q</b></td>
      <td>string</td>
      <td>String in a form suitable to be safely read back by the Lua interpreter. The string is written between double quotes and all double quotes, new lines, embedded zeros, and backslashes are correctly escaped.</td>
      <td>"print(\"Hi\")"</td>
    </tr>
    <tr>
      <td><b>s</b></td>
      <td>string</td>
      <td></td>
      <td>Hello world!</td>
    </tr>
    <tr>
      <td><b>u</b></td>
      <td>integer</td>
      <td>Decimal representation.</td>
      <td>3131</td>
    </tr>
    <tr>
      <td><b>x</b> or <b>X</b></td>
      <td>integer</td>
      <td>Hexadecimal representation.</td>
      <td>7fa<br>7FA</td>
    </tr>
    <tr>
      <td><b>%</b></td>
      <td></td>
      <td><b>%</b> followed by another <b>%</b> will return the <b>%</b> sign itself.</td>
      <td>%</td>
    </tr>
  </tbody>
</table>

```
local str = "The magic word is %s"
print(string.format(str, "Roblox"))
-- The magic word is Roblox

local str = "The magic word is %q"
print(string.format(str, "Roblox"))
-- The magic word is "Roblox"

local str = "Skip to \na new line and \nanother new line!"
print(string.format(str, "%q"))
--[[ Output:
Skip to
a new line and
another new line!
]]
```

#### Flags

<table>
<thead>
  <tr>
    <th>Flag</th>
    <th>Description</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td><b>-</b></td>
    <td>Left-justify the given field width (see <b>Width</b> below). Right justification is the default.</td>
  </tr>
  <tr>
    <td><b>+</b></td>
    <td>Forces a "+" sign to precede a number. Has no effect on negative numbers.</td>
  </tr>
  <tr>
    <td>(space)</td>
    <td>One blank space is inserted before a positive number, while negative numbers are unaffected. This is useful for making positive and negative numbers vertically align in a visual stacked list.</td>
  </tr>
  <tr>
    <td><b>#</b></td>
    <td>When used with <b>o</b> and <b>x</b>/<b>X</b>, writes a 0 (octal) or 0x/0X (hex) before values other than zero.<br>When used with <b>e</b>/<b>E</b> and <b>f</b>, forces the output to contain a decimal point, even if no digits would follow (by default, no decimal point is written if no digits follow).<br>When used with <b>g</b> or <b>G</b>, the result is the same as with <b>e</b> or <b>E</b> but trailing zeros are not removed.</td>
  </tr>
  <tr>
    <td><b>0</b></td>
    <td>Left-pads the number with zeros instead of empty spaces (see <b>Width</b> below).</td>
  </tr>
</tbody>
</table>

```lua
local str = "%-10d"
print(string.format(str, 300) .. "]")
-- 300       ]
-- There are 7 spaces between '300' and ']'

local str = "%+i versus %+i"
print(string.format(str, 300, -300)) -- +300 versus -300

local str = "There is a% i%% chance of rain in Seattle today."
print(string.format(str, 100))
-- There is a 100% chance of rain in Seattle today.
```

#### Width

<table>
  <thead>
    <tr>
      <th>Width</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>(number)</td>
      <td>Minimum number of characters to return. If the number of characters to be formatted is less than this number, the result is padded with blank spaces.</td>
    </tr>
  </tbody>
</table>

```lua
local str = "%012i"
print("Score: " .. string.format(str, 15000))
-- Output: Score: 000000015000
-- The output has 12 digits total, left-padded with zeros
```

#### Precision

The default precision is 1. If you give a period without a value, the
default is 0.

<table>
  <thead>
    <tr>
      <th>Precision</th>
      <th>Description</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><b>.</b>(number)</td>
      <td>For integer specifiers (<b>d</b>, <b>i</b>, <b>o</b>, <b>u</b>, <b>x</b>/<b>X</b>), precision specifies the minimum number of digits to be returned. If the value to be formatted is shorter than this number, the result is padded with leading zeros. A precision of 0 means that no character is written for the value 0.<br>For <b>e</b>/<b>E</b> and <b>f</b> specifiers, this is the number of digits to be printed after the decimal point.<br>For <b>g</b>/<b>G</b> specifiers, this is the maximum number of digits (before the <b>e</b>/<b>E</b>, if present).<br>For <b>s</b>, this is the maximum number of characters to be returned.<br>For <b>c</b> and <b>q</b>, this has no effect.</td>
    </tr>
  </tbody>
</table>

```lua
-- Add decimal with precision of 2 for a currency output
local str = "$%.2f"
print(string.format(str, 300)) -- Output: $300.00

-- Return first 6 letters of a string
local str = "%.6s"
print(string.format(str, "Robloxian")) -- Output: Roblox

local str = "Once upon a time, there was a dragon named %s and it had %.8f horns."
print(string.format(str, "Pi", math.pi))
-- Output: Once upon a time, there was a dragon named Pi and it had 3.14159265 horns.
```


string.format

formatstring

Returns a formatted version of its variable number of arguments following
the description given in its first argument, which must be a string.


Returns an iterator function that returns the next captures from pattern
over the string `s` each time it's called.


string.gmatch

Short for global substitution. Returns a copy of `s` in which all (or the
first n, if given) occurrences of the pattern are substituted (replaced)
with the given `replacement`. The second value returned is the total
number of substitutions made.

The `replacement` can be one of several types, each used differently to
determine the actual string:

- string: The pattern is replaced with the string directly
- table: The string that matched the pattern is looked up in the table as
  a key, and the value (string) is what replaces it, if it exists.
- function: Called with the string that matched the pattern, should return
  the string to replace the matched pattern.

An optional final argument can be provided which specifies the maximum
number of substitutions to make (for example, stop after 2 replacements)

#### Various Examples

```lua
-- Simple replacement
string.gsub("I love tacos!", "tacos", "Roblox") --> I love Roblox! 1
-- Using a pattern (hint: %w+ matches whole words)
string.gsub("I like red!", "%w+", "word") --> word word word 3
-- Replacement table
string.gsub("I play Roblox.", "%w+", {I="Je", play="joue à"}) --> Je joue à Roblox. 3
-- Replacement function
string.gsub("I have 2 cats.", "%d+", function (n) return tonumber(n) * 12 end) --> I have 24 cats. 1
-- Replace only twice
string.gsub("aaa", "a", "b", 2) --> "bba", 2
```


string.gsub

The string whose occurrences of the given pattern shall be replaced.


replacement

Determines what should replace the occurrence(s) of the given pattern.


replacements

The maximum number of substitutions to make.


Returns a copy of `s` in which all or the first `n` occurrences of the
pattern are replaced with the given replacement. The second value returned
is the total number of substitutions made.


string.len

Returns a copy of a string with all uppercase letters changed to
lowercase.


string.lower

Looks for the first match of pattern in the string `s`. If a match is
found, it is returned; otherwise, it returns nil. A third, optional
numerical argument, init, specifies where to start the search; its default
value is 1 and can be negative.


string.match

Looks for the first match of pattern in the string `s`. If a match is
found, it is returned; otherwise, it returns nil. A third, optional
numerical argument, init, specifies where to start the search.


Returns a binary string containing the provided arguments. The description
in the first argument, which must be a string, determines the way the
remaining arguments are packed.


string.pack

format

Returns a binary string containing the provided arguments.


Returns the size in bytes of any string packed with a given description.
You can't use `s` and `z` because they have variable lengths.


string.packsize

Returns the size in bytes of any string packed with a given description.


Returns a string that is the concatenation of `n` copies of the string
`s`.


string.rep

Returns a string that is the string `s` reversed.


string.reverse

Splits a string into parts based on the defined separator character(s),
returning a table of ordered results.

If an empty "slice" is located, that part will be returned as an empty
string. For instance `string.split("abc||def", "|")` will return a table
with three strings: `"abc"`, `""`, and `"def"`.

```lua
local values = input:split(",")
print(values[1], values[2], values[3])
```

Also note that whitespace from the original string will be preserved, for
example `string.split("abc _ def", "_")` will honor the whitespace on both
sides of the `_` separator. By default, the separator character is `,` but
you can specify an alternative character or series of characters.

**Corner Cases**

#### Empty String

```lua
"" --> ""
```

#### Empty Slices

```lua
"foo,,bar" --> "foo", "", "bar"
",foo" --> "", "foo"
"foo," --> "foo", ""
"," --> "", ""
",," --> "", "", ""
```

#### Whitespace Preserved

```lua
"   whitespace   " --> "   whitespace   "
"foo , bar" --> "foo ", " bar"
```

#### Invalid UTF-8

```lua
"\xFF" --> "\xFF"
"\xFD,\xFE" --> "\xFD", "\xFE"
```

#### Unicode

```lua
"，" --> U+FF0C FULLWIDTH COMMA
"我很高兴，你呢？" --> "我很高兴", "你呢？"
"•" --> U+2022 BULLET
"hello•world" --> "hello", "world"
```


string.split

separator

The separator character(s) to be used for splitting the string.


Splits a string into parts based on the defined separator character(s),
returning a table of ordered results.


Returns the substring of `s` that starts at `i` and continues until j. `i`
and `j` can be negative. `i` defaults to 1 and `j` defaults to `-1`.


string.sub

Extracts the values packed in the provided binary string based on the
description in the first argument. The description should match the one
originally used to pack the string. The optional third parameter
determines the byte at which the reading starts.


string.unpack

data

readStart

The values packed into the provided binary string, plus the index of
the first unread byte.


Extracts the values packed in the provided binary string.


Returns a copy of a string with all lowercase letters changed to
uppercase.


string.upper

string

Provides generic functions to manipulate strings.


Default Value: {defaultValueStart}{defaultValueEnd}

This function returns immediately if possible, but can yield the thread that called it until it can return a value.

This member doesn’t appear in the object browser and is not intended for widespread use.

This member is only accessible only through the command bar. Attempting to access this member from scripts causes an error.

This function can’t pause the Lua thread that called it.

Attempting to access this member in scripts causes an error. You might be able to access this member from Roblox Studio's property window.

This member doesn’t appear in Roblox Studio’s Object Browser.

You can’t create an instance of this class with the Instance.new constructor.

Roblox does not replicate this member across its server-client boundary.

Lua code can’t access this member. You might be able to change its value from the property window in Roblox Studio.

This object’s replication behavior is dependent on the player who owns it.

This member is accessible only through the command bar and plugins only. Attempting to access this member from scripts causes an error.

This property is read-only and is safe to read in unsynchronized threads. Attempting to write to it causes an error.

This member is read only. Attempting to write to this member causes an error.

This member is accessible only in CoreScripts.

Only Roblox CoreScripts can access this member, and it isn’t usable by Players.

You can read and write to this property safely from multiple threads.

This class is a top-level singleton. Retrieve an instance of this class with the GetService function.

Multiple threads can potentially write to this property, so it’s unsafe to read from unsynchronized threads.

This function pauses the Lua thread that called it until it returns a result. This doesn’t interrupt other scripts.

{pageTitle} | {SiteName}

We’re making things more awesome. Thanks for your patience.

By clicking "Continue", you will be directed to {redirectLinkStart}{redirectLinkEnd}

This site is not owned or operated by Roblox. They may have different terms and privacy policies.

string

Summary

Functions

Functions

byte

Parameters

Returns

char

Parameters

Returns

find

Parameters

Returns

format

Parameters

Returns

gmatch

Parameters

Returns

gsub

Parameters

Returns

len

Parameters

Returns

lower

Parameters

Returns

match

Parameters

Returns

pack

Parameters

Returns

packsize

Parameters

Returns

rep

Parameters

Returns

reverse

Parameters

Returns

split

Parameters

Returns

sub

Parameters

Returns

unpack

Parameters

Returns

upper

Parameters

Returns