`Class.StarterGui` è un oggetto contenitore progettato per contenere
oggetti `Class.LayerCollector` come i `Class.ScreenGui|ScreenGuis`.

Quando un `Class.Player.Character` viene generato, il contenuto del loro
`Class.PlayerGui` (se presente) viene svuotato. I figli del `Class.StarterGui` vengono
quindi copiati insieme ai loro discendenti nel `Class.PlayerGui`. Tuttavia,
si noti che gli oggetti `Class.LayerCollector` come i
`Class.ScreenGui|ScreenGuis` con la proprietà
`Class.LayerCollector.ResetOnSpawn|ResetOnSpawn` impostata su `false`
vengono posti nel `Class.PlayerGui` di ciascun giocatore solo una volta e non
verranno eliminati quando il `Class.Player` viene rigenerato.

`Class.StarterGui` include anche una serie di funzioni che consentono di
interagire con il `Class.CoreGui`. Ad esempio, `Class.StarterGui:SetCoreGuiEnabled()`
puo' essere usato per disabilitare elementi del `Class.CoreGui`, e
`Class.StarterGui:SetCore()` può eseguire una serie di funzioni tra cui
creare notifiche e messaggi di sistema.

Questo metodo restituisce dati impostati o resi disponibili dagli script di base di Roblox.
Il primo e unico parametro è una stringa che seleziona le informazioni da
recuperare. Le sezioni seguenti descrivono le stringhe e i dati che esse
restituiscono tramite questa funzione.

Chiamare questo metodo potrebbe restituire risultati. Molti di questi registrano anche
una funzione equivalente `Class.StarterGui:SetCore()|SetCore()` (queste sono contrassegnate
con un asterisco).

##### PointsNotificationsActive \\*

Restituisce `true` se le notifiche dei punti giocatore sono attivate.

##### BadgesNotificationsActive \\*

Restituisce `true` se le notifiche dei badge sono attivate.

##### AvatarContextMenuEnabled \\*

Restituisce `true` se il
[Menu di Contesto Avatar](/players/avatar-context-menu) è attivato.

##### ChatActive \\*

Restituisce se la chat è attiva o meno. Questo è indicato dallo
stato di selezione dell'icona della chat nella barra superiore.

##### ChatWindowSize \\*

Restituisce la dimensione della finestra della chat come `Datatype.UDim2`.

##### ChatWindowPosition \\*

Restituisce la posizione della finestra della chat come `Datatype.UDim2`.

##### ChatBarDisabled \\*

Restituisce `true` se la barra della chat è disabilitata.

##### GetBlockedUserIds

Restituisce un elenco di `Class.Player.UserId|UserIds` associati agli utenti che
sono stati bloccati dal giocatore locale.

##### PlayerBlockedEvent

Restituisce un `Class.BindableEvent` che viene attivato ogni volta che un giocatore viene bloccato
dal giocatore locale.

##### PlayerUnblockedEvent

Restituisce un `Class.BindableEvent` che viene attivato ogni volta che un giocatore viene
sbloccato dal giocatore locale.

##### PlayerMutedEvent

Restituisce un `Class.BindableEvent` che viene attivato ogni volta che un giocatore viene messo in silenzio
dal giocatore locale.

##### PlayerUnmutedEvent

Restituisce un `Class.BindableEvent` che viene attivato ogni volta che un giocatore viene
riattivato dal giocatore locale.

##### PlayerFriendedEvent

Restituisce un `Class.BindableEvent` che viene attivato ogni volta che un giocatore è
connesso dal giocatore locale.

##### PlayerUnfriendedEvent

Restituisce un `Class.BindableEvent` che viene attivato ogni volta che un giocatore è
sconnesso dal giocatore locale.

##### DevConsoleVisible \\*

Restituisce `true` se la
[Console per Sviluppatori](/studio/developer-console) è visibile.

##### VRRotationIntensity

