Questo esempio di codice include un semplice esempio di come il giocatore locale
`PlayerMouse` può essere recuperato utilizzando la funzione `Class.Player:GetMouse()` in
uno `LocalScript`. Questo codice dovrebbe essere posizionato in uno `LocalScript` in
`StarterPlayerScripts`.

Il PlayerMouse si comporta in modo identico all'oggetto `Class.Mouse` che viene
ottenuto utilizzando `Class.Tool.Equipped`. Può essere accessibile da
`Class.LocalScript|LocalScripts` utilizzando il metodo `Class.Player:GetMouse()`
del giocatore locale. Sia PlayerMouse che `Class.Mouse` sono
API legacy, superate da `Class.UserInputService`.

L'unica differenza tra il PlayerMouse e l'oggetto `Class.Mouse` è che
il PlayerMouse può essere ottenuto utilizzando il metodo `Class.Player:GetMouse()`.

Nella maggior parte dei casi si consiglia agli sviluppatori di utilizzare il nuovo
`Class.UserInputService`. Tuttavia, gli oggetti PlayerMouse e Mouse rimangono supportati per diversi
motivi. Consulta [Input e Telecamera](/input) per ulteriori informazioni
su come personalizzare gli input nella tua esperienza.


PlayerMouse

Il PlayerMouse si comporta in modo identico all'oggetto `Class.Mouse` che viene
ottenuto utilizzando `Class.Tool.Equipped`. Sia PlayerMouse che `Class.Mouse` sono
API legacy, superate da `Class.UserInputService`.


**Mouse** è stato soppiantato da `Class.UserInputService` e
`Class.ContextActionService`, che coprono un ambito più ampio, sono più ricchi di funzionalità
 e supportano meglio i modelli **cross-platform**. Rimane supportato
 a causa del suo ampio utilizzo, ma dovresti prendere seriamente in considerazione di utilizzare questi
 alternative.

L'oggetto **Mouse** ospita varie API per puntatori, principalmente per pulsanti
e raycasting. Può essere accesso tramite `Class.Player:GetMouse()` chiamato su
the `Class.Players.LocalPlayer` in uno `Class.LocalScript`. Viene anche passato dall'evento
`Class.Tool.Equipped`.

- È particolarmente noto per la proprietà `Class.Mouse.Icon|Icon`, che cambia
  l'aspetto del cursore.
- Effettua continuamente raycasting della posizione del mouse sullo schermo nel mondo 3D utilizando
  la proprietà `Class.Mouse.TargetFilter|TargetFilter`, memorizzando i risultati del
  raycast nelle proprietà `Class.Mouse.Hit|Hit`, `Class.Mouse.Target|Target`, e
  `Class.Mouse.TargetSurface|TargetSurface`. Questi possono essere utili
  in casi semplici, ma `Class.WorldRoot:Raycast()` dovrebbe essere utilizzato in scenari più
  complessi di [raycasting](/workspace/raycasting).
- `Class.Plugin|Plugins` possono usare `Class.Plugin:GetMouse()` per ottenere un
  `Class.PluginMouse`, che si comporta in modo simile.

```lua
-- Da un LocalScript:
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
-- Impostazione dell'icona del mouse
mouse.Icon = "rbxasset://SystemCursors/Wait"
```
Nota:

- Questo oggetto non controlla/restringe il movimento del puntatore. Per questo, vedere
  `Class.UserInputService.MouseBehavior` e
  `Class.UserInputService.MouseDeltaSensitivity`.
- Se due funzioni sono connesse allo stesso evento di input, come
  `Class.Mouse.Button1Down|Button1Down`, **entrambe** le funzioni verranno eseguite quando il
  evento viene attivato. Non c'è il concetto di affondare/passare input, poiché gli eventi non
  supportano questo comportamento. Tuttavia, `Class.ContextActionService` ha questo
  comportamento tramite `Class.ContextActionService:BindAction()|BindAction`.
- Anche se un mouse potrebbe non essere disponibile su tutte le piattaforme, il Mouse continuerà
  a funzionare su mobile (touch) e console (gamepad), che tipicamente non hanno
  mouse o hardware di puntamento. Per comportamenti espliciti cross-platform, usare
  `Class.UserInputService` e `Class.ContextActionService`.

  Vedi [Input e Camera](/input) per ulteriori informazioni su
  come personalizzare gli input nella tua esperienza.

