Un `Class.Actor` è un contenitore per codice che può essere suddiviso in modo sicuro in un
thread utilizzando `Library.task.desynchronize()`. Dovrebbe anche contenere le
istanze utilizzate dai suoi script.

Per saperne di più su come utilizzare più Actor per ottimizzare le prestazioni degli script, vedere
[Parallel Luau](/scripting/multithreading).

#### Note

- Ogni `Actor` viene eseguito nella propria VM Luau. I `Class.ModuleScript|ModuleScripts`
  richiesti da un `Actor` **non** sono condivisi o memorizzati nella cache tra `Actors` o con
  il thread principale. Ogni VM esegue la propria copia del modulo, quindi
  lo stato a livello di modulo è isolato per ogni `Actor`. Progetta di conseguenza se i tuoi
  moduli detengono uno stato che intendi condividere.
- `script:GetActor()` restituisce `nil` quando chiamato da un `Class.ModuleScript`
  a meno che il `ModuleScript` non sia un discendente dell'`Actor`. I `ModuleScripts`
  memorizzati altrove (ad esempio, `Class.ReplicatedStorage`) e richiesti da un
  `Actor` non sono considerati discendenti dell'`Actor`.


Questo metodo è utilizzato per collegare un callback Luau a un messaggio con l'
argomento specificato. Quando un messaggio viene inviato (utilizzando
`Class.Actor:SendMessage()|SendMessage()`) all'argomento specificato, il
callback fornito verrà chiamato in un contesto di esecuzione _seriale_.

È possibile collegare più callback Luau a un singolo attore e anche a un
singolo argomento di messaggio.

Nota: Solo gli script che sono discendenti di un attore possono collegarsi ai suoi
messaggi.

```lua
local actor = script:GetActor()

-- Stampa un messaggio quando un messaggio di saluto viene inviato all'Attore
-- di cui questo script è discendente.
local connection = actor:BindToMessage("Greeting", function(message)
  print("Messaggio di saluto ricevuto:", message)
end)
```

Actor:BindToMessage

topic

L'argomento utilizzato per identificare il tipo di messaggio.

function

Questo oggetto di connessione può essere utilizzato per disconnettere il callback Luau
 dalla ricezione di messaggi.

Collega un callback Luau a un messaggio con l'argomento specificato.

Questo metodo è utilizzato per collegare un callback Luau a un messaggio con l'
argomento specificato. Quando un messaggio viene inviato (utilizzando
`Class.Actor:SendMessage()|SendMessage()`) all'argomento specificato, il
callback fornito verrà chiamato in un contesto di esecuzione _parallela_.

È possibile collegare più callback Luau a un singolo attore e anche a un
singolo argomento di messaggio.

Nota: Solo gli script che sono discendenti di un attore possono collegarsi ai suoi
messaggi.

```lua
local actor = script:GetActor()

-- Stampa un messaggio quando un messaggio di saluto viene inviato all'Attore
-- di cui questo script è discendente.
local connection = actor:BindToMessageParallel("Greeting", function(message)
  print("Messaggio di saluto ricevuto:", message)
end)
```

Actor:BindToMessageParallel

Invia un messaggio a un Actor. I messaggi vengono inviati in modo asincrono, quindi il
mittente non bloccherà o cederà quando chiama il
`Class.Actor:SendMessage()|SendMessage()` metodo.

Poiché un singolo Actor può ricevere diversi tipi di messaggi, un parametro `topic`
è utilizzato per distinguere tra vari tipi di messaggi.

Vedi `Class.Actor:BindToMessage()|BindToMessage()` per dettagli su come ricevere
un messaggio inviato utilizzando `Class.Actor:SendMessage()|SendMessage()`.

Nota che gli argomenti del messaggio sono **passati per copia** attraverso i limiti della VM Luau,
non per riferimento. Inviare tabelle grandi comporta una copia completa su
ogni chiamata. Le funzioni sono vincolate a una specifica VM e non possono essere passate nei
messaggi.

```lua
-- Supponi che `actor` sia una variabile locale che si riferisce a un'istanza di Actor
actor:SendMessage("Saluto", "Ciao Mondo")
```


Actor:SendMessage

L'argomento utilizzato per identificare il messaggio inviato.

message

Il contenuto del messaggio da inviare all'Attore.

Actor

Un `Class.Actor` è un contenitore per codice che può essere suddiviso in modo sicuro in un
thread.

Il seguente esempio include una funzione di base che prende una tabella di oggetti
ed è genitore in un nuovo Modello, restituendo quel Modello.

I modelli sono oggetti contenitore, il che significa che raggruppano insieme oggetti. Sono
utilizzati al meglio per contenere collezioni di `Class.BasePart|BaseParts` e hanno un certo numero
di funzioni che ne estendono la funzionalità.

I modelli sono destinati a rappresentare raggruppamenti **geometrici**. Se il tuo raggruppamento non ha
alcuna interpretazione geometrica, per esempio una collezione di
`Class.Script|Scripts`, usa invece una `Class.Folder`.

I modelli i cui componenti sono uniti insieme con giunti (in modo che possano
muoversi o essere distrutti tramite simulazione fisica) di solito hanno un
`Class.Model.PrimaryPart|PrimaryPart` impostato, poiché specifica quale parte all'interno
del modello il pivot e la bounding box "seguiranno" mentre il modello si muove. I modelli statici
che rimangono fermi in un posto non beneficiano della presenza di una parte primaria impostata.

I modelli hanno un ampio raggio di applicazioni, inclusi i personaggi dei giocatori di Roblox.
Hanno anche un certo numero di comportamenti unici che è importante tenere a
mente:

