Cet exemple de code comprend un exemple simple de la façon dont la souris du joueur local
`SourisJoueur` peut être récupérée en utilisant la fonction `Class.Player:GetMouse()` dans
un `LocalScript`. Ce code doit être placé dans un `LocalScript` dans
`StarterPlayerScripts`.

Le PlayerMouse se comporte de manière identique à l'objet `Class.Mouse` qui est
obtenu en utilisant `Class.Tool.Equipped`. Il peut être accessible depuis
`Class.LocalScript|LocalScripts` en utilisant la méthode
`Class.Player:GetMouse()` du joueur local. À la fois PlayerMouse et `Class.Mouse` sont
des API obsolètes, remplacées par `Class.UserInputService`.

La seule différence entre le PlayerMouse et l'objet `Class.Mouse` est
que le PlayerMouse peut être obtenu en utilisant la méthode `Class.Player:GetMouse()`.

Dans la plupart des cas, il est conseillé aux développeurs d'utiliser le nouveau `Class.UserInputService`.
Cependant, les objets PlayerMouse et Mouse restent pris en charge pour un certain nombre de
raisons. Voir [Input and Camera](/input) pour plus d'informations
sur la personnalisation des entrées dans votre expérience.


PlayerMouse

Le PlayerMouse se comporte de manière identique à l'objet `Class.Mouse` qui est
obtenu en utilisant `Class.Tool.Equipped`. À la fois PlayerMouse et `Class.Mouse` sont
des API obsolètes, remplacées par `Class.UserInputService`.


**Mouse** a été remplacé par `Class.UserInputService` et
`Class.ContextActionService`, qui couvrent un champ d'application plus large, sont plus riches en fonctionnalités et prennent mieux en charge les modèles **multiplateformes**. Il reste supporté en raison de son utilisation répandue, mais vous devriez fortement envisager d'utiliser ces alternatives.

L'objet **Mouse** regroupe diverses API pour les pointeurs, principalement pour les boutons et le raycasting. Il peut être accédé via `Class.Player:GetMouse()` appelé sur
`Class.Players.LocalPlayer` dans un `Class.LocalScript`. Il est également passé par l'événement `Class.Tool.Equipped`.

- Il est surtout connu pour la propriété `Class.Mouse.Icon|Icon`, qui change
  l'apparence du curseur.
- Il raycast constamment la position de la souris sur l'écran dans le monde 3D en utilisant
  la propriété `Class.Mouse.TargetFilter|TargetFilter`, stockant les résultats du
  raycast dans les propriétés `Class.Mouse.Hit|Hit`, `Class.Mouse.Target|Target` et
  `Class.Mouse.TargetSurface|TargetSurface`. Celles-ci peuvent être utiles
  pour des cas simples, mais `Class.WorldRoot:Raycast()` devrait être utilisé dans des
  scénarios de [raycasting](/workspace/raycasting) plus compliqués.
- `Class.Plugin|Plugins` peut utiliser `Class.Plugin:GetMouse()` pour obtenir un
  `Class.PluginMouse`, qui se comporte de manière similaire.

```lua
-- Depuis un LocalScript :
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
-- Définir l'icône de la souris
mouse.Icon = "rbxasset://SystemCursors/Wait"
```
Note :

- Cet objet ne contrôle/restrict pas le mouvement du pointeur. Pour cela, voir
  `Class.UserInputService.MouseBehavior` et
  `Class.UserInputService.MouseDeltaSensitivity`.
- Si deux fonctions sont connectées à le même événement d'entrée, comme
  `Class.Mouse.Button1Down|Button1Down`, **les deux** fonctions s'exécuteront lorsque
  l'événement se déclenche. Il n'existe pas de concept de couplage/de passage d'entrée, car les événements ne prennent pas en charge ce comportement. Cependant, `Class.ContextActionService` a ce comportement via `Class.ContextActionService:BindAction()|BindAction`.
- Bien qu'une souris puisse ne pas être disponible sur toutes les plateformes, Mouse fonctionnera toujours
  sur mobile (tactile) et console (manette), qui n'ont généralement pas de souries ou de matériel pointeur. Pour des comportements multiplateformes explicites, utilisez
  `Class.UserInputService` et `Class.ContextActionService`.

  Voir [Input and Camera](/input) pour plus d'informations sur
  la personnalisation des entrées dans votre expérience.

This event fires when the player presses their left mouse button. Note
that this can be accessed from a `Class.Tool`; for example, when placed in
a `Class.LocalScript`, the code below prints `Button1Down` whenever the
left mouse button is pressed.

```lua
local tool = script.Parent  -- Make sure this is a Tool object

tool.Equipped:Connect(function(mouse)
	mouse.Button1Down:Connect(function()
		print("Button1Down")
	end)
end)
```

You can find out the position of the mouse in world space and if it's
pointing at any `Class.BasePart` using the `Class.Mouse.Hit|Hit` and
`Class.Mouse.Target|Target` properties.


Mouse.Button1Down

Se déclenche lorsque le bouton gauche de la souris est pressé.

This event fires when the player releases their left mouse button. Note
that this can be accessed from a `Class.Tool`; for example, when placed in
a `Class.LocalScript`, the code below prints `Button1Up` whenever the left
mouse button is released.

```lua
local tool = script.Parent  -- Make sure this is a Tool object

tool.Equipped:Connect(function(mouse)
	mouse.Button1Up:Connect(function()
		print("Button1Up")
	end)
end)
```

You can find out the position of the mouse in world space and if it's
pointing at any `Class.BasePart` using the `Class.Mouse.Hit|Hit` and
`Class.Mouse.Target|Target` properties.


Mouse.Button1Up

Se déclenche lorsque le bouton gauche de la souris est relâché.

This event fires when the player presses their right mouse button. Note
that this can be accessed from a `Class.Tool`; for example, when placed in
a `Class.LocalScript`, the code below prints `Button2Down` whenever the
right mouse button is pressed.

```lua
local tool = script.Parent  -- Make sure this is a Tool object

tool.Equipped:Connect(function(mouse)
	mouse.Button2Down:Connect(function()
		print("Button2Down")
	end)
end)
```

You can find out the position of the mouse in world space and if it's
pointing at any `Class.BasePart` using the `Class.Mouse.Hit|Hit` and
`Class.Mouse.Target|Target` properties.


Mouse.Button2Down

Se déclenche lorsque le bouton droit de la souris est pressé.

This event fires when the player releases their right mouse button. Note
that this can be accessed from a `Class.Tool`; for example, when placed in
a `Class.LocalScript`, the code below prints `Button2Up` whenever the
right mouse button is released.

```lua
local tool = script.Parent  -- Make sure this is a Tool object

tool.Equipped:Connect(function(mouse)
	mouse.Button2Up:Connect(function()
		print("Button2Up")
	end)
end)
```

You can find out the position of the mouse in world space and if it's
pointing at any `Class.BasePart` using the `Class.Mouse.Hit|Hit` and
`Class.Mouse.Target|Target` properties.


Mouse.Button2Up

Déclenché lorsque le bouton droit de la souris est relâché.

Cet exemple démontre comment les événements de la souris sont transmis à chaque image

Déclenché à chaque battement de cœur lorsque la souris n'est pas passée à un autre
event de souris.

