Un servizio che gestisce le query riguardanti gli utenti sulla piattaforma Roblox.


Questa funzione consente di richiedere informazioni sugli utenti al di fuori del
rispetto corrente di `Class.DataModel` in blocco. I valori di input e output sono entrambi
array.

- L'ordine degli oggetti informativi degli utenti nell'array del valore di ritorno potrebbe non
  corrispondere all'ordine dei `Class.Player.UserId|UserIds` inviati nell'array del
  parametro di input. Usa il campo `Id` dell'oggetto informativo dell'utente per
  identificare il tuo array di input con l'array di output.
- È possibile ricevere meno oggetti informativi degli utenti rispetto a quanto richiesto se uno
  o più degli `Class.Player.UserId|UserIds` nell'array della richiesta sono
  non validi, come numeri negativi o ID utente che non hanno account
  associati. È possibile ricevere una risposta con zero
  risultati se tutti gli `Class.Player.UserId|UserIds` sono non validi.
- Se un utente Roblox non ha un `Class.Player.DisplayName|DisplayName`
  associato al proprio account, questa funzione restituirà invece la
  stessa stringa del nome utente dell'utente nel campo `DisplayName`
  del suo oggetto informativo. Anche se l' `Class.Player.UserId|UserId` di un utente non cambierà mai,
  possono cambiare il proprio nome utente o il nome visualizzato, quindi lo stesso input
  `Class.Player.UserId|UserIds` può restituire una stringa diversa per questi
  campi da un giorno all'altro.
- Poiché
  `Class.UserService:GetUserInfosByUserIdsAsync()|GetUserInfosByUserIdsAsync()`
  effettua una richiesta web esterna, verrà messa in attesa e potrebbe fallire se il servizio
  backend sta subendo interruzioni. Assicurati di gestire il downtime
  in modo appropriato racchiudendo questo metodo con un
  `Global.LuaGlobals.pcall()`.
- I risultati sono limitati a 250 al minuto, quindi se ricevi un errore HTTP 429,
  riprova più tardi, idealmente dopo aver ridotto il numero di
  `Class.Player.UserId|UserIds` nel tuo array di input, riducendo il numero
  di chiamate al metodo, o entrambi.

La firma di un singolo oggetto informativo dell'utente è:

<table>
<thead>
<tr>
  <th>Chiave</th>
  <th>Tipo</th>
  <th>Descrizione</th>
</tr>
</thead>
<tbody>
<tr>
  <td><code>Id</code></td>
  <td>numero</td>
  <td>Il
  <code>Class.Player.UserId|UserId</code> associato all'utente.</td>
</tr>
<tr>
  <td><code>Username</code></td>
  <td>stringa</td>
  <td>Il nome utente associato all'utente.</td>
</tr>
<tr>
  <td><code>DisplayName</code></td>
  <td>stringa</td>
  <td>Il
  <code>Class.Player.DisplayName|DisplayName</code> associato all'
  utente.</td>
</tr>
<tr>
  <td><code>HasVerifiedBadge</code></td>
  <td>booleano</td>
  <td>Il
  <code>Class.Player.HasVerifiedBadge|HasVerifiedBadge</code> valore
  associato all'utente.</td>
</tr>
</tbody>
</table>


UserService:GetUserInfosByUserIdsAsync

userIds

Un array di `Class.Player.UserId|UserIds` richiesti.


Un array di oggetti dizionario che contengono informazioni sugli utenti.


Restituisce un array di informazioni sugli utenti, incluso il nome utente e il nome visualizzato.


UserService

`Instance` è la classe base per tutte le classi nella gerarchia delle classi di Roblox
che possono far parte dell'albero `Class.DataModel`.

Non è possibile creare direttamente oggetti `Instance` radice, ma il costruttore speciale
`Datatype.Instance.new()` crea oggetti tramite codice, prendendo il
nome della classe come parametro e restituendo l'oggetto creato.


Dimostra come rilevare le modifiche all'ascendenza di un'istanza connettendosi all'evento `Class.Instance.AncestryChanged`.

Il genitore di ChangingPart viene impostato su valori diversi nel tempo. Il genitore della parte è l'antenato della parte, quindi l'evento `Class.Instance.AncestryChanged` si attiverà ogni volta che cambia.

Si attiva quando la proprietà `Class.Instance.Parent` dell'oggetto o uno dei
suoi antenati viene modificata.

Questo evento include due parametri: `child` si riferisce a `Class.Instance`
il cui `Class.Instance.Parent` è stato effettivamente modificato, mentre `parent` si riferisce
al nuovo `Class.Instance.Parent` di questa istanza.

Puoi usare questo evento per tenere traccia della cancellazione di un'istanza in Studio,
come la cancellazione manuale nell'Explorer o tramite un plugin. Se hai bisogno
di rilevare quando un'istanza viene distrutta usando `Class.Instance:Destroy()`,
usa invece l'evento `Class.Instance.Destroying`.


Instance.AncestryChanged

child

Il `Class.Instance` il cui `Class.Instance.Parent` è stato modificato.


parent

Il nuovo `Class.Instance.Parent` dell'istanza `Class.Instance` il cui
`Class.Instance.Parent` è stato cambiato.


Si attiva quando la proprietà `Class.Instance.Parent` dell'oggetto o uno dei
suoi antenati viene modificata.


Questo evento si attiva ogni volta che qualsiasi attributo viene modificato sull'istanza,
compreso quando un attributo viene impostato su `nil`. Il nome dell'attributo
modificato viene passato alla funzione connessa.

Ad esempio, il seguente frammento di codice collega la funzione `attributeChanged()`
per attivarsi ogni volta che uno degli attributi della parte cambia:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "cambiato")
end

part.AttributeChanged:Connect(attributeChanged)
```
Vedi anche `Class.Instance:GetAttributeChangedSignal()` che restituisce un
evento che si attiva quando un attributo specifico cambia.


Instance.AttributeChanged

attribute

Il nome dell'attributo che è stato modificato.


Si attiva ogni volta che un attributo viene modificato sull'oggetto `Class.Instance`.


Questo frammento stampa i nomi degli oggetti man mano che vengono aggiunti allo spazio di lavoro:

Si attiva dopo che un oggetto è stato parentato a questo `Class.Instance`.

Nota, quando si utilizza questa funzione su un client per rilevare oggetti creati dal
server è necessario usare `Class.Instance:WaitForChild()` quando si indicizzano le discendenze di questi oggetti. Questo perché l'oggetto e le sue
discendenze non sono garantiti per replicarsi dal server al client
simultaneamente. Ad esempio:

```
local Workspace = game:GetService("Workspace")

