Il codice di esempio qui sotto dà a tutti i nuovi giocatori dei sparkles dello stesso colore
che il loro torso.

Sparkles è una delle diverse classi di emettitori di particelle. Come altri emettitori di particelle della sua categoria, gli oggetti Sparkles emettono particelle quando sono parentati a un `Class.BasePart` (come un `Class.Part`) o a un `Class.Attachment` all'interno di un tale `Class.BasePart`. Rispetto alla classe `Class.ParticleEmitter`, Sparkles manca di molte proprietà di personalizzazione e metodi speciali, come `Class.ParticleEmitter.Lifetime` o `Class.ParticleEmitter:Emit()`. È utile per creare un effetto speciale rapido in una situazione di emergenza; per lavori più dettagliati, è preferibile utilizzare un `Class.ParticleEmitter` al suo posto.

Quando `Class.Sparkles.Enabled` è disattivato, le particelle emesse da questo oggetto continueranno a essere visualizzate fino alla scadenza della loro vita. Quando il `Class.Instance.Parent` di un oggetto Sparkles è impostato su `nil` (e/o `Class.Instance:Destroy()`), tutte le particelle scompariranno istantaneamente. Se questo effetto non è desiderato, prova a nascondere l'oggetto genitore in una posizione lontana, quindi rimuovi le scintille dopo alcuni secondi usando `Class.Debris` per dare alle ultime particelle la possibilità di scadere. Questo oggetto non ha un metodo `Class.ParticleEmitter:Clear()`, ma è possibile impostare il `Class.Instance.Parent` su `nil` e poi di nuovo sullo stesso oggetto per ottenere lo stesso effetto.

Le particelle Sparkles vengono emesse solo dal centro del `Class.BasePart` a cui sono parentate. Parentare un oggetto Sparkles a un `Class.Attachment` consente invece di personalizzare la posizione di partenza delle particelle.


Sparkles

La proprietà Colore determina il colore di tutte le particelle emesse da un oggetto `Class.Sparkles` (sia particelle esistenti che future). Comporta in modo simile a `Class.ParticleEmitter.Color`, tranne per il fatto che è solo un colore e non una `Datatype.ColorSequence`. Le scintille hanno una sequenza di colori naturale applicata che è più evidente quando questa proprietà è impostata su bianco; le scintille animano molto debolmente tra un verde e un rosso sottili.

Va notato che le scintille hanno un effetto parziale `Class.ParticleEmitter.LightEmission`, quindi i colori scuri tendono a essere più trasparenti e i colori bianchi sembrano molto luminosi.


Sparkles.Color

Determina il colore delle particelle di scintille.


La proprietà Enabled, molto simile a `Class.ParticleEmitter.Enabled`, determina se le particelle di scintille vengono emesse. Qualsiasi particella già emessa continuerà a essere visualizzata fino alla scadenza della loro vita. Questa proprietà è utile per mantenere gli effetti di scintille pre-creati spenti fino a quando non sono necessari in seguito. Poiché le particelle di scintille vengono distrutte quando il `Class.Instance.Parent` dell'oggetto `Sparkle` è impostato su `nil`, questa proprietà è utile per dare alle particelle esistenti la possibilità di scadere prima di distruggere completamente l'oggetto Fire. Vedi la funzione qui sotto.

```
local Debris = game:GetService("Debris")
local part = script.Parent
function stopSparkling(sparkles)
	sparkles.Enabled = false -- Non più nuove particelle
	Debris:AddItem(sparkles, 4) -- Rimuovi l'oggetto dopo un ritardo (dopo che le particelle esistenti sono scadute)
end
stopSparkling(part.Sparkles)
```


Sparkles.Enabled

Determina se le scintille vengono emesse.


Sparkles.LocalTransparencyModifier

Questa proprietà funziona in modo identico a `Class.Sparkles.Color`.

La proprietà SparkleColor determina il colore di tutte le particelle emesse da un oggetto `Class.Sparkles` (sia particelle esistenti che future). Si comporta in modo simile a `Class.ParticleEmitter.Color`, tranne per il fatto che è solo un colore e non una `Datatype.ColorSequence`. Le scintille hanno una sequenza di colori naturale applicata che è più evidente quando questa proprietà è impostata su bianco; le scintille animano molto debolmente tra un verde e un rosso sottili.

Va notato che le scintille hanno un effetto parziale `Class.ParticleEmitter.LightEmission`, quindi i colori scuri tendono a essere più trasparenti e i colori bianchi sembrano molto luminosi.


Sparkles.SparkleColor