Notez que cet événement ne devrait pas être utilisé pour déterminer quand la souris est immobile.
Comme il se déclenche à chaque battement de cœur, il se déclenche entre les
events `Class.Mouse.Move`.

Pour des informations sur comment obtenir l'objet `Class.Mouse`, veuillez consulter la
page `Class.Mouse`.

Les développeurs peuvent découvrir la position de la souris dans l'espace mondial, et si elle
pointe sur n'importe quel `Class.BasePart` en utilisant les propriétés `Class.Mouse.Hit` et
`Class.Mouse.Target`.

Notez que les développeurs sont recommandés d'utiliser `Class.UserInputService` au lieu
de l'objet `Class.Mouse` dans les nouveaux travaux.

Mouse.Idle

Déclenché à chaque battement de cœur lorsque la souris n'est pas passée à un autre
event de souris.

L'exemple ci-dessous, en supposant que 'mouse' a été défini, afficherait la touche qui a
été pressée (par exemple "q") ainsi que la valeur ascii pour cette touche (par exemple 113).

Cet événement se déclenche lorsqu'une touche est pressée, l'argument passé étant la
clé qui a été pressée.

Note :

- Toutes les touches ne génèrent pas cet événement. Cependant, vous pouvez contourner cela avec
  certaines des touches, par exemple, "/" en utilisant l'événement `Class.Mouse.KeyUp`.
- Certaines touches génèrent la même chaîne que d'autres touches.
- Il est possible que la chaîne soit vide (probablement dû au code clé "\\0").

Mouse.KeyDown

Se déclenche lorsqu'une touche est pressée.

Mouse.keyDown

L'exemple ci-dessous, en supposant que 'mouse' était défini, imprimerait la touche qui
était relâchée (par exemple "q") ainsi que la valeur ascii pour cette touche (par exemple 113).

Cet événement est déclenché lorsqu'une touche est relâchée, avec l'argument passé étant la touche qui a été relâchée.

Remarque :

- Toutes les touches ne génèrent pas cet événement. Cependant, vous pouvez contourner cela avec quelques touches, "/" par exemple, en utilisant l'événement [[API:Class/Mouse/KeyUp|KeyUp]].
- Certaines touches génèrent la même chaîne que d'autres touches.
- Il est possible que la chaîne soit vide (probablement à cause du code de touche "\\0").


Mouse.KeyUp

Se déclenche lorsqu'une touche est relâchée.


L'exemple ci-dessous permet au `Class.Players.LocalPlayer|joueur local` de déplacer
les pièces avec sa souris.

Lorsque le joueur appuie sur son bouton gauche de la souris sur une pièce, cette pièce est le
`Class.Mouse.Target|cible de la souris` et devient le _point_. Jusqu'à ce que le joueur
relâche son bouton gauche de la souris, cette pièce se déplacera vers la position du monde de la souris
lorsque le joueur déplace sa souris.

Notez que la propriété `Class.Mouse.TargetFilter` permet au code d'ignorer
la pièce déplacée lors de la détermination de la position du monde de la souris.

Le code devrait fonctionner comme prévu lorsqu'il est placé dans un `LocalScript`.

Se déclenche lorsque la souris est déplacée.

Notez que cet événement est déclenché lorsque la position de la souris est mise à jour, il se déclenchera donc plusieurs fois lors du déplacement.

Pour des informations sur la manière d'obtenir l'objet `Class.Mouse`, veuillez voir la page `Class.Mouse`.

Les développeurs peuvent connaître la position de la souris dans l'espace monde, et si elle pointe vers un `Class.BasePart` à l'aide des propriétés `Class.Mouse.Hit` et `Class.Mouse.Target`.

```
mouse.Move:Connect(function()
	local position = mouse.Hit.p
	local target = mouse.Target
	print(target, position)
end)
```
Notez que les développeurs sont recommandés d'utiliser `Class.UserInputService` au lieu de l'objet `Class.Mouse` dans les nouveaux travaux.


Mouse.Move

Se déclenche lorsque la souris est déplacée.


L'exemple ci-dessous suppose que vous avez déjà récupéré la souris du joueur (et
que vous l'avez définie comme une variable nommée 'mouse'), que ce soit par l'utilisation d'un `Class.Tool`,
`Class.HopperBin` ou la méthode `Class.Player:GetMouse()`. Il affichera
"La roulette est allée en arrière !" lorsque le joueur fait défiler vers l'arrière.

L'événement WheelBackward se déclenche lorsque la molette de la souris est défilée en arrière. Les utilisations possibles de cet événement incluent le basculement du viseur d'un fusil dans un jeu de tir à la première personne (FPS) ou le zoom dans la caméra du joueur.

Cela peut être utilisé aux côtés de l'événement de défilement vers l'avant, `Class.Mouse.WheelForward`.

Pour des informations sur la manière d'obtenir l'objet `Class.Mouse`, veuillez voir la page `Class.Mouse`.

Notez que les développeurs sont recommandés d'utiliser `Class.UserInputService` au lieu de l'objet `Class.Mouse` dans les nouveaux travaux.


Mouse.WheelBackward

Se déclenche lorsque la molette de la souris est défilée en arrière.


L'exemple ci-dessous suppose que vous avez déjà obtenu la souris du joueur (et
l'avez définie comme une variable nommée 'souris'), que ce soit par l'utilisation d'un `Tool`, `HopperBin`
ou la méthode `Class.Player:GetMouse()`. Il affichera "La roulette est avancée!"
quand le joueur fait défiler vers l'avant.

L'événement WheelForward se déclenche lorsque la molette de la souris est défilée en avant. Les utilisations possibles de cet événement incluent le basculement du viseur d'un fusil dans un jeu de tir à la première personne (FPS) ou le zoom dans la caméra du joueur.

Cela peut être utilisé aux côtés de l'événement de défilement vers l'arrière, `Class.Mouse.WheelBackward`.

Pour des informations sur la manière d'obtenir l'objet `Class.Mouse`, veuillez voir la page `Class.Mouse`.

Notez que les développeurs sont recommandés d'utiliser `Class.UserInputService` au lieu de l'objet `Class.Mouse` dans les nouveaux travaux.


Mouse.WheelForward

Se déclenche lorsque la molette de la souris est défilée en avant.


Mouse

Le code dans cet exemple, lorsqu'il est placé dans un `LocalScript` dans
`StarterPlayerScripts` dessine un faisceau laser rouge entre la tête du personnage
et `Class.Mouse.Hit` en tout temps.

Notez que ce faisceau passera directement à travers les obstructions en vue à la
première personne car le raycasting de `Mouse` est effectué à partir de
`Class.Workspace.CurrentCamera` et non de la tête.

Le code ci-dessous visualise la différence entre `Class.Mouse.Hit` et
`Class.Mouse.Origin`. Pour ce faire, le code utilise les
positions `Datatype.Vector3` des valeurs d'impact et d'origine `Datatype.CFrame`
en utilisant `.p`.

La différence est que l'origine est "d'où vient la souris" (son origine)
et l'impact est la position où la souris touche (c'est lorsque le joueur appuie
theur souris).