Questo evento si attiva quando il giocatore preme il pulsante sinistro del mouse. Nota
che questo può essere accessibile da uno `Class.Tool`; ad esempio, se posto in
uno `Class.LocalScript`, il codice seguente stampa `Button1Down` ogni volta che il
pulsante sinistro del mouse viene premuto.

```lua
local tool = script.Parent  -- Assicurati che questo sia un oggetto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button1Down:Connect(function()
		print("Button1Down")
	end)
end)
```
Puoi scoprire la posizione del mouse nello spazio mondiale e se sta
puntando verso qualche `Class.BasePart` usando le proprietà `Class.Mouse.Hit|Hit` e
`Class.Mouse.Target|Target`.

Mouse.Button1Down

Si attiva quando il pulsante sinistro del mouse viene premuto.

Questo evento si attiva quando il giocatore rilascia il pulsante sinistro del mouse. Nota
che questo può essere accessibile da uno `Class.Tool`; ad esempio, se posto in
uno `Class.LocalScript`, il codice seguente stampa `Button1Up` ogni volta che il sinistro
il pulsante del mouse è rilasciato.

```lua
local tool = script.Parent  -- Assicurati che questo sia un oggetto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button1Up:Connect(function()
		print("Button1Up")
	end)
end)
```
Puoi scoprire la posizione del mouse nello spazio mondiale e se sta
puntando verso qualche `Class.BasePart` usando le proprietà `Class.Mouse.Hit|Hit` e
`Class.Mouse.Target|Target`.

Mouse.Button1Up

Si attiva quando il pulsante sinistro del mouse viene rilasciato.

Questo evento si attiva quando il giocatore preme il pulsante destro del mouse. Nota
che questo può essere accessibile da uno `Class.Tool`; ad esempio, se posto in
uno `Class.LocalScript`, il codice seguente stampa `Button2Down` ogni volta che il
pulsante destro del mouse viene premuto.

```lua
local tool = script.Parent  -- Assicurati che questo sia un oggetto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button2Down:Connect(function()
		print("Button2Down")
	end)
end)
```
Puoi scoprire la posizione del mouse nello spazio mondiale e se sta
puntando verso qualche `Class.BasePart` usando le proprietà `Class.Mouse.Hit|Hit` e
`Class.Mouse.Target|Target`.

Mouse.Button2Down

Si attiva quando il pulsante destro del mouse viene premuto.

Questo evento si attiva quando il giocatore rilascia il pulsante destro del mouse. Nota
che questo può essere accessibile da uno `Class.Tool`; ad esempio, se posto in
uno `Class.LocalScript`, il codice seguente stampa `Button2Up` ogni volta che il
pulsante destro del mouse viene rilasciato.

```lua
local tool = script.Parent  -- Assicurati che questo sia un oggetto Tool

tool.Equipped:Connect(function(mouse)
	mouse.Button2Up:Connect(function()
		print("Button2Up")
	end)
end)
```
Puoi scoprire la posizione del mouse nello spazio mondiale e se sta
puntando verso qualche `Class.BasePart` usando le proprietà `Class.Mouse.Hit|Hit` e
`Class.Mouse.Target|Target`.

Mouse.Button2Up

Attivato quando il pulsante destro del mouse viene rilasciato.

Questo esempio dimostra come gli eventi del mouse vengono passati durante ogni fotogramma


Attivato ad ogni battito del cuore in cui il mouse non viene passato a un altro
evento del mouse.

Nota, questo evento non dovrebbe essere utilizzato per determinare quando il mouse è fermo.
Poiché si attiva ad ogni battito del cuore, si attiverà tra gli eventi `Class.Mouse.Move`.

Per informazioni su come ottenere l'oggetto `Class.Mouse`, si prega di consultare la
pagina `Class.Mouse`.

Gli sviluppatori possono scoprire la posizione del mouse nello spazio mondiale, e se
sta puntando verso qualche `Class.BasePart` utilizzando le proprietà `Class.Mouse.Hit` e
`Class.Mouse.Target`.

