Sets the value for all keys within the given table to nil. This causes the
`#` operator to return `0` for the given table. The allocated capacity of
the table's array portion is maintained, which allows for efficient re-use
of the space.

```lua
local grades = {95, 82, 71, 92, 100, 60}
print(grades[4], #grades) --> 92, 6
table.clear(grades)
print(grades[4], #grades) --> nil, 0
-- If grades is filled again with the same number of entries,
-- no potentially expensive array resizing will occur
-- because the capacity was maintained by table.clear.
```

This function does not delete/destroy the table provided to it. This
function is meant to be used specifically for tables that are to be
re-used.


table.clear

table

Sets all keys in the given table to nil.


Returns an unfrozen shallow copy of the provided table.


table.clone

Returns a shallow copy of the provided table.


Given an array where all elements are strings or numbers, returns the
string `t[i] ... sep ... t[i+1] ... sep ... t[j]`. The default value for
sep is an empty string, the default for `i` is 1, and the default for `j`
is #t. If i is greater than `j`, returns the empty string.


table.concat

The table that will be converted into a string.


The string that will be concatenated between each entry in the table.


The starting index of the table concatenation.


The ending index of the table concatenation.


Returns the given range of table elements as a string where each element
is separated by the given separator.


Creates a table with the array portion allocated to the given `number` of
elements, optionally filled with the given `value`.

```lua
local t = table.create(3, "Roblox")
print(table.concat(t)) --> RobloxRobloxRoblox
```

If you are inserting into large array-like tables and are certain of a
reasonable upper limit to the number of elements, it's recommended to use
this function to initialize the table. This ensures the table's array
portion of its memory is sufficiently sized, as resizing it can be
expensive. For small quantities this is typically not noticeable.


table.create

count

value

Returns a new table populated with many instances of the specified value.


Within the given array-like table `haystack`, find the first occurrence of
value `needle`, starting from index `init` or the beginning if not
provided. If the value is not found, `nil` is returned.