Cet exemple visualise également que l'origine de la souris est très similaire à la
position de la `CurrentCamera` en imprimant la magnitude (distance) entre
les deux positions.

Cette propriété indique le `Datatype.CFrame` de la position de la souris dans l'espace 3D. Notez que `Class.Mouse.TargetFilter` et ses descendants seront ignorés.

Les développeurs peuvent obtenir la position de Hit comme ceci :

```
local position = mouse.Hit.Position
```
Hit est souvent utilisé par `Class.Tool|Tools` pour tirer une arme vers la souris
en vue à la troisième personne.

Les développeurs à la recherche de la `Class.BasePart` sur laquelle la souris pointe
devraient utiliser `Class.Mouse.Target`.

#### Comment Mouse.Hit est-il calculé ?

La position du CFrame Hit est calculée comme le point d'intersection entre le `Datatype.Ray` interne de la souris (une version étendue de
`Class.Mouse.UnitRay`) et un objet dans l'espace 3D (comme une pièce).

L'orientation du CFrame Hit correspond à la direction du `Class.Mouse.UnitRay`.

```
local unitRayDirection = mouse.UnitRay.Direction
local mouseHitDirection = mouse.Hit.lookVector
-- unitRayDirection ≈ mouseHitDirection
-- les vecteurs sont environ égaux
```
Notez que le roulis de la `Class.Workspace.CurrentCamera` n'est pas utilisé lors
calculant l'orientation du CFrame Hit.

Le rayon interne de la souris s'étend sur 1 000 studs. Si la souris ne pointe pas
vers un objet dans l'espace 3D (par exemple lorsqu'elle pointe vers le ciel),
propriété sera éloignée de 1 000 studs de la
`Class.Workspace.CurrentCamera`.

Mouse.Hit

Le `Datatype.CFrame` de la position de la souris dans l'espace 3D.

Mouse.hit

Cet exemple change l'icône de souris de `Class.Players.LocalPlayer` pour ressembler à une
image de dragon.


**Icône** est une propriété qui détermine l'image utilisée comme pointeur. Si elle est vide, une flèche par défaut est utilisée. Lorsque le curseur survole un `Class.GuiButton`, cette propriété est temporairement ignorée.

Pour cacher complètement le curseur, **ne** pas utiliser une image transparente &ndash; à la place, définissez `Class.UserInputService.MouseIconEnabled` sur false.

Pour obtenir/mettre à jour l'icône de la souris de l'utilisateur dans les expériences, vous devez utiliser `Class.UserInputService.MouseIcon`. `Class.Mouse.Icon` sera obsolète après la sortie de la nouvelle API pour que les plugins définissent le curseur de la souris.

##### Conception d'un curseur

Les lignes directrices suivantes peuvent être utiles lors de la création de vos propres curseurs de souris :

- Les dimensions de l'image utilisée déterminent la taille du curseur.
- Les dimensions de l'image ne doivent pas dépasser 256 pixels sur un axe.
- Le **centre** de l'image est l'endroit d'où proviennent les entrées de la souris.
- L'image de souris par défaut mesure 64x64 pixels, la souris occupant 17x24 pixels d'espace.

##### Curseurs système

Lors de l'utilisation d'un `Class.PluginMouse` récupéré depuis `Class.Plugin:GetMouse()`, vous pouvez utiliser les icônes suivantes similaires à celles de vos curseurs système par défaut, telles que les mains, les flèches, les I-beams, etc. Vous pouvez les utiliser avec des événements GUI comme `Class.GuiObject.MouseEnter|MouseEnter`, `Class.GuiObject.MouseLeave|MouseLeave`, et `Class.GuiButton.MouseButton1Down|MouseButton1Down` pour fournir une expérience Studio cohérente lors de l'interaction avec certains types de composants GUI. Notez que ceux-ci ne fonctionnent que pour les plugins Studio ; ils ne fonctionneront pas pour les autres objets `Class.Mouse`.

<table>
    <thead>
        <tr>
            <th>Apparence*</th>
            <th>Actif</th>
            <th>Utilisation suggérée</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>Clic et sélection par défaut.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-PointingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/PointingHand</code></td>
            <td>Surchargé sur un lien/bouton actif.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-OpenHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/OpenHand</code></td>
            <td>Surchargé sur un élément déplaçable.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-GrabbingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/ClosedHand</code></td>
            <td>Déplacement d'un élément.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-IBeam.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/IBeam</code></td>
            <td>Surchargé dans un champ de texte.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNS.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNS</code></td>
            <td>Surchargé sur une poignée de redimensionnement verticale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeEW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeEW</code></td>
            <td>Surchargé sur une poignée de redimensionnement horizontale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNESW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNESW</code></td>
            <td>Surchargé sur une poignée de redimensionnement d'angle.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNWSE.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNWSE</code></td>
            <td>Surchargé sur une poignée de redimensionnement d'angle.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeAll.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeAll</code></td>
            <td>Surchargé sur une poignée de redimensionnement multidirectionnelle.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitV.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitNS</code></td>
            <td>Surchargé sur une poignée "split" verticale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitH.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitEW</code></td>
            <td>Surchargé sur une poignée "split" horizontale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Forbidden.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Forbidden</code></td>
            <td>Surchargé sur un élément verrouillé/interdit.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Wait.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Wait</code></td>
            <td>Indiquant qu'une action est en cours.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Busy.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Busy</code></td>
            <td>Indiquant que le système est occupé.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Crosshair.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Cross</code></td>
            <td>Surchargé sur une zone de sélection précise.</td>
        </tr>
    </tbody>
</table>

<figcaption>* Ces apparences sont des approximations &mdash; l'apparence réelle dépend de votre système d'exploitation.</figcaption>


Mouse.Icon

L'ID de contenu de l'image utilisée comme icône `Class.Mouse`.


**Icône** est une propriété qui détermine l'image utilisée comme pointeur. Si elle est vide, une flèche par défaut est utilisée. Lorsque le curseur survole un `Class.GuiButton`, cette propriété est temporairement ignorée. Cette propriété ne prend en charge que les URI d'actifs.

Pour cacher complètement le curseur, **ne** pas utiliser une image transparente &ndash; à la place, définissez `Class.UserInputService.MouseIconEnabled` sur false.

Pour obtenir/mettre à jour l'icône de la souris de l'utilisateur dans les expériences, vous devez utiliser `Class.UserInputService.MouseIcon`. `Class.Mouse.Icon` sera obsolète après la sortie de la nouvelle API pour que les plugins définissent le curseur de la souris.

##### Conception d'un curseur

Les lignes directrices suivantes peuvent être utiles lors de la création de vos propres curseurs de souris :

- Les dimensions de l'image utilisée déterminent la taille du curseur.
- Les dimensions de l'image ne doivent pas dépasser 256 pixels sur un axe.
- Le **centre** de l'image est l'endroit d'où proviennent les entrées de la souris.
- L'image de souris par défaut mesure 64x64 pixels, la souris occupant 17x24 pixels d'espace.

##### Curseurs système