Restituisce una stringa che descrive la sensibilità della rotazione della telecamera in VR: `Bassa`,
`Alta` e `Morbida`. Questo non sarà disponibile a meno che
`Class.VRService.VREnabled` non sia `true`.

StarterGui:GetCore

parameterName

Restituisce una variabile specificata da uno script di base di Roblox.

L'esempio sottostante stampa se la lista dei giocatori è visibile al
LocalPlayer.

Questa funzione restituisce se il dato `Enum.CoreGuiType` è attivato, o
se è stato disabilitato utilizzando `Class.StarterGui:SetCoreGuiEnabled()`. Questa
funzione dovrebbe essere chiamata sul client.

Nota che impostare `"TopbarEnabled"` su `false` utilizzando
`Class.StarterGui:SetCore()|SetCore()` nasconde tutti gli
`Enum.CoreGuiType|CoreGuiTypes`, ma non influisce sul risultato di questa
funzione.

StarterGui:GetCoreGuiEnabled

coreGuiType

Se il dato `Enum.CoreGuiType` è abilitato.

Restituisce se il dato `Enum.CoreGuiType` è attivato, o se è stato
disabilitato utilizzando `Class.StarterGui:SetCoreGuiEnabled()`.

Questo metodo (non da confondere con
`Class.StarterGui:SetCoreGuiEnabled()|SetCoreGuiEnabled()`) espone una
varietà di funzionalità definite dagli script core di Roblox, come l'invio
di notifiche, l'attivazione delle notifiche per medaglie/punti, la definizione di un
callback per il pulsante di reset, o l'attivazione della barra superiore.

Il primo parametro è una stringa che seleziona la funzionalità con cui
la chiamata interagirà. Potrebbe essere necessario chiamare questo metodo più
volte utilizzando `Global.LuaGlobals.pcall()` nel caso in cui il rispettivo script
core non sia ancora stato caricato (o se è stato completamente disabilitato).

La seguente tabella descrive le stringhe che possono essere accettate come
primo parametro. I parametri che dovrebbero seguire dipendono dalla
funzionalità che verrà utilizzata e sono descritti in sotto-tabelle.

##### ChatActive

Controlla se la chat è attiva.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>active</code></td>
    <td>boolean</td>
    <td>(richiesto)</td>
    <td>Determina se la chat deve essere attivata.</td>
  </tr>
  </tbody>
</table>

##### PointsNotificationsActive

Controlla se le notifiche per i punti guadagnati dai giocatori appariranno.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>active</code></td>
    <td>boolean</td>
    <td>(richiesto)</td>
    <td>Determina se le notifiche per i punti guadagnati dai giocatori appariranno.</td>
  </tr>
  </tbody>
</table>

##### BadgesNotificationsActive

Controlla se le notifiche per le medaglie guadagnate appariranno.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
      </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>active</code></td>
    <td>boolean</td>
    <td>(richiesto)</td>
    <td>Determina se le notifiche per le medaglie guadagnate
appariranno.</td>
  </tr>
  </tbody>
</table>

##### ResetButtonCallback

Determina il comportamento, se presente, del pulsante di reset date un booleano o un
`Class.BindableEvent` da attivare quando un giocatore richiede di resettare.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
		</thead>
    <tbody>
	<tr>
    <td><code>enabled</code></td>
    <td>boolean</td>
    <td>(richiesto)</td>
    <td>Determina se il pulsante di reset mantiene il suo comportamento predefinito.</td>
  </tr>
	<tr>
    <td colspan="4"><b>O</b></td>
  </tr>
	<tr>
    <td><code>callback</code></td>
    <td><code>Class.BindableEvent</code></td>
    <td>(richiesto)</td>
    <td>Un <code>Class.BindableEvent</code> da attivare quando il giocatore conferma di voler resettare.</td>
  </tr>
  </tbody>
</table>

##### ChatMakeSystemMessage