Nota, agli sviluppatori è consigliato di utilizzare `Class.UserInputService` invece
che l'oggetto `Class.Mouse` nelle nuove lavori.

Mouse.Idle

Attivato ad ogni battito del cuore in cui il mouse non viene passato a un altro
evento del mouse.

L'esempio qui sotto, assumendo che 'mouse' sia stato definito, stamperà il tasto che
è stato premuto (ad esempio "q") insieme al valore ascii per quel tasto (ad esempio 113).


Questo evento si attiva quando un tasto viene premuto, con l'argomento passato che è il
tasto premuto.

Nota:

- Non tutti i tasti generano questo evento. Tuttavia, puoi aggirare questo con
  alcuni dei tasti, ad esempio con "/", utilizzando l'evento `Class.Mouse.KeyUp`.
- Alcuni tasti generano la stessa stringa di altri tasti.
- È possibile che la stringa sia vuota (possibilmente a causa del codice tasto "\\0").

Mouse.KeyDown

Mouse.keyDown

L'esempio sottostante, assumendo che 'mouse' fosse definito, stamperebbe il tasto che
è stato rilasciato (es. "q") insieme al valore ascii per quel tasto (es. 113).


Questo evento viene attivato quando un tasto viene rilasciato, con l'argomento passato che è
il tasto che è stato rilasciato.

Nota:

- Non tutti i tasti generano questo evento. Tuttavia, puoi aggirare questo con
  alcuni dei tasti, ad esempio,"/" utilizzando l'evento
  [[API:Class/Mouse/KeyUp|KeyUp]].
- Alcuni tasti generano la stessa stringa di altri tasti.
- È possibile che la stringa sia vuota (possibilmente a causa di un codice
  chiave "\\0").


Mouse.KeyUp

Si attiva quando un tasto viene rilasciato.


L'esempio qui sotto consente al `Class.Players.LocalPlayer|giocatore locale` di
spostare le parti con il proprio mouse.

Quando il giocatore preme il pulsante sinistro del mouse su una parte, quella parte è il
`Class.Mouse.Target|target del mouse` e diventa il _punto_. Fino a quando il giocatore
rilascia il pulsante sinistro del mouse, quella parte si muoverà alla posizione del mouse
nel mondo quando il giocatore muove il mouse.

Nota che la proprietà `Class.Mouse.TargetFilter` consente al codice di ignorare
la parte in movimento quando si determina la posizione del mouse nel mondo.

Il codice dovrebbe funzionare come previsto se inserito in un `LocalScript`.

Attivato quando il mouse viene spostato.

Nota, questo evento viene attivato quando la posizione del mouse viene aggiornata, quindi
verrà attivato ripetutamente mentre è in movimento.

Per informazioni su come ottenere l'oggetto `Class.Mouse`, si prega di vedere la
pagina `Class.Mouse`.

Gli sviluppatori possono scoprire la posizione del mouse nello spazio mondiale, e se
sta puntando a qualche `Class.BasePart` utilizzando le proprietà `Class.Mouse.Hit` e
`Class.Mouse.Target`.

```
mouse.Move:Connect(function()
	local position = mouse.Hit.p
	local target = mouse.Target
	print(target, position)
end)
```
Nota, si raccomanda agli sviluppatori di utilizzare `Class.UserInputService` invece
che l'oggetto `Class.Mouse` in nuovi lavori.


Mouse.Move

Attivato quando il mouse viene spostato.


L'esempio qui sotto presuppone che tu abbia già ottenuto il mouse del giocatore (e
lo abbia impostato come variabile chiamata 'mouse'), sia utilizzando un `Class.Tool`,
un `Class.HopperBin` o il metodo `Class.Player:GetMouse()`. Stampa
"La ruota è andata indietro!" quando il giocatore scorre all'indietro.

L'evento WheelBackward si attiva quando la rotella del mouse viene scorsa all'indietro.
Possibili usi per questo evento includono l'attivazione del mirino di un'arma in uno sparatutto in prima persona (FPS) o lo zoom della fotocamera del giocatore.