Lors de l'utilisation d'un `Class.PluginMouse` récupéré depuis `Class.Plugin:GetMouse()`, vous pouvez utiliser les icônes suivantes similaires à celles de vos curseurs système par défaut, telles que les mains, les flèches, les I-beams, etc. Vous pouvez les utiliser avec des événements GUI comme `Class.GuiObject.MouseEnter|MouseEnter`, `Class.GuiObject.MouseLeave|MouseLeave`, et `Class.GuiButton.MouseButton1Down|MouseButton1Down` pour fournir une expérience Studio cohérente lors de l'interaction avec certains types de composants GUI. Notez que ceux-ci ne fonctionnent que pour les plugins Studio ; ils ne fonctionneront pas pour les autres objets `Class.Mouse`.

<table>
    <thead>
        <tr>
            <th>Apparence*</th>
            <th>Actif</th>
            <th>Utilisation suggérée</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>Clic et sélection par défaut.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-PointingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/PointingHand</code></td>
            <td>Surchargé sur un lien/bouton actif.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-OpenHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/OpenHand</code></td>
            <td>Surchargé sur un élément déplaçable.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-GrabbingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/ClosedHand</code></td>
            <td>Déplacement d'un élément.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-IBeam.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/IBeam</code></td>
            <td>Surchargé dans un champ de texte.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNS.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNS</code></td>
            <td>Surchargé sur une poignée de redimensionnement verticale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeEW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeEW</code></td>
            <td>Surchargé sur une poignée de redimensionnement horizontale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNESW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNESW</code></td>
            <td>Surchargé sur une poignée de redimensionnement d'angle.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNWSE.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNWSE</code></td>
            <td>Surchargé sur une poignée de redimensionnement d'angle.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeAll.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeAll</code></td>
            <td>Surchargé sur une poignée de redimensionnement multidirectionnelle.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitV.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitNS</code></td>
            <td>Surchargé sur une poignée "split" verticale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitH.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitEW</code></td>
            <td>Surchargé sur une poignée "split" horizontale.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Forbidden.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Forbidden</code></td>
            <td>Surchargé sur un élément verrouillé/interdit.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Wait.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Wait</code></td>
            <td>Indiquant qu'une action est en cours.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Busy.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Busy</code></td>
            <td>Indiquant que le système est occupé.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Crosshair.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Cross</code></td>
            <td>Surchargé sur une zone de sélection précise.</td>
        </tr>
    </tbody>
</table>

<figcaption>* Ces apparences sont des approximations &mdash; l'apparence réelle dépend de votre système d'exploitation.</figcaption>


Mouse.IconContent

Le contenu de l'image utilisée comme icône `Class.Mouse`. Ne prend en charge que les URI d'actifs.


L'objet dans l'espace 3D sur lequel `Class.Mouse|mouse` pointe.

Note :

- Si `Class.Mouse.TargetFilter` a été défini, le filtre cible et ses
  descendants seront ignorés.
- Lorsque la souris ne pointe pas vers un `Class.BasePart`, par exemple lorsqu'elle
  pointe vers le ciel, Target sera `nil`.
- Les développeurs à la recherche de la position de la souris dans l'espace 3D devraient utiliser
  `Class.Mouse.Hit`.

Mouse.Origin

Un `Datatype.CFrame` positionné à `Class.Workspace.CurrentCamera` et orienté vers la position 3D de la souris.


Lorsqu'il est placé dans un `LocalScript` dans `StarterPlayerScripts`, le code suivant
modifie le `Class.BasePart.BrickColor` de chaque `BasePart` sur lequel le joueur clique,
comme l'emplacement de spawn ou la plaque de base.


Cette propriété détermine un objet à ignorer par la souris lors
calculant `Class.Mouse.Hit` et `Class.Mouse.Target`. Les descendants de
l'objet sont également ignorés, il est donc possible d'ignorer plusieurs objets
à condition qu'ils soient des descendants de l'objet auquel cette propriété est
définie. Cette propriété est utile pour filtrer des modèles contenant des effets
ou des décorations spéciaux qui ne doivent pas affecter `Class.Mouse.Hit` ou
`Class.Mouse.Target`.

Cette propriété peut être définie sur toute `Class.Instance` ou `nil`, par exemple :

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