- Quando un `Class.Humanoid` e un `Class.Part` chiamato **Head** sono parentati sotto
  un modello, una GUI di nome/salute apparirà sopra il modello; vedere
  [Visualizzazione Nome/Salute del Personaggio](/characters/name-health-display)
  per dettagli.
- Se la posizione di una parte sull'asse **Y** supera il
  `Class.Workspace.FallenPartsDestroyHeight`, e questo era l'ultimo oggetto
  all'interno di un `Class.Model`, anche il modello sarà distrutto.
- Quando utilizzato in un luogo con `Class.Workspace.StreamingEnabled` impostato su true,
  il valore di `Class.Model.ModelStreamingMode|ModelStreamingMode` controlla
  vari comportamenti riguardo a come il modello e eventuali discendenti vengono replicati
  e/o rimossi dai client. Inoltre, il valore di
  `Class.Model.LevelOfDetail|LevelOfDetail` influisce sul rendering del modello.

Come per tutti i tipi di `Class.Instance`, il fatto che un modello padre `Class.Model` sia
replicato a un client non garantisce che tutti i suoi bambini siano
replicati. Questo è particolarmente importante se queste istanze vengono
accedute da codice che viene eseguito sul client, come in un `Class.LocalScript`.
Utilizzando `Class.Model.ModelStreamingMode|ModelStreamingMode` con valori come
`Enum.ModelStreamingMode|Atomic` si può garantire che l'intero modello e tutti i
suoi discendenti siano presenti se il modello padre esiste sul client, oppure
si può utilizzare `Class.Instance:WaitForChild()|WaitForChild()` quando l'atomicità non è
desiderata.

Imposta questo modello come persistente per il giocatore specificato. I modelli
persistenti rimangono presenti per il giocatore indipendentemente dalle impostazioni o
condizioni di streaming.

`Class.Model.ModelStreamingMode|ModelStreamingMode` deve essere impostato su
`Enum.ModelStreamingMode|PersistentPerPlayer` affinché il comportamento venga modificato
come risultato dell'aggiunta.

Model:AddPersistentPlayer

playerInstance

Il `Class.Player` per rendere questo modello persistente.

Imposta questo modello come persistente per il giocatore specificato.
`Class.Model.ModelStreamingMode|ModelStreamingMode` deve essere impostato su
`Enum.ModelStreamingMode|PersistentPerPlayer` affinché il comportamento venga modificato
come risultato dell'aggiunta.

In questo esempio, i joints in ogni Modello del personaggio del Giocatore aggiunto verranno rotti
3 secondi dopo la comparsa. Rompere questi joints causerà la morte dell'Umanoide.


Questo esempio di codice dimostra la creazione manuale di giunture su due parti che sono
sorelle dello script (PartA e PartB). Crea una giuntura su due parti che si toccano
con tipi di superficie compatibili (Studs e Inlet).

Interrompe le connessioni tra `BaseParts`, incluse le connessioni superficiali con
qualsiasi parte adiacente, `Class.WeldConstraint|WeldConstraints`, e tutte
`Class.Weld|Welds` e altre `Class.JointInstance|JointInstances`.

Quando BreakJoints viene utilizzato su un modello di personaggio di un giocatore,
`Class.Humanoid` del personaggio morirà in quanto si basa sul giunto del collo.

Nota che, sebbene i giunti prodotti da connessioni superficiali con adiacenti
Part possono tecnicamente essere ricreati utilizzando `Class.Model:MakeJoints()`, questo
ripristinerà solo giunti prodotti dalle superfici. Gli sviluppatori non dovrebbero fare affidamento
su questo poiché, dopo la rottura dei giunti, le parti potrebbero non trovarsi più in
contatto tra di loro.

Model:BreakJoints

Interrompe le connessioni tra `BaseParts`, incluse le connessioni superficiali con
qualsiasi parte adiacente, `Class.WeldConstraint|WeldConstraints` e tutti
`Class.Weld|Welds` e altre `Class.JointInstance|JointInstances`.

Model:breakJoints

Questa funzione restituisce una descrizione di un volume che contiene tutti
`Class.BasePart` figli all'interno di un `Class.Model`. L'orientamento del volume
è basato sull'orientamento della `Class.Model.PrimaryPart|PrimaryPart`,
e corrisponde alla casella di selezione renderizzata in Studio quando il modello è
selezionato. Rispecchiando il comportamento di `Class.Terrain:FillBlock()`, restituisce un
`Datatype.CFrame` che rappresenta il centro di quella bounding box e un
`Datatype.Vector3` che rappresenta la sua grandezza. La grandezza può essere imprecisa
al runtime se vincoli fisici stanno agendo sulle parti all'interno del
`Class.Model`.

L'orientamento della bounding box corrisponde all'orientamento del
`Class.PVInstance.GetPivot|Pivot` - sia il pivot della
`Class.Model.PrimaryPart|PrimaryPart` (se presente) o il
`Class.Model.WorldPivot|WorldPivot` del modello.

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

local model = Workspace.Model
local part = Workspace.Part
local orientation, size = model:GetBoundingBox()