Questo può essere utilizzato insieme all'evento di scorrimento in avanti,
`Class.Mouse.WheelForward`.

Per informazioni su come ottenere l'oggetto `Class.Mouse`, si prega di vedere la
pagina `Class.Mouse`.

Nota, si raccomanda agli sviluppatori di utilizzare `Class.UserInputService` invece
che l'oggetto `Class.Mouse` in nuovi lavori.


Mouse.WheelBackward

Attivato quando la rotella del mouse viene scorsa all'indietro.


L'esempio qui sotto presume che tu abbia già ottenuto il mouse del giocatore (e
lo abbia impostato come variabile chiamata 'mouse'), sia tramite un `Tool`, `HopperBin`
o il metodo `Class.Player:GetMouse()`. Stamperà "La ruota è andata avanti!"
quando il giocatore scorre in avanti.

L'evento WheelForward si attiva quando la rotella del mouse viene scorsa in avanti.
Possibili usi per questo evento includono l'attivazione del mirino di un'arma in uno sparatutto in prima persona (FPS) o lo zoom della fotocamera del giocatore.

Questo può essere utilizzato insieme all'evento di scorrimento all'indietro,
`Class.Mouse.WheelBackward`.

Per informazioni su come ottenere l'oggetto `Class.Mouse`, si prega di vedere la
pagina `Class.Mouse`.

Nota, si raccomanda agli sviluppatori di utilizzare `Class.UserInputService` invece
che l'oggetto `Class.Mouse` in nuovi lavori.


Mouse.WheelForward

Attivato quando la rotella del mouse viene scorsa in avanti.


Mouse

Il codice in questo esempio, se posizionato all'interno di un `LocalScript` in
`StarterPlayerScripts`, disegnerà un raggio laser rosso tra la testa del personaggio
ed `Class.Mouse.Hit` in ogni momento.

Nota, questo raggio passerà direttamente attraverso gli ostacoli in terza persona poiché il
raggio del `Mouse` viene tracciato dalla `Class.Workspace.CurrentCamera`, non dalla
testa.

Il codice qui sotto visualizza la differenza tra `Class.Mouse.Hit` e
`Class.Mouse.Origin`. Per fare questo, il codice utilizza le
posizioni `Datatype.Vector3` dei valori di impatto e origine `Datatype.CFrame`
utilizzando `.p`.

La differenza è che l'origine è "dove il mouse è partito" (la sua origine)
e l'impatto è la posizione in cui il mouse colpisce (è quando il giocatore preme
tasto del mouse).

Questo esempio visualizza anche che l'origine del mouse è molto simile alla
posizione della `CurrentCamera` stampando la grandezza (distanza) tra
le due posizioni.

Questa proprietà indica il `Datatype.CFrame` della posizione del mouse nello spazio 3D.
Nota che `Class.Mouse.TargetFilter` e i suoi discendenti verranno
ignorati.

Gli sviluppatori possono ottenere la posizione di Hit in questo modo:

```
local position = mouse.Hit.Position
```
Hit è spesso usato da `Class.Tool|Tools` per sparare un'arma verso il mouse
in terza persona.

Gli sviluppatori che cercano il `Class.BasePart` su cui punta il mouse
dovrebbero usare `Class.Mouse.Target`.

#### Come viene calcolato Mouse.Hit?

La posizione del CFrame di Hit è calcolata come il punto di intersezione
tra il `Datatype.Ray` interno del mouse (una versione estesa di
`Class.Mouse.UnitRay`) e un oggetto nello spazio 3D (come una parte).

L'orientamento del CFrame di Hit corrisponde alla direzione del
`Class.Mouse.UnitRay`.

```
local unitRayDirection = mouse.UnitRay.Direction
local mouseHitDirection = mouse.Hit.lookVector
-- unitRayDirection ≈ mouseHitDirection
-- i vettori sono approssimativamente uguali
```
Nota, il roll del `Class.Workspace.CurrentCamera` non viene utilizzato quando
si calcola l'orientamento del `Datatype.CFrame` di Hit.

Il raggio interno del mouse si estende per 1.000 studs. Se il mouse non è
puntato su un oggetto nello spazio 3D (ad esempio quando punta al cielo),
questa proprietà sarà a 1.000 studs di distanza dal
`Class.Workspace.CurrentCamera`.

