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 `Library.string.sub()`.


string.byte

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.


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><code>c</code></td>
      <td>integer</td>
      <td></td>
      <td>3</td>
    </tr>
    <tr>
      <td><code>d</code> or <code>i</code></td>
      <td>integer</td>
      <td>Decimal representation.</td>
      <td> 321 </td>
    </tr>
    <tr>
      <td><code>e</code> or <code>E</code></td>
      <td>float</td>
      <td>Scientific notation using <code>e</code> or <code>E</code>.</td>
      <td>3.296e2<br>3.296E2</td>
    </tr>
    <tr>
      <td><code>f</code></td>
      <td>float</td>
      <td></td>
      <td>3231.1231</td>
    </tr>
    <tr>
      <td><code>g</code> or <code>G</code></td>
      <td>float</td>
      <td>The shorter of <code>e</code>/<code>E</code> and <code>f</code>.</td>
      <td>3E14<br>3e14</td>
    </tr>
    <tr>
      <td><code>o</code></td>
      <td>integer</td>
      <td>Octal representation.</td>
      <td>610</td>
    </tr>
    <tr>
      <td><code>q</code></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><code>s</code></td>
      <td>string</td>
      <td></td>
      <td>Hello world!</td>
    </tr>
    <tr>
      <td><code>u</code></td>
      <td>integer</td>
      <td>Decimal representation.</td>
      <td>3131</td>
    </tr>
    <tr>
      <td><code>x</code> or <code>X</code></td>
      <td>integer</td>
      <td>Hexadecimal representation.</td>
      <td>7fa<br>7FA</td>
    </tr>
    <tr>
      <td><code>*</code></td>
      <td>any</td>
      <td>Equivalent to <code>s</code> but accepts any variable by converting it to a string using <code>Global.LuaGlobals.tostring()</code>.</td>
      <td>table: 0x0123456789abcdef</td>
    </tr>
    <tr>
      <td><code>%</code></td>
      <td></td>
      <td><code>%</code> followed by another <code>%</code> will return the <code>%</code> 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><code>-</code></td>
    <td>Left-justify the given field width (see <code>Width</code> below). Right justification is the default.</td>
  </tr>
  <tr>
    <td><code>+</code></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><code>#</code></td>
    <td>When used with <code>o</code> and <code>x</code>/<code>X</code>, writes a 0 (octal) or 0x/0X (hex) before values other than zero.<br>When used with <code>e</code>/<code>E</code> and <code>f</code>, 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 <code>g</code> or <code>G</code>, the result is the same as with <code>e</code> or <code>E</code> but trailing zeros are not removed.</td>
  </tr>
  <tr>
    <td><code>0</code></td>
    <td>Left-pads the number with zeros instead of empty spaces (see <code>Width</code> 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><code>.</code>(number)</td>
      <td>For integer specifiers (<code>d</code>, <code>i</code>, <code>o</code>, <code>u</code>, <code>x</code>/<code>X</code>), 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 <code>e</code>/<code>E</code> and <code>f</code> specifiers, this is the number of digits to be printed after the decimal point.<br>For <code>g</code>/<code>G</code> specifiers, this is the maximum number of digits (before the <code>e</code>/<code>E</code>, if present).<br>For <code>s</code>, this is the maximum number of characters to be returned.<br>For <code>c</code> and <code>q</code>, 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 first
argument, `format`, determines the way the remaining arguments are packed;
see [here](https://www.lua.org/manual/5.3/manual.html#6.4.2) for options.


string.pack

format

Returns a binary string containing the provided arguments.


Returns the size in bytes of any string packed with a given description.
The sole argument, `format`, determines the way the remaining arguments
are packed, but you cannot use `s` and `z` because they have variable
lengths. See [here](https://www.lua.org/manual/5.3/manual.html#6.4.2) for
options.


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
first argument, `format`, which should match the one originally used to
`Library.string.pack|pack()` the string; see
[here](https://www.lua.org/manual/5.3/manual.html#6.4.2) for options. 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.


An object that runs connected functions upon a specific occurrence.

Data Type

RBXScriptSignal

Luau

Tuple

Variant

Data type having a value of either true or false.

bool

Functions are blocks of code that can execute multiple times on command.

function

A double-precision floating-point number.

number

A sequence of characters, such as letters, numbers, and symbols.

Data type which can store multiple values of any non-nil type, including booleans, numbers, strings, functions, and other tables.

table

개요

가이드

튜토리얼

참조

리소스

아트

디자인

엔진

Avatar

클라우드

이 필드는 리소스를 생성할 때 설정될 수 있지만 후속 요청에 의해 수정될 수는 없습니다.

이 필드는 요청에 제공될 수 있지만 응답에는 포함되지 않습니다.

각 API 키별: IP 주소당 {periodInSeconds}초마다 {maxInPeriod} 요청

이 필드는 요청에서 무시됩니다.

이 엔드포인트를 호출하려면 다음 API 키 권한이 필요합니다. 적절한 키 생성에 대한
자세한 내용은 [API 키 관리]({apiKeyReferenceDocLink})에서 확인하세요.

다음 끝점은 기준 URL과 관련된 경로에서 사용할 수 있습니다.

이 문자열은 [FieldMask](/cloud/reference/types#fieldmask) 형식으로 지정됩니다.

JSON 값은 `null`, `boolean`, `string`, `number`, `array`, `object`일 수 있습니다.

OAuth 2.0 애플리케이션에서 이 엔드포인트를 사용하려면 다음 범위가 필요합니다. OAuth 2.0 애플리케이션 등록 방법에 대한 자세한 내용은 [앱 등록 및 심사]({oauth2ReferenceDocLink})에서 확인하세요.

다음 개체는 수락되거나 반환되는 페이로드를 설명합니다. 이러한 개체가 사용되는 시기에 대한 자세한 정보는 각 개별 끝점을 참고하세요.

이 문자열은 [Timestamp](/cloud/reference/types#timestamp) 형식으로 지정됩니다.

이를 통해 애셋에 대한 정보를 볼 수 있습니다.

이를 통해 애셋을 Roblox에 업로드하고 업데이트할 수 있습니다.

이를 통해 크리에이터 상점 상품에 대한 정보를 볼 수 있습니다.

이를 통해 크리에이터 상점 상품에 대한 정보를 수정할 수 있습니다.

이를 통해 그룹에 대한 정보를 볼 수 있습니다.

이제 계정에 대한 그룹 가입 요청을 관리할 수 있습니다.

이를 통해 인벤토리에 대한 정보를 볼 수 있습니다.

사용자를 대신해 메시지를 게시할 수 있는 권한이 부여됩니다.

이를 통해 체험에서 사용자에게 알림을 보낼 수 있습니다

이를 통해 체험과 관련된 시크릿을 나열할 수 있습니다.

이를 통해 체험과 관련된 시크릿을 생성하고 업데이트할 수 있습니다.

플레이스 정보를 읽을 수 있는 권한을 부여합니다.

플레이스 정보를 편집할 수 있는 권한을 부여합니다.

이 작업은 새로운 버전의 체험을 Roblox에 게시할 수 있는 권한을 부여합니다.

체험 정보를 읽을 수 있는 권한을 부여합니다.

체험 정보를 편집할 수 있는 권한을 부여합니다.

Allows you to view user restrictions in the experience.

Allows you to edit user restrictions in the experience.

사용자의 Premium 및 인증 상태를 읽을 수 있는 권한을 부여합니다.

이를 통해 사용자의 소셜 계정을 볼 수 있습니다.

이 작업은 싱글 사인온 기능을 활성화합니다

프로필 정보를 읽을 수 있는 액세스 권한을 부여합니다

기본값: {defaultValueStart}{defaultValueEnd}

배열은 순서가 지정된 값 목록입니다. 배열은 데이터 컬렉션을 저장하는 데 유용합니다.

키-값 쌍 집합으로, 이때 키는 숫자, 문자열 또는 개체일 수 있습니다.

{tuples}(와)과 마찬가지로, 값의 목록입니다.

이 함수는 가능한 경우 즉시 반환하지만, 값을 반환할 수 있을 때까지 호출한 스레드를 일시 중단할 수 있습니다.

{nameStart}이름{nameEnd}(은)는 더 이상 Roblox에서 지원하거나 유지 관리하지 않습니다.

이 수학 연산은 더 이상 Roblox에서 지원하거나 유지 관리하지 않습니다.

이 멤버는 개체 브라우저에 표시되지 않으며 널리 사용하기 위한 것이 아닙니다.

이 멤버는 명령 모음을 통해서만 액세스할 수 있습니다. 스크립트에서 이 멤버에 액세스하려고 하면 오류가 발생합니다.

이 함수는 호출한 Lua 스레드를 일시 중지할 수 없습니다.

스크립트에서 이 멤버에 액세스하려고 하면 오류가 발생합니다. Roblox Studio의 속성 창에서 이 멤버에 액세스가 가능할 수 있습니다.

이 멤버는 Roblox Studio의 개체 브라우저에 표시되지 않습니다.

Instance.new 생성자로 이 클래스의 인스턴스를 만들 수 없습니다.

Roblox는 서버-클라이언트 경계를 넘어 이 멤버를 복제하지 않습니다.

Lua 코드는 이 멤버에 액세스할 수 없습니다. Roblox Studio의 속성 창에서 값의 변경이 가능할 수 있습니다.

이 개체의 복제 동작은 개체를 소유한 플레이어에 따라 다릅니다.

이 멤버는 명령 모음 및 플러그인을 통해서만 액세스할 수 있습니다. 스크립트에서 이 멤버에 액세스하려고 하면 오류가 발생합니다.

이 속성은 읽기 전용이며 동기화되지 않은 스레드에서 안전하게 읽을 수 있습니다. 쓰기를 시도하면 오류가 발생합니다.

이 멤버는 읽기 전용입니다. 이 멤버에 쓰려고 하면 오류가 발생합니다.

이 멤버는 CoreScript에서만 액세스할 수 있습니다.

Roblox CoreScript만 이 멤버에 액세스할 수 있으며, Players는 이를 사용할 수 없습니다.

여러 스레드에서 이 속성에 안전하게 읽고 쓸 수 있습니다.

이 클래스는 최상위 Singleton입니다. GetService 함수를 사용해 이 클래스의 인스턴스를 가져옵니다.

여러 스레드가 이 속성에 쓸 수 있으므로, 동기화되지 않은 스레드에서 읽는 것은 안전하지 않습니다.

이 함수는 결과를 반환할 때까지 호출한 Lua 스레드를 일시 중지합니다. 다른 스크립트를 방해하지 않습니다.

종합 가이드, 코드 샘플, 참조, 튜토리얼을 통해 Roblox에서 성공적인 콘텐츠를 만드는 방법에 대해 알아보세요.


{pageTitle} | {SiteName}

제목

인벤토리에 추가할 수 없습니다

코드 샘플 {title}(이)가 인벤토리에 추가되었습니다.

버전 {versionNumber}에는 일반적인 성능 개선 및 버그 수정이 포함되어 있습니다. 특정 개선 사항 및 버그에 대한 상태는 다른 릴리스 정보를 통해 확인하세요.

개인정보는 포함하지 마세요. 최대 {maxDescriptionLength} 단어까지 가능합니다.

설명에는 최소 {minDescriptionLength}단어를 입력해야 합니다.

Roblox Studio 버전 {versionNumber}의 릴리스 정보

더욱 멋진 Roblox 세상이 될 수 있도록 점검을 진행하고 있습니다. 양해해 주셔서 감사합니다.

'계속'을 클릭하면 {redirectLinkStart}{redirectLinkEnd}(으)로 이동하게 됩니다

본 사이트는 Roblox에서 소유 및 운영하지 않습니다. 약관 및 개인정보 처리방침이 다를 수 있습니다.

string

요약

함수

함수

byte

매개 변수

반환

char

매개 변수

반환

find

매개 변수

반환

format

매개 변수

반환

gmatch

매개 변수

반환

gsub

매개 변수

반환

len

매개 변수

반환

lower

매개 변수

반환

match

매개 변수

반환

pack

매개 변수

반환

packsize

매개 변수

반환

rep

매개 변수

반환

reverse

매개 변수

반환

split

매개 변수

반환

sub

매개 변수

반환

unpack

매개 변수

반환

upper

매개 변수

반환