Sparkles.TimeScale

Un emettitore di particelle con l'estetica visiva delle scintille.


`Instance` è la classe base per tutte le classi nella gerarchia di 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 al `Class.Instance`
il cui `Class.Instance.Parent` è stato effettivamente modificato, mentre `parent`
si riferisce al nuovo `Class.Instance.Parent` di questa istanza.

Puoi utilizzare questo evento per tenere traccia della cancellazione di un'istanza in Studio,
such come la cancellazione manuale nell'Explorer o tramite un plugin. Se hai bisogno
di rilevare quando un'istanza viene distrutta utilizzando `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` del `Class.Instance` il cui
`Class.Instance.Parent` è stato modificato.


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


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

Per esempio, il seguente frammento di codice connette 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'`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 associato a questa `Class.Instance`.

Nota, quando si utilizza questa funzione su un client per rilevare oggetti creati dal
gestore, è necessario utilizzare `Class.Instance:WaitForChild()` quando
si indicizzano i discendenti di questi oggetti. Questo perché l'oggetto ei suoi
discendenti non sono garantiti per replicarsi dal server al client
tutte e due contemporaneamente. Ad esempio:

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

Workspace.ChildAdded:Connect(function(child)
	-- Usa WaitForChild() poiché i discendenti potrebbero non essere ancora replicati
	local head = child:WaitForChild("Head")
end)
```
Nota, questa funzione funziona solo per i figli immediati della
`Class.Instance`. Per una funzione che cattura tutti i discendenti, usa
`Class.Instance.DescendantAdded`.

Vedi anche `Class.Instance.ChildRemoved`.


Instance.ChildAdded

La `Class.Instance` che è stata aggiunta.


Si attiva dopo che un oggetto è stato parentato a questa `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 questa `Class.Instance`.

Rimosso si riferisce a quando il genitore di un oggetto cambia da questo
`Class.Instance` a qualcos'altro rispetto a questo `Class.Instance`. Nota, questo
evento si attiverà anche quando un figlio viene distrutto (utilizzando
`Class.Instance:Destroy()`) poiché la funzione di distruzione imposta il genitore di un oggetto a `nil`.

Questa funzione funziona solo per i figli immediati della `Class.Instance`.
Per una funzione che cattura tutti i discendenti, usa
`Class.Instance.DescendantRemoving`.

Vedi anche `Class.Instance.ChildAdded`.


Instance.ChildRemoved

La `Class.Instance` che è stata rimossa.


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


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

Questo evento si attiva dopo che un discendente è stato aggiunto alla `Class.Instance`.

Poiché si attiva per ogni discendente, associare un oggetto alla
`Class.Instance` attiverà l'evento per questo oggetto e tutti i suoi
discendenti singolarmente.

Se ti interessano solo i **figli diretti** della
`Class.Instance`, usa `Class.Instance.ChildAdded` invece.

Vedi anche `Class.Instance.DescendantRemoving`.


Instance.DescendantAdded

descendant

Si attiva dopo che un discendente è stato aggiunto alla `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`
cambii in modo tale che un'istanza di **discendente** non sia più un
discendente. `Class.Instance:Destroy()|Destroy()` cambia il `Class.Instance.Parent|Parent` di un'istanza a `nil`, quindi chiamare quel metodo su un
discendente del genitore causerà l'attivazione di questo evento.

Poiché questo evento si attiva **prima** della rimozione del discendente, il genitore
del discendente non sarà cambiato al momento dell'attivazione di questo evento. Se il
discendente è anche un **figlio diretto** del genitore, questo evento si attiverà
prima di `Class.Instance.ChildRemoved`.

Se un discendente ha figli, questo evento si attiva prima con il discendente,
seguito dai suoi discendenti.

##### Attenzione

Questo evento si attiva con l'oggetto discendente che sta venendo rimosso.
Tentare di impostare il `Class.Instance.Parent|Parent` del discendente 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 del discendente in questa funzione!
	-- Questo evento si attiva PERCHÉ il genitore è stato manipolato, e il cambiamento non è ancora avvenuto
	-- 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

La `Class.Instance` che sta per essere rimossa.


Si attiva immediatamente prima che un discendente della `Class.Instance` venga rimosso.


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.

La `Class.Instance` non verrà mai eliminata dalla memoria mentre una funzione connessa
la sta ancora utilizzando. Tuttavia, se la funzione cede a un certo punto,
la `Class.Instance` e i suoi discendenti verranno impostati a `nil`.

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

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

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