Mostra un messaggio formattato nella chat. Utilizzare questo metodo richiede che
`Class.TextChatService.ChatVersion` dell'esperienza sia impostato su
`Enum.ChatVersion|LegacyChatService`, sebbene la chat legacy sia
**deprecata** e l'uso sia sconsigliato. Per le esperienze che utilizzano il
corrente `Class.TextChatService`, fare riferimento a
`Class.TextChannel:DisplaySystemMessage()`.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
      </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>configTable</code></td>
    <td>dizionario</td>
    <td>(richiesto)</td>
    <td>Un dizionario di informazioni che descrivono il messaggio (vedi sotto).</td>
  </tr>
  </tbody>
</table>

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>Text</code></td>
    <td>string</td>
    <td>(richiesto)</td>
    <td>Il messaggio da mostrare.</td>
  </tr>
	<tr>
    <td><code>Color</code></td>
    <td><code>Datatype.Color3</code></td>
    <td><code>Datatype.Color3.fromRGB(255, 255, 243)</code></td>
    <td>Colore del testo del messaggio.</td>
  </tr>
	<tr>
    <td><code>Font</code></td>
    <td><code>Enum.Font</code></td>
    <td><code>SourceSansBold</code></td>
    <td>Carattere del messaggio.</td>
  </tr>
	<tr>
    <td><code>TextSize</code></td>
    <td>intero</td>
    <td><code>18</code></td>
    <td>Dimensione del testo del messaggio.</td>
  </tr>
  </tbody>
</table>

##### SendNotification

Causa l'apparizione di una notifica non intrusiva in basso a destra dello
schermo. La notifica può avere fino a due pulsanti.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
  <tbody>
	<tr>
    <td><code>configTable</code></td>
    <td>dizionario</td>
    <td>(richiesto)</td>
    <td>Un dizionario di informazioni che descrivono la notifica (vedi sotto).</td>
  </tr>
  </tbody>
</table>

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>Title</code></td>
    <td>string</td>
    <td>(richiesto)</td>
    <td>Il titolo della notifica.</td>
  </tr>
	<tr>
    <td><code>Text</code></td>
    <td>string</td>
    <td>(richiesto)</td>
    <td>Il testo principale della notifica.</td>
  </tr>
	<tr>
    <td><code>Icon</code></td>
    <td>string</td>
    <td></td>
    <td>L'immagine da visualizzare con la notifica.</td>
  </tr>
	<tr>
    <td><code>Duration</code></td>
    <td>numero</td>
    <td><code>5</code></td>
    <td>Durata (in secondi) per cui la notifica dovrebbe essere visibile.</td>
  </tr>
	<tr>
    <td><code>Callback</code></td>
    <td><code>Class.BindableFunction</code></td>
    <td></td>
    <td>Una <code>Class.BindableFunction</code> che dovrebbe essere invocata con il testo del pulsante premuto dal giocatore.</td>
  </tr>
	<tr>
    <td><code>Button1</code></td>
    <td>string</td>
    <td></td>
    <td>Il testo da mostrare sul primo pulsante.</td>
  </tr>
	<tr>
    <td><code>Button2</code></td>
    <td>string</td>
    <td></td>
    <td>Il testo da mostrare sul secondo pulsante.</td>
  </tr>
  </tbody>
</table>

##### TopbarEnabled

Determina se la barra superiore è mostrata. Disabilitare la barra superiore disabiliterà anche
 tutti i `Class.CoreGui|CoreGuis` come la chat, l'inventario e
la lista dei giocatori (ad esempio, quelli impostati con
`Class.StarterGui:SetCoreGuiEnabled()|SetCoreGuiEnabled`).

Quando disabilitata, la regione che occupava prima la barra superiore catturerà comunque
eventi del mouse; tuttavia, i pulsanti messi lì non risponderanno ai clic.
L'origine dello spazio GUI sarà comunque spostata di 36 pixel dalla parte superiore dello
schermo.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>enabled</code></td>
    <td>boolean</td>
    <td>(richiesto)</td>
    <td>Determina se la barra superiore deve essere visibile.</td>
  </tr>