A [linear search](https://en.wikipedia.org/wiki/Linear_search) algorithm
is performed.

```lua
local t = {"a", "b", "c", "d", "e"}
print(table.find(t, "d")) --> 4
print(table.find(t, "z")) --> nil, because z is not in the table
print(table.find(t, "b", 3)) --> nil, because b appears before index 3
```


table.find

haystack

needle

init

Returns the index of the first occurrence of `needle` within `haystack`
starting from `init`.


Iterates over the provided table, passing the key and value of each
iteration over to the provided function.


table.foreach

The function that will be used for the iteration. This function will
receive 2 arguments for each iteration, where the 1st argument is the
key, and the 2nd argument is the value.


This is similar to table.foreach() except that index-value pairs are
passed, not key-value pairs.


table.foreachi

The function that will be used for the iteration. This function will
receive 2 arguments for each iteration, where the 1st argument is the
index, and the 2nd argument is the value.


Similar to table.foreach() except index-value pairs are passed instead of
key-value pairs.


This function makes the given table read-only, effectively "freezing" it
in its current state. Attempting to modify a frozen table throws an error.

This freezing effect is shallow, which means that you can write to a table
within a frozen table. To deep freeze a table, call this function
recursively on all of the descending tables.


table.freeze

Returns the number of elements in the table passed.


table.getn

Inserts the provided value to the target position of the array.


table.insert

The position at which the value will be inserted.


The value that will be appended to the table.


Appends the provided value to the end of the array.


This function returns `true` if the given table is frozen and `false` if
it isn't frozen. You can freeze tables using `Library.table.freeze()`.


table.isfrozen

Whether the table is frozen from `Library.table.freeze()`.


Returns `true` if the given table is frozen and `false` if it isn't
frozen.


Returns the maximum numeric key of the provided table, or zero if the
table has no numeric keys. Gaps in the table are ignored.


table.maxn

Returns the maximum numeric key of the provided table, or zero if the
table has no numeric keys.


Copies elements from table `src` into table `dst`. Is equivalent to the
multiple assignment statement: `dst[t], ... = src[a], ..., src[b]`.

The default for `dst` is `src`. The destination range may overlap with the
source range.

Returns `dst` for convenience.


table.move

Copies the specified range of elements from one table to another.


Returns a new table with all arguments stored into keys 1, 2, etc. and
with a field "n" with the total number of arguments. Note that the
resulting table may not be a sequence.

```lua
local t = table.pack(1, 2, 3)
print(table.concat(t, ", ")) --> 1, 2, 3
```


table.pack

values...

Returns a new table containing the provided values.


Removes from array t the element at position pos, returning the value of
the removed element. When pos is an integer between `1` and `#t`, it
shifts down the elements `t[pos+1], t[pos+2], ..., t[#t]` and erases
element `t[#t]`. The index `pos` can also be `0` when `#t` is `0` or
`#t+1`; in those cases, the function erases the element `t[pos]``.


table.remove

The table that is having an element removed.


Removes the specified element from the array, shifting later elements down
to fill in the empty space if possible.


Sorts elements of array t in a given order, from `t[1]` to `t[#t]`. If
`comp` is given, then it must be a function that receives two elements and
returns true when the first element must come before the second in the
final order (so that not `comp(t[i+1],t[i])` will be true after the sort).
If `comp` is not given, then the standard Lua operator `<` is used
instead.


table.sort

comp

An optional comparison function to be used when comparing elements in
the table. This function receives two elements, `a` and `b`, and
should return true if `a < b`.


Sorts table elements using the provided comparison function or the `<`
operator.


Returns the elements from the given list. By default, `i` is 1 and `j` is
the length of `list`.

Note that this same functionality is also provided by the global
`Global.LuaGlobals.unpack()` function.


table.unpack

list

The index of the first element to unpack.


The index of the last element to unpack.


Returns all elements from the given list as a tuple.


Luau

Array

An object that runs connected functions upon a specific occurrence.

Data Type

RBXScriptSignal

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.

string

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

void

Panoramica

Guide

Tutorial

Referenza

Risorse

Arte

Design

Motore

Avatar

Cloud

This field may be set when creating a resource, but may not be modified by subsequent requests.

This field may be provided in requests, but will never be included in responses.

Per chiave API: {maxInPeriod} richieste ogni {periodInSeconds} secondi per indirizzo IP

This field may be set on responses, but will be ignored in requests.

Per chiamare questo endpoint sono richiesti i seguenti permessi della chiave API. Per maggiori informazioni
sulla generazione delle chiavi corrette, vedere [Gestione delle chiavi API]({apiKeyReferenceDocLink}).

I seguenti endpoint sono disponibili nei percorsi relativi all'URL di base.

Questa stringa è formattata come [Timestamp](/cloud/reference/types#timestamp).

Un valore JSON può essere `null`, `boolean`, `string`, `number`, `array`, or `object`.

Per utilizzare questo endpoint sono necessari i seguenti ambiti per la tua applicazione OAuth 2.0. Per ulteriori informazioni su come registrare un'applicazione OAuth 2.0, vedere [Registrazione e revisione dell'app]({oauth2ReferenceDocLink}).

Gli oggetti seguenti descrivono i payloads accettati o restituiti. Per maggiori informazioni su quando vengono utilizzati questi oggetti, consultare ogni singolo endpoint.

Questo permette di visualizzare informazioni sui tuoi beni.

Questo permette di caricare e aggiornare gli asset su Roblox.

This allows you to view information about your Creator Store products.

This allows you to modify information about your Creator Store products.

Questo permette di vedere le informazioni sui tuoi Gruppi.

This allows you to manage group join requests for your account.

Ciò garantisce la possibilità di pubblicare messaggi per conto degli utenti.

This allows sending notifications from your experience to users

Questo permette di elencare i segreti associati alla tua esperienza.

Ciò consente di creare e aggiornare i segreti associati alla tua esperienza.

Grants the ability to read place information.

Grants the ability to edit place information.

Questa operazione consente di pubblicare nuove versioni di esperienze a Roblox.

Grants the ability to read experience information.

Grants the ability to edit experience information.

Consente di visualizzare le restrizioni degli utenti nell'esperienza.

Grants the ability to read user's premium and verified status.

This allows you to view a user's social accounts.

Questo garantisce l'accesso alla lettura delle informazioni del tuo profilo

Valore predefinito: {defaultValueStart}{defaultValueEnd}

An array is an ordered list of values. Arrays are useful for storing collections of data.

A set of key-value pairs, where the keys can be any number, string, or object.

Questa funzione restituisce immediatamente, se possibile, ma può restituire il thread che lo ha chiamato fino a quando non può restituire un valore.

{nameStart}nome{nameEnd} non è più supportato o mantenuto da Roblox.

Questa operazione matematica non è più supportata o mantenuta da Roblox.

Questo membro non appare nel browser degli oggetti e non è destinato ad un uso diffuso.

Questo membro è accessibile solo tramite la barra dei comandi. Il tentativo di accedere a questo membro dagli script provoca un errore.

Questa funzione non può mettere in pausa il thread di Lua che l'ha chiamato.

Il tentativo di accedere a questo membro negli script causa un errore. Potresti essere in grado di accedere a questo membro dalla finestra delle proprietà di Roblox Studio.

Questo membro non appare nel browser degli oggetti di Roblox Studio.

Non è possibile creare un'istanza di questa classe con il Instance.new constructor.

Roblox non replica questo membro attraverso il suo confine server-client.

Il codice Lua non può accedere a questo membro. Potresti cambiare il suo valore dalla finestra di proprietà in Roblox Studio.

Il comportamento di replica di questo oggetto dipende dal giocatore che lo possiede.

Questo membro è accessibile solo attraverso la barra dei comandi e solo i plugin. Tentando di accedere a questo membro dagli script provoca un errore.

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

Questa proprietà è in sola lettura ed è sicura da leggere in thread non sincronizzati. Tentando di scriverci causa un errore.

Questo membro è in sola lettura. Tentando di scrivere a questo membro causa un errore.

Questo membro è accessibile solo in CoreScripts.

Solo Roblox CoreScripts può accedere a questo membro e non è utilizzabile dai giocatori.

È possibile leggere e scrivere a questa proprietà in modo sicuro da più thread.

Questa classe è un singleton di primo livello. Recupera un'istanza di questa classe con la funzione GetService.

Più thread possono potenzialmente scrivere su questa proprietà, quindi non è sicuro leggere da thread non sincronizzati.

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

Questa funzione interrompe il thread di Lua che lo chiamava fino a quando non restituisce un risultato. Questo non interrompe altri script.

Scopri come creare contenuti di successo su Roblox con guide complete, esempi di codice, riferimenti e tutorial.


{pageTitle} | {SiteName}

title

Impossibile aggiungere all'inventario

L'esempio di codice {title} è stato aggiunto al tuo inventario.

La versione {versionNumber} include miglioramenti generali delle prestazioni e correzioni di bug. Controlla le nostre altre note di rilascio per lo stato su miglioramenti specifici e bug.

Si prega di non includere informazioni private o personali. Massimo {maxDescriptionLength} parole.

Minimo {minDescriptionLength} parole richieste nella descrizione.

Note di rilascio per la versione Roblox Studio {versionNumber}

Stiamo rendendo tutto più fantastico. Grazie per la tua pazienza.

Cliccando su "Continua", sarai indirizzato a {redirectLinkStart}{redirectLinkEnd}

Questo sito non è di o gestito da Roblox. Possono avere termini e privacy policy diversi.

table

Sommario

Funzioni

Funzioni

clear

Parametri

Restituzioni

clone

Parametri

Restituzioni

concat

Parametri

Restituzioni

create

Parametri

Restituzioni

find

Parametri

Restituzioni

foreach

Parametri

Restituzioni

foreachi

Parametri

Restituzioni

freeze

Parametri

Restituzioni

getn

Parametri

Restituzioni

insert

Parametri

Restituzioni

insert

Parametri

Restituzioni

isfrozen

Parametri

Restituzioni

maxn

Parametri

Restituzioni

move

Parametri

Restituzioni

Campioni di codice

pack

Parametri

Restituzioni

remove

Parametri

Restituzioni

sort

Parametri

Restituzioni

unpack

Parametri

Restituzioni