Quando si elimina una `Class.Instance` in Studio, ad esempio eliminando manualmente
tramite l'[Explorer](/studio/explorer) o tramite un plugin,
la `Class.Instance` non viene distrutta. Invece, il genitore viene impostato a `nil`
che puoi monitorare con `Class.Instance.AncestryChanged`.


Instance.Destroying

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


Questo evento si attiva ogni volta che una qualsiasi proprietà di stile viene modificata sull'istanza,
compresa quando una proprietà è impostata a `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à stilistiche cambiate")
end

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


Instance.StyledPropertiesChanged

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


Instance.childAdded

Questo metodo applica un tag all'istanza, senza effetto se il tag è
già applicato. Aggiungere con successo un tag attiverà un segnale creato da
`Class.CollectionService:GetInstanceAddedSignal()` con il tag dato.

##### Avvertenze

- I tag di un'istanza aggiunti lato client verranno esclusi se il
  server in seguito aggiunge o rimuove un tag su quell'istanza poiché il server
  replica tutti i tag insieme e sovrascrive i tag precedenti.

- Quando si etichetta un'istanza, è comune che alcune risorse vengano utilizzate per
  dare al tag la sua funzionalità, ad esempio connessioni di eventi o tabelle.
  Per prevenire perdite di memoria, è buona norma pulirle (disconnettere,
  impostare a `nil`, ecc.) quando non sono più necessarie per un tag. Fai questo 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 di un'istanza e i discendenti.

```
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 i discendenti, utilizza oppure
`Class.Instance:GetChildren()` o `Class.Instance:GetDescendants()` per
iterare attraverso quei figli/discendenti e selezionare cosa distruggere. Per
esempio, il seguente campione di codice distruggerà tutti
`Class.BasePart|BaseParts` discendenti da 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 viene
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 è **anche** clonata,
  la copia si riferirà 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.

Smaltire oggetti non necessari è importante, poiché oggetti e
connessioni non necessari in un luogo utilizzano memoria che può portare a gravi problemi di prestazioni nel tempo.

Come buona pratica, dopo aver chiamato `Destroy()` su un oggetto, impostare le variabili
che fanno riferimento all'oggetto (o ai suoi discendenti) su `nil`. Questo
impedisce al tuo codice di accedere a qualsiasi cosa relativa all'oggetto.

```lua
local part = Instance.new("Part")
part.Name = "Ciao, mondo"
part:Destroy()
-- Non farlo:
print(part.Name)  --> "Ciao, mondo"
-- Fai questo per prevenire il funzionamento della riga precedente:
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 anziché distruggerlo, impostare
`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 periodo di tempo, utilizzare
`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 dato.

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

Il seguente frammento di codice troverebbe il primo antenato dell'oggetto
chiamato `Auto`.

```
local car = object:FindFirstAncestor("Car")
```
Per le varianti di questa funzione che trovano antenati di una classe specifica,
per favore 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 dato.


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

Questa funzione lavora verso l'alto, il che significa che inizia dal `Class.Instance.Parent`
immediato dell'istanza 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()` per rispettare l'ereditarietà delle classi.


Instance:FindFirstAncestorOfClass

className

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


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

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

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

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
Pertanto, il seguente campione di codice restituirà il primo
antenato `Class.BasePart`, indipendentemente dal fatto che sia 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 il quale
`Class.Object:IsA()` restituisce true per il className dato.


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 dato, o
`nil` se non esiste alcun figlio di questo tipo. Se l'argomento opzionale `recursive`
è`true`, questa funzione cerca tutti i discendenti piuttosto che solo i
figli immediati del `Class.Instance`.

##### Controllo dell'esistenza di un oggetto

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

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