</tbody>
</table>

##### DevConsoleVisible

Determina se la
[Console dello Sviluppatore](/studio/developer-console) è visibile.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>visibility</code></td>
    <td>boolean</td>
    <td>(richiesto)</td>
    <td>Determina se la console è visibile.</td>
  </tr>
</tbody>
</table>

##### PromptSendFriendRequest

Richiede al giocatore attuale di inviare una richiesta di amicizia al
`Class.Player` dato.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(richiesto)</td>
    <td>Il giocatore a cui dovrebbe essere inviata la richiesta di amicizia.</td>
  </tr>
</tbody>
</table>

##### PromptUnfriend

Richiede al giocatore attuale di rimuovere un dato `Class.Player` dalla loro
lista di amici.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(richiesto)</td>
    <td>Il giocatore che dovrebbe essere disconnesso.</td>
  </tr>
</tbody>
</table>

##### PromptBlockPlayer

Richiede al giocatore attuale di bloccare il dato `Class.Player`.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(richiesto)</td>
    <td>Il giocatore che dovrebbe essere bloccato.</td>
  </tr>
  </tbody>
</table>

##### PromptUnblockPlayer

Richiede al giocatore attuale di sbloccare il dato `Class.Player`.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
 </thead>
 <tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(richiesto)</td>
    <td>Il giocatore che dovrebbe essere sbloccato.</td>
  </tr>
  </tbody>
</table>

##### AvatarContextMenuEnabled

Determina se il
[Menu Contestuale Avatar](/players/avatar-context-menu) è abilitato.

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>enabled</code></td>
    <td>boolean</td>
    <td>(richiesto)</td>
    <td>Determina se il menu contestuale è abilitato.</td>
  </tr>
</tbody>
</table>

##### AvatarContextMenuTarget

Apre forzosamente il
[Menu Contestuale Avatar](/players/avatar-context-menu).

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(richiesto)</td>
    <td>Il giocatore su cui sarà aperto il menu contestuale.</td>
  </tr>
</tbody>
</table>

##### AddAvatarContextMenuOption

Aggiunge un'opzione al
[Menu Contestuale Avatar](/players/avatar-context-menu).

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>option</code></td>
    <td><code>Enum.AvatarContextMenuOption</code></td>
    <td>(richiesto)</td>
    <td>Opzione da aggiungere.</td>
  </tr>
	<tr>
    <td colspan="4"><b>O</b></td>
  </tr>
	<tr>
    <td><code>option</code></td>
    <td>tabella</td>
    <td>(richiesto)</td>
    <td>Una tabella a due elementi, dove il primo è il nome dell'azione personalizzata, e il secondo è un <code>Class.BindableEvent</code> che sarà attivato quando l'opzione è stata selezionata.</td>
  </tr>
</tbody>
</table>

##### RemoveAvatarContextMenuOption

Rimuove un'opzione dal
[Menu Contestuale Avatar](/players/avatar-context-menu). L'argomento
`option` deve essere lo stesso di quello utilizzato con
`"AddAvatarContextMenuOption"` (vedi sopra).

<table size="small">
	<thead>
		<tr>
			<th>Nome</th>
			<th>Tipo</th>
			<th>Predefinito</th>
			<th>Descrizione</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>option</code></td>
    <td>Variante</td>
    <td>(richiesto)</td>
    <td>Lo stesso valore fornito a <b>AddAvatarContextMenuOption</b>.</td>
  </tr>
  </tbody>
</table>

##### AvatarContextMenuTheme

Configura il personalizzabile
[Menu Contestuale Avatar](/players/avatar-context-menu) che è una
funzione opzionale che consente una facile interazione sociale tra i giocatori
grazie ad azioni personalizzate, come l'avvio di scambi, battaglie e altro. Per ulteriori
informazioni su come personalizzare il suo tema, consultare l'articolo sul
[Menu Contestuale Avatar](/players/avatar-context-menu).