-- Ridimensiona e posiziona la parte uguale alla bounding box del modello
part.Size = size
part.CFrame = orientation
```

Model:GetBoundingBox

Un `Datatype.CFrame` che rappresenta l'orientamento del volume
seguìto da un `Datatype.Vector3` che rappresenta la dimensione del volume.

Restituisce una descrizione di un volume che contiene tutte le parti di un modello.

Il codice di esempio qui sotto dimostra come Model.GetExtentsSize può essere utilizzato per ottenere
la dimensione della bounding box che contiene i pezzi.

Restituisce la dimensione della più piccola bounding box che contiene tutte le
`Class.BasePart|BaseParts` nel `Class.Model`. L'orientamento corrisponde
all'orientamento del `Class.PVInstance.GetPivot|Pivot` - sia il
pivot della `Class.Model.PrimaryPart|PrimaryPart` (se presente) o il
`Class.Model.WorldPivot|WorldPivot` del modello.

Nota che questa funzione restituisce solo la dimensione della più piccola bounding box, e
lo sviluppatore deve impiegare il proprio metodo per ottenere la posizione della
bounding box.

Model:GetExtentsSize

La dimensione `Datatype.Vector3` degli estremi del `Class.Model`.

Restituisce la dimensione della più piccola bounding box che contiene tutte le
`Class.BasePart|BaseParts` nel `Class.Model`, allineata con la
`Class.Model.PrimaryPart` se è impostata.

Questo valore storicamente restituiva il CFrame di una posizione centrale nel
modello.

Model:GetModelCFrame

Questo codice crea un modello, ci mette dentro alcune parti, le posiziona casualmente,
e poi stampa la sua dimensione:


La funzione GetModelSize restituisce la dimensione `Datatype.Vector3` del
`Class.Model`.

Model:GetModelSize

Restituisce la dimensione Vector3 del modello.

Quando questo metodo viene chiamato da un `Class.Script`, restituisce tutti gli
oggetti `Class.Player` per i quali questo modello è persistente. Quando viene chiamato da
un `Class.LocalScript`, questo metodo controlla solo se questo modello è persistente
per il `Class.Players.LocalPlayer|LocalPlayer`.

Model:GetPersistentPlayers

Una tabella con tutti gli oggetti `Class.Player` per i quali questo oggetto modello è
persistente.

Restituisce tutti gli oggetti `Class.Player` per i quali questo oggetto modello è
persistente. Il comportamento varia a seconda che questo metodo venga chiamato
da un `Class.Script` o da un `Class.LocalScript`.

Il seguente codice dimostra come GetPrimaryPartCFrame e
SetPrimaryPartCFrame possano essere utilizzati per ruotare un modello.

Un semplice modello viene creato nello Workspace e viene avviato un ciclo che
ruoterà il modello di 10 gradi attorno all'asse Y ogni 0,2 secondi.

Questa funzione è stata sostituita da `Class.PVInstance:GetPivot()` che
funge da sostituto e non modifica il comportamento del tuo codice. Usa
`Class.PVInstance:GetPivot()` per nuovi lavori e migra le tue chiamate
esistenti a `Class.Model:GetPrimaryPartCFrame()` quando conveniente.

Restituisce il `Datatype.CFrame` della `Class.Model.PrimaryPart` del modello.

Questa funzione è equivalente alla seguente.

    Model.PrimaryPart.CFrame

Nota che questa funzione genererà un errore se non esiste una parte primaria per il
`Class.Model`. Se questo comportamento non è desiderato, gli sviluppatori possono fare
quanto segue, che sarà uguale a `nil` se non esiste la parte primaria.

    local cFrame = Model.PrimaryPart and Model.PrimaryPart.CFrame

Model:GetPrimaryPartCFrame

Restituisce il `Datatype.CFrame` della `Class.Model.PrimaryPart` del modello.
Questa funzione genererà un errore se non esiste parte primaria per il
`Class.Model`.

Questo esempio di codice dimostra come sostituire tutte le copie di un modello di albero utilizzando `Class.Model:PivotTo()` e `Class.Model:ScaleTo()`. Il pivot e la scala dei modelli sono utilizzati come riferimento per garantire che le dimensioni e le posizioni relative dei modelli di sostituzione corrispondano a quelle degli originali.


I modelli contengono un fattore di scala canonico persistente, che parte da 1
per i modelli appena creati e cambia man mano che il modello viene scalato chiamando
`Class.Model:ScaleTo()`. Questa funzione restituisce l'attuale fattore di scala canonico
del modello.

L'attuale fattore di scala non influisce _direttamente_ sulla dimensione delle istanze
sotto il modello. Viene utilizzato per l'autore di contenuti e per scopi di scripting
per ricordare come il modello è stato scalato rispetto alla sua dimensione originale.

All'interno di una data sessione, il modello memorizzerà le informazioni esatte sulla dimensione originale
delle istanze discendenti dopo la prima chiamata a
`Class.Model:ScaleTo()`. Questo significa che chiamare
`Class.Model:ScaleTo()|ScaleTo(x)` seguito da
`Class.Model:ScaleTo()|ScaleTo(1)` ti riporterà _esattamente_ alla
configurazione originale del modello senza deriva in virgola mobile. Evitare
la deriva in virgola mobile è la motivazione per avere una funzione Scale**To**
invece di una funzione Scale**By**.

Il fattore di scala influenza anche il comportamento del motore in un modo: Il fattore di scala
di un modello sarà applicato agli offset dei giunti di
`Class.Animation|Animations` riprodotti su un `Class.AnimationController`
sotto quel modello, affinché i rig animati riproducano correttamente
animazioni anche quando scalati.

Model:GetScale

L'attuale fattore di scala canonico del modello.

Restituisce la scala canonica del modello, che per i modelli appena creati
diventa 1 e cambierà man mano che verrà scalarizzato tramite
`Class.Model:ScaleTo()`.

Questo esempio di codice dimostra come i giunti possono essere creati utilizzando la
funzione Model:MakeJoints.

Un modello è istanziato, con due parti una sopra l'altra. La parte superiore è
ancorata e la parte inferiore non lo è. Normalmente, quando è collegata allo Workspace
a la parte inferiore cadrebbe sulla Baseplate.

Tuttavia, poiché la proprietà TopSurface della parte inferiore è impostata su
Enum.SurfaceType.Weld, questo significa che quando Model:MakeJoints viene eseguito, viene
creata una connessione tra di esse.

Pertanto, la parte inferiore non cade fino a quando i giunti nel modello non sono
rotti. Questo viene spesso fatto utilizzando Model:BreakJoints, ma in questo esempio la
connessione è interrotta utilizzando un'esplosione.

Questo esempio di codice dimostra la creazione di giunti su due parti che sono
sorelle dello script (PartA e PartB). Utilizza MakeJoints su due parti toccanti
con tipi di superficie compatibili (Studs e Inlet).

L'unione basata su SurfaceType è deprecata. Non utilizzare MakeJoints per nuovi
progetti. Utilizza invece `Class.WeldConstraint|WeldConstraints` e
`Class.HingeConstraint|HingeConstraints`.

Scorre tra tutti i `Class.BasePart|Parts` nel `Class.Model` e crea
giunti tra le parti specificate e qualsiasi superficie piana che si tocca,
a seconda delle superfici delle parti.

- Le superfici lisce non creeranno giunti
- Le superfici incollate creeranno un giunto di `Class.Glue`
- Il saldatura creerà un giunto di `Class.Weld` con qualsiasi superficie ad eccezione di
  Unjoinable
- Studs, Inlet, o Universale creeranno ciascuno un giunto di `Class.Snap` con
  una delle altre due superfici (ad esempio, Studs con Inlet e
  Universale)
- Le superfici Hinge e Motor creeranno istanze di giunto `Class.Rotate` e `Class.RotateV`

Questa funzione non funziona se la parte non è un discendente di
`Class.Workspace`. Pertanto, devi prima assicurarti che il modello sia parentato
al Workspace prima di utilizzare MakeJoints.

Model:MakeJoints

Scorre tra tutti i `Class.BasePart|BaseParts` nel `Class.Model`. Se la superficie di qualsiasi
parte ha un SurfaceType che può creare un giunto, creerà un giunto con
qualsiasi parte adiacente.

Model:makeJoints

Model:move

location

Questo esempio dimostra come `Class.Model:MoveTo()` eviti le collisioni.

Viene creato un semplice `Class.Model` in due parti e la sua `Class.Model.PrimaryPart`
viene impostata. Un grosso oggetto di ostacolo viene posizionato accanto ad esso.

Dopo 5 secondi, `Class.Model:MoveTo()` viene utilizzato per indirizzare il modello a muoversi
all'interno dell'oggetto di ostacolo. Tuttavia, poiché MoveTo non sposterà un modello all'interno
di un ostacolo, il `Class.Model` viene spostato verso l'alto lungo l'asse Y e posizionato sopra
l'ostacolo.


Muove la `Class.Model.PrimaryPart|PrimaryPart` nella posizione data. Se
non è stata specificata alcuna parte primaria, verrà utilizzata la parte radice del
modello, ma la parte radice non è deterministica e si raccomanda che
venga sempre impostata una parte primaria quando si utilizza `Class.Model:MoveTo()|MoveTo()`.

Se ci sono ostruzioni dove il modello è da essere spostato, come
`Class.Terrain` o altre `Class.BasePart|BaseParts`, il modello verrà
spostato verticalmente verso l'alto fino a quando non ci sarà
niente in mezzo. Se questo comportamento non è desiderato, dovrebbe essere
utilizzato `Class.PVInstance:PivotTo()`.

Nota che la rotazione non è preservata quando si sposta un modello con
`Class.Model:MoveTo()|MoveTo()`. Si raccomanda di utilizzare
`Class.Model:TranslateBy()|TranslateBy()` o `Class.PVInstance:PivotTo()`
se l'attuale rotazione del modello deve essere preservata.

Model:MoveTo

position

Il `Datatype.Vector3` in cui verrà spostato il `Class.Model`.

Muove la `Class.Model.PrimaryPart|PrimaryPart` nella posizione data. Se
non è stata specificata alcuna parte primaria, verrà utilizzata la parte radice del
modello.

Model:moveTo

Rende questo modello non più persistente per il giocatore specificato. Ciò non
garantisce che il modello verrà immediatamente rimosso per il giocatore; dopo
aver chiamato questo metodo, il modello sarà trattato come
`Enum.ModelStreamingMode|Atomic` per quel giocatore e rimarrà presente
finché è all'interno del raggio di streaming target.

`Class.Model.ModelStreamingMode|ModelStreamingMode` deve essere impostato su
`Enum.ModelStreamingMode|PersistentPerPlayer` affinché il comportamento venga modificato
come risultato della rimozione.

Model:RemovePersistentPlayer

Il `Class.Player` per rendere questo modello non più persistente.

Rende questo modello non più persistente per il giocatore specificato.
`Class.Model.ModelStreamingMode|ModelStreamingMode` deve essere impostato su
`Enum.ModelStreamingMode|PersistentPerPlayer` affinché il comportamento venga modificato
come risultato della rimozione.

Ripristina la rotazione delle parti del modello alla rotazione di identità precedentemente
impostata, che avviene tramite il metodo `Class.Model:SetIdentityOrientation()`.

Model:ResetOrientationToIdentity

I modelli contengono un fattore di scala canonico persistente, che parte da 1
per i modelli appena creati. Questa funzione scala il modello, attorno alla posizione del pivot,
rispetto a come apparirebbe con un fattore di scala di 1. Per
realizzare ciò, esegue due operazioni:

- Imposta l'attuale fattore di scala del modello sul valore specificato
- Ridimensiona e riposiziona di conseguenza tutte le istanze discendenti

Il ridimensionamento delle posizioni avviene attorno alla posizione del pivot.

Tutte le proprietà "geometriche" delle istanze discendenti saranno scalate. Questo
ovviamente include le dimensioni delle parti, ma ecco alcuni altri esempi di
proprietà che vengono scalate:

- La lunghezza dei giunti come `Class.WeldConstraint|WeldConstraints`, e
  `Class.RopeConstraint`
- Velocità e forze fisiche come `Class.HingeConstraint`
- Proprietà visive come dimensioni di emettitori di particelle
- Altre proprietà di lunghezza come `Class.Sound.RollOffMinDistance`

Model:ScaleTo

newScaleFactor

Imposta il fattore di scala del modello, regolando la dimensione e la posizione di
tutte le istanze discendenti in modo che abbiano quel fattore di scala rispetto alle
loro dimensioni e posizioni iniziali quando il fattore di scala era 1.

Imposta la rotazione di identità del modello dato, consentendo di ripristinare
la rotazione dell'intero modello in seguito, tramite l'uso del metodo
`ResetOrientationToIdentity`.

Model:SetIdentityOrientation

Questa funzione è stata sostituita da `Class.PVInstance:PivotTo()` che
funge da sostituto più performante e non modifica il comportamento del tuo codice. Usa
`Class.PVInstance:PivotTo()` per nuovi lavori e migra le tue chiamate
esistenti a `Class.Model:SetPrimaryPartCFrame()` quando conveniente.

Imposta il `Class.BasePart.CFrame` della `Class.Model.PrimaryPart` del modello.
Tutte le altre parti nel modello verranno anch'esse spostate e manterranno la loro
orientazione e offset rispetto alla `Class.Model.PrimaryPart`.

Nota, questa funzione genererà un errore se non esiste `Class.Model.PrimaryPart`
per il modello. Questo può causare problemi se, ad esempio, la parte primaria non è
gia stata impostata o è stata distrutta.

Model:SetPrimaryPartCFrame

cframe

Imposta il `Class.BasePart.CFrame` della `Class.Model.PrimaryPart` del modello.
Tutte le altre parti nel modello verranno anch'esse spostate e manterranno la loro
orientazione e offset rispetto alla `Class.Model.PrimaryPart`.

Questo campione dimostra come `Class.Model:TranslateBy()` ignori le collisioni
 e rispetti l'orientamento del modello.

Viene creato un semplice modello `Class.Model` a due parti, ruotato di 45 gradi
sull'asse Y, e il suo `Class.Model.PrimaryPart` è impostato. Una grande parte di ostacolo
è posizionata accanto ad esso.

Dopo 5 secondi, `Class.Model:TranslateBy()` viene utilizzato per indirizzare il
modello a muoversi all'interno della parte di ostacolo. Il modello si muoverà
dentro l'ostacolo e manterrà il proprio orientamento attuale.


Sposta un `Class.Model` tramite l'offset `Datatype.Vector3` dato, preservando
l'orientazione del modello. Se un'altra `Class.BasePart` o `Class.Terrain`
esiste già nella nuova posizione, il `Class.Model` sovrapporrà detto oggetto.

La traduzione viene applicata nello spazio mondiale piuttosto che nello spazio dell'oggetto,
ciò significa che, anche se le parti del modello sono orientate in modo diverso, si muoverà sempre
lungo l'asse standard.

Model:TranslateBy

delta

Il `Datatype.Vector3` con cui tradurre il `Class.Model`.

Sposta un `Class.Model` tramite l'offset `Datatype.Vector3` dato, preservando
l'orientazione del modello. Se un'altra `Class.BasePart` o `Class.Terrain`
esiste già nella nuova posizione, il `Class.Model` sovrapporrà detto oggetto.

Model

Imposta il livello di dettaglio del modello per le esperienze con
[streaming](/workspace/streaming) abilitato. I mesh compositi o
imposter non supportano la fisica, la rilevazione delle collisioni o
il raycasting.

Quando impostato su `Enum.ModelLevelOfDetail|StreamingMesh`, un mesh di
"imposter" a risoluzione più bassa (mesh colorato e grossolano che avvolge tutte le parti figlio del
modello) viene renderizzato al di fuori del raggio di streaming. Non supporta
texture.

Quando impostato su `Enum.ModelLevelOfDetail|SLIM`, un **SLIM** model (Modello
Interattivo Leggero Scalabile) rende una composizione di tutte le parti figlio a
risoluzioni progressivamente più basse a distanze basate sul raggio di streaming. Questo migliora
notevolmente la qualità visiva rispetto a `Enum.ModelLevelOfDetail|StreamingMesh`.

Quando impostato su `Enum.ModelLevelOfDetail|Disabled` o
`Enum.ModelLevelOfDetail|Automatic`, i mesh a risoluzione più bassa non verranno
displayati.


Model.LevelOfDetail

Imposta il livello di dettaglio del modello per esperienze con streaming di
istanze abilitato.

Controlla come i `Class.Model|Models` vengono streaming dentro e fuori quando lo streaming
[streaming](/workspace/streaming) delle istanze è abilitato. Il comportamento
dipende dall'enum selezionato. Non ha effetto se lo streaming non è abilitato.

Questa proprietà dovrebbe essere cambiata solo in Studio tramite la
finestra di [Proprietà](/studio/properties) quando lo streaming è
abilitato, o in `Class.Script|Scripts`, ma mai in
`Class.LocalScript|LocalScripts` (farlo può risultare in un comportamento non definito).

Model.ModelStreamingMode

Controlla il comportamento di streaming del modello `Class.Model|Models` quando
lo streaming di istanze è abilitato.

Questo esempio di codice crea e lancia un modello di dado, quindi restituisce se è
atterrato con il lato blu rivolto in alto. Se `Class.Model.PrimaryPart` non era impostato,
il pivot / la bounding box del dado ruoterebbe, poiché le parti al suo interno
vengono simulate fisicamente durante il lancio.

Punta alla parte primaria del `Class.Model`. La parte primaria è il
`Class.BasePart` che funge da riferimento fisico per il pivot del
modello. Cioè, quando le parti all'interno del modello vengono spostate a causa di simulazione
fisica o altri mezzi, il pivot si muoverà in sincronia con la parte primaria.

Nota che i `Class.Model|Models` non hanno `PrimaryPart` impostato per impostazione
predefinita. Se stai creando un modello che deve essere influenzato dalla fisica,
dovresti impostare manualmente questa proprietà in Studio o all'interno di uno script. Se la
parte primaria **non** è impostata, il pivot rimarrà nella stessa posizione nello
spazio mondiale, anche se le parti all'interno del modello vengono spostate.

Nota anche che quando si imposta questa proprietà, deve essere un `Class.BasePart`
che è un discendente del modello. Se provi a impostare
`Class.Model.PrimaryPart` su un `Class.BasePart` che **non** è un
descendente del modello, verrà impostato su quella parte ma ripristinato a `nil`
durante il passaggio di simulazione successivo &mdash; questo è un comportamento legacy per supportare
script che presumono di poter impostare temporaneamente la parte primaria su un
`Class.BasePart` che non è un discendente del modello.

La regola generale per i modelli è che:

- I modelli i cui pezzi sono uniti tramite giunti fisici come
  `Class.WeldConstraint|WeldConstraints` o `Class.Motor6D|Motor6Ds`
  dovrebbero avere una parte primaria assegnata. Ad esempio, i modelli di
  personaggi di Roblox hanno il loro `Class.Model.PrimaryPart` impostato su
  **HumanoidRootPart** per impostazione predefinita.
- I modelli statici (di solito `Class.BasePart.Anchored|Anchored`) che rimangono in
  un posto a meno che uno script non li sposti esplicitamente non richiedono un
  `Class.Model.PrimaryPart` e non tendono a beneficiare dell'avere uno impostato.

Model.PrimaryPart

La parte primaria del `Class.Model`, o `nil` se non impostata esplicitamente.

Impostare questa proprietà nella finestra Proprietà scalerà il modello come
se fosse stata chiamata `Class.Model:ScaleTo()` su di esso, scalando tutte le istanze
discendenti nel modello, come materiali, immagini e la geometria 3D delle
parti, in modo che il modello abbia il fattore di scala specificato rispetto alla sua
dimensione originale.

Questa proprietà è disponibile solo in Studio e genererà un errore se utilizzata
in un `Class.Script` o `Class.LocalScript`. Dovrebbero essere utilizzati
`Class.Model:ScaleTo()` e `Class.Model:GetScale()` dagli script.

Model.Scale

Proprietà solo per editor utilizzata per scalare il modello attorno al suo pivot. Impostare
questa proprietà muoverà la scala come se fosse stata chiamata `Class.Model:ScaleTo()` su di essa.

Questo esempio di codice mostra una funzione personalizzata per ripristinare il pivot di un modello
alla posizione centrale della sua bounding box.


Questa proprietà determina dove si trova il pivot di un `Class.Model` che
**non** ha un `Class.Model.PrimaryPart` impostato. Se il
`Class.Model` **ha** un `Class.Model.PrimaryPart|PrimaryPart`, il
pivot del `Class.Model` è uguale al pivot di quella parte primaria
invece, e questa proprietà `Class.Model.WorldPivot|WorldPivot` viene ignorata.

Per un `Class.Model` appena creato, il suo pivot sarà trattato come il centro
della bounding box dei suoi contenuti fino al **primo** impiego della
proprietà `Class.Model.WorldPivot`. Una volta impostato il world pivot per
la prima volta, è impossibile ripristinare questo comportamento iniziale.

Più comunemente, spostando il modello con gli strumenti di Studio, o con funzioni di
movimento del modello come `Class.PVInstance:PivotTo()` e
`Class.Model:MoveTo()`, verrà impostato il world pivot e quindi terminerà questo nuovo
comportamento del modello.

Lo scopo di questo comportamento è consentire al codice Luau di ottenere un pivot
sensato semplicemente creando un nuovo modello e parentando oggetti ad esso, evitando di
necessitare di impostare esplicitamente `Class.Model.WorldPivot` ogni volta che crei un
modello nel codice.

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

local model = Instance.new("Model")
Workspace.BluePart.Parent = model
Workspace.RedPart.Parent = model
model.Parent = Workspace

print(model:GetPivot())  -- Attualmente uguale al centro della bounding box contenente "BluePart" e "RedPart"

model:PivotTo(CFrame.new(0, 10, 0))  -- Questo funziona senza necessità di impostare esplicitamente "model.WorldPivot"
```