Mouse.Hit

Il `Datatype.CFrame` della posizione del mouse nello spazio 3D.

Mouse.hit

Questo esempio cambia l'icona del mouse di `Class.Players.LocalPlayer` per farla assomigliare a un'immagine di un
drago.


**Icona** è una proprietà che determina l'immagine utilizzata come puntatore. Se
è vuota, viene utilizzata una freccia predefinita. Quando il cursore si trova sopra un
`Class.GuiButton`, questa proprietà viene temporaneamente ignorata.

Per nascondere completamente il cursore, **non** utilizzare un'immagine trasparente &ndash;
invece, imposta `Class.UserInputService.MouseIconEnabled` su false.

Per ottenere/impostare l'icona del mouse dell'utente nelle esperienze, è necessario utilizzare
`Class.UserInputService.MouseIcon`. `Class.Mouse.Icon` sarà deprecato
una volta rilasciata la nuova API per i plugin per impostare il cursore del mouse.

##### Progettare un cursore

Le seguenti linee guida possono risultare utili quando si creano i propri cursori del mouse:

- Le dimensioni dell'immagine utilizzata determinano la dimensione del cursore.
- Le dimensioni dell'immagine non devono superare i 256 pixel su nessun asse.
- Il **centro** dell'immagine è il punto in cui vengono emessi gli input del mouse.
- L'immagine del mouse predefinita è 64x64 pixel, con il mouse che occupa 17x24
  pixel di spazio.

##### Cursori di sistema

Quando si utilizza un `Class.PluginMouse` recuperato da `Class.Plugin:GetMouse()`,
potete utilizzare le seguenti icone simili ai cursori predefiniti del sistema,
come mani, frecce, I-beams, ecc. Puoi usare questi con eventi GUI
come `Class.GuiObject.MouseEnter|MouseEnter`,
`Class.GuiObject.MouseLeave|MouseLeave`, e
`Class.GuiButton.MouseButton1Down|MouseButton1Down` per fornire un
'esperienza coerente nello Studio quando si interagisce con determinati tipi di GUI
componenti. Si noti che questi funzionano solo per i plugin di Studio; non funzioneranno
per altri oggetti `Class.Mouse`.

<table>
    <thead>
        <tr>
            <th>Aspetto*</th>
            <th>Asset</th>
            <th>Utilizzo suggerito</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Pointer.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Arrow</code></td>
            <td>Selezione e clic predefiniti.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-PointingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/PointingHand</code></td>
            <td>Passando sopra un link/bottone attivo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-OpenHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/OpenHand</code></td>
            <td>Passando sopra un oggetto trascinabile.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-GrabbingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/ClosedHand</code></td>
            <td>Trascinando un oggetto.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-IBeam.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/IBeam</code></td>
            <td>Passando in un campo di testo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNS.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNS</code></td>
            <td>Passando sopra una maniglia di ridimensionamento verticale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeEW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeEW</code></td>
            <td>Passando sopra una maniglia di ridimensionamento orizzontale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNESW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNESW</code></td>
            <td>Passando sopra una maniglia di ridimensionamento d'angolo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNWSE.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNWSE</code></td>
            <td>Passando sopra una maniglia di ridimensionamento d'angolo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeAll.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeAll</code></td>
            <td>Passando sopra una maniglia di ridimensionamento multidirezionale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitV.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitNS</code></td>
            <td>Passando sopra una maniglia di "separazione" verticale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitH.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitEW</code></td>
            <td>Passando sopra una maniglia di "separazione" orizzontale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Forbidden.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Forbidden</code></td>
            <td>Passando sopra un oggetto bloccato/forbidden.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Wait.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Wait</code></td>
            <td>Indica che un'azione è in corso.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Busy.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Busy</code></td>
            <td>Indica che il sistema è occupato.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Crosshair.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Cross</code></td>
            <td>Passando sopra un'area di selezione precisa.</td>
        </tr>
    </tbody>
</table>

<figcaption>* Questi aspetti sono approssimativi &mdash; l'aspetto reale dipende dal tuo sistema operativo.</figcaption>