-- La seguente riga genera un errore se la parte non esiste nello spazio di lavoro
Workspace.Part.Transparency = 0.5
```
Un approccio migliore è utilizzare `FindFirstChild()` per prima verificare `Part`,
quindi utilizzare una dichiarazione `if` per eseguire codice che ne ha bisogno.

```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 `Class.Instance.Name|Name` di un oggetto è lo stesso di una
proprietà del suo `Class.Instance.Parent|Parent`. Quando si utilizza 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` fa riferimento al valore della proprietà `Datatype.Color3`, non all'istanza del figlio
`Class.Folder`. Un vantaggio di utilizzare
`Class.Instance:FindFirstChild()|FindFirstChild()` è che l'introduzione di nuove proprietà non
oferisce rischi per il 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 sulle prestazioni

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


Instance:FindFirstChild

recursive

Se la ricerca deve essere condotta ricorsivamente.


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


Restituisce il primo figlio del `Class.Instance` il cui
`Class.Object.ClassName|ClassName` è uguale al `className` dato.
A differenza di `Class.Instance:FindFirstChildWhichIsA()`, questa funzione
restituisce solo oggetti la cui classe corrisponde a `className`, ignorando l'ereditarietà
basket. 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 di classe dato.


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

Se non viene trovato alcun figlio corrispondente, questa funzione restituisce `nil`. Se l'
argomento ricorsivo opzionale è vero, questa funzione cerca tutti i
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'ereditarietà delle classi. Ad esempio:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Pertanto, il seguente campione di codice restituirà il primo
figlio `Class.BasePart`, indipendentemente dal fatto che sia un `Class.WedgePart`,
`Class.MeshPart` o `Class.Part`.

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


Instance:FindFirstChildWhichIsA

Restituisce il primo figlio del `Class.Instance` per il quale
`Class.Object:IsA()` restituisce true per il nome di classe dato.


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

Questo metodo è disabilitato e non può essere utilizzato. Per trovare il primo discendente
un'istanza, considera di utilizzare il parametro `recursive` 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`, il `Class.Actor` stesso viene
restituito. Altrimenti, il suo antenato più vicino `Class.Actor` viene restituito. 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`.

Per esempio, il seguente frammento di codice imposta e poi ottiene il valore
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 nessun
attributo è stato assegnato, 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
evento `Class.Object.Changed|Changed`, tranne che si attiva solo quando il
specifico attributo dato cambia; effettivamente è simile a
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` ma
per gli attributi.

È generalmente una buona idea usare questo metodo invece di una connessione a
`Class.Object.Changed|Changed` con una funzione che controlla il nome
dell'attributo. 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 l'attributo `InitialPosition` della parte cambia:

```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 un attributo
viene cambiato sull'istanza.


Instance:GetAttributeChangedSignal

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


Un evento che si attiva quando il dato attributo cambia.


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


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

Per esempio, il seguente frammento di codice stampa gli attributi e i valori
sull'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 ciascun 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 la loro
proprietà `Class.Instance.Parent|Parent` è stata impostata sull'oggetto.

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


Instance:GetChildren

Un array contenente i figli dell'istanza.


Restituisce un array contenente 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 debug. Permette a un debugger di
  leggere ciascuna istruzione prima che un'applicazione la elabori. Tutti gli oggetti in
  Roblox funzionano come processi e ciascun esegue istruzioni (o 'codice') che possono
  essere debugate se necessario.
- Questo può essere utile per i plugin che hanno bisogno di distinguere 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` può
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
incluso il più alto senza un `Class.Instance.Parent|Parent`.

Questa funzione è utile per la registrazione e il debug. Non dovresti tentare di
analizzare la stringa restituita per nessuna operazione utile; questa funzione non
escape punti (o altri simboli) nei nomi degli oggetti. In altre parole,
sebbene la sua uscita sembri spesso un identificatore Luau valido, non è
garantita.


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 della proprietà predefinito se non è stato
stilizzato/modificato. 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 attraverso la proprietà della regola stilizzata
rule:SetProperty("Rotation", 30)