Model.WorldPivot

Determina dove si trova il pivot di un `Class.Model` che **non** ha un
`Class.Model.PrimaryPart` impostato.

I modelli sono oggetti contenitore, il che significa che raggruppano insieme oggetti. Sono
utilizzati al meglio per contenere collezioni di `Class.BasePart|BaseParts` e hanno un certo numero
di funzioni che ne estendono la funzionalità.

Una `Class.PVInstance` è una classe astratta che non può essere creata. È la
base per tutti gli oggetti che hanno una posizione fisica nel mondo.


Questo campione di codice è un semplice script di teletrasporto che sposta il tuo personaggio
10&nbsp;studs in avanti nella direzione in cui stai attualmente guardando quando premi
tu tasto <kbd>F</kbd>. Lo fa ottenendo il pivot attuale con
`Class.PVInstance:GetPivot()` e chiamando `PVInstance|PivotTo` per muovere il
personaggio in avanti.

Questa funzione ottiene il pivot di una `Class.PVInstance`. Questo è spesso utilizzato
con `Class.PVInstance:PivotTo()` per muovere un modello.

`Class.Model|Models` e `Class.BasePart|BaseParts` sono entrambi
`Class.PVInstance|PVInstances` ("Position Velocity Instances") e quindi entrambi
hanno questa funzione.