Mouse.Icon

L'ID del contenuto dell'immagine utilizzata come icona di `Class.Mouse`.


**Icona** è una proprietà che determina l'immagine utilizzata come puntatore. Se
è vuota, viene utilizzata una freccia predefinita. Quando il cursore si trova sopra un
`Class.GuiButton`, questa proprietà viene temporaneamente ignorata. Questa proprietà
supporta solo URI degli asset.

Per nascondere completamente il cursore, **non** utilizzare un'immagine trasparente &ndash;
invece, imposta `Class.UserInputService.MouseIconEnabled` su false.

Per ottenere/impostare l'icona del mouse dell'utente nelle esperienze, è necessario utilizzare
`Class.UserInputService.MouseIcon`. `Class.Mouse.Icon` sarà deprecato
after la nuova API per i plugin per impostare il cursore del mouse è rilasciata.

##### Progettare un cursore

Le seguenti linee guida possono risultare utili quando si creano i propri cursori del mouse:

- Le dimensioni dell'immagine utilizzata determinano la dimensione del cursore.
- Le dimensioni dell'immagine non devono superare i 256 pixel su nessun asse.
- Il **centro** dell'immagine è il punto in cui vengono emessi gli input del mouse.
- L'immagine del mouse predefinita è 64x64 pixel, con il mouse che occupa 17x24
  pixel di spazio.

##### Cursori di sistema

Quando si utilizza un `Class.PluginMouse` recuperato da `Class.Plugin:GetMouse()`,
potete utilizzare le seguenti icone simili ai cursori predefiniti del sistema,
come mani, frecce, I-beams, ecc. Puoi usare questi con eventi GUI
come `Class.GuiObject.MouseEnter|MouseEnter`,
`Class.GuiObject.MouseLeave|MouseLeave`, e
`Class.GuiButton.MouseButton1Down|MouseButton1Down` per fornire un
'esperienza coerente nello Studio quando si interagisce con determinati tipi di GUI
componenti. Si noti che questi funzionano solo per i plugin di Studio; non funzioneranno
per altri oggetti `Class.Mouse`.

<table>
    <thead>
        <tr>
            <th>Aspetto*</th>
            <th>Asset</th>
            <th>Utilizzo suggerito</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Pointer.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Arrow</code></td>
            <td>Selezione e clic predefiniti.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-PointingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/PointingHand</code></td>
            <td>Passando sopra un link/bottone attivo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-OpenHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/OpenHand</code></td>
            <td>Passando sopra un oggetto trascinabile.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-GrabbingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/ClosedHand</code></td>
            <td>Trascinando un oggetto.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-IBeam.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/IBeam</code></td>
            <td>Passando in un campo di testo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNS.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNS</code></td>
            <td>Passando sopra una maniglia di ridimensionamento verticale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeEW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeEW</code></td>
            <td>Passando sopra una maniglia di ridimensionamento orizzontale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNESW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNESW</code></td>
            <td>Passando sopra una maniglia di ridimensionamento d'angolo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNWSE.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNWSE</code></td>
            <td>Passando sopra una maniglia di ridimensionamento d'angolo.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeAll.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeAll</code></td>
            <td>Passando sopra una maniglia di ridimensionamento multidirezionale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitV.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitNS</code></td>
            <td>Passando sopra una maniglia di "separazione" verticale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitH.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitEW</code></td>
            <td>Passando sopra una maniglia di "separazione" orizzontale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Forbidden.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Forbidden</code></td>
            <td>Passando sopra un oggetto bloccato/forbidden.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Wait.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Wait</code></td>
            <td>Indica che un'azione è in corso.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Busy.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Busy</code></td>
            <td>Indica che il sistema è occupato.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Crosshair.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Cross</code></td>
            <td>Passando sopra un'area di selezione precisa.</td>
        </tr>
    </tbody>
</table>

<figcaption>* Questi aspetti sono approssimativi &mdash; l'aspetto reale dipende dal tuo sistema operativo.</figcaption>


Mouse.IconContent

Il contenuto dell'immagine utilizzata come icona di `Class.Mouse`. Supporta solo
URI degli asset.