##### CoreGuiChatConnections

Configura una connessione di gateway bindable tra il pulsante chat della barra superiore di
`Class.CoreGui` e il sistema di chat legacy. Il secondo parametro deve essere una
tabella di `Class.BindableEvent|BindableEvents` e
`Class.BindableFunction|BindableFunctions`.


StarterGui:SetCore

Seleziona la funzionalità con cui la chiamata interagirà.

value

Una tabella di `Class.BindableEvent|BindableEvents` e
`Class.BindableFunction|BindableFunctions`.

Ti consente di eseguire alcune interazioni con gli script di base di Roblox.

Questa funzione imposta se l'elemento `Class.CoreGui` associato al
dato `Enum.CoreGuiType` è abilitato o disabilitato.

La barra superiore non può essere disabilitata utilizzando questa funzione. Per
disabilitarla, imposta `"TopbarEnabled"` su `false` utilizzando `Class.StarterGui:SetCore()`.

StarterGui:SetCoreGuiEnabled

enabled

Se abilitare o disabilitare il dato `Enum.CoreGuiType`.

Imposta se l'elemento `Class.CoreGui` associato al dato
`Enum.CoreGuiType` è abilitato o disabilitato.

StarterGui

Consente a `Class.StarterGui` di elaborare l'input come fanno `Class.PlayerGui` e
`Class.CoreGui`. Il valore predefinito è `false`.

StarterGui.ProcessUserInput

Consente a questo servizio di elaborare l'input come fa `Class.PlayerGui` e
`Class.CoreGui`.

Se impostato su true, ogni figlio parentato a `Class.StarterGui` sarà
clonato nella `Class.PlayerGui` di un giocatore quando il personaggio di quel giocatore viene
rigenerato.

Se uno dei figli è un PlayerGui e ha la sua proprietà PlayerGui
impostata su false, non verrà clonata.

StarterGui.ResetPlayerGuiOnSpawn

Determina se ogni figlio parentato a `StarterGui` sarà clonabile
nella `PlayerGui` di un giocatore quando il personaggio di quel giocatore viene rigenerato.

StarterGui.RtlTextSupport

Questa proprietà imposta la modalità di orientamento dello schermo preferita per gli utenti con
devices mobili. Per le diverse modalità disponibili, vedere
`Enum.ScreenOrientation`.

Per impostazione predefinita, questa proprietà è impostata su
`Enum.ScreenOrientation.Sensor|Sensor`, il che significa che l'esperienza viene
display in base alla migliore corrispondenza con l'orientamento attuale del dispositivo,
sia in orizzontale (sinistra/destra) che in verticale.

Quando un `Class.Player` si unisce all'esperienza su un dispositivo mobile, questa
proprietà determina l'orientamento iniziale del dispositivo e imposta la
`Class.PlayerGui.ScreenOrientation` di quel giocatore di conseguenza. Puoi anche ottenere
l'orientamento attuale dello schermo del giocatore attraverso
`Class.PlayerGui.CurrentScreenOrientation`, utile quando usi una delle
impostazioni di "sensore" di `Enum.ScreenOrientation`.

Nota che cambiare questa proprietà non cambierà l'orientamento dello schermo
per i `Class.Player|Players` già presenti nell'esperienza. Per cambiare l'
'orientamento per un giocatore esistente, usa la loro
`Class.PlayerGui.ScreenOrientation` proprietà.

StarterGui.ScreenOrientation

Imposta la modalità di orientamento dello schermo predefinita per gli utenti con dispositivi mobili.

Questa proprietà determina se i contenuti di `Class.StarterGui` sono
visibili in Studio.

StarterGui.ShowDevelopmentGui

Determina se i contenuti di `Class.StarterGui` sono visibili in
Studio.

StarterGui.VirtualCursorMode