local player = Players.LocalPlayer
local mouse = player:GetMouse()
mouse.TargetFilter = Workspace.Model
```
Notez que le `Class.Player.Character|Character` de la
`Class.Players.LocalPlayer` est ignoré par la souris automatiquement.

Mouse.Target

Détermine un objet (et ses descendants) à ignorer lors de la détermination
`Class.Mouse.Hit` et `Class.Mouse.Target`.

Mouse.target

La propriété UnitRay est un `Datatype.Ray` dirigé vers la position de la souris dans l'espace 3D (décrite par `Class.Mouse.Hit`). Il provient de la `Class.Camera.CFrame|CFrame` de `Class.Workspace.CurrentCamera`.
Comme tous les rayons unitaires, il a une distance de 1.

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

Mouse.TargetFilter

Un `Datatype.Ray` dirigé vers la position mondiale de la souris, provenant
de la position mondiale de `Class.Workspace.CurrentCamera`.

Le code dans cet exemple, lorsqu'il est placé dans un `LocalScript` à l'intérieur de
`StarterPlayerScripts`, définira la surface de tout `BasePart` cliqué sur à une
surface aléatoire.

La propriété ViewSizeX décrit le composant horizontal de la taille de la
fenêtre de jeu en pixels.

Mouse.TargetSurface

Décrit la largeur de la fenêtre de jeu en pixels.

La propriété UnitRay est un `Datatype.Ray` dirigé vers la position de la souris dans l'espace 3D (décrite par `Class.Mouse.Hit`). Elle provient du `Class.Camera.CFrame|CFrame` de `Class.Workspace.CurrentCamera`. Comme tous les rayons unitaires, elle a une distance de 1.

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


Mouse.UnitRay

Un `Datatype.Ray` dirigé vers la position mondiale de la souris, provenant de la position mondiale de `Class.Workspace.CurrentCamera`.


Cet exemple de code montre comment créer un `Datatype.Vector2` représentant
la position de l'objet `Mouse` à l'écran (`Class.Mouse.X|X()` et
`Class.Mouse.Y|Y()`) ainsi que la taille de l'écran lui-même
(`Class.Mouse.ViewSizeX|ViewSizeX()` et `Class.Mouse.ViewSizeY|ViewSizeY()`).
En utilisant ces informations, vous pouvez normaliser la position de la souris à l'écran de sorte que
le coin supérieur gauche juste sous la barre du haut correspond à (0, 0) et le coin inférieur droit correspond à
(1, 1). Cette position normalisée est calculée et affichée à mesure que la souris se déplace
en utilisant l'événement `Class.Mouse.Move|Move()`.

La propriété ViewSizeX décrit le composant horizontal de la taille de la fenêtre du jeu en pixels.


Mouse.ViewSizeX

Décrit la largeur de la fenêtre du jeu en pixels.


La propriété ViewSizeY décrit le composant vertical de la taille de la fenêtre du jeu en pixels. Cette longueur inclut l'espace utilisé par la barre supérieure.


Mouse.ViewSizeY

Décrit la hauteur de la fenêtre du jeu en pixels.


Lors de la détection des changements de position de la souris à l'écran, il est recommandé d'utiliser `Class.ContextActionService:BindAction()` avec `Enum.UserInputType.MouseMovement` ou `Class.UserInputService.InputChanged`, qui décrivent tous deux la position de la souris en utilisant `Class.InputObject.Position|Position` (un `Datatype.Vector3`) d'un `Class.InputObject`, au lieu d'utiliser cette propriété et les propriétés associées.

La propriété X décrit le composant horizontal de la position de la souris sur l'écran. La position est mesurée en pixels par rapport au coin supérieur gauche, sous la barre supérieure. Cette propriété peut être utilisée en conjonction avec `Class.Mouse.Y` pour produire un `Datatype.Vector2` représentant la position de la souris :

```lua
local position = Vector2.new(mouse.X, mouse.Y)
```
Cette propriété ne déclenche pas `Class.Object.Changed|Changed` ou le signal renvoyé par `Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal`. Utilisez l'événement `Class.Mouse.Move` à la place.


Mouse.X

Décrit le composant X (horizontal) de la position de la souris sur l'écran.


Lors de la détection des changements de position de la souris à l'écran, il est recommandé d'utiliser `Class.ContextActionService:BindAction()` avec `Enum.UserInputType.MouseMovement` ou `Class.UserInputService.InputChanged`, qui décrivent tous deux la position de la souris en utilisant `Class.InputObject.Position|Position` (un `Datatype.Vector3`) d'un `Class.InputObject`, au lieu d'utiliser cette propriété et les propriétés associées.

La propriété Y décrit le composant vertical de la position de la souris sur l'écran. La position est mesurée en pixels par rapport au coin supérieur gauche, sous la barre supérieure. Cette propriété peut être utilisée en conjonction avec `Class.Mouse.X` pour produire un `Datatype.Vector2` représentant la position de la souris :

```lua
local position = Vector2.new(mouse.X, mouse.Y)
```
Cette propriété ne déclenche pas `Class.Object.Changed|Changed` ou le signal renvoyé par `Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal`. Utilisez l'événement `Class.Mouse.Move` à la place.


Mouse.Y

Décrit le composant Y (vertical) de la position de la souris à l'écran.


Objet hérité qui contient des membres utiles pour l'entrée par pointeur.

`Instance` est la classe de base pour toutes les classes de la hiérarchie des classes Roblox
qui peuvent faire partie de l'arbre `Class.DataModel`.

Il n'est pas possible de créer directement des objets `Instance` racines, mais le constructeur spécial
`Datatype.Instance.new()` crée des objets via le code, prenant le
nom de la classe comme paramètre et retournant l'objet créé.

Démontre la détection des changements dans la descendance d'une instance en se connectant à l'événement
`Class.Instance.AncestryChanged`.

Le Parent de ChangingPart est défini sur différentes valeurs au fil du temps. Le parent de
la pièce est l'ancêtre de la pièce, donc l'événement `Class.Instance.AncestryChanged`
se déclenchera chaque fois qu'il change.


Déclenche lorsque cette instance est re-parentée ou lorsque l'un de ses
ancêtres est re-parenté.

Vous pouvez utiliser cet événement pour suivre la suppression d'une instance
dans Studio, comme une suppression manuelle dans l'Explorateur ou via un
plugin. Si vous devez détecter lorsqu'une instance est détruite à l'aide de
`Class.Instance:Destroy()`, utilisez plutôt l'événement `Class.Instance.Destroying`.

Instance.AncestryChanged

child

L'instance dont la propriété `Class.Instance.Parent|Parent` a changé,
qui peut être cette instance ou un ancêtre plus lointain, **pas**
nécessairement l'instance à laquelle le gestionnaire est connecté.

parent

Déclenche lorsqu'il y a un changement dans la propriété `Class.Instance.Parent`
de cet objet ou de l'un de ses ancêtres.

Cet événement déclenche chaque fois qu'un attribut est modifié sur l'instance,
notamment lorsque l'attribut est défini sur `nil`. Le nom de l'attribut modifié
est passé à la fonction connectée.

Par exemple, le snippet de code suivant connecte la fonction `attributeChanged()`
qui se déclenche chaque fois qu'un des attributs de la pièce change:

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

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "modifié")
end

part.AttributeChanged:Connect(attributeChanged)
```
Voir aussi `Class.Instance:GetAttributeChangedSignal()` qui renvoie un
event qui se déclenche lorsqu'un attribut spécifique donné change.

Instance.AttributeChanged

attribute

Le nom de l'attribut qui a été modifié.

Déclenche chaque fois qu'un attribut est modifié sur la `Class.Instance`.

Ce fragment imprime les noms des objets lorsqu'ils sont ajoutés à l'espace de travail :

Déclenche après qu'un objet a été parenté à cette `Class.Instance`.

Notez que, lors de l'utilisation de cette méthode sur un client pour détecter des objets créés par le
serveur, il est nécessaire d'utiliser `Class.Instance:WaitForChild()` lors
de l'indexation des descendants de ces objets. Cela est dû au fait que l'objet et ses
descendants ne sont pas garantis d'être répliqués du serveur au client
simultanément. Par exemple:

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

Workspace.ChildAdded:Connect(function(child)
	-- Utilisez WaitForChild() car les descendants peuvent ne pas avoir encore été répliqués
	local head = child:WaitForChild("Head")
end)
```
Notez que cet événement ne fonctionne que pour les enfants immédiats de la
`Class.Instance`. Pour un événement qui capture tous les descendants, utilisez
`Class.Instance.DescendantAdded`.

Voir aussi `Class.Instance.ChildRemoved`.

Instance.ChildAdded

La `Class.Instance` qui a été ajoutée.

Déclenche après qu'un objet a été parenté à cette `Class.Instance`.

Instance.childAdded

Ce fragment imprime les noms des objets au fur et à mesure qu'ils sont retirés du
Workspace :

Déclenche après qu'un enfant a été supprimé de cette `Class.Instance`.

Supprimé fait référence au moment où le parent d'un objet est changé de
cette `Class.Instance` à autre chose que cette `Class.Instance`. Notez que cet\événement sera également déclenché lorsqu'un enfant est détruit (à l'aide de
`Class.Instance:Destroy()`) car la fonction de destruction définit le parent d'un objet
sur `nil`.

Cet événement ne fonctionne que pour les enfants immédiats de la `Class.Instance`.
Pour un événement qui capture tous les descendants, utilisez
`Class.Instance.DescendantRemoving`.

Voir aussi `Class.Instance.ChildAdded`.

Instance.ChildRemoved

La `Class.Instance` qui a été supprimée.

Déclenche après qu'un enfant a été supprimé de cette `Class.Instance`.

Cet exemple suivant affichera le nom de tout objet ajouté au
Espace de travail :

Cet événement se déclenche après qu'un descendant a été ajouté à la `Class.Instance`.

Comme il se déclenche pour chaque descendant, la parenté d'un objet à la
`Class.Instance` déclenchera l'événement pour cet objet et tous ses
descendants individuellement.

Si vous vous préoccupez uniquement des **enfants directs** de la
`Class.Instance`, utilisez `Class.Instance.ChildAdded` à la place.

Voir aussi `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

Déclenche après qu'un descendant a été ajouté à la `Class.Instance`.

L'exemple suivant affiche le nom de tout descendant au moment où il est supprimé
du Workspace :