La proprietà origine `Class.Mouse` è un `Datatype.CFrame` che indica da dove
è partito il mouse. È posizionata presso il
`Class.Workspace.CurrentCamera` e orientata verso la posizione 3D del mouse.

`Class.Mouse.UnitRay` inizia dalla stessa posizione dell'Origine e si estende
per un stud nella stessa direzione.

```lua
local unitRay = mouse.UnitRay
local origin = mouse.Origin
-- unitRay.Direction = origin.p
-- unitRay.Direction ≈ origin.lookVector
```
Per la posizione del `Class.Mouse` nello spazio 3D, vedere `Class.Mouse.Hit`.


Mouse.Origin

Un `Datatype.CFrame` posizionato presso il `Class.Workspace.CurrentCamera` e
orientato verso la posizione 3D del mouse.


Quando inserito in un `LocalScript` in `StarterPlayerScripts`, il seguente codice
modifica il `Class.BasePart.BrickColor` di ogni `BasePart` su cui il giocatore clicca,
come la posizione di spawn o il pavimento.


L'oggetto nello spazio 3D a cui `Class.Mouse|mouse` sta puntando.

Nota:

- Se `Class.Mouse.TargetFilter` è stato impostato, il filtro del target e i suoi
  discendenti verranno ignorati.
- Quando il mouse non punta a un `Class.BasePart`, ad esempio quando
  punta al cielo, il Target sarà `nil`.
- Gli sviluppatori che cercano la posizione del mouse nello spazio 3D dovrebbero utilizzare
  `Class.Mouse.Hit`.


Mouse.Target

L'oggetto nello spazio 3D a cui `Class.Mouse|mouse` sta puntando.


Mouse.target

Questa proprietà determina un oggetto da ignorare dal mouse quando
calcola `Class.Mouse.Hit` e `Class.Mouse.Target`. I discendenti
dell'oggetto vengono anch'essi ignorati, quindi è possibile ignorare più oggetti
finché sono discendenti dell'oggetto a cui è impostata questa proprietà.
Questa proprietà è utile quando si filtrano modelli contenenti effetti
o decorazioni speciali che non dovrebbero influire su `Class.Mouse.Hit` o
`Class.Mouse.Target`.

Questa proprietà può essere impostata su qualsiasi `Class.Instance` o `nil`, ad esempio:

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

local player = Players.LocalPlayer
local mouse = player:GetMouse()
mouse.TargetFilter = Workspace.Model
```
Si noti che il `Class.Player.Character|Character` del
`Class.Players.LocalPlayer` viene ignorato automaticamente dal mouse.


Mouse.TargetFilter

Determina un oggetto (e i suoi discendenti) da ignorare quando si determina
`Class.Mouse.Hit` e `Class.Mouse.Target`.


Il codice in questo esempio, se inserito in un `LocalScript` all'interno di
`StarterPlayerScripts`, imposterà la superficie di qualsiasi `BasePart` cliccato su una
superficie casuale.

Questa proprietà indica il `Enum.NormalId` della superficie `Class.BasePart`
a cui il mouse sta puntando. Questa proprietà è derivata dalla
posizione nel mondo del mouse (`Class.Mouse.Hit`) e dalla parte verso cui il
mouse sta puntando (`Class.Mouse.Target`).

Questa proprietà non è significativa quando il mouse non punta a una parte,
ad esempio quando il mouse punta al cielo. In questo momento, questa
proprietà è impostata su 'Right' in queste circostanze. Prima di utilizzare questa
proprietà, controlla che il target del mouse non sia `nil`.

```lua
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
-- Controlla che esista una parte a cui il mouse sta puntando
if mouse.Target then
	print("Il mouse sta puntando al " .. mouse.TargetSurface.Name .. " lato di " .. mouse.Target.Name)
else
	print("Il mouse non punta a nulla.")