PVInstance:GetPivot

Ottiene il pivot di una `Class.PVInstance`.


Trasforma il `Class.PVInstance` insieme a tutti i suoi discendenti
`Class.PVInstance|PVInstances` in modo che il pivot si trovi ora nella
specificata `Datatype.CFrame`. Questa è la funzione principale che dovrebbe essere
utilizzata per muovere `Class.Model|Models` tramite scripting.

`Class.BasePart|BaseParts` vengono spostati in questo modo trasformando il
loro `Datatype.CFrame` attraverso l'offset necessario.
`Class.Model|Models` vengono spostati in questo modo trasformando il
loro `Class.Model.WorldPivot` attraverso l'offset necessario.

Nota che per motivi di efficienza, gli eventi `Class.Object.Changed` non vengono
attivati per `Class.BasePart.Position|Position` e
`Class.BasePart.Orientation|Orientation` di `Class.BasePart|BaseParts`
spostati in questo modo; vengono attivati solo per `Datatype.CFrame`.

Quando si chiama `Class.PVInstance:PivotTo()|PivotTo` su `Class.Model|Models`,
gli offset delle parti e dei modelli discendenti vengono memorizzati,
in modo che le chiamate successive a `Class.PVInstance:PivotTo()|PivotTo` sullo stesso modello
non accumulino drift dei punti flottanti tra le parti che compongono il
modello.