Un contenitore per gli oggetti `Class.LayerCollector` da copiare nel
`Class.PlayerGui` di `Class.Player|Players`. Fornisce anche una gamma di
funzioni per interagire con il `Class.CoreGui`.

`BasePlayerGui` è una classe astratta da cui ereditano tutte le classi di memorizzazione del disegno GUI
.

Tutte le GUI restituite da `Class.BasePlayerGui:GetGuiObjectsAtPosition()` sono
'clonate' dalla funzione locale `highlightAsFrame()`, che crea una `Frame`
GUI posizionata sopra la GUI specificata, semi-trasparente e con le
stesse dimensioni `Class.GuiBase2d.AbsoluteSize` e `Class.GuiBase2d.AbsolutePosition`.

Questi evidenziatori vengono aggiunti al `ScreenGui` di HighlightsContainer
nella cartella Highlight della cartella PlayerGui del giocatore. Entrambi vengono
creati dal campione di codice. Tutte le GUI di evidenziazione vengono
`Class.Instance:Destroy()`ate ogni volta che viene eseguita `highlightGui()`.

Nota che l'ordine di visualizzazione di `HighlightContainer` è 99999, un
numero elevato, in modo che sia improbabile che altre GUI vengano
renderizzate sopra le GUI di evidenziazione.

Prende una posizione sullo schermo e restituisce un elenco di tutte le istanze di `Class.GuiObject`
che occupano quella posizione sullo schermo, ordinate nell'ordine\in cui appaiono sullo schermo dall'alto verso il basso come primo e ultimo indice,
rispettivamente. L'uso principale è ottenere oggetti GUI sotto il mouse del giocatore
o gli input di tocco per consentire selezioni o evidenziazioni.

Poiché le classi figlie di `Class.BasePlayerGui` ereditano questa funzione, può
essere attivata da classi contenitore come `Class.PlayerGui` e
`Class.StarterGui`.

BasePlayerGui:GetGuiObjectsAtPosition

La posizione **X** sullo schermo relativa all'angolo in alto a sinistra dopo\che è stata applicata l'inserzione GUI (vedi `Class.GuiService:GetGuiInset()`).

La posizione **Y** sullo schermo relativa all'angolo in alto a sinistra dopo\che è stata applicata l'inserzione GUI (vedi `Class.GuiService:GetGuiInset()`).

Una tabella delle istanze di `Class.GuiObject` che occupano lo spazio
sullo schermo dato.

Restituisce un elenco di tutte le istanze di `Class.GuiObject` che occupano il dato


BasePlayerGui

`BasePlayerGui` è una classe astratta dalla quale ereditano le classi di memorizzazione del disegno GUI
.

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

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

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

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


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

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

Instance.AncestryChanged

child

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

parent

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

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

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

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

local part = Workspace.Part

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

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

Instance.AttributeChanged

attribute

Il nome dell'attributo che è stato modificato.

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

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


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

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

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

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

Vedi anche `Class.Instance.ChildRemoved`.

Instance.ChildAdded

Il `Class.Instance` che è stato aggiunto.

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

Instance.childAdded

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

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

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

Questo evento opera solo per i figli immediati del `Class.Instance`.
Per un evento che cattura tutti i discendenti, usa
`Class.Instance.DescendantRemoving`.

Vedi anche `Class.Instance.ChildAdded`.

Instance.ChildRemoved

Il `Class.Instance` che è stato rimosso.

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

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

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

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

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

Vedi anche `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

Si attiva dopo che un discendente è stato aggiunto all'`Class.Instance`.

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

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

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

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

#### Attenzione

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

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

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

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

Instance.DescendantRemoving

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

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

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


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

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

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

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

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

Instance.Destroying

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

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

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

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

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

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

Instance.StyledPropertiesChanged

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

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

#### Avvertenze

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

- Quando si etichetta un'istanza, è comune che alcune risorse siano utilizzate per
  dare al tag la sua funzionalità, ad esempio connessioni di eventi o tabelle.
  Per prevenire perdite di memoria, è una buona idea pulirle (disconnettersi,
  impostarle su `nil`, ecc.) quando non sono più necessarie per un tag. Farlo quando
  si chiama `Class.Instance:RemoveTag()`, si chiama
  `Class.Instance:Destroy()`, o in una funzione collegata a un segnale
  restituito da `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

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