Workspace.ChildAdded:Connect(function(child)
	-- Usa WaitForChild() poiché le discendenze potrebbero non essersi replicate ancora
	local head = child:WaitForChild("Head")
end)
```
Nota, questa funzione funziona solo per i figli immediati del
`Class.Instance`. Per una funzione che cattura tutte le discendenze, usa
`Class.Instance.DescendantAdded`.

Vedi anche `Class.Instance.ChildRemoved`.


Instance.ChildAdded

Il `Class.Instance` che è stato aggiunto.


Si attiva dopo che un oggetto è stato parentato a questo `Class.Instance`.


Questo frammento stampa i nomi degli oggetti man mano che vengono rimossi dal
Workspace:

Si attiva dopo che un figlio è stato rimosso da questo `Class.Instance`.

Rimosso si riferisce a quando il genitore di un oggetto viene cambiato da questo
`Class.Instance` a qualcosa di diverso da questo `Class.Instance`. Nota, questo
evento si attiverà anche quando un figlio viene distrutto (usando
`Class.Instance:Destroy()`) poiché la funzione di distruzione imposta il genitore di un oggetto
su `nil`.

Questa funzione funziona solo per i figli immediati del `Class.Instance`.
Per una funzione che cattura tutte le discendenze, usa
`Class.Instance.DescendantRemoving`.

Vedi anche `Class.Instance.ChildAdded`.


Instance.ChildRemoved

Il `Class.Instance` che è stato rimosso.


Si attiva dopo che un figlio è stato rimosso da questo `Class.Instance`.


Il seguente esempio stamperà il nome di qualsiasi oggetto che viene aggiunto a
Workspace:

Questo evento si attiva dopo che una discendenza è stata aggiunta all' `Class.Instance`.

Poiché si attiva per ogni discendenza, parentare un oggetto all' `Class.Instance`
attiverà l'evento per questo oggetto e per tutte le sue discendenze individualmente.

Se ti interessa solo i **figli diretti** dell' `Class.Instance`, usa
`Class.Instance.ChildAdded` invece.

Vedi anche `Class.Instance.DescendantRemoving`.


Instance.DescendantAdded

descendant

Si attiva dopo che una discendenza è stata aggiunta all' `Class.Instance`.


L'esempio seguente stampa il nome di qualsiasi discendente mentre viene rimosso
dallo Workspace:

Questo evento si attiva **immediatamente prima** che il genitore `Class.Instance`
venga cambiato in modo che una **discendenza** non sarà più una
discendenza. `Class.Instance:Destroy()|Destroy()` cambia il `Class.Instance.Parent|Parent`
di un'istanza in `nil`, quindi chiamando quel metodo su una discendenza del genitore
del genitore farà scattare questo evento.

Poiché questo evento si attiva **prima** della rimozione della discendenza, il genitore
della discendenza rimarrà invariato al momento di attivare questo evento. Se la discendenza è
también un **figlio diretto** del genitore, questo evento si attiverà
prima di `Class.Instance.ChildRemoved`.

Se una discendenza ha figli, questo evento si attiva con la discendenza prima,
seguita dalle sue discendenze.

##### Avviso

Questo evento si attiva con l'oggetto discendente che viene rimosso.
Tentare di impostare il `Class.Instance.Parent|Parent` della discendenza su
qualcos'altro fallirà. Di seguito è riportato un esempio che dimostra questo:

```
local Workspace = game:GetService("Workspace")

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Non manipolare il genitore della discendenza in questa funzione!
	-- Questo evento si attiva PERCHÉ il genitore è stato manipolato, e la modifica non è successa ancora
	-- Pertanto, è problematico cambiare il genitore in questo modo:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```
Vedi anche `Class.Instance.DescendantAdded|DescendantAdded`.


Instance.DescendantRemoving

Si attiva immediatamente prima che una discendenza dell' `Class.Instance` venga rimossa.


Questo esempio dimostra come, utilizzando il comportamento del segnale immediato, un'istanza in fase di distruzione rimanga al suo posto finché la funzione collegata non si ferma.

Questo esempio dimostra come, quando si utilizza il comportamento dei segnali differiti,
un'istanza viene distrutta prima che il segnale venga emesso.

Il `Class.Instance` non sarà mai eliminato dalla memoria mentre una funzione collegata
lo sta ancora utilizzando. Tuttavia, se la funzione si blocca in qualsiasi momento,
il `Class.Instance` e le sue discendenze saranno impostate su `nil`.

Se la proprietà `Class.Workspace.SignalBehavior` è impostata su
`Enum.SignalBehavior.Immediate`, questo evento si attiverà immediatamente prima che il
`Class.Instance` o uno dei suoi antenati venga distrutto con
`Class.Instance:Destroy()`.

Se la proprietà `Class.Workspace.SignalBehavior` è impostata su
`Enum.SignalBehavior.Deferred`, questo evento si attiverà al prossimo punto di ripresa,
che sarà dopo che il `Class.Instance` o uno dei suoi antenati sarà
distrutto con `Class.Instance:Destroy()`.

Con il comportamento `Enum.SignalBehavior.Deferred|Deferred`, collegare uno script
al proprio evento `Class.Instance.Destroying` è problematico, poiché lo script
verrà distrutto prima che il callback possa essere chiamato (il che significa che non
verrà eseguito).

Quando si elimina un `Class.Instance` in Studio, come la cancellazione manuale
tramite l'[Explorer](/studio/explorer) o tramite un plugin,
il `Class.Instance` non viene distrutto. Invece, il genitore è impostato su `nil`
che puoi tenere traccia con `Class.Instance.AncestryChanged`.


Instance.Destroying

Si attiva immediatamente prima (o è posticipato fino a dopo) che l'istanza venga
distrutta tramite `Class.Instance:Destroy()`.


Questo evento si attiva ogni volta che qualsiasi proprietà di stile viene modificata sull'istanza,
compreso quando una proprietà è impostata su `nil`.

```lua
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")
local meterBar = HUDContainer.MeterBar

