`UIGradient` applica un gradiente di colore e trasparenza all'oggetto padre
`Class.GuiObject`. L'aspetto del gradiente è configurabile tramite il suo
`Class.UIGradient.Color|Color`, `Class.UIGradient.Transparency|Transparency`,
`Class.UIGradient.Offset|Offset`, `Class.UIGradient.Rotation|Rotation`,
`Class.UIGradient.Scale|Scale`, `Class.UIGradient.TileMode|TileMode`, e
`Class.UIGradient.Type|Type`.

`UIGradient` non si applicherà agli oggetti figli o discendenti
`Class.GuiObject|GuiObjects`. Per applicare lo stesso gradiente a più
oggetti, sarà necessario avere più istanze di gradiente.

Vedi anche [modificatori di aspetto](/ui/appearance-modifiers#gradient)
per ulteriori informazioni sul modificatore `UIGradient` e su come funziona.

#### Oggetti supportati

Puoi applicare modificatori `UIGradient` a `Class.Frame`, `Class.TextLabel`,
`Class.TextButton`, `Class.ImageLabel`, `Class.ImageButton`, `Class.Path2D`,
e `Class.ViewportFrame`. Tuttavia, `Class.ScrollingFrame` e `Class.TextBox`
non sono attualmente supportati.

#### Considerazioni sulle prestazioni

Per utilizzare in modo efficiente un `UIGradient`, segui questi principi:

- Evita di utilizzare più di 6 fermate di colore nella sequenza di
  `Class.UIGradient.Color|Color`.

- Evita di utilizzare un `UIGradient` su qualsiasi oggetto che applica un
  contorno di testo (`Class.TextLabel.TextStrokeColor3|TextStrokeColor3`), poiché il gradiente
  cercherà di fondersi con i contorni e i bordi, e potrebbe causare problemi di prestazioni.

- Evita di impostare frequentemente `Class.UIGradient.Color|Color` e
  `Class.UIGradient.Transparency|Transparency`: questo causa la
  ricostruzione frequente della sequenza di colori, il che è costoso. Se possibile, imposta
  queste proprietà solo una volta e cerca di animare le
  `Class.UIGradient.Offset|Offset` o `Class.UIGradient.Rotation|Rotation`
  per ottenere un effetto simile. In alternativa, puoi cambiare il
  colore dell'oggetto padre `Class.GuiObject` utilizzando proprietà come
  `Class.GuiObject.BackgroundColor3|BackgroundColor3`,
  `Class.ImageLabel.ImageColor3|ImageColor3`, o
  `Class.TextLabel.TextColor3|TextColor3`.

- Quando si applica un gradiente immutabile a un elemento UI il cui stato cambia
  frequentemente, c'è un compromesso tra l'utilizzo di un `UIGradient` (tempo di elaborazione) e
  un'immagine di gradiente statica (memoria).


UIGradient

Questa proprietà descrive il colore da mescolare con l'oggetto padre
`Class.GuiObject` lungo la `Datatype.ColorSequence` fornita. Questa
proprietà funziona in modo simile a `Class.Beam.Color` o
`Class.Trail.Color`, eccetto che si applica su una distanza determinata da
`Class.UIGradient.Offset|Offset` e
`Class.UIGradient.Rotation|Rotation`.


UIGradient.Color

Determina il colore mescolato con l'oggetto padre `Class.GuiObject` lungo la
lunghezza del gradiente.


UIGradient.Enabled

Questa proprietà determina la traduzione scalare del gradiente dal
centro dell'oggetto padre `Class.GuiObject`. È una traduzione scalare,
ciò significa che l'offset reale in pixel è determinato dalla
`Class.GuiBase2d.AbsoluteSize|AbsoluteSize` dell'oggetto padre
`Class.GuiObject`. Ad esempio, un valore di `(1, 0)` sposta il gradiente
orizzontalmente a destra di una distanza pari alla dimensione dell'oggetto padre.
A seconda di `Class.UIGradient.Rotation|Rotation`, questo potrebbe causare il
gradiente a essere parzialmente visibile o non visibile affatto.

Vedi anche `Class.UIGradient.Rotation|Rotation` che influisce anche sulla
geometria del gradiente applicato.


UIGradient.Offset

Determina la traduzione scalare del gradiente dal centro dell'oggetto
padre `Class.GuiObject`.


Questa proprietà determina la rotazione **in senso orario** in gradi del
`UIGradient` partendo da sinistra a destra. I punti di controllo di inizio e fine
si agganciano ai bordi dell'oggetto padre `Class.GuiObject`, ma mantengono la
rotazione fornita.

Vedi anche `Class.UIGradient.Offset|Offset` che influisce anche sulla geometria
del gradiente applicato.


UIGradient.Rotation

Determina la rotazione oraria in gradi del gradiente che parte da
sinistra a destra.

Questa proprietà moltiplica l'estensione del gradiente, controllando quanto
è visibile della sequenza di colore/trasparenza all'interno dell'oggetto
padre `Class.GuiObject`.

- Un valore di `1` (predefinito) significa che l'intera sequenza si estende
  esattamente una volta nell'elemento.

- Valori **minori** di `1` comprimono il gradiente in modo che l'intera sequenza
  si adatti in una regione più piccola. L'area rimanente è determinata da
  `Class.UIGradient.TileMode|TileMode`. Nota che `Scale` è limitato a un
  minimo di `0.001` per evitare gradienti degenerati.

- Valori **maggiore** di `1` allungano il gradiente oltre i confini dell'elemento
  in modo che solo una parte della sequenza sia visibile.

L'effetto di `Scale` dipende anche dal
`Class.UIGradient.Type|Type` del gradiente:

- `Enum.GradientType.Linear` — `Scale` influisce sulla distanza tra i
  punti di controllo di inizio e fine.

- `Enum.GradientType.Radial` — `Scale` influisce sul raggio del gradiente
  radiale.

- `Enum.GradientType.Conical` — `Scale` influisce sull'angolo di apertura, limitato
  in modo che l'apertura non superi una rivoluzione completa.

Vedi anche `Class.UIGradient.TileMode|TileMode` che determina come il
gradiente si ripete quando `Scale` causa che non riempia l'intero elemento.


UIGradient.Scale

Moltiplica l'estensione del gradiente, controllando quanto della
sequenza di colore/trasparenza è visibile all'interno dell'elemento.


Questa proprietà determina cosa succede quando il gradiente
`Class.UIGradient.Scale|Scale` è inferiore a `1` o quando
`Class.UIGradient.Offset|Offset` sposta il gradiente in modo che non copra
completamente l'elemento. Vedi `Enum.GradientTileMode` per i valori possibili
ed il loro effetto.

Vedi anche `Class.UIGradient.Scale|Scale` che controlla quanto della
sequenza di colore/trasparenza è visibile.


UIGradient.TileMode

Questa proprietà descrive quanto sarà opaco l'elemento UI padre lungo la
`Datatype.NumberSequence` fornita. Questa proprietà funziona in modo simile
alla `Class.Beam.Transparency` o `Class.Trail.Transparency`, eccetto
che si applica su una distanza determinata da
`Class.UIGradient.Offset|Offset` e `Class.UIGradient.Rotation|Rotation`.

Nota che i valori dell'involucro dei
`Datatype.NumberSequenceKeypoint|NumberSequenceKeypoints` vengono ignorati.


UIGradient.Transparency

Determina quanto l'oggetto padre `Class.GuiObject` può essere visto lungo
la lunghezza del gradiente.


Questa proprietà determina come varia il gradiente attraverso l'oggetto
padre `Class.GuiObject`. Vedi `Enum.GradientType` per i valori possibili e il loro
effetto.

Vedi anche `Class.UIGradient.Scale|Scale` che controlla quanto della
sequenza di colore/trasparenza è visibile, e
`Class.UIGradient.TileMode|TileMode` che determina il comportamento di ripetizione.


UIGradient.Type

Determina la forma del gradiente come lineare, radiale o conico.


Applica un gradiente di colore e trasparenza all'oggetto padre `Class.GuiObject`.


Una classe base per le classi di constraint e layout dell'interfaccia utente; eredita da
`Class.UIBase`.


UIComponent

Una classe base per le classi di constraint e layout dell'interfaccia utente.


`Class.UIBase` è la classe base per le classi di layout e vincoli UI.


UIBase

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

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


Dimostra come rilevare 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 riparentata o quando uno dei suoi
antenati viene riparentato.

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


Instance.AncestryChanged

child

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


parent

Il nuovo genitore del parametro `child`.


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


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

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

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

local part = Workspace.Part

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

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


Instance.AttributeChanged

attribute

Il nome dell'attributo che è stato modificato.


Si attiva ogni volta che un attributo viene modificato sull'`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 riparentato a questo `Class.Instance`.

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

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

Workspace.ChildAdded:Connect(function(child)
	-- Usa WaitForChild() poiché 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

Il `Class.Instance` che è stato aggiunto.


Si attiva dopo che un oggetto è stato riparentato 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, impostare un oggetto come figlio del
`Class.Instance` attiverà l'evento per questo oggetto e tutti i suoi
discendenti individualmente.

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

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`
dell'istanza su `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 rimarrà invariato 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.

#### Avviso

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
	-- Pertanto, è problematico cambiare il genitore in questo modo:
	descendant.Parent = game
end)

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


Instance.DescendantRemoving

Si attiva immediatamente prima che 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 connessa
lo sta ancora utilizzando. Tuttavia, se la funzione attende in qualsiasi momento,
il `Class.Instance` e i suoi discendenti verranno impostati su `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 attiva al prossimo punto di ripresa,
che sarà dopo che il `Class.Instance` o uno dei suoi antenati è stato
distrutto con `Class.Instance:Destroy()`.

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


Instance.Destroying

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


Dimostra `Class.Instance.StyledPropertiesChanged`.


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


Instance.StyledPropertiesChanged

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


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 fornito.

#### Avvertenze

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

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


Instance:AddTag

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


Instance:children

Restituisce un array dei figli dell'oggetto.


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
iterare 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 dell'originale:

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


Instance:Clone

Una copia dell'istanza, o `nil` se l'istanza non è
`Class.Instance.Archivable|Archivable`.


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`, 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 consumano memoria che può portare a seri problemi di prestazioni nel tempo.

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

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

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

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Per distruggere un oggetto dopo un certo 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.


Instance:destroy

Restituisce il primo antenato dell'`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
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 dell'`Class.Instance` il cui
`Class.Instance.Name` è uguale al nome fornito.


Restituisce il primo antenato dell'`Class.Instance` il cui
`Class.Object.ClassName` è uguale al nome di classe 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
nessun antenato corrispondente, restituisce `nil`.

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

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


Instance:FindFirstAncestorOfClass

className

Restituisce il primo antenato dell'`Class.Instance` il cui
`Class.Object.ClassName` è uguale al nome di classe fornito.


Restituisce il primo antenato dell'`Class.Instance` per cui
`Class.Object:IsA()` restituisce true per il nome di classe 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
nessun antenato corrispondente, restituisce `nil`.

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

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

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


Instance:FindFirstAncestorWhichIsA

Restituisce il primo antenato dell'`Class.Instance` per cui
`Class.Object:IsA()` restituisce true per il nome di classe 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 dell'`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 piuttosto che solo i
figli immediati dell'`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 genera un errore se il figlio non esiste.

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

-- La seguente riga genera un errore se la parte non esiste nello spazio di lavoro
Workspace.Part.Transparency = 0.5
```
Un approccio migliore è utilizzare `FindFirstChild()` per prima 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 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, una `Class.Folder` chiamata `Color` viene aggiunta a un
`Class.Part`, che ha anche la proprietà `Class.Part.Color`. Nota che
`part.Color` si riferisce al valore della proprietà `Datatype.Color3`, non all'istanza figlio `Class.Folder`. Un vantaggio dell'utilizzo di
`Class.Instance:FindFirstChild()|FindFirstChild()` è che l'introduzione di nuove proprietà non impone un rischio sul tuo codice.

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

#### Note sulle prestazioni

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


Instance:FindFirstChild

recursive

Se la ricerca deve essere condotta ricorsivamente o meno.


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


Instance:findFirstChild

Restituisce il primo figlio dell'`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 a `className`, ignorando l'ereditarietà delle classi. Se non viene trovato
nessun figlio corrispondente, questo metodo restituisce `nil`.


Instance:FindFirstChildOfClass

Restituisce il primo figlio dell'`Class.Instance` il cui
`Class.Object.ClassName|ClassName` è uguale al nome di classe fornito.


Restituisce il primo figlio dell'`Class.Instance` per cui
`Class.Object:IsA()` restituisce true per il nome di classe fornito.

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

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

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

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


Instance:FindFirstChildWhichIsA

Restituisce il primo figlio dell'`Class.Instance` per cui
`Class.Object:IsA()` restituisce true per il nome di classe fornito.


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

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


Instance:FindFirstDescendant

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


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


Instance:GetActor

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


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

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

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

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

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

#### Vedi anche

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


Instance:GetAttribute

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


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


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

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

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

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

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

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

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


Instance:GetAttributeChangedSignal

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


Un evento che si attiva quando l'attributo fornito cambia.


Restituisce un evento che si attiva quando l'attributo fornito 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`.

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

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

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

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


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 nullo.


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 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 .. " è il 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 .. " è il figlio numero " .. i)
end
```
Nota che l'array restituito **non** è ordinato in alcun ordine particolare, quindi
è consigliabile un ordinamento manuale (ad esempio utilizzando `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.


Instance:getChildren

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

- Questo elemento è protetto. Tentare di utilizzarlo 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 ogni istruzione prima che un'applicazione la elabori. Tutti gli oggetti in
  Roblox agiscono come processi e ogni esecuzione di istruzioni (o 'codice') può
  essere eseguita in debug se necessario.
- Questo può essere utile per i plugin che devono 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
gi figli immediati di un oggetto, questo metodo trova ogni figlio dell'oggetto, ogni figlio di quei figli, e così via.

Nota che l'array restituito **non** è ordinato in alcun ordine particolare, quindi
è consigliabile un ordinamento manuale (ad esempio utilizzando `Library.table.sort()`) per
ordinare i discendenti restituiti da questo metodo. Considera anche il
metodo `Class.Instance:QueryDescendants()|QueryDescendants()` per interrogare
discendenti tramite una combinazione di selettori e combinatori.


Instance:GetDescendants

Un array contenente i discendenti dell'istanza.


Restituisce un array contenente tutti i discendenti dell'istanza.


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

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


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

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

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


Instance:GetFullName

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


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


Instance:GetStyled

selector

Selettore opzionale per l'istanza pseudo che stai mirando sull'istanza.


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


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


Dimostra `Class.Instance:GetStyledPropertyChangedSignal()`.


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

Nota che questo evento non passerà alcun argomento a una funzione connessa,
quindi il valore della proprietà cambiata deve essere letto direttamente all'interno di uno
script.


Instance:GetStyledPropertyChangedSignal

property

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


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


Restituisce un evento che si attiva quando la proprietà di stile fornita cambia sull'istanza.


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

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


Instance:GetTags

Un array di stringhe, ciascuna rappresentante un tag applicato all'istanza.


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


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


Instance:HasTag

`true` se l'istanza ha il tag fornito, `false` altrimenti.


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

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

SpawnLocation e il suo decal sono discendenti di Workspace, non antenati.
Il decal è un discendente di SpawnLocation, non un antenato.


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

Un `Class.Instance` è considerato l'antenato di un oggetto se il
`Class.Instance.Parent` dell'oggetto o uno dei suoi genitori
`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 true se un `Class.Instance` è un antenato del dato
discendente.


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

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

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


Instance:IsDescendantOf

ancestor

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


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


Instance:isDescendantOf

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

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

Nota che questo metodo restituisce solo risultati utili per servizi e
istanze creati dagli utenti. I valori di ritorno per le proprietà popolate dal sistema di
istanze come `Class.PackageLink` sono un comportamento indefinito.

Nota anche che se questo metodo restituisce `true`, lo styling **non** influenzerà
la proprietà perché modificare esplicitamente una proprietà ha la precedenza
sullo styling. Per ripristinare una proprietà al suo valore predefinito istanziato nel codice e consentire
lo styling su di essa, utilizza
`Class.Instance:ResetPropertyToDefault()|ResetPropertyToDefault()`.


Instance:IsPropertyModified

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


Restituisce `true` se il valore memorizzato nella proprietà specificata non è uguale
a quello predefinito istanziato nel codice.


Questo metodo dell'oggetto restituisce un array che contiene tutti i discendenti dell'oggetto
che corrispondono alla stringa `selector` fornita. `selector` può includere
selettori e combinatori multipli per abbinare caratteristiche come il
nome della classe, il nome dell'istanza e le relazioni gerarchiche, così come
valori specifici delle proprietà e degli attributi dell'istanza. La grammatica di `selector`
è simile a quella utilizzata in `Class.StyleRule`, con solo alcune
piccole differenze riguardo a quali parti della grammatica sono supportate o meno.

#### Selettori

- `ClassName` — Abbina le istanze della classe specificata in una
  relazione `Class.Object:IsA()`.
- `.Tag` — Abbina le istanze contrassegnate con un tag di `Class.CollectionService`.
- `#Name` — Abbina le istanze di un specifico `Class.Instance.Name`.
- `[property = value]` — Abbina le istanze che hanno la proprietà specificata e che
  quella proprietà ha il valore specificato. Valori booleani, numerici e
  stringa sono supportati. Lettere, numeri, `_` e `-` possono essere utilizzati
  senza mettere il valore tra virgolette.
- `[$attribute]` — Abbina le istanze che hanno l'attributo specificato
  impostato.
- `[$attribute = value]` — Abbina le istanze che hanno l'attributo specificato **e**
  che quell'attributo ha il valore specificato. Le stesse
  limitazioni si applicano come per i selettori di proprietà. Se vuoi controllare l'assenza di un attributo, non interrogarlo come `nil`; invece utilizza la
  pseudo-classe `:not` come in `:not([$attribute])`.

I selettori possono anche essere combinati. Ad esempio,
`Model.Apple[$Variety = Fuji][$Flavor = 4]` abbinerà le istanze che sono
un `Class.Model` contrassegnato come `Apple` e che hanno un attributo `Variety`
eguagliato a `Fuji` così come un attributo `Flavor` uguale a `4`.

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

-- Ottieni tutti i discendenti MeshPart
print(Workspace:QueryDescendants("MeshPart"))

-- Ottieni tutti i discendenti contrassegnati come "Fruit"
print(Workspace:QueryDescendants(".Fruit"))

-- Ottieni tutti i discendenti con il nome "RedTree"
print(Workspace:QueryDescendants("#RedTree"))

-- Ottieni tutti i discendenti con la proprietà CanCollide impostata su false
print(Workspace:QueryDescendants("[CanCollide = false]"))

-- Ottieni tutti i discendenti con un attributo "FuelCapacity" assegnato
print(Workspace:QueryDescendants("[$FuelCapacity]"))
-- Ottieni tutti i discendenti con un attributo "FuelCapacity" impostato su 75
print(Workspace:QueryDescendants("[$FuelCapacity = 75]"))
```

#### Combinatori

I combinatori ti permettono di mescolare selettori di base per abbinare relazioni gerarchiche più profonde.

- `>` — Abbina le istanze che sono **figli diretti** delle corrispondenze del filtro precedente.

- `>>` — Abbina le istanze che sono **discendenti** delle corrispondenze del filtro precedente. Questo è il primo filtro predefinito, il che significa che `SpotLight.Red`
  è lo stesso di `>> SpotLight.Red`.

- `,` — Specifica un elenco di più selettori indipendenti per la query discendente. Solo gli elementi che corrispondono al filtro vengono inseriti nell'array restituito; `nil` non sarà incluso per le non corrispondenze in un elenco di query.

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

-- Ottieni figli diretti di qualsiasi Modello che sono contrassegnati come "SwordPart"
print(Workspace:QueryDescendants("Model > .SwordPart"))

-- Ottieni figli diretti che sono una Parte e sono contrassegnati come "Apple"
print(Workspace:QueryDescendants("> Part.Apple"))

-- Ottieni discendenti di qualsiasi Modello con un attributo "OnFire" impostato su true
print(Workspace:QueryDescendants("Model >> [$OnFire = true]"))

-- Ottieni discendenti MeshPart contrassegnati come "SwordPart" O con un attributo "OnFire" impostato su true
print(Workspace:QueryDescendants("MeshPart.SwordPart, MeshPart[$OnFire = true]"))
```

#### Selettori di pseudo-classe

- `:not(complex-selector-list)` — Consente di selezionare istanze che **non** corrispondono a nessuno dei selettori all'interno, eseguendo effettivamente una
  negazione dei selettori. Poiché l'espressione interna è un elenco di
  selettori complessi, è possibile filtrare in base a più condizioni.

- `:has(relative-selector-list)` — Consente di selezionare istanze in base a
  quali istanze contengono all'interno. L'elenco dei selettori viene valutato
  rispetto a ciascuna istanza.

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

-- Ottieni tutti i discendenti che NON sono di classe SpotLight
print(Workspace:QueryDescendants(":not(SpotLight)"))
-- Ottieni tutti i discendenti che NON sono di classe SpotLight O PointLight
print(Workspace:QueryDescendants(":not(SpotLight, PointLight)"))
-- Ottieni tutti i discendenti che NON hanno un attributo "OnFire"
print(Workspace:QueryDescendants(":not([$OnFire])"))
-- Ottieni tutti i discendenti ECCETTO i figli di un Modello contrassegnato come "SwordPart"
print(Workspace:QueryDescendants(":not(Model > .SwordPart)"))

-- Ottieni discendenti che contengono un'istanza Tool come loro stesso discendente
print(Workspace:QueryDescendants(":has(Tool)"))
-- Ottieni discendenti MeshPart che contengono un figlio diretto contrassegnato come "SwordPart"
print(Workspace:QueryDescendants("MeshPart:has(> .SwordPart)"))

-- Ottieni discendenti MeshPart con figli diretti NON di classe SurfaceAppearance o Texture
print(Workspace:QueryDescendants("MeshPart:has(> :not(SurfaceAppearance, Texture))"))
```


Instance:QueryDescendants

Stringa di selettore utilizzata per filtrare gli elementi.


Un array di istanze (vuoto se nulla ha corrisposto al selettore).


Restituisce un array contenente tutti i discendenti dell'istanza che corrispondono al
stringa `selector`.


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 è referenziato prima di essere rimosso, è possibile
recuperare l'oggetto in un secondo momento.


Instance:Remove

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


Instance:remove

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

Nota che quando si 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 pulire questi
( disconnettere, impostare su `nil`, ecc.) quando non sono più necessari per un tag.


Instance:RemoveTag

Instance

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


/reference/engine/classes/UIGradient.yaml