Instance:children

Restituisce un array dei figli dell'oggetto.

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

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

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

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

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

part:ClearAllChildren()

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

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

local model = Workspace:FindFirstChild("TestModel")

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

Instance:ClearAllChildren

Questo metodo distrugge tutti i figli di un'istanza.

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


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

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

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

Instance:Clone

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

Instance:clone

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

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


Imposta la proprietà `Class.Instance.Parent` su `nil`, blocca la
proprietà `Class.Instance.Parent`, disconnetta tutte le connessioni e chiama
`Destroy()` su tutti i figli. Questo metodo è il modo corretto per eliminare
oggetti che non sono più richiesti.

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

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

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

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

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Per distruggere un oggetto dopo un determinato periodo di tempo, usa
`Class.Debris:AddItem()`.

Instance:Destroy

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

Instance:destroy

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

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

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

```
local car = object:FindFirstAncestor("Car")
```
Per varianti di questo metodo che trovano antenati di una classe specifica,
si prega di vedere `Class.Instance:FindFirstAncestorOfClass()` e
`Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

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

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

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

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

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

Instance:FindFirstAncestorOfClass

className

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

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

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

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

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

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

Instance:FindFirstAncestorWhichIsA

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

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

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

#### Verifica dell'esistenza di un oggetto

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

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

-- La seguente riga genera un errore se la parte non esiste
Workspace.Part.Transparency = 0.5
```
Un approccio migliore è usare `FindFirstChild()` per prima controllare `Part`, poi usare un'istruzione `if` per eseguire codice di cui ha bisogno.

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

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

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

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

Nell'esempio seguente, un `Class.Folder` chiamato `Color` è stato aggiunto a un
`Class.Part`, che ha anche la proprietà `Class.Part.Color`. Nota che
`part.Color` si riferisce al valore della proprietà `Datatype.Color3`, non all'istanza figlio `Class.Folder`. Un vantaggio dell'uso di
`Class.Instance:FindFirstChild()|FindFirstChild()` è che l'introduzione di nuove proprietà non comporta un rischio per il tuo codice.

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

#### Note sulle prestazioni

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

Instance:FindFirstChild

recursive

Se la ricerca deve essere effettuata ricorsivamente.

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

Instance:findFirstChild

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 a `className`, ignorando l'ereditarietà della classe. 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 della classe fornito.

Restituisce il primo figlio del `Class.Instance` per cui
`Class.Object:IsA()` restituisce vero 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 anziché
solo i figli immediati del `Class.Instance`.

A differenza di `Class.Instance:FindFirstChildOfClass()`, questo metodo utilizza
`Class.Object:IsA()` che rispetta l'ereditarietà della classe. 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")
```
I programmatori che cercano un figlio per nome dovrebbero usare
`Class.Instance:FindFirstChild()` invece.

Instance:FindFirstChildWhichIsA

Restituisce il primo figlio del `Class.Instance` per cui
`Class.Object:IsA()` restituisce vero per il className 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 il `Class.Instance` è un `Class.Actor`, viene restituito il `Class.Actor` stesso.
Altrimenti, viene restituito il suo antenato `Class.Actor` più vicino. Se nessun
autore è un `Class.Actor`, il risultato è `nil`.

Instance:GetActor

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

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

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

```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 valore fornito.
- `Class.Instance:GetAttributes()` che restituisce un dizionario di coppie chiave‑valore
  per ciascuno degli attributi dell'istanza.

Instance:GetAttribute

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

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

Questo metodo restituisce un evento che si comporta esattamente come il
`Class.Object.Changed|Changed` evento, eccetto che si attiva solo quando
il dato attributo specifico cambia; 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 l'attributo `InitialPosition` della parte cambia:

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

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

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

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