local function stylePropertyChanged()
	print("Proprietà stilizzata cambiate")
end

meterBar:StyledPropertiesChanged():Connect(stylePropertyChanged)
```


Instance.StyledPropertiesChanged

Si attiva ogni volta che una proprietà di stile viene modificata sull'istanza, quindi
quando una proprietà è impostata su `nil`.


Instance.childAdded

Questo metodo applica un tag all'istanza, senza effetto se il tag è
già applicato. L'aggiunta di un tag avvierà un segnale creato da
`Class.CollectionService:GetInstanceAddedSignal()` con il tag fornito.

##### Avvertenze

- I tag di un'istanza aggiunti dal lato client verranno rimossi se il
  server successivamente aggiunge o rimuove un tag su quell'istanza perché il server
  replica tutti i tag insieme e sovrascrive i tag precedenti.

- Quando si tagga un'istanza, è comune che alcune risorse siano utilizzate per
dare al tag la sua funzionalità, ad esempio collegamenti a eventi o tabelle.
  Per prevenire perdite di memoria, è buona norma ripulire queste risorse (disconnettere,
  impostare a `nil`, ecc.) quando non sono più necessarie per un tag.
  Fallo quando chiami `Class.Instance:RemoveTag()`, chiamando
  `Class.Instance:Destroy()`, o in una funzione collegata a un segnale
  restituito da `Class.CollectionService:GetInstanceRemovedSignal()`.


Instance:AddTag

Questa funzione distrugge tutti i figli e discendenti di un'istanza.

```
local part = Instance.new("Part")

-- Aggiungi alcune scintille
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

  local sc = Instance.new("Sparkles")
  sc.Parent = sparkles
end

