La classe base per le classi di vincoli UI.


UIConstraint

Una classe base per le classi di vincolo e layout UI; eredita da
`Class.UIBase`.


UIComponent

Una classe base per le classi di vincolo e layout UI.


`Class.UIBase` è la classe base per le classi di layout e vincoli dell'interfaccia utente.


UIBase

`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 perseguito a questa `Class.Instance`.

Nota: quando si utilizza questo metodo su un client per rilevare oggetti creati dal
server, è necessario utilizzare `Class.Instance:WaitForChild()` quando
indicizziamo i discendenti di questi oggetti. Questo perché l'oggetto e i suoi
discendenti non sono garantiti a replicarsi dal server al client
dello stesso. 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: 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

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 questa `Class.Instance` a qualcosa di diverso da questa `Class.Instance`. Nota, questo
evento si attiverà anche quando un figlio è distrutto (usando
`Class.Instance:Destroy()`) poiché la funzione di distruzione imposta il genitore di un oggetto su `nil`.

Questo evento opera solo per i figli immediati della `Class.Instance`.
Per un evento 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

Questo metodo distrugge tutti i figli e discendenti di un'istanza.

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

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

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

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

part:ClearAllChildren()

print("Children:", #part:GetChildren())  --> Children: 0
```
Se non desideri distruggere **tutti** i figli e discendenti, utilizza
`Class.Instance:GetChildren()` o `Class.Instance:GetDescendants()` per
ciclare attraverso quei figli/discendenti e selezionare cosa distruggere. Per
esempio, il seguente esempio di codice distruggerà tutti gli
`Class.BasePart|BaseParts` che discendono 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 usando `Class.Instance:Clone()`.

`Clone()` crea una copia di un'istanza e di tutte le sue 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 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 è** 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`.

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. Questo metodo è 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, il che può
dare origine a seri problemi di prestazioni nel tempo.

Come buona pratica, dopo aver chiamato `Destroy()` su un oggetto, imposta eventuali
variabili che fanno riferimento all'oggetto (o ai suoi discendenti) su `nil`. Questo
impedisce che il tuo codice acceda a qualsiasi cosa relativa all'oggetto.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- Non fare questo:
print(part.Name)  --> "Hello, world"
-- Fai così per impedire al codice precedente di funzionare:
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`. Per 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, utilizza
`Class.Debris:AddItem()`.

Instance:Destroy

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

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

Questo metodo 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
nominato `Car`.

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

Questo metodo 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
visto alcun antenato corrispondente, restituisce `nil`.

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

```
local model = part:FindFirstAncestorOfClass("Model")
```
Questo metodo è una variante di `Class.Instance:FindFirstAncestor()` che
controlla la proprietà `Class.Object.ClassName` anziché
`Class.Instance.Name`. Esiste anche `Class.Instance:FindFirstAncestorWhichIsA()`,
che utilizza 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` fornito.

Questo metodo 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
visto alcun antenato corrispondente, restituisce `nil`.

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

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
Pertanto, il seguente esempio 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 fornito, o
`nil` se non esiste alcun figlio di questo tipo. Se l'argomento opzionale `recursive`
è impostato su `true`, questo metodo cerca tutti i discendenti piuttosto che solo i
figli immediati del `Class.Instance`.

##### Controllare l'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
lancia un errore se il figlio non esiste.

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

-- La seguente riga restituisce un errore se la parte non esiste nello spazio di lavoro
Workspace.Part.Transparency = 0.5
```
Un'approccio migliore è usare `FindFirstChild()` per prima controllare `Part`,
quindi utilizzare un'istruzione `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 quello
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` è aggiunta a un
`Class.Part`, che ha anche la proprietà `Class.Part.Color`. Nota che
`part.Color` si riferisce al valore della proprietà `Datatype.Color3`, non all'istanza
`Class.Folder` figlio. Un vantaggio di utilizzare
`Class.Instance:FindFirstChild()|FindFirstChild()` è che l'introduzione di nuove proprietà non
comporta 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% in più
rispetto all'uso dell'operatore punto e quasi 8 volte di più rispetto all'archiviazione
semplice di un riferimento a un oggetto. Pertanto, dovresti evitare di chiamarlo in
codice dove le prestazioni sono importanti, come in cicli stretti o funzioni collegate
a `Class.RunService.Heartbeat` e `Class.RunService.PreRender`. Invece,
esternalizza il risultato in una variabile, o considera di usare
`Class.Instance.ChildAdded|ChildAdded` o
`Class.Instance:WaitForChild()|WaitForChild()` per rilevare quando un figlio di un
certo nome diventa disponibile.

Instance:FindFirstChild

recursive

Se la ricerca deve essere condotta ricorsivamente.

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

Restituisce il primo figlio del `Class.Instance` il cui
`Class.Object.ClassName|ClassName` è uguale al `className` fornito.
A differenza di `Class.Instance:FindFirstChildWhichIsA()`, questo metodo restituisce solo
oggetti la cui classe corrisponde al `className`, ignorando l'ereditarietà delle classi. Se non viene
trovato alcun figlio corrispondente, questo metodo 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` fornito.

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