`Class.Model|Models` e `Class.BasePart|BaseParts` sono entrambi
`Class.PVInstance|PVInstances` ("Position Velocity Instances") e quindi entrambi
hanno questa funzione.


PVInstance:PivotTo

targetCFrame

Il `Datatype.CFrame` al quale il pivot della `Class.PVInstance` dovrebbe
essere uguale dopo il suo spostamento.


Trasforma il `Class.PVInstance` insieme a tutti i suoi discendenti
`Class.PVInstance|PVInstances` in modo che il pivot si trovi ora nella
specificata `Datatype.CFrame`.


PVInstance

PVInstance.Origin

PVInstance.Pivot Offset

Classe astratta per tutti gli oggetti che hanno una posizione fisica nel mondo.


`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 attraverso il codice, prendendo il
nome della classe come parametro e restituendo l'oggetto creato.

Dimostra come rilevare i cambiamenti nell'ascendenza di un'istanza collegandosi all'evento
`Class.Instance.AncestryChanged`.

Il Parent di ChangingPart viene impostato su valori diversi nel tempo. Il parent
del pezzo è l'antenato del pezzo, quindi l'evento `Class.Instance.AncestryChanged`
viene attivato ogni volta che cambia.


Si attiva quando questa istanza viene ripristinata o quando uno dei suoi
antenati viene ripristinato.

Puoi utilizzare questo evento per tenere traccia della cancellazione di un'istanza
in Studio, come la cancellazione manuale nell'Explorer o attraverso 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

L'istanza la cui proprietà `Class.Instance.Parent|Parent` è stata modificata,
che può essere questa istanza o un antenato più lontano, **non**
necessariamente l'istanza a cui è collegato gestore.

parent

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

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

Ad esempio, il seguente frammento di codice collega la funzione `attributeChanged()`
che si attiva 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 aggiunto a questo `Class.Instance`.

Nota, quando utilizzi questo metodo su un client per rilevare oggetti creati dal
server è necessario usare `Class.Instance:WaitForChild()` quando si indicizzano i
discendenti di questi oggetti. Questo perché l'oggetto e i suoi discendenti non
sono garantiti di replicarsi dal server al client simultaneamente. Ad esempio:

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

Workspace.ChildAdded:Connect(function(child)
	-- Usa WaitForChild() poiché i discendenti potrebbero non essere stati ancora replicati
	local head = child:WaitForChild("Head")
end)
```
Nota, questo evento opera solo per i figli immediati del
`Class.Instance`. Per un evento che cattura tutti i discendenti, usa
`Class.Instance.DescendantAdded`.