print("Children:", #part:GetChildren())  --> Children: 3

part:ClearAllChildren()

print("Children:", #part:GetChildren())  --> Children: 0
```
Se non desideri distruggere **tutti** i figli e discendenti, utilizza
o `Class.Instance:GetChildren()` o `Class.Instance:GetDescendants()` per
iterare su quei figli/discendenti e selezionare cosa distruggere. Ad esempio,
il seguente codice distruggerà tutti i `Class.BasePart|BaseParts` discendenti
un `Class.Model`:

```
local Workspace = game:GetService("Workspace")

local model = Workspace:FindFirstChild("TestModel")

for _, descendant in model:GetDescendants() do
	if descendant:IsA("BasePart") then
		descendant:Destroy()
	end
end
```


Instance:ClearAllChildren

Questa funzione distrugge tutti i figli di un'istanza.


Dimostra come clonare un modello usando `Class.Instance:Clone()`.

`Clone()` crea una copia di un'istanza e di tutti i suoi discendenti,
ignorando tutte le istanze che non sono
`Class.Instance.Archivable|Archivable`. La copia dell'istanza radice è
restituita da questo metodo e il suo `Class.Instance.Parent|Parent` è impostato su
`nil`. Nota che se l'istanza stessa ha
`Class.Instance.Archivable|Archivable` impostato su `false`, questa funzione restituirà
`nil`.

Se una proprietà di riferimento come `Class.ObjectValue.Value` è impostata in un'istanza
clonata, il valore della proprietà della copia dipende dal 
valore dell'originale:

- Se una proprietà di riferimento si riferisce a un'istanza che è stata **anch'essa** clonata,
  la copia farà riferimento alla copia.
- Se una proprietà di riferimento si riferisce a un'istanza che **non** è stata clonata,
  lo stesso valore viene mantenuto nella copia.


Instance:Clone

Crea una copia di un'istanza e di tutti i suoi discendenti, ignorando le istanze
che non sono `Class.Instance.Archivable|Archivable`.


Dimostra come distruggere un Part utilizzando la funzione `Class.Instance:Destroy()`.

Questa funzione è il modo corretto per smaltire gli oggetti che non sono più necessari.

Imposta la proprietà `Class.Instance.Parent` su `nil`, blocca la
proprietà `Class.Instance.Parent`, disconnette tutte le connessioni e chiama
`Destroy()` su tutti i figli. Questa funzione è il modo corretto per smaltire
oggetti che non sono più necessari.

Eliminare oggetti non necessari è importante, poiché oggetti e
collegamenti superflui in un luogo utilizzano memoria che può portare a seri problemi di
prestazioni nel tempo.

Come prassi consigliata dopo aver chiamato `Destroy()` su un oggetto, imposta qualsiasi
variabile che fa riferimento all'oggetto (o ai suoi discendenti) su `nil`. Questo
prevenire che il tuo codice acceda a qualsiasi cosa riguardante l'oggetto.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- Non farlo:
print(part.Name)  --> "Hello, world"
-- Fallo per prevenire che la riga sopra funzioni:
part = nil
```
Una volta che un `Class.Instance` è stato distrutto da questo metodo, non può essere
riutilizzato perché la proprietà `Class.Instance.Parent` è bloccata. Per
**rimuovere temporaneamente** un oggetto invece di distruggerlo, imposta
`Class.Instance.Parent|Parent` su `nil`. Ad esempio:

```
local Workspace = game:GetService("Workspace")

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Per distruggere un oggetto dopo un certo tempo, utilizza
`Class.Debris:AddItem()`.


Instance:Destroy

Imposta la proprietà `Class.Instance.Parent` su `nil`, blocca la
proprietà `Class.Instance.Parent`, disconnette tutte le connessioni e chiama
`Destroy()` su tutti i figli.


Restituisce il primo antenato del `Class.Instance` il cui
`Class.Instance.Name` è uguale al nome fornito.

Questa funzione lavora verso l'alto, significando che inizia dal `Class.Instance.Parent`
immediato e lavora verso il `Class.DataModel`. Se non viene trovato alcun
antenato corrispondente, restituisce `nil`.

Il seguente frammento di codice troverà il primo antenato dell'oggetto
chiamato `Car`.

```
local car = object:FindFirstAncestor("Car")
```
Per varianti di questa funzione che trovano antenati di una specifica classe,
vedi `Class.Instance:FindFirstAncestorOfClass()` e
`Class.Instance:FindFirstAncestorWhichIsA()`.


Instance:FindFirstAncestor

name

Restituisce il primo antenato del `Class.Instance` il cui
`Class.Instance.Name` è uguale al nome fornito.


Restituisce il primo antenato del `Class.Instance` il cui
`Class.Object.ClassName` è uguale al given className.

Questa funzione lavora verso l'alto, significando che inizia dal `Class.Instance.Parent`
immediato e lavora verso il `Class.DataModel`. Se non viene trovato alcun
antenato corrispondente, restituisce `nil`.

Un uso comune di questa funzione è trovare il `Class.Model` a cui
un `Class.BasePart` appartiene. Ad esempio:

```
local model = part:FindFirstAncestorOfClass("Model")
```
Questa funzione è una variante di `Class.Instance:FindFirstAncestor()` che
controlla la proprietà `Class.Object.ClassName` piuttosto che
`Class.Instance.Name`. `Class.Instance:FindFirstAncestorWhichIsA()` esiste anche,
utilizzando il metodo `Class.Object:IsA()` invece per rispettare l'eredità delle classi.


Instance:FindFirstAncestorOfClass

className

Restituisce il primo antenato del `Class.Instance` il cui
`Class.Object.ClassName` è uguale al given className.


Restituisce il primo antenato del `Class.Instance` per cui
`Class.Object:IsA()` restituisce true per il given className.

Questa funzione lavora verso l'alto, significando che inizia dal `Class.Instance.Parent`
immediato e lavora verso il `Class.DataModel`. Se non viene trovato alcun
antenato corrispondente, restituisce `nil`.

A differenza di `Class.Instance:FindFirstAncestorOfClass()`, questa funzione utilizza
`Class.Object:IsA()` che rispetta l'eredità delle classi. Ad esempio:

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
Quindi, il seguente frammento di codice restituirà il primo
antenato `Class.BasePart`, indipendentemente se si tratta di un `Class.WedgePart`,
`Class.MeshPart` o `Class.Part`.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```
Vedi anche `Class.Instance:FindFirstAncestor()`.


Instance:FindFirstAncestorWhichIsA

Restituisce il primo antenato del `Class.Instance` per cui
`Class.Object:IsA()` restituisce true per il given className.


Il seguente codice cercherebbe un oggetto di nome "Brick" nel Workspace. Se trovato, cambierà il nome dell'oggetto in "Foo".

Restituisce il primo figlio del `Class.Instance` con il nome fornito, o
`nil` se non esiste alcun figlio di questo tipo. Se l'argomento `recursive` è
`true`, questa funzione cerca tra tutti i discendenti piuttosto che solo i
figli immediati del `Class.Instance`.

##### Controllare l'esistenza di un oggetto

`FindFirstChild()` è necessario se è necessario verificare che un oggetto esista
prima di continuare. Tentare di indicizzare un figlio per nome utilizzando
l'operatore punto solleverà un errore se il figlio non esiste.

```lua
local Workspace = game:GetService("Workspace")

-- La seguente riga dà errore se la parte non esiste nello spazio di lavoro
Workspace.Part.Transparency = 0.5
```
Un approccio migliore è utilizzare `FindFirstChild()` per prima controllare `Part`,
quindi utilizzare un'istruzione `if` per eseguire codice che ha bisogno di esso.

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace:FindFirstChild("Part")
if part then
	part.Transparency = 0.5
end
```

##### Trovare un figlio il cui nome corrisponde a una proprietà

A volte il nome del `Class.Instance.Name|Name` di un oggetto è lo stesso di
quello di una proprietà del suo `Class.Instance.Parent|Parent`. Quando si usa
l'operatore punto, le proprietà hanno la precedenza sui figli se condividono un nome.

Nel seguente esempio, una `Class.Folder` chiamata `Color` viene aggiunta a un
`Class.Part`, che ha anche la proprietà `Class.Part.Color`. Nota che
`part.Color` si riferisce al valore della proprietà `Datatype.Color3`, non all'istanza del
`Class.Folder` figlio. Un vantaggio dell'utilizzo di
`Class.Instance:FindFirstChild()|FindFirstChild()` è che l'introduzione di nuove proprietà non
imporrà rischi sul tuo codice.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- La proprietà
local c2 = part:FindFirstChild("Color")  -- La cartella figlio
```

##### Note di prestazioni

`Class.Instance:FindFirstChild()|FindFirstChild()` richiede circa il 20% in più
rispetto all'utilizzo dell'operatore punto e quasi 8 volte in più rispetto a semplicemente
memorizzare un riferimento a un oggetto. Pertanto, dovresti evitare di chiamarlo in
codice dipendente dalle prestazioni come in cicli stretti o funzioni collegate a
`Class.RunService.Heartbeat` e `Class.RunService.PreRender`. Invece,
memorizza il risultato in una variabile, o prendi in considerazione di utilizzare
`Class.Instance.ChildAdded|ChildAdded` o
`Class.Instance:WaitForChild()|WaitForChild()` per rilevare quando un figlio di un
certo nome diventa disponibile.


Instance:FindFirstChild

recursive

Se la ricerca deve essere condotta ricorsivamente.


Restituisce il primo figlio del `Class.Instance` trovato con il nome fornito.


Restituisce il primo figlio del `Class.Instance` il cui
`Class.Object.ClassName|ClassName` è uguale al dato `className`.
A differenza di `Class.Instance:FindFirstChildWhichIsA()`, questa funzione restituisce
solo oggetti la cui classe corrisponde a `className`, ignorando l'eredità delle classi.
Se non viene trovato alcun figlio corrispondente, questa funzione restituisce `nil`.


Instance:FindFirstChildOfClass

Restituisce il primo figlio del `Class.Instance` il cui
`Class.Object.ClassName|ClassName` è uguale al nome della classe fornito.


Restituisce il primo figlio del `Class.Instance` per cui
`Class.Object:IsA()` restituisce true per il given className.

Se non viene trovato alcun figlio corrispondente, questa funzione restituisce `nil`. Se
l'argomento ricorsivo opzionale è true, questa funzione cerca tutti
discendenti piuttosto che solo i figli immediati del
`Class.Instance`.

A differenza di `Class.Instance:FindFirstChildOfClass()`, questa funzione utilizza
`Class.Object:IsA()` che rispetta l'eredità delle classi. Ad esempio:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Pertanto, il seguente frammento di codice restituirà il primo
figlio `Class.BasePart`, indipendentemente se si tratta di un `Class.WedgePart`,
`Class.MeshPart` o `Class.Part`.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```
Gli sviluppatori che cercano un figlio per nome, dovrebbero usare
`Class.Instance:FindFirstChild()` invece.


Instance:FindFirstChildWhichIsA

Restituisce il primo figlio del `Class.Instance` per cui
`Class.Object:IsA()` restituisce true per il given className.


Restituisce il primo discendente trovato con il dato `Class.Instance.Name`.

Questo metodo è disabilitato e non può essere utilizzato. Per trovare il primo discendente
di un'istanza, considera di utilizzare l'argomento `ricorsivo` su
`Class.Instance:FindFirstChild()` invece.


Instance:FindFirstDescendant

Restituisce il primo discendente trovato con il dato `Class.Instance.Name`.


Se il `Class.Instance` è un `Class.Actor`, viene restituito il `Class.Actor` stesso.
Altrimenti, viene restituito il suo più vicino antenato `Class.Actor`. Se nessun
antenato è un `Class.Actor`, il risultato è `nil`.


Instance:GetActor

Restituisce il `Class.Actor` associato all'istanza, se presente.


Questo metodo restituisce il valore che è stato assegnato al dato
nome dell'attributo. Se non è stato assegnato alcun attributo, viene restituito `nil`.

Ad esempio, il seguente frammento di codice imposta e poi ottiene il valore dell'
attributo `InitialPosition` dell'istanza:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local initialPosition = instance:GetAttribute("InitialPosition")
print(initialPosition)
```

##### Vedi Anche

- `Class.Instance:SetAttribute()` che imposta l'attributo con il dato
  nome al dato valore.
- `Class.Instance:GetAttributes()` che restituisce un dizionario di coppie chiave-valore
  per ciascuno degli attributi dell'istanza.


Instance:GetAttribute

Il valore che è stato assegnato al dato nome dell'attributo. Se non è
stato assegnato alcun attributo, viene restituito `nil`.


Restituisce il valore che è stato assegnato al dato nome dell'attributo.


Questa funzione restituisce un evento che si comporta esattamente come il
`Class.Object.Changed|Changed` evento, eccetto che si attiva solo quando
cambia il dato attributo specifico; effettivamente è simile a
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` ma
per gli attributi.

È generalmente una buona idea utilizzare questo metodo invece di una connessione a
`Class.Object.Changed|Changed` con una funzione che controlla il nome
dell'attributo. Le chiamate successive a questo metodo sullo stesso oggetto con lo stesso
nome dell'attributo restituiscono lo stesso evento.

Il seguente esempio di codice restituisce un segnale che attiva la funzione
`attributeChanged()` quando cambia l'attributo `InitialPosition` della parte:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local function attributeChanged()
	print("Attributo cambiato")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```
Vedi anche `Class.Instance.AttributeChanged` che si attiva ogni volta che cambia qualsiasi
attributo nell'istanza.


Instance:GetAttributeChangedSignal

Il nome dell'attributo specificato per il quale viene restituito il segnale di cambiamento.


Un evento che si attiva quando cambia il dato attributo.


Restituisce un evento che si attiva quando cambia il dato attributo.


Questo metodo restituisce un dizionario di coppie chiave-valore per ogni attributo
dove la chiave è il nome dell'attributo e il valore è un valore non `nil`.

Ad esempio, il seguente frammento di codice output gli attributi e i valori
di un'istanza:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)
part:SetAttribute("CanUse", true)

for name, value in part:GetAttributes() do
	print(name .. " = " .. value)
end
```
Vedi anche `Class.Instance:GetAttribute()` che restituisce il valore che è stato
assegnato al dato nome dell'attributo.


Instance:GetAttributes

Un dizionario di coppie stringa → variante per ogni attributo in cui la
stringa è il nome dell'attributo e la variante è un valore non nil.


Restituisce un dizionario degli attributi dell'istanza.


Di seguito verrà stampato il nome di tutti gli oggetti attualmente in Workspace quando eseguito.

Restituisce un array (una tabella indicizzata numericamente) contenente tutti i
figli diretti dell'istanza, o ogni `Class.Instance` il cui
`Class.Instance.Parent|Parent` è uguale all'oggetto. L'array può essere
iterato utilizzando sia un ciclo `for` numerico che generico:

```lua
local Workspace = game:GetService("Workspace")

-- Esempio di ciclo for numerico
local children = Workspace:GetChildren()
for i = 1, #children do
	local child = children[i]
	print(child.Name .. " è il figlio numero " .. i)
end
```

```lua
local Workspace = game:GetService("Workspace")

-- Esempio di ciclo for generico
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " è il figlio numero " .. i)
end
```
I figli sono ordinati in base all'ordine in cui è stata impostata la loro
proprietà `Class.Instance.Parent|Parent` sull'oggetto.

Vedi anche la funzione `Class.Instance:GetDescendants()|GetDescendants`.


Instance:GetChildren

Un array contenente i figli dell'istanza.


Restituisce un array che contiene tutti i figli dell'istanza.


Restituisce una stringa codificata dell'ID di debug utilizzato internamente da Roblox. Nota
che:

- Questo elemento è protetto. Tentare di usarlo in un `Class.Script` o
  `Class.LocalScript` causerà un errore.
- Un ID di debug è un ID utilizzato nei processi di debugging. Permette a
un debugger di leggere ogni istruzione prima che un'applicazione la elabori. Tutti gli oggetti in
  Roblox agiscono come processi e ciascun oggetto esegue istruzioni (o 'codice') che possono
  essere debugged se necessario.
- Questo può essere utile per i plugin che devono differenziare oggetti simili
  l'uno dall'altro (come oggetti che condividono lo stesso nome).


Instance:GetDebugId

scopeLength

Restituisce una stringa codificata dell'ID di debug utilizzato internamente da Roblox.


GetDescendants viene spesso utilizzato per fare qualcosa a tutti i discendenti che sono di un
particolare tipo di oggetto. Il codice in questo esempio utilizza GetDescendants e
`Class.Instance:IsA()` per trovare tutte le parti nello spazio di lavoro e le rende
di colore verde.

Questo metodo dell'oggetto restituisce un array che contiene tutti i discendenti
di quell'oggetto. A differenza di `Class.Instance:GetChildren()`, che restituisce solo
i figli immediati di un oggetto, questo metodo trova ogni figlio dell'oggetto, ogni figlio di quei figli,
e così via.


Instance:GetDescendants

Un array contenente i discendenti dell'istanza.


Restituisce un array contenente tutti i discendenti dell'istanza.


Questo esempio di codice dimostra il comportamento di `Class.Instance:GetFullName()`.
Mostra come si comporta la funzione quando viene chiamata su un oggetto non presente nella
gerarchia `DataModel`, e mostra anche come il valore di ritorno non esce
caratteri speciali.

Questo esempio di codice re-implementa la funzione `Class.Instance:GetFullName()` in
Lua.

Restituisce una stringa che descrive l'ascendenza dell'istanza. La stringa è una
concatenazione del `Class.Instance.Name|Name` dell'oggetto e dei suoi
antenati, separati da punti. Il `Class.DataModel` (`game`) non è
considerato. Ad esempio, un `Class.Part` nel `Class.Workspace` potrebbe
restituire `Class.Workspace.Part`.

Quando viene chiamato su un `Class.Instance` che non è un discendente del
`Class.DataModel`, questa funzione considera tutti gli antenati fino e
compreso il più alto senza un `Class.Instance.Parent|Parent`.

Questa funzione è utile per registrare e fare debugging. Non dovresti cercare di
analizzare la stringa restituita per alcuna operazione utile; questa funzione non
escapa i punti (o qualsiasi altro simbolo) nei nomi degli oggetti. In altre parole,
anche se la sua output appare spesso come un identificatore Luau valido, non è
garantito.


Instance:GetFullName

Restituisce una stringa che descrive l'ascendenza dell'istanza.


Questo metodo restituisce il valore stilizzato o esplicitamente modificato della
proprietà specificata, o altrimenti il valore predefinito della proprietà se non è stata
stilizzata/modificata. Questo differisce leggermente dall'accesso diretto al valore della
proprietà, come `[GuiObject].Rotation`, che restituisce il valore predefinito o
modificato della proprietà.

```lua
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")

local coreSheet = ReplicatedStorage:FindFirstChild("CoreSheet")
local rule = coreSheet:FindFirstChildWhichIsA("StyleRule")
rule.Selector = "TextButton"

-- Riferimento a un pulsante
local button = HUDContainer:FindFirstChildWhichIsA("TextButton")

print(button:GetStyled("Rotation")) --> 0 (valore predefinito)
print(button.Rotation) --> 0 (valore predefinito)

-- Applica rotazione tramite proprietà della regola di stile
rule:SetProperty("Rotation", 30)

print(button:GetStyled("Rotation")) --> 30 (valore stilizzato basato sulla regola)
print(button.Rotation) --> 0 (valore predefinito)

-- Modifica esplicitamente/sovrascrivi la proprietà stilizzata
button.Rotation = 45

print(button:GetStyled("Rotation")) --> 45 (valore modificato)
print(button.Rotation) --> 45 (valore modificato)
```


Instance:GetStyled

Il valore stilizzato o esplicitamente modificato della proprietà specificata, o
altrimenti il valore predefinito della proprietà se non è stato stilizzato/modificato.


Restituisce il valore stilizzato o esplicitamente modificato della proprietà specificata,
o altrimenti il valore predefinito della proprietà se non è stato stilizzato/modificato.


Questo metodo restituisce un evento che si comporta esattamente come il
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` evento,
eccetto che si attiva solo quando cambia la funzione di stile specificata. È
generale una buona idea utilizzare questo metodo invece di una connessione a
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` con una
funzione che controlla il nome della proprietà. Le chiamate successive a questo metodo su
lo stesso oggetto con lo stesso nome della proprietà restituiscono lo stesso evento.

Nota che questo evento non passerà alcun argomento a una funzione collegata,
quindi il valore della proprietà cambiata deve essere letto direttamente in
uno script.

```lua
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")
local meterBar = HUDContainer.MeterBar

local function stylePropertyChanged()
	print("Proprietà di stile cambiata!")
end

meterBar:GetStyledPropertyChangedSignal("AnchorPoint"):Connect(stylePropertyChanged)
```


Instance:GetStyledPropertyChangedSignal

property

Nome della proprietà di stile per cui ascoltare i cambiamenti.


Evento che si attiva quando cambia la funzione di stile specificata.


Questo metodo restituisce un array dei tag applicati al dato'istanza, come
stringhe. Puoi aggiungere tag sia in Studio nella finestra
[Proprietà](/studio/properties) o a runtime con
`Class.Instance:AddTag()|AddTag()`.

Questo metodo è utile quando desideri fare qualcosa con più tag su
un'istanza contemporaneamente. Tuttavia, è inefficiente usare questo metodo per
controllare l'esistenza di un singolo tag; utilizza invece
`Class.Instance:HasTag()|HasTag()` per controllare un tag specifico.


Instance:GetTags

Ottiene un array di tutti i tag applicati all'istanza.


Questo metodo restituisce `true` se il tag fornito è stato aggiunto all'
oggetto. Puoi aggiungere tag sia in Studio nella finestra
[Proprietà](/studio/properties) o a runtime con
`Class.Instance:AddTag()|AddTag()`.


Instance:HasTag

Dimostra come determinare se un'istanza è l'antenato di un'altra utilizzando `Class.Instance:IsAncestorOf()`

Workspace e SpawnLocation sono antenati del decalcomania di SpawnLocation.
Workspace è un antenato di SpawnLocation.

SpawnLocation e la sua decalcomania sono discendenti di Workspace, non antenati.
Decalcomania è un discendente di SpawnLocation, non un antenato.

Restituisce true se un `Class.Instance` è un antenato del dato
discendente.

Un `Class.Instance` è considerato l'antenato di un oggetto se il
`Class.Instance.Parent` dell'oggetto o uno dei suoi genitori ha
impostato `Class.Instance`.

Vedi anche, `Class.Instance:IsDescendantOf()`.


Instance:IsAncestorOf

True se il `Class.Instance` è un antenato del dato discendente.


Restituisce true se un `Class.Instance` è un antenato del dato
discendente.


Restituisce `true` se un `Class.Instance` è un discendente del dato
antenato.

Nota che `IsDescendantOf()` non può essere utilizzato con un parametro di `nil` per
controllare se un oggetto è stato rimosso.

Vedi anche `Class.Instance:IsAncestorOf()`.


Instance:IsDescendantOf

ancestor

True se il `Class.Instance` è un discendente del dato antenato.


Restituisce `true` se un `Class.Instance` è un discendente del dato
antenato.


Restituisce `true` se il valore memorizzato nella proprietà specificata è uguale al
valore predefinito creato dal codice. Ad esempio, se l'output della
proprietà `Class.TextLabel.TextSize|TextSize` di un `Class.TextLabel`
indica `8`, allora chiamare `IsPropertyModified("TextSize")` sull'etichetta
restituirà `false` perché `8` è il valore predefinito per
`Class.TextLabel.TextSize` quando l'etichetta è creata tramite
`Instance.new("TextLabel")` piuttosto che inserita attraverso i flussi di
inserimento dello Studio.

Nota che se questo metodo restituisce `true`, la stilizzazione **non** influenzerà la
proprietà perché la modifica esplicita di una proprietà ha la precedenza
sulla stilizzazione.


Instance:IsPropertyModified

Booleano che indica se la proprietà è modificata.


Restituisce `true` se il valore memorizzato nella proprietà specificata è uguale al
valore predefinito creato dal codice.


Il seguente codice dimostra come una parte può essere riaggiunta al DataModel
dopo essere stata rimossa:

Questa funzione imposta il `Class.Instance.Parent` dell'oggetto su `nil`, e fa
the same for all its descendants.

Se l'oggetto è referenziato prima di essere rimosso, è possibile
ripristinarlo in un secondo momento.


Instance:Remove

Imposta il `Parent` dell'oggetto su `nil`, e fa lo stesso per tutti i suoi
discendenti.


Questo metodo rimuove un tag da un'istanza. Non solleverà un errore se
l'oggetto non ha il tag. Rimuovere con successo un tag attiverà un
segnale creato da `Class.CollectionService:GetInstanceRemovedSignal()`
con il tag fornito.

Nota che quando si tagga un'istanza, è comune che alcune risorse siano
utilizzate per dare al tag la sua funzionalità, ad esempio collegamenti a eventi o
tabelle. Per prevenire perdite di memoria, è buona norma ripulire queste risorse
(disconnettere, impostare a `nil`, ecc.) quando non sono più necessarie per un tag.


Instance:RemoveTag

Ripristina una proprietà al suo valore predefinito. Ad esempio, chiamare
`ResetPropertyToDefault("Rotation")` su un `Class.TextLabel` è equivalente
a impostare la sua `Class.TextLabel.Rotation|Rotation` su `0` (il valore
default della proprietà). Questo metodo può essere utilizzato per garantire che
la stilizzazione sovrascriva il valore predefinito di questa proprietà.


Instance:ResetPropertyToDefault

Ripristina una proprietà al suo valore predefinito.


Questo metodo imposta l'attributo con il nome dato al valore dato. Se
il valore fornito è `nil`, l'attributo verrà rimosso, poiché `nil` è
restituito per impostazione predefinita.

Ad esempio, il seguente frammento di codice imposta l'attributo
`InitialPosition` dell'istanza su `Datatype.Vector3|Vector3.new(0, 10, 0)`:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", Vector3.new(0, 10, 0))
```

##### Limitazioni

Requisiti e restrizioni sui nomi:

- I nomi devono utilizzare solo caratteri alfanumerici e underscore.
- Non sono consentiti spazi o simboli unici.
- Le stringhe devono essere lunghe 100 caratteri o meno.
- I nomi non possono iniziare con **RBX** a meno che il chiamante non sia uno
  script core di Roblox (riservato per Roblox).

Quando si tenta di impostare un attributo a un tipo non supportato, verrà
sollevato un errore.

##### Vedi Anche

- `Class.Instance:GetAttribute()` che restituisce il valore che è stato
  assegnato al dato nome dell'attributo.
- `Class.Instance:GetAttributes()` che restituisce un dizionario di coppie chiave-valore
  per ciascuno degli attributi dell'istanza.


Instance:SetAttribute

value

Il valore da impostare sull'attributo specificato.


Imposta l'attributo con il nome dato al valore dato.


Il seguente codice aspetta che un'istanza chiamata "Part" venga aggiunta a
Workspace.

Restituisce il figlio di `Class.Instance` con il nome specificato. Se il
figlio non esiste, si bloccherà il thread corrente fino a quando non esisterà. Se
il parametro `timeOut` è specificato, questo metodo si interromperà dopo il
determinato numero di secondi e restituirà `nil`.

##### Utilizzo Primario

`Class.Instance:WaitForChild()|WaitForChild()` è estremamente importante quando
si lavora su codice eseguito dal client in un `Class.LocalScript`. Il motore
Roblox non garantisce il tempo o l'ordine in cui gli oggetti vengono
replicati dal server al client. Inoltre, se un'esperienza ha `Class.Workspace.StreamingEnabled` impostato su true,
`Class.BasePart|BaseParts` che si trovano lontano dal personaggio del giocatore
potrebbero non essere trasmessi al client, causando potenzialmente la rottura dei
script quando si indicizzano oggetti che non esistono ancora sul client.

##### Note

- Questa funzione non si blocca se un figlio con il nome specificato esiste quando
  viene effettuata la chiamata.
- `Class.Instance:FindFirstChild()` è un'alternativa più efficiente a
  `Class.Instance:WaitForChild()|WaitForChild()` per oggetti che si
  presuppone esistano.
- Se una chiamata a questo metodo supera i 5 secondi senza restituire, e non è
  stato specificato alcun parametro `timeOut`, verrà stampato un avviso all'output
  che il thread potrebbe bloccarsi indefinitamente.


Instance:WaitForChild

childName

timeOut

Restituisce il figlio del `Class.Instance` con il nome dato. Se il
figlio non esiste, porterà il thread corrente in attesa fino a quando non esiste.


La funzione children restituisce un array dei figli dell'oggetto.


Instance:children

Restituisce un array dei figli dell'oggetto.


Instance:clone

Instance:destroy

Instance:findFirstChild

Instance:getChildren

Instance:isDescendantOf

Instance:remove

Instance

Questa proprietà determina se l'istanza deve essere inclusa quando l'
esperienza viene pubblicata o salvata, o quando `Class.Instance:Clone()|Clone()`
viene chiamato su uno degli antenati dell'istanza. Chiamando
`Class.Instance:Clone()|Clone()` direttamente su un'istanza restituirà `nil`
se quell'istanza non è `Class.Instance.Archivable|Archivable`.

Copiare un oggetto in Studio utilizzando le opzioni **Duplicate** o **Copy**/**Paste**
ignorerà la sua propria proprietà `Class.Instance.Archivable|Archivable`
e imposterà `Class.Instance.Archivable|Archivable` su `true` per la
copia.

```
local part = Instance.new("Part")
print(part:Clone())  --> Part
part.Archivable = false
print(part:Clone())  --> nil
```


Instance.Archivable

Determina se un `Class.Instance` e i suoi discendenti possono essere clonati usando
`Class.Instance:Clone()`, e possono essere salvati/pubblicati.


L'insieme delle capacità consentite per essere utilizzate per gli script all'interno di questa
istanza. Affinché le capacità abbiano effetto, la proprietà `Class.Instance.Sandboxed`
dev'essere abilitata.

Questa proprietà è utilizzata da una funzione sperimentale. Vedi
[capacità degli script](/scripting/capabilities) per ulteriori
dettagli.


Instance.Capabilities

L'insieme delle capacità consentite per essere utilizzate per gli script all'interno di questo
contenitore.


Un identificatore non unico del `Class.Instance`. I nomi sono utilizzati per mantenere
organizzata la gerarchia degli oggetti, consentendo anche agli script di accedere
agli oggetti specifici. Il nome di un'istanza non può superare i 100 caratteri di
lunghezza.

Il nome di un oggetto è spesso utilizzato per accedere all'oggetto attraverso la gerarchia
del modello dati utilizzando i seguenti metodi:

```
local Workspace = game:GetService("Workspace")

local baseplate = Workspace.Baseplate
local baseplate = Workspace["Baseplate"]
local baseplate = Workspace:FindFirstChild("BasePlate")
```
Per rendere un oggetto accessibile utilizzando l'operatore punto (`.`), il suo
nome deve iniziare con un underscore o una lettera, e il resto del nome può
contiene solo lettere, numeri o underscore (nessun altro carattere speciale).
Se il nome di un oggetto non segue questa sintassi, non sarà
accessibile usando l'operatore punto e Luau non interpreterà il suo nome
come un identificatore.

Se più di un oggetto con lo stesso nome sono fraterni, qualsiasi tentativo di
indicizzare un oggetto con quel nome restituirà solo uno degli oggetti, simile
al `Class.Instance:FindFirstChild()`, ma non sempre l'oggetto desiderato.
Se un oggetto specifico deve essere accessibile tramite codice, è consigliato
dargli un nome unico o garantire che nessuno dei suoi fratelli condivida il
stesso nome.

Vedi anche `Class.Instance:GetFullName()` per ottenere un nome completo che include
la gerarchia dell'oggetto.


Instance.Name

Un identificatore non unico del `Class.Instance`.


La proprietà `Parent` determina il genitore gerarchico del
`Class.Instance`. La seguente terminologia è comunemente usata quando si parla
di come questa proprietà è impostata:

- Un oggetto è un **figlio** di, o è **genitore di**, un altro oggetto quando
  il suo `Parent` è impostato su quell'oggetto.

- I **discendenti** di un `Class.Instance` sono i figli di quell'
  oggetto, più i discendenti dei figli.

- Gli **antenati** di un `Class.Instance` sono tutti gli oggetti di cui l'
  istanza è un discendente.

È dalla proprietà `Parent` che molti altri membri API ottengono il loro
nome, come `Class.Instance:GetChildren()|GetChildren()` e
`Class.Instance:FindFirstChild()|FindFirstChild()`. Questa proprietà è anche
utilizzata per gestire se un oggetto esiste nell'esperienza o deve essere
rimosso. Finché il genitore di un oggetto è nel `Class.DataModel`, è
memorizzato in una variabile o è referenziato dalla proprietà di un altro oggetto,
l'oggetto rimane nell'esperienza; altrimenti, l'oggetto verrà automaticamente
rimosso.

Chiamare `Class.Instance:Destroy()|Destroy()` imposterà il `Parent` di un
`Class.Instance` e tutti i suoi discendenti su `nil`, e inoltre **bloccherà**
la proprietà `Parent`. Un errore viene sollevato quando si imposta il `Parent` di un
oggetto distrutto.

Gli oggetti appena creati utilizzando `Datatype.Instance.new()` non avranno un
genitore, e di solito non saranno visibili o funzioneranno fino a quando non ne viene impostato uno.

##### Replica di oggetti

Un oggetto creato dal server non verrà replicato ai client finché non è
imparentato con un oggetto che viene replicato. Quando si crea un oggetto e
si impostano molte proprietà, è consigliato impostare la proprietà `Parent`
**ultima**. Questo garantisce che l'oggetto venga replicato una sola volta, invece di replicare
molte modifiche alle proprietà.

```lua
local Workspace = game:GetService("Workspace")

-- Imposta il genitore della nuova istanza per ultimo (consigliato)
local part = Instance.new("Part")
part.Position = Vector3.new(0, 10, 0)
part.Parent = Workspace
```
Tuttavia, se si stanno impiantando parti a un `Class.Model` il cui genitore non è ancora stato
impostato, è accettabile impiantare ogni parte in quel modello poiché il modello
non sarebbe stato replicato.


Instance.Parent

Determina il genitore gerarchico del `Class.Instance`.


Questa proprietà era utilizzata per proteggere gli oggetti nel servizio `Class.CoreGui`
dall'essere alterati dagli utenti in modo non autorizzato. È stata deprecata
ed non fa nulla.


Instance.RobloxLocked

Una proprietà deprecata che proteggerebbe gli oggetti `Class.CoreGui`.


Rende l'istanza un **contenitore sandbox**, una funzione sperimentale
che limita le azioni che gli script all'interno di un particolare
contenitore possono eseguire. Vedi
[capacità degli script](/scripting/capabilities) per ulteriori
dettagli.


Instance.Sandboxed

Un identificatore unico per l'istanza, distinto da `Class.Instance.Name`
che non è necessariamente unico.


Instance.UniqueId

`Instance` è la classe base per tutte le classi nella gerarchia delle classi di Roblox
che possono far parte dell'albero `Class.DataModel`.


/reference/engine/classes/UserService.yaml