end
```


Mouse.TargetSurface

Indica il `Enum.NormalId` della superficie `Class.BasePart` a cui
il mouse sta puntando.


La proprietà UnitRay è un `Datatype.Ray` diretto verso la posizione del mouse
nello spazio 3D (descritta da `Class.Mouse.Hit`). Origina dal
`Class.Camera.CFrame|CFrame` della `Class.Workspace.CurrentCamera`.
Come tutti i raggi unitari, ha una distanza di 1.

```lua
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
print(mouse.UnitRay.Direction.Magnitude) -- Sempre 1
```


Mouse.UnitRay

Un `Datatype.Ray` diretto verso la posizione del mouse nel mondo, originato
dalla posizione mondiale di `Class.Workspace.CurrentCamera`.


Questo esempio di codice mostra come puoi creare un `Datatype.Vector2` che rappresenta
la posizione dell'oggetto `Mouse` sullo schermo (`Class.Mouse.X|X()` e
`Class.Mouse.Y|Y()`) e le dimensioni dello schermo stesso
(`Class.Mouse.ViewSizeX|ViewSizeX()` e `Class.Mouse.ViewSizeY|ViewSizeY()`).
Usando questi, puoi normalizzare la posizione del mouse sullo schermo in modo tale che
l'angolo in alto a sinistra proprio sotto la barra superiore corrisponda a (0, 0) e l'angolo in basso a destra corrisponda a
(1, 1). Questa posizione normalizzata viene calcolata e stampata mentre il mouse si muove
usando l'evento `Class.Mouse.Move|Move()`.

La proprietà ViewSizeX descrive la componente orizzontale della finestra
di gioco in pixel.


Mouse.ViewSizeX

Descrive la larghezza della finestra di gioco in pixel.


La proprietà ViewSizeY descrive la componente verticale della finestra
di gioco in pixel. Questa lunghezza include lo spazio utilizzato dalla
topbar.


Mouse.ViewSizeY

Descrive l'altezza della finestra di gioco in pixel.


Quando si rilevano cambiamenti nella posizione del mouse sullo schermo, è
consigliato utilizzare `Class.ContextActionService:BindAction()` con
`Enum.UserInputType.MouseMovement` o
`Class.UserInputService.InputChanged`, che descrivono entrambi la posizione del
mouse utilizzando il `Class.InputObject.Position|Position` (un
`Datatype.Vector3`) di un `Class.InputObject`, invece di utilizzare questa e
le relative proprietà.

La proprietà X descrive il componente orizzontale della posizione del mouse
sullo schermo. La posizione è misurata in pixel rispetto all'angolo in alto a sinistra,
sotto la barra superiore. Questa proprietà può essere utilizzata in combinazione con
`Class.Mouse.Y` per produrre un `Datatype.Vector2` che rappresenta la posizione del mouse:

```lua
local position = Vector2.new(mouse.X, mouse.Y)
```
Questa proprietà non attiva `Class.Object.Changed|Changed` o il segnale
restituito da
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal`. Utilizza
gli eventi `Class.Mouse.Move` invece.


Mouse.X

Descrive il componente X (orizzontale) della posizione del mouse sul
lo schermo.


Quando si rilevano cambiamenti nella posizione del mouse sullo schermo, è
consigliato utilizzare `Class.ContextActionService:BindAction()` con
`Enum.UserInputType.MouseMovement` o
`Class.UserInputService.InputChanged`, che descrivono entrambi la posizione del
mouse utilizzando il `Class.InputObject.Position|Position` (un
`Datatype.Vector3`) di un `Class.InputObject`, invece di utilizzare questa e
le relative proprietà.

La proprietà Y descrive il componente verticale della posizione del mouse sul
lo schermo. La posizione è misurata in pixel rispetto all'angolo in alto a sinistra,
sotto la barra superiore. Questa proprietà può essere utilizzata in combinazione con
`Class.Mouse.X` per produrre un `Datatype.Vector2` che rappresenta la posizione del mouse:

```lua
local position = Vector2.new(mouse.X, mouse.Y)
```
Questa proprietà non attiva `Class.Object.Changed|Changed` o il segnale
restituito da
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal`. Utilizza
gli eventi `Class.Mouse.Move` invece.


Mouse.Y

Descrive il componente Y (verticale) della posizione del mouse sul
lo schermo.


Oggetto legacy che contiene membri utili per l'input del puntatore.

`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

Restituisce un array contenente tutti i discendenti dell'istanza.

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