Cet événement se déclenche **immédiatement avant** que le parent `Class.Instance`
change de sorte qu'une instance **descendante** ne soit plus un
descendant. `Class.Instance:Destroy()|Destroy()` change le `Class.Instance.Parent|Parent`
d'une instance en `nil`, donc appeler cette méthode sur un descendant du parent
déclenchera cet événement.

Puisque cet événement se déclenche **avant** la suppression du descendant, le parent du
descendant ne sera pas modifié au moment du déclenchement de cet événement. Si le
descendant est également un **enfant direct** du parent, cet événement se déclenchera
avant `Class.Instance.ChildRemoved`.

Si un descendant a des enfants, cet événement se déclenche d'abord avec le descendant,
puis avec ses descendants.

#### Avertissement

Cet événement se déclenche avec l'objet descendant qui est en cours de suppression.
Tenter de définir le `Class.Instance.Parent|Parent` du descendant sur autre chose échouera. Voici un exemple qui démontre cela:

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

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Ne pas manipuler le parent du descendant dans cette fonction!
	-- Cet événement se déclenche PARCE QUE le parent a été manipulé, et le changement n'est pas encore arrivé
	-- Par conséquent, il est problématique de changer le parent de cette manière:
	descendant.Parent = game
end)

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

Instance.DescendantRemoving

La `Class.Instance` qui est en cours de suppression.

Déclenche immédiatement avant qu'un descendant de la `Class.Instance` ne soit supprimé.

Cet exemple montre comment, lors de l'utilisation du comportement de signal immédiat, une
Instance étant détruite reste en place jusqu'à ce que la fonction connectée se mette en attente.


Cet exemple démontre comment, lors de l'utilisation du comportement de signal différé, une Instance
est détruite avant que le signal ne se déclenche.


La `Class.Instance` ne sera jamais supprimée de la mémoire tant qu'une fonction connectée
l'utilise encore. Cependant, si la fonction se met en pause à tout moment,
la `Class.Instance` et ses descendants seront parentés à `nil`.

Si la propriété `Class.Workspace.SignalBehavior` est définie sur
`Enum.SignalBehavior.Immediate`, cet événement se déclenche immédiatement avant que le
`Class.Instance` ou l'un de ses ancêtres soit détruit avec
`Class.Instance:Destroy()`.

Si la propriété `Class.Workspace.SignalBehavior` est définie sur
`Enum.SignalBehavior.Deferred`, cet événement se déclenche au prochain point de
ergonomie, qui sera après que le `Class.Instance` ou l'un de ses ancêtres soit
détruit avec `Class.Instance:Destroy()`.

Avec le comportement `Enum.SignalBehavior.Deferred|Deferred`, connecter un script à son propre événement `Class.Instance.Destroying` est problématique, car le script
sera détruit avant que le rappel puisse être appelé (ce qui signifie qu'il ne s'exécutera pas).

Lors de la suppression d'une `Class.Instance` dans Studio, comme la suppression manuelle
via l'[Explorateur](/studio/explorer) ou à travers un plugin,
la `Class.Instance` n'est pas détruite. Au lieu de cela, le parent est défini sur `nil`
ce que vous pouvez suivre avec `Class.Instance.AncestryChanged`.

Instance.Destroying