Vedi anche `Class.Instance.ChildRemoved`.

Instance.ChildAdded

Il `Class.Instance` che è stato aggiunto.

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

Instance.childAdded

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 (utilizzando
`Class.Instance:Destroy()`) poiché la funzione di distruzione imposta il genitore di un oggetto
su `nil`.

Questo evento opera solo per i figli immediati del `Class.Instance`.
Per un evento che cattura tutti i discendenti, 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 un discendente è stato aggiunto all'`Class.Instance`.

Poiché si attiva per ogni discendente, l'aggiunta di un oggetto all'`Class.Instance`
attiverà l'evento per questo oggetto e per tutti i suoi discendenti individualmente.

Se ti preoccupa solo i **figli diretti** del
`Class.Instance`, usa `Class.Instance.ChildAdded` invece.

Vedi anche `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

Si attiva dopo che un discendente è stato aggiunto 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`
cambi in modo tale che un'istanza **discendente** non sarà più un
discendente. `Class.Instance:Destroy()|Destroy()` cambia il `Class.Instance.Parent|Parent`
a `nil`, quindi chiamando quel metodo su un discendente del genitore farà scattare questo evento.

Poiché questo evento si attiva **prima** della rimozione del discendente, il genitore del
discendente non sarà cambiato al momento della chiamata 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 viene 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 la modifica non è ancora avvenuta
	-- Quindi, è 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 un discendente dell'`Class.Instance` venga rimosso.