print(button:GetStyled("Rotation")) --> 30 (valore stilizzato in base alla 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 della proprietà predefinito se non è stato stilizzato/modificato.


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


Questo metodo restituisce un evento che si comporta esattamente come il
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` evento,
tranne che si attiva solo quando la proprietà di stile data cambia. È
generalmente una buona idea utilizzare questo metodo invece di una connessione a
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` con una
funzione che controlla il nome della proprietà. 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 all'interno di 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("La proprietà stile è cambiata!")
end

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


Instance:GetStyledPropertyChangedSignal

property

Nome della proprietà di stile per la quale ascoltare le modifiche.


Evento che si attiva quando la data proprietà di stile cambia.


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

Questo metodo è utile quando vuoi fare qualcosa con più tag su
un'istanza contemporaneamente. Tuttavia, è inefficiente utilizzare questo metodo per
verificare l'esistenza di un singolo tag; invece, usa
`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) oppure 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 vero 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
`Class.Instance.Parent` è impostato sul `Class.Instance`.

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


Instance:IsAncestorOf

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


Restituisce vero 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 usato con un parametro di `nil` per
verificare se un oggetto è stato rimosso.

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


Instance:IsDescendantOf

ancestor

Vero 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 istanziato dal codice. Ad esempio, se stampare il
valore della proprietà `Class.TextLabel.TextSize|TextSize` di un `Class.TextLabel`
indica `8`, chiamare `IsPropertyModified("TextSize")` sull'etichetta
restituirà `false` poiché `8` è il valore predefinito per
`Class.TextLabel.TextSize` quando l'etichetta viene creata tramite
`Instance.new("TextLabel")` invece di essere inserita attraverso i flussi di lavoro
 di inserimento in Studio.

Nota che se questo metodo restituisce `true`, lo stile **non** influenzerà la
proprietà poiché la modifica esplicita di una proprietà ha la precedenza rispetto al
farne lo stile.


Instance:IsPropertyModified

Booleano che indica se la proprietà è stata modificata.


Restituisce `true` se il valore memorizzato nella proprietà specificata è uguale
al valore predefinito istanziato 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
lo stesso per tutti i suoi discendenti.

Se l'oggetto è referenziato prima di essere rimosso, è possibile
recuperare l'oggetto 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
the l'oggetto non ha il tag. Rimuovere con successo un tag attiverà un segnale creato da
`Class.CollectionService:GetInstanceRemovedSignal()`
con il tag dato.

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


Instance:RemoveTag

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


Instance:ResetPropertyToDefault

Reimposta una proprietà al suo valore predefinito.


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

Per 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 possono utilizzare solo caratteri alfanumerici.
  - Puoi anche includere punti, trattini, barre e trattini bassi.
- Non sono ammessi spazi o simboli unici (come @, ~, !) .
- Le stringhe devono essere lunghe al massimo 100 caratteri.
- I nomi non possono iniziare con **RBX** a meno che il chiamante non sia uno
  script principale 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 per l'attributo specificato.


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


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

Restituisce il figlio del `Class.Instance` con il nome dato. Se il
figlio non esiste, sospenderà il thread corrente fino a quando non è disponibile. Se
il parametro `timeOut` è specificato, questo metodo scadrà dopo il
certo numero di secondi e restituirà `nil`.

##### Uso 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 sono lontani dal personaggio del giocatore
potrebbero non essere trasmessi al client, causando potenzialmente interruzioni
agli script quando si indicizzano oggetti che non esistono ancora sul client.

##### Note

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


Instance:WaitForChild

childName

timeOut

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


La funzione figli 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 chiamata su uno degli antenati dell'istanza. Chiamare
`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 **Duplica** o **Copia**/**Incolla**
ignorerà la 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 di capacità che possono essere utilizzate per gli script all'interno di questo
'istanza. Per le capacità per avere effetto, la proprietà `Class.Instance.Sandboxed`
deve essere abilitata.

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


Instance.Capabilities

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


Un identificatore non unico del `Class.Instance`. I nomi vengono utilizzati per mantenere
l'eredità degli oggetti organizzata, insieme a consentire agli script di accedere a
specifici oggetti. Il nome di un'istanza non può superare i 100 caratteri in
lunghezza.

Il nome di un oggetto è spesso usato 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 trattino basso o una lettera, e il resto del nome può
contenere solo lettere, numeri o trattini bassi (nessun altro carattere speciale).
Se il nome di un oggetto non rispetta questa sintassi, non sarà
accessibile utilizzando l'operatore punto e Luau non interpreterà il suo nome
come identificatore.

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

Vedi anche `Class.Instance:GetFullName()` per ottenere un nome completo includendo
l'eredità 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 anch'essi.

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

È 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
usata per gestire se un oggetto esiste nell'esperienza o se 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 a `nil`, e **bloccherà** anche 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 uno non verrà impostato.

##### Replica dell'Oggetto

Un oggetto creato dal server non verrà replicato ai client fino a quando non è
imparentato a qualche oggetto che viene replicato. Quando si crea un oggetto e
si impostano molte proprietà, si consiglia di impostare la proprietà `Parent`
**per ultima**. Questo assicura che l'oggetto venga replicato una volta, invece di replicarsi
molti cambiamenti di proprietà.

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

-- Imposta l'istanza appena creata come ultima (raccomandato)
local part = Instance.new("Part")
part.Position = Vector3.new(0, 10, 0)
part.Parent = Workspace
```
Tuttavia, se si imparentano parti a un `Class.Model` il cui genitore non è
ancora stato impostato, è accettabile imparentare ciascuna parte a quel modello poiché il modello
non si sarebbe replicato.


Instance.Parent

Determina il genitore gerarchico del `Class.Instance`.


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


Sparkles

Campioni di codice

Sommario

Proprietà

Metodi

Eventi

Proprietà

Metodi

Eventi

Su questa pagina