Déclenche immédiatement avant (ou est différé jusqu'après) que l'instance soit
détruite via `Class.Instance:Destroy()`.

Cet événement se déclenche chaque fois qu'une propriété de style est modifiée sur l'instance,
notamment lorsque l'attribut est défini sur `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("Les propriétés de style ont changé")
end

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

Instance.StyledPropertiesChanged

Déclenche chaque fois qu'une propriété de style est modifiée sur l'instance, y compris
lorsqu'une propriété est définie sur `nil`.

Cette méthode applique une étiquette à l'instance, sans effet si l'étiquette est
déjà appliquée. L'ajout réussi d'une étiquette déclenchera un signal créé par
`Class.CollectionService:GetInstanceAddedSignal()` avec l'étiquette donnée.

#### Avertissements

- Les étiquettes d'une instance ajoutées côté client seront supprimées si le
  serveur ajoute ou supprime plus tard une étiquette sur cette instance car le serveur
  réplique toutes les étiquettes ensemble et écrase les étiquettes précédentes.

- Lors de l'étiquetage d'une instance, il est courant que des ressources soient
  utilisées pour donner à l'étiquette sa fonctionnalité, par exemple des connexions d'événements ou des tables.
  Pour éviter les fuites de mémoire, il est bon de nettoyer cela (déconnecter,
  définir à `nil`, etc.) lorsque ce n'est plus nécessaire pour une étiquette. Faites le lorsque
  vous appelez `Class.Instance:RemoveTag()`, en appelant
  `Class.Instance:Destroy()` ou dans une fonction connectée à un signal
  renvoyé par `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

La fonction enfants renvoie un tableau des enfants de l'objet.

Instance:children

Renvoie un tableau des enfants de l'objet.

Cette méthode détruit tous les enfants d'une instance ainsi que ses descendants.

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

-- Ajouter des étincelles
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

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

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

part:ClearAllChildren()

print("Enfants:", #part:GetChildren())  --> Enfants: 0
```
Si vous ne souhaitez pas détruire **tous** les enfants et descendants, utilisez soit
`Class.Instance:GetChildren()` ou `Class.Instance:GetDescendants()` pour
parcourir ces enfants/descendants et sélectionner ceux à détruire. Par
exemple, l'échantillon de code suivant détruira tous les
`Class.BasePart|BaseParts` descendant d'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

Cette méthode détruit tous les enfants d'une instance.

Démontre le clonage d'un modèle en utilisant `Class.Instance:Clone()`.

`Clone()` crée une copie d'une instance et de tous ses descendants,
ignorant toutes les instances qui ne sont pas
`Class.Instance.Archivable|Archivable`. La copie de l'instance racine est
renvoyée par cette méthode et son `Class.Instance.Parent|Parent` est défini sur
`nil`. Notez que si l'instance elle-même a
`Class.Instance.Archivable|Archivable` défini sur `false`, cette méthode renverra
`nil`.

Si une propriété de référence telle que `Class.ObjectValue.Value` est définie dans une
instance clonée, la valeur de la propriété de la copie dépendra de la
valeur d'origine :

- Si une propriété de référence fait référence à une instance qui a également été clonée,
  la copie fera référence à la copie.
- Si une propriété de référence fait référence à une instance qui n'a **pas** été clonée,
  la même valeur est maintenue dans la copie.

Instance:Clone

Crée une copie d'une instance et de tous ses descendants, en ignorant les instances
qui ne sont pas `Class.Instance.Archivable|Archivable`.

Instance:clone

Démontre la destruction d'une Partie en utilisant la fonction `Class.Instance:Destroy()`.

Cette fonction est la manière correcte de se débarrasser des objets qui ne sont plus
nécessaires.


Définit la propriété `Class.Instance.Parent` à `nil`, verrouille la
propriété `Class.Instance.Parent`, déconnecte toutes les connexions, et appelle
`Destroy()` sur tous les enfants. Cette méthode est la bonne façon de se débarrasser des
objets qui ne sont plus nécessaires.

Se débarrasser des objets inutiles est important, car des objets et des
connexions inutiles dans un endroit utilisent de la mémoire, ce qui peut
entraîner de graves problèmes de performance dans le temps.

En tant que meilleure pratique, après avoir appelé `Destroy()` sur un objet, définissez toute
variable faisant référence à l'objet (ou à ses descendants) à `nil`. Cela
empêche votre code d'accéder à quoi que ce soit lié à l'objet.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- Ne pas faire cela :
print(part.Name)  --> "Hello, world"
-- Faites cela pour empêcher la ligne ci-dessus de fonctionner :
part = nil
```
Une fois qu'un `Class.Instance` a été détruit par cette méthode, il ne peut pas être
réutilisé car la propriété `Class.Instance.Parent` est verrouillée. Pour
**supprimer temporairement** un objet au lieu de le détruire, définissez
`Class.Instance.Parent|Parent` à `nil`. Par exemple :

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

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Pour détruire un objet après un temps défini, utilisez
`Class.Debris:AddItem()`.

Instance:Destroy

Définit la propriété `Class.Instance.Parent` à `nil`, verrouille la
propriété `Class.Instance.Parent`, déconnecte toutes les connexions, et appelle
`Destroy()` sur tous les enfants.

Instance:destroy

Renvoie le premier ancêtre de l'`Class.Instance` dont
`Class.Instance.Name` est égal au nom donné.

Cette méthode fonctionne vers le haut, ce qui signifie qu'elle commence par le `Class.Instance.Parent` immédiat
et remonte vers le `Class.DataModel`. Si aucun ancêtre correspondant n'est trouvé, elle renvoie `nil`.

L'extrait de code suivant trouverait le premier ancêtre de l'objet
nommé `Car`.

```
local car = object:FindFirstAncestor("Car")
```
Pour les variantes de cette méthode qui trouvent des ancêtres d'une classe spécifique,
voir `Class.Instance:FindFirstAncestorOfClass()` et
`Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

Renvoie le premier ancêtre de l'`Class.Instance` dont
`Class.Instance.Name` est égal au nom donné.

Renvoie le premier ancêtre de l'`Class.Instance` dont
`Class.Object.ClassName` est égal au nom de classe donné.

Cette méthode fonctionne vers le haut, ce qui signifie qu'elle commence par le `Class.Instance.Parent` immédiat
et remonte vers le `Class.DataModel`. Si aucun ancêtre correspondant n'est trouvé, elle renvoie `nil`.

Une utilisation courante de cette méthode est de trouver le `Class.Model` auquel
un `Class.BasePart` appartient. Par exemple :

```
local model = part:FindFirstAncestorOfClass("Model")
```
Cette méthode est une variante de `Class.Instance:FindFirstAncestor()` qui
vérifie la propriété `Class.Object.ClassName` plutôt que
`Class.Instance.Name`. `Class.Instance:FindFirstAncestorWhichIsA()` existe également,
en utilisant la méthode `Class.Object:IsA()` à la place pour respecter l'héritage des classes.

Instance:FindFirstAncestorOfClass

className

Le `Class.Object.ClassName` à rechercher.

Renvoie le premier ancêtre de l'`Class.Instance` dont
`Class.Object.ClassName` est égal au nom de classe donné.

Renvoie le premier ancêtre de l'`Class.Instance` pour qui
`Class.Object:IsA()` renvoie vrai pour le nom de classe donné.

Cette méthode fonctionne vers le haut, ce qui signifie qu'elle commence par le `Class.Instance.Parent` immédiat
et remonte vers le `Class.DataModel`. Si aucun ancêtre correspondant n'est trouvé, elle renvoie `nil`.

Contrairement à `Class.Instance:FindFirstAncestorOfClass()`, cette méthode utilise
`Class.Object:IsA()` qui respecte l'héritage des classes. Par exemple :

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
Par conséquent, l'extrait de code suivant renverra le premier
ancêtre `Class.BasePart`, peu importe s'il s'agit d'un `Class.WedgePart`,
`Class.MeshPart` ou `Class.Part`.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```
Voir aussi `Class.Instance:FindFirstAncestor()`.

Instance:FindFirstAncestorWhichIsA

Renvoie le premier ancêtre de l'`Class.Instance` pour qui
`Class.Object:IsA()` renvoie vrai pour le nom de classe donné.

Le code ci-dessous cherchera dans Workspace un objet nommé "Brick". S'il est trouvé, il changera le nom de l'objet en "Foo".

Renvoie le premier enfant de l'`Class.Instance` avec le nom donné, ou
`nil` si aucun enfant de ce type n'existe. Si l'argument optionnel `recursive` est
`true`, cette méthode recherche tous les descendants plutôt que seulement les
enfants immédiats de l'`Class.Instance`.

#### Vérification de l'existence d'un objet

`FindFirstChild()` est nécessaire si vous devez vérifier qu'un objet existe
avant de continuer. Essayer d'indexer un enfant par son nom en utilisant l'opérateur
point génère une erreur si l'enfant n'existe pas.

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

-- La ligne suivante génère une erreur si la partie n'existe pas dans l'espace de travail
Workspace.Part.Transparency = 0.5
```
Une meilleure approche est d'utiliser `FindFirstChild()` pour d'abord vérifier `Part`,
puis d'utiliser une instruction `if` pour exécuter le code qui en a besoin.

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

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

#### Trouver un enfant dont le nom correspond à une propriété

Parfois, le `Class.Instance.Name|Name` d'un objet est le même que celui d'une
des propriétés de son `Class.Instance.Parent|Parent`. Lorsqu'on utilise l'opérateur point, les propriétés
dépassent les enfants s'ils ont le même nom.

Dans l'exemple suivant, un `Class.Folder` appelé `Color` est ajouté à un
`Class.Part`, qui a également la propriété `Class.Part.Color`. Remarquez que
`part.Color` fait référence à la valeur de la propriété `Datatype.Color3`, et non à l'instance de
l'enfant `Class.Folder`. Un avantage d'utiliser
`Class.Instance:FindFirstChild()|FindFirstChild()` est que l'introduction de nouvelles propriétés ne pose
pas de risque pour votre code.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- La propriété
local c2 = part:FindFirstChild("Color")  -- Le dossier enfant
```

#### Remarques de performance

`Class.Instance:FindFirstChild()|FindFirstChild()` prend environ 20% plus de temps
que l'utilisation de l'opérateur point et presque 8 fois plus de temps que simplement stocker
une référence à un objet. Par conséquent, vous devriez éviter de l'appeler dans
un code dépendant de la performance tel que dans des boucles serrées ou des fonctions connectées
à `Class.RunService.Heartbeat` et `Class.RunService.PreRender`. Au lieu de cela,
stockez le résultat dans une variable, ou envisagez d'utiliser
`Class.Instance.ChildAdded|ChildAdded` ou
`Class.Instance:WaitForChild()|WaitForChild()` pour détecter quand un enfant d'un
donné nom devient disponible.

Instance:FindFirstChild

recursive

Si la recherche doit être effectuée récursivement ou non.

Renvoie le premier enfant de l'`Class.Instance` trouvé avec le nom donné.

Instance:findFirstChild

Renvoie le premier enfant de l'`Class.Instance` dont
`Class.Object.ClassName|ClassName` est égal au `className` donné.
Contrairement à `Class.Instance:FindFirstChildWhichIsA()`, cette méthode ne renvoie que
les objets dont la classe correspond à `className`, en ignorant l'héritage des classes. Si aucun
enfant correspondant n'est trouvé, cette méthode renvoie `nil`.

Instance:FindFirstChildOfClass

Renvoie le premier enfant de l'`Class.Instance` dont
`Class.Object.ClassName|ClassName` est égal au nom de classe donné.

Renvoie le premier enfant de l'`Class.Instance` pour qui
`Class.Object:IsA()` renvoie vrai pour le nom de classe donné.

Si aucun enfant correspondant n'est trouvé, cette méthode renvoie `nil`. Si l'argument
optionnel `recursive` est vrai, cette méthode recherche tous les descendants plutôt
que seulement les enfants immédiats de l'`Class.Instance`.

Contrairement à `Class.Instance:FindFirstChildOfClass()`, cette méthode utilise
`Class.Object:IsA()` qui respecte l'héritage des classes. Par exemple :

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Par conséquent, l'échantillon de code suivant renverra le premier
enfant `Class.BasePart`, peu importe s'il s'agit d'un `Class.WedgePart`,
`Class.MeshPart` ou `Class.Part`.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```
Les développeurs cherchant un enfant par nom devraient utiliser
`Class.Instance:FindFirstChild()` à la place.

Instance:FindFirstChildWhichIsA

Renvoie le premier enfant de l'`Class.Instance` pour qui
`Class.Object:IsA()` renvoie vrai pour le nom de classe donné.

Renvoie le premier descendant trouvé avec le `Class.Instance.Name` donné.

Cette méthode est désactivée et ne peut pas être utilisée. Pour trouver le premier descendant
 d'une instance, envisagez d'utiliser le paramètre `recursive` sur
`Class.Instance:FindFirstChild()` à la place.

Instance:FindFirstDescendant

Renvoie le premier descendant trouvé avec le `Class.Instance.Name` donné.

Si l'`Class.Instance` est un `Class.Actor`, le `Class.Actor` lui-même est
renvoyé. Sinon, son plus proche ancêtre `Class.Actor` est renvoyé. Si aucun
ancêtre n'est un `Class.Actor`, le résultat est `nil`.

Instance:GetActor

Renvoie le `Class.Actor` associé à l'Instance, le cas échéant.

Cette méthode renvoie la valeur qui a été assignée au nom d'attribut donné. Si
aucun attribut n'a été assigné, `nil` est renvoyé.

Par exemple, l'extrait de code suivant définit et obtient ensuite la valeur de
l'attribut `InitialPosition` de l'instance :

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

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

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

#### Voir aussi

- `Class.Instance:SetAttribute()` qui définit l'attribut avec le nom donné
a la valeur donnée.
- `Class.Instance:GetAttributes()` qui renvoie un dictionnaire de paires clé‑valeur
pour chacun des attributs de l'instance.

Instance:GetAttribute

La valeur qui a été assignée au nom d'attribut donné. Si aucun
attribut n'a été assigné, `nil` est renvoyé.

Renvoie la valeur qui a été assignée au nom d'attribut donné.

Cette méthode renvoie un événement qui se comporte exactement comme le
événement `Class.Object.Changed|Changed`, sauf qu'il ne se déclenche que lorsque l'
attribut donné change ; c'est effectivement similaire à
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` mais
pour les attributs.

Il est généralement conseillé d'utiliser cette méthode plutôt qu'une connexion à
`Class.Object.Changed|Changed` avec une fonction qui vérifie le nom de l'attribut. Des appels subséquents à cette méthode sur le même objet avec le même
nom d'attribut renvoient le même événement.

L'exemple de code suivant renvoie un signal qui déclenchera la fonction
`attributeChanged()` lorsque l'attribut `InitialPosition` de la pièce change :

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

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

local function attributeChanged()
	print("Attribut changé")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```
Voir aussi `Class.Instance.AttributeChanged` qui se déclenche chaque fois qu'un
attribut est modifié sur l'instance.

Instance:GetAttributeChangedSignal

Le nom de l'attribut spécifié pour lequel le signal de changement est
renvoyé.

Un événement qui se déclenche lorsque l'attribut donné change.

Renvoie un événement qui se déclenche lorsque l'attribut donné change.

Cette méthode renvoie un dictionnaire de paires clé‑valeur pour chaque attribut
où la clé est le nom de l'attribut et la valeur est une valeur non‐`nil`.

Par exemple, l'extrait de code suivant affiche les attributs d'une instance
et leurs valeurs :

```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
```
Voir aussi `Class.Instance:GetAttribute()` qui renvoie la valeur qui a été
assignée au nom d'attribut donné.

Instance:GetAttributes

Un dictionnaire de paires chaîne → variante pour chaque attribut où la
chaîne est le nom de l'attribut et la variante est une valeur non-nulle.

Renvoie un dictionnaire des attributs de l'instance.

Le code ci-dessous afficherait le nom de tous les objets actuellement dans Workspace lorsqu'il est exécuté.

Renvoie un tableau (une table indexée numériquement) contenant tous les
enfants directs de l'instance, ou chaque `Class.Instance` dont
`Class.Instance.Parent|Parent` est égal à l'objet. Le tableau peut être
itéré en utilisant soit une boucle numérique soit une boucle générique :

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

-- Exemple de boucle numérique
local children = Workspace:GetChildren()
for i = 1, #children do
	local child = children[i]
	print(child.Name .. " est enfant numéro " .. i)
end
```

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

-- Exemple de boucle générique
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " est enfant numéro " .. i)
end
```
Notez que le tableau retourné n'est **pas** trié dans un ordre particulier, donc
le tri manuel (par exemple à l'aide de `Library.table.sort()`) est conseillé pour
trier les enfants renvoyés par cette méthode.

Voir aussi la méthode `Class.Instance:GetDescendants()|GetDescendants()`.

Instance:GetChildren

Un tableau contenant les enfants de l'instance.

Renvoie un tableau contenant tous les enfants de l'instance.

Instance:getChildren

Renvoie une chaîne codée de l'ID de débogage utilisée en interne par Roblox. Notez
que :

- Cet élément est protégé. Tenter de l'utiliser dans un `Class.Script` ou
  `Class.LocalScript` causera une erreur.
- Un ID de débogage est un ID utilisé dans les processus de débogage. Il permet à un débogueur de
  lire chaque instruction avant qu'une application ne la traite. Tous les objets dans
  Roblox agissent comme des processus et exécutent chaque instruction (ou 'code') qui peut
  être déboguée si nécessaire.
- Cela peut être utile pour les plugins qui ont besoin de distinguer des objets similaires
  les uns des autres (comme des objets qui partagent le même nom).

Instance:GetDebugId

scopeLength

Renvoie une chaîne codée de l'ID de débogage utilisée en interne par Roblox.

Instance

`Instance` est la classe de base pour toutes les classes de la hiérarchie des classes Roblox
qui peuvent faire partie de l'arbre `Class.DataModel`.

/reference/engine/classes/PlayerMouse.yaml