Questo campione dimostra come, quando si utilizza il comportamento del segnale Immediato, un
Oggetto in fase di distruzione rimane in posizione fino a quando la funzione collegata non restituisce.

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


Il `Class.Instance` non verrà mai eliminato dalla memoria mentre una funzione collegata
lo sta ancora utilizzando. Tuttavia, se la funzione attende in qualsiasi
momento, il `Class.Instance` e i suoi discendenti verranno impostati a `nil`.

Se la proprietà `Class.Workspace.SignalBehavior` è impostata su
`Enum.SignalBehavior.Immediate`, questo evento si attiva 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 è
distrutto con `Class.Instance:Destroy()`.

Con il comportamento `Enum.SignalBehavior.Deferred|Deferred`, collegare uno script
a 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 un `Class.Instance` in Studio, come l'eliminazione manuale
attraverso l'[Explorer](/studio/explorer) o tramite un plugin,
il `Class.Instance` non viene distrutto. Invece, il genitore viene impostato su `nil`
che puoi tracciare con `Class.Instance.AncestryChanged`.

Instance.Destroying

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

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

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

Instance.StyledPropertiesChanged

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

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

#### Avvertenze

- I tag di un'istanza aggiunti lato client verranno eliminati se il
  server aggiunge o rimuove successivamente 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 siano utilizzate per
  dare al tag la sua funzionalità, ad esempio connessioni di eventi o tabelle.
  Per prevenire perdite di memoria, è una buona idea pulirle (disconnettersi,
  impostarle su `nil`, ecc.) quando non sono più necessarie per un tag. Farlo quando
  si chiama `Class.Instance:RemoveTag()`, si chiama
  `Class.Instance:Destroy()`, o in una funzione collegata a un segnale
  restituito da `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

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

Instance:children

Restituisce un array dei figli dell'oggetto.

Questo metodo 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, usa o
`Class.Instance:GetChildren()` o `Class.Instance:GetDescendants()` per
ciclare attraverso quei figli/discendenti e selezionare cosa distruggere. Ad
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

Questo metodo distrugge tutti i figli di un'istanza.

Dimostra come clonare un modello utilizzando `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`, questo metodo 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
originale:

- Se una proprietà di riferimento fa riferimento a un'istanza che è **stata** clonata,
  la copia farà riferimento alla copia.
- Se una proprietà di riferimento fa riferimento a un'istanza che **non è stata** clonata,
  lo stesso valore è 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`.

Instance:clone

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`, disconnetta tutte le connessioni e chiama
`Destroy()` su tutti i figli. Questo metodo è il modo corretto per eliminare
oggetti che non sono più richiesti.

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

Come migliore pratica dopo aver chiamato `Destroy()` su un oggetto, imposta qualsiasi
variabile che fa riferimento all'oggetto (o ai suoi discendenti) su `nil`. Questo
prevenire il tuo codice di accedere a qualsiasi cosa riguardo all'oggetto.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- Non farlo:
print(part.Name)  --> "Hello, world"
-- Fai questo per impedire 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 determinato periodo di tempo, usa
`Class.Debris:AddItem()`.

Instance:Destroy

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

Instance:destroy

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

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

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

```
local car = object:FindFirstAncestor("Car")
```
Per varianti di questo metodo che trovano antenati di una classe specifica,
si prega di vedere `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 className fornito.

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

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

```
local model = part:FindFirstAncestorOfClass("Model")
```
Questo metodo è una variante di `Class.Instance:FindFirstAncestor()`
che controlla la proprietà `Class.Object.ClassName` invece di
`Class.Instance.Name`. Esiste anche `Class.Instance:FindFirstAncestorWhichIsA()`
che utilizza il metodo `Class.Object:IsA()` invece per rispettare l'ereditarietà della classe.

Instance:FindFirstAncestorOfClass

className

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

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

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

A differenza di `Class.Instance:FindFirstAncestorOfClass()`, questo metodo utilizza
`Class.Object:IsA()` che rispetta l'ereditarietà della classe. 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 cui
`Class.Object:IsA()` restituisce vero per il className fornito.

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 opzionale `recursive`
è `true`, questo metodo cerca tutti i discendenti anziché solo i
figli immediati del `Class.Instance`.

#### Verifica 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 utilizzando 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
Workspace.Part.Transparency = 0.5
```
Un approccio migliore è usare `FindFirstChild()` per prima controllare `Part`, poi usare un'istruzione `if` per eseguire codice di cui 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 quello
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.

Nell'esempio seguente, un `Class.Folder` chiamato `Color` è stato aggiunto 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 figlio `Class.Folder`. Un vantaggio dell'uso di
`Class.Instance:FindFirstChild()|FindFirstChild()` è che l'introduzione di nuove proprietà non comporta un rischio 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% in più
rispetto a utilizzare l'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 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 considera di utilizzare
`Class.Instance.ChildAdded|ChildAdded` o
`Class.Instance:WaitForChild()|WaitForChild()` per rilevare quando un figlio di un
certo nome diventa disponibile.

Instance:FindFirstChild

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

Instance

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