A differenza di `Class.Instance:FindFirstChildOfClass()`, questo metodo utilizza
`Class.Object:IsA()` che rispetta l'ereditarietà delle classi. Per esempio:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Pertanto, il seguente esempio 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 che cercano un figlio per nome dovrebbero utilizzare
`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.

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

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

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

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

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

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

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```
Vedi anche `Class.Instance.AttributeChanged` che si attiva ogni volta che 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 un ciclo `for` numerico o generico:

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

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

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

-- Esempio di ciclo generico
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " è figlio numero " .. i)
end
```
Nota che l'array **non** è ordinato in alcun modo particolare, quindi è consigliabile
una ordinamento manuale (ad esempio usando `Library.table.sort()`) per ordinare
i figli restituiti da questo metodo.

Vedi anche il metodo `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. Per esempio, un `Class.Part` nello `Class.Workspace` potrebbe
restituire `Class.Workspace.Part`.

Quando chiamato su un `Class.Instance` che non è un discendente del
`Class.DataModel`, questo metodo considera tutti gli antenati up to and including
quello al di sopra senza un `Class.Instance.Parent|Parent`.

Questo metodo è utile per il logging e il debug. Non dovresti tentare
di analizzare la stringa restituita per operazioni utili; questo metodo non
escape i punti (o qualsiasi altro simbolo) nei nomi degli oggetti. In altre parole,
sebbene la sua uscita appaia spesso come un identificatore Luau valido, non è garantito.

Instance:GetFullName

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

Questo metodo restituisce il valore stilizzato o esplicitamente modificato della
proprietà specificata, o altrimenti il valore 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.

Questo metodo indica se una specifica proprietà è stata modificata rispetto
a quella predefinita istanziata dal codice. Se chiamato su un'istanza nuova creata tramite
codice (`Datatype.Instance.new()`), questo metodo restituirà `false`. Se
chiamato su un oggetto nuovo creato da flussi di lavoro di Studio come
[Explorer](/studio/explorer) l'inserimento della finestra, il risultato può
variare.

Ad esempio, interrogare la
`Class.TextLabel.BackgroundColor3|BackgroundColor3` proprietà di un
`Class.TextLabel` inserito tramite l'[Explorer](/studio/explorer)
restituirà `true`, ma interrogare la stessa proprietà di un `Class.TextLabel`
creato tramite `Datatype.Instance.new()` restituirà `false`, supposizione che non
siano state fatte altre modifiche al suo
`Class.TextLabel.BackgroundColor3|BackgroundColor3`.

Nota che se questo metodo restituisce `true`, lo stile **non** influenzerà la
proprietà poiché modificare esplicitamente una proprietà ha la precedenza su
stilizzarla. Per ripristinare una proprietà al suo valore predefinito istanziato dal codice e consentire
la stilizzazione, utilizza
`Class.Instance:ResetPropertyToDefault()|ResetPropertyToDefault()`.


Instance:IsPropertyModified

Booleano che indica se la proprietà è stata modificata rispetto al suo
valore predefinito istanziato dal codice.


Restituisce `true` se il valore memorizzato nella proprietà specificata è diverso
dal valore predefinito istanziato dal codice.


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

Questo metodo imposta il `Class.Instance.Parent` dell'oggetto su `nil`, e fa
lo stesso per tutti i suoi discendenti.

Se l'oggetto viene referenziato prima di essere rimosso, è possibile
recuperarlo 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 fornito. Se il
figlio non esiste, attenderà il thread corrente fino a quando non esiste.
Se è specificato il parametro `timeOut`, questo metodo scadrà dopo il
numero specificato di secondi e restituirà `nil`.

##### Uso Principale

`Class.Instance:WaitForChild()|WaitForChild()` è estremamente importante quando
si lavora su codice eseguito dal client in uno `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, il che potrebbe causare il malfunzionamento degli script
quando si indicizzano oggetti che non esistono ancora sul client.

##### Note

- Questo metodo non attende se un figlio con il nome fornito 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 i 5 secondi senza restituire, e non è
t stata specificato un parametro `timeOut`, verrà stampato un avviso sull'output
di cui il thread potrebbe attendere 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`.

Questa proprietà serviva a proteggere gli oggetti nel servizio `Class.CoreGui` da
essere alterati dagli utenti in modo non autorizzato. È stata deprecata
 e non fa nulla.

Instance.RobloxLocked

Una proprietà deprecata che in passato proteggeva gli oggetti `Class.CoreGui`.

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

Instance.Sandboxed

Trasforma l'istanza in un contenitore sandboxed.

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

Instance.UniqueId

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

/reference/engine/classes/UIConstraint.yaml