Instance:GetAttributeChangedSignal

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

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

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 assegnato al dato nome
dell'attributo.

Instance:GetAttributes

Un dizionario di coppie stringa → varianti 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 usando 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 nessun ordine particolare, quindi
l'ordinamento manuale (ad esempio utilizzando `Library.table.sort()`) è consigliato 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 usarlo in un `Class.Script` o
  `Class.LocalScript` causerà un errore.
- Un ID di debug è un ID utilizzato nei processi di debug. Consente a un debugger di
  leggere ogni istruzione prima che un'applicazione la elabori. Tutti gli oggetti in
  Roblox si comportano come processi e ciascuno esegue istruzioni (o 'codice') che possono
  essere esaminati in caso di necessità.
- 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
portare i 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 nessun ordine particolare, quindi
l'ordinamento manuale (ad esempio utilizzare `Library.table.sort()`) è consigliato 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 viene chiamato su un `Class.Instance` che non è un discendente del
`Class.DataModel`, questo metodo considera tutti gli antenati fino a e
inclusa il più alto senza un `Class.Instance.Parent|Parent`.

Questo metodo è utile per la registrazione e il debug. Non dovresti tentare di
analizzare la stringa restituita per alcuna operazione utile; questo metodo non
escape i punti (o qualsiasi altro simbolo) nei nomi degli oggetti. In altre parole,
sebbene il suo output appaia spesso come un identificatore valido di Luau, 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 al valore della proprietà
direttamente, come `[GuiObject].Rotation`, che restituisce il valore predefinito o
modificato della proprietà.

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

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

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

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

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

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

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

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

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

Instance:GetStyled

selector

Selettore opzionale per l'istanza pseudo a cui ti stai indirizzando
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.

Questo metodo restituisce un evento che si comporta esattamente come il
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` evento,
eccetto che si attiva solo quando la data proprietà di stile cambia. È
generally a good idea to use this method instead of a connection to
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` with a
function that checks the property name. Subsequent calls to this method on
the same object with the same property name return the same event.

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.

```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à di 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 all'istanza data, come
stringhe. Puoi aggiungere tag sia in Studio nella finestra
[Proprietà](/studio/properties) o durante l'esecuzione con
`Class.Instance:AddTag()|AddTag()`.

Questo metodo è utile quando vuoi fare qualcosa con più tag su
un'istanza contemporaneamente. Tuttavia, è inefficiente usare questo metodo per
controllare 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) o durante l'esecuzione 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 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 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 genitori di questo
`Class.Instance.Parent` è impostato su `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 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 proprietà specifica è stata modificata da
quella predefinita istanziata dal codice. Se chiamato su un'istanza appena creata tramite
codice (`Datatype.Instance.new()`), questo metodo restituirà `false`. Se
chiamato su un oggetto appena creato dai flussi di lavoro di Studio come
l'inserimento dalla 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 attraverso `Datatype.Instance.new()` restituirà `false`, assumendo che non
sia stata apportata alcuna modifica ai
`Class.TextLabel.BackgroundColor3|BackgroundColor3`.

Nota che questo metodo restituisce risultati utili solo per servizi e
istanze creati dall'utente. I valori di ritorno per le proprietà popolate dal sistema
delle istanze come `Class.PackageLink` hanno un comportamento indefinito.

Nota inoltre che se questo metodo restituisce `true`, lo styling **non** influirà
sulla proprietà poiché la modifica esplicita di una proprietà ha la precedenza sullo
styling. Per resettare una proprietà al suo predefinito istanziato dal codice e consentire
lo styling su di essa, usa
`Class.Instance:ResetPropertyToDefault()|ResetPropertyToDefault()`.

Instance:IsPropertyModified

Booleano che indica se la proprietà è modificata dal suo
predefinito istanziato dal codice.

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

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/StarterGui.yaml