Un `Class.Actor` est un conteneur pour du code qui peut être exécuté en toute sécurité dans son propre
fil à l'aide de `Library.task.desynchronize()`. Il doit également contenir les
instances utilisées par ses scripts.

Pour en savoir plus sur l'utilisation de plusieurs Acteurs afin d'optimiser les performances des scripts, consultez
[Parallel Luau](/scripting/multithreading).

#### Remarques

- Chaque `Actor` s'exécute dans son propre VM Luau. Les `Class.ModuleScript|ModuleScripts`
  nécessaires à un `Actor` ne sont **pas** partagés ou mis en cache entre les `Actors` ou avec
  le fil principal. Chaque VM exécute sa propre copie du module, donc
  l'état au niveau du module est isolé par `Actor`. Concevez en conséquence si vos
  modules détiennent un état que vous souhaitez partager.
- `script:GetActor()` renvoie `nil` lorsqu'il est appelé depuis un `Class.ModuleScript`
  à moins que le `ModuleScript` ne soit un descendant de l'`Actor`. Les `ModuleScripts`
  stockés ailleurs (par exemple, `Class.ReplicatedStorage`) et requis par un
  `Actor` ne sont pas considérés comme des descendants de l'`Actor`.


Cette méthode est utilisée pour lier un rappel Luau à un message avec le sujet spécifié. Lorsque un message est envoyé (en utilisant
`Class.Actor:SendMessage()|SendMessage()`) au sujet spécifié, le rappel fourni sera appelé dans un contexte d'exécution _série_.

Plusieurs rappels Luau peuvent être liés à un seul acteur et même à un seul sujet de message.

Remarque : Seuls les scripts qui sont des descendants d'un Acteur peuvent se lier à ses messages.

```lua
local actor = script:GetActor()

-- Imprime un message lorsque un message de salutation est envoyé à l'Acteur
-- dont ce script est un descendant.
local connection = actor:BindToMessage("Greeting", function(message)
  print("Message de salutation reçu :", message)
end)
```

Actor:BindToMessage

topic

Le sujet utilisé pour identifier le type de message.

function

Cet objet de connexion peut être utilisé pour déconnecter le rappel Luau
de la réception des messages.

Lie un rappel Luau à un message avec le sujet spécifié.

Cette méthode est utilisée pour lier un rappel Luau à un message avec le sujet spécifié. Lorsque un message est envoyé (en utilisant
`Class.Actor:SendMessage()|SendMessage()`) au sujet spécifié, le rappel fourni sera appelé dans un contexte d'exécution _parallel_.

Plusieurs rappels Luau peuvent être liés à un seul acteur et même à un seul sujet de message.

Remarque : Seuls les scripts qui sont des descendants d'un Acteur peuvent se lier à ses messages.

```lua
local actor = script:GetActor()

-- Imprime un message lorsque un message de salutation est envoyé à l'Acteur
-- dont ce script est un descendant.
local connection = actor:BindToMessageParallel("Greeting", function(message)
  print("Message de salutation reçu :", message)
end)
```

Actor:BindToMessageParallel

Envoie un message à un Actor. Les messages sont envoyés de manière asynchrone, donc l'
expéditeur ne bloquera pas ou ne yield pas lors de l'appel de la méthode
`Class.Actor:SendMessage()|SendMessage()`.

Étant donné qu'un seul Actor peut recevoir différents types de messages, un paramètre `topic`
est utilisé pour distinguer entre les différents types de messages.

Voir `Class.Actor:BindToMessage()|BindToMessage()` pour les détails sur la réception
d'un message envoyé à l'aide de `Class.Actor:SendMessage()|SendMessage()`.

Notez que les arguments des messages sont **passés par copie** à travers les frontières de VM Luau,
nan par référence. L'envoi de grandes tables entraîne une copie complète à chaque appel. Les fonctions
sont liées à une VM spécifique et ne peuvent pas être passées dans les messages.

```lua
-- Supposons que `actor` est une variable locale se référant à une instance d'Actor
actor:SendMessage("Greeting", "Hello World")
```


Actor:SendMessage

Le sujet utilisé pour identifier le message envoyé.

message

Le contenu du message à envoyer à l'Acteur.

Actor

Un `Class.Actor` est un conteneur pour du code qui peut être sécurisé séparé dans son propre fil.

L'exemple suivant comprend une fonction de base qui prend une table d'objets
et les parenté dans un nouveau modèle, retournant ce modèle.

Les modèles sont des objets conteneurs, ce qui signifie qu'ils regroupent des objets. Ils sont
meilleures utilisées pour contenir des collections de `Class.BasePart|BaseParts` et disposent d'un certain
nombre de fonctions qui étendent leur fonctionnalité.

Les modèles sont destinés à représenter des regroupements **géométriques**. Si votre regroupement n'a
aucune interprétation géométrique, par exemple une collection de
`Class.Script|Scripts`, utilisez un `Class.Folder` à la place.

Les modèles dont les parties constitutives sont reliées entre elles par des joints (si bien qu'elles
peuvent se déplacer ou être détruites via la simulation physique) ont généralement un
`Class.Model.PrimaryPart|PrimaryPart` défini, car il spécifie quelle partie à l'intérieur
modèle le pivot et la boîte de délimitation suivront » alors que le modèle se déplace. Les modèles
statique qui restent au même endroit ne bénéficient pas d'une partie principale définie.

Les modèles ont une large gamme d'applications, y compris les personnages de joueur Roblox.
Ils ont également un certain nombre de comportements uniques qu'il est important de garder à l'esprit :

- Lorsque `Class.Humanoid` et une `Class.Part` nommée **Head** sont parentés sous
  un modèle, un GUI de nom/santé apparaîtra au-dessus du modèle ; voir
  [Affichage du Nom/Santé du Personnage](/characters/name-health-display)
  pour plus de détails.
- Si la position d'une partie sur l'axe **Y** atteint la
  valeur `Class.Workspace.FallenPartsDestroyHeight`, et que c'était le dernier objet
  à l'intérieur d'un `Class.Model`, le modèle sera également détruit.
- Lorsqu'il est utilisé dans un endroit avec `Class.Workspace.StreamingEnabled` défini sur vrai,
  la valeur de `Class.Model.ModelStreamingMode|ModelStreamingMode` contrôle
  divers comportements concernant la façon dont le modèle et les descendants sont répliqués
  et/ou retirés des clients. De plus, la valeur de
  `Class.Model.LevelOfDetail|LevelOfDetail` impacte le rendu du modèle.

Comme pour tous les types `Class.Instance`, le fait qu'un parent `Class.Model` soit
répliqué sur un client ne garantit pas que tous ses enfants soient
répliqués. Ceci est particulièrement important si ces instances sont accessibles par un code s'exécutant sur le client, comme dans un `Class.LocalScript`.
Utiliser `Class.Model.ModelStreamingMode|ModelStreamingMode` avec des valeurs telles que
`Enum.ModelStreamingMode|Atomic` peut garantir que le modèle entier et tous ses descendants sont présents si le modèle parent existe sur le client, ou vous
pouvez utiliser `Class.Instance:WaitForChild()|WaitForChild()` lorsque l'atomicité n'est pas
souhaitée.

Rend ce modèle persistant pour le joueur spécifié. Les modèles persistants
restent présents pour le joueur indépendamment des paramètres ou conditions de streaming.

`Class.Model.ModelStreamingMode|ModelStreamingMode` doit être défini sur
`Enum.ModelStreamingMode|PersistentPerPlayer` pour que le comportement change
suite à l'ajout.

Model:AddPersistentPlayer

playerInstance

Le `Class.Player` pour rendre ce modèle persistant.

Rend ce modèle persistant pour le joueur spécifié.
`Class.Model.ModelStreamingMode|ModelStreamingMode` doit être défini sur
`Enum.ModelStreamingMode|PersistentPerPlayer` pour que le comportement change
suite à l'ajout.

Dans cet exemple, les articulations de chaque Modèle de personnage ajouté seront cassées
3 secondes après l'apparition. Casser ces articulations fera mourir le Humanoïde.

Cet exemple de code montre la création manuelle de joints sur deux pièces qui sont
sœurs du script (PartA et PartB). Il crée des joints sur deux pièces touchant
avec des types de surface compatibles (Studs et Inlet).

Brise les connexions entre `BaseParts`, y compris les connexions de surface avec
les parties adjacentes, `Class.WeldConstraint|WeldConstraints`, et toutes
`Class.Weld|Welds` et autres `Class.JointInstance|JointInstances`.

Lorsque BreakJoints est utilisé sur un personnage joueur `Class.Model`, le
`Class.Humanoid` du personnage mourra car il dépend du joint de cou.

Notez que bien que les joints produits par des connexions de surface avec des
parties adjacentes puissent techniquement être recréés en utilisant `Class.Model:MakeJoints()`, cela
ne recréera que les joints produits par des surfaces. Les développeurs ne devraient pas compter
là-dessus car, après la rupture des joints, les parties ne seront peut-être plus en
contact les unes avec les autres.

Model:BreakJoints

Brise les connexions entre `BaseParts`, y compris les connexions de surface avec
les parties adjacentes, `Class.WeldConstraint|WeldConstraints` et toutes
`Class.Weld|Welds` et autres `Class.JointInstance|JointInstances`.

Model:breakJoints

Cette fonction renvoie une description d'un volume qui contient tous
les enfants `Class.BasePart` à l'intérieur d'un `Class.Model`. L'orientation du volume
dépend de l'orientation de la `Class.Model.PrimaryPart|PrimaryPart`,
et correspond à la boîte de sélection rendue dans Studio lorsque le modèle est
sélectionné. Miroitant le comportement de `Class.Terrain:FillBlock()`, elle
renvoie un `Datatype.CFrame` représentant le centre de cette boîte de délimitation
et un `Datatype.Vector3` représentant sa taille. La taille peut être inexacte
au moment de l'exécution si des contraintes physiques agissent sur les parties à l'intérieur du
`Class.Model`.

L'orientation de la boîte de délimitation correspond à l'orientation de la
`Class.PVInstance.GetPivot|Pivot` - soit le pivot de la
`Class.Model.PrimaryPart|PrimaryPart` (s'il est présent) ou le
`Class.Model.WorldPivot|WorldPivot` du modèle.

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

local model = Workspace.Model
local part = Workspace.Part
local orientation, size = model:GetBoundingBox()

-- Redimensionnez et positionnez la partie égale à la boîte de délimitation du modèle
part.Size = size
part.CFrame = orientation
```

Model:GetBoundingBox

Un `Datatype.CFrame` représentant l'orientation du volume
suivi d'un `Datatype.Vector3` représentant la taille du volume.

Renvoie une description d'un volume qui contient toutes les parties d'un Modèle.

L'exemple de code ci-dessous démontre comment Model.GetExtentsSize peut être utilisé pour obtenir
la taille de la boîte englobante contenant les pièces.

Renvoie la taille de la plus petite boîte de délimitation qui contient toutes les
`Class.BasePart|BaseParts` dans le `Class.Model`. L'orientation correspond à
l'orientation de la `Class.PVInstance.GetPivot|Pivot` - soit le
pivot de la `Class.Model.PrimaryPart|PrimaryPart` (s'il est présent) ou le
`Class.Model.WorldPivot|WorldPivot` du modèle.

Notez que cette fonction ne renvoie que la taille de la plus petite boîte de délimitation, et
le développeur doit utiliser sa propre méthode pour obtenir la position de la
boîte de délimitation.

Model:GetExtentsSize

Les dimensions `Datatype.Vector3` de la `Class.Model`.

Renvoie la taille de la plus petite boîte de délimitation qui contient toutes les
`Class.BasePart|BaseParts` dans le `Class.Model`, alignée avec le
`Class.Model.PrimaryPart` si celui-ci est défini.

Cette valeur renvoyait historiquement le CFrame d'une position centrale dans le
modèle.

Model:GetModelCFrame

Ce code créerait un modèle, y placerait des pièces, les positionnerait au hasard,
et imprimerait sa taille :

La fonction GetModelSize renvoie la taille `Datatype.Vector3` du
`Class.Model`.

Model:GetModelSize

Lorsque cette méthode est appelée à partir d'un `Class.Script`, elle renvoie tous les
objets `Class.Player` pour lesquels ce modèle est persistant. Lorsqu'elle est appelée à partir d'une
`Class.LocalScript`, cette méthode vérifie uniquement si ce modèle est persistant
pour le `Class.Players.LocalPlayer|LocalPlayer`.

Model:GetPersistentPlayers

Une table avec tous les objets `Class.Player` pour lesquels cet objet modèle est
persistant.

Renvoie tous les objets `Class.Player` pour lesquels cet objet modèle est
persistant. Le comportement varie en fonction de si cette méthode est appelée
à partir d'un `Class.Script` ou d'un `Class.LocalScript`.

Le code suivant démontre comment GetPrimaryPartCFrame et
SetPrimaryPartCFrame peuvent être utilisés pour faire tourner un modèle.

Un modèle simple est créé dans l'Espace de travail et une boucle est lancée qui va
faire tourner le modèle de 10 degrés autour de l'axe Y toutes les 0,2 secondes.

Cette fonction a été remplacée par `Class.PVInstance:GetPivot()` qui
agit comme un remplacement et ne change pas le comportement de votre code. Utilisez
`Class.PVInstance:GetPivot()` pour de nouveaux travaux et migrez vos appels existants
`Class.Model:GetPrimaryPartCFrame()` lorsque cela est possible.

Renvoie le `Datatype.CFrame` de la `Class.Model.PrimaryPart` du modèle.

Cette fonction est équivalente à ce qui suit.

    Model.PrimaryPart.CFrame

Notez que cette fonction renverra une erreur si aucune partie principale n'existe pour le
`Class.Model`. Cela peut causer des problèmes si, par exemple, la partie principale
n'a jamais été définie ou a été détruite.

Model:GetPrimaryPartCFrame

Renvoie le `Datatype.CFrame` de la `Class.Model.PrimaryPart` du modèle.
Cette fonction renverra une erreur si aucune partie principale n'existe pour le
`Class.Model`.

Cet exemple de code démontre comment substituer un remplacement pour toutes les copies
 d'un modèle d'arbre en utilisant `Class.Model:PivotTo()` et `Class.Model:ScaleTo()`. Le
 pivot et l'échelle des modèles sont utilisés comme référence pour garantir que les
 tailles et emplacements relatifs des modèles de remplacement correspondent à ceux des
 originaux.


Les modèles contiennent un facteur d'échelle canonique persistant, qui commence à 1
pour les modèles nouvellement créés et change lorsque le modèle est mis à l'échelle en appelant
`Class.Model:ScaleTo()`. Cette fonction renvoie le facteur d'échelle canonique actuel
du modèle.

Le facteur d'échelle actuel n'impacte pas _directement_ la taille des Instances
sous le modèle. Il est utilisé à des fins d'autorisation de contenu et de scripting
pour se souvenir de la manière dont le modèle a été mis à l'échelle par rapport à sa taille d'origine.

Au cours d'une session donnée, le modèle mettra en cache les informations précises sur la taille
originale des Instances descendantes après le premier
`Class.Model:ScaleTo()` appel. Cela signifie que l'appel
`Class.Model:ScaleTo()|ScaleTo(x)` suivi de
`Class.Model:ScaleTo()|ScaleTo(1)` vous ramènera _exactement_ à la configuration
originale du modèle sans dérive de point flottant. Éviter la dérive de point flottant est la motivation
pour avoir une fonction Scale**To** plutôt qu'une fonction Scale**By**.

Le facteur d'échelle impacte le comportement du moteur d'une manière : le facteur d'échelle
d'un modèle sera appliqué aux décalages de joint des
`Class.Animation|Animations` jouées sur un `Class.AnimationController`
sous ce modèle, de sorte que les rigs animés joueront correctement les
animations même lorsqu'ils sont mis à l'échelle.

Model:GetScale

Le facteur d'échelle canonique actuel du modèle.

Renvoie l'échelle canonique du modèle, qui est par défaut 1 pour les modèles
nouvellement créés et changera lorsqu'il sera mis à l'échelle via
`Class.Model:ScaleTo()`.

Cet exemple de code montre comment des joints peuvent être créés en utilisant la
fonction Model:MakeJoints.

Un modèle est instancié, avec deux parties l'une sur l'autre. La partie supérieure est
ancrée et la partie inférieure ne l'est pas. Normalement, lorsqu'elle est parentée au Workspace,
la partie inférieure tomberait sur la Baseplate.

Cependant, comme la propriété TopSurface de la partie inférieure est définie sur
Enum.SurfaceType.Weld, cela signifie que lorsque Model:MakeJoints est exécuté, une
connexion est faite entre elles.

Par conséquent, la partie inférieure ne tombe pas tant que les joints dans le modèle ne sont
pas cassés. Cela se fait souvent en utilisant Model:BreakJoints, mais dans cet exemple, la
connexion est rompue à l'aide d'une explosion.

Cet exemple de code démontre la création de joints sur deux pièces qui sont
sœurs du script (PartA et PartB). Il utilise MakeJoints sur deux pièces touchant
avec des types de surface compatibles (Studs et Inlet).

L'assemblage basé sur le SurfaceType est obsolète. N'utilisez pas MakeJoints pour de nouveaux
projets. Utilisez plutôt `Class.WeldConstraint|WeldConstraints` et
`Class.HingeConstraint|HingeConstraints`.

Parcours tous les `Class.BasePart|Parts` dans le `Class.Model` et crée des
joints entre les Parties spécifiées et toutes les surfaces planes touchant,
suivant les surfaces des parties.

- Les surfaces lisses ne créeront pas de joints
- Les surfaces autocollantes créeront un joint de `Class.Glue`
- Le Weld créera un joint de `Class.Weld` avec n'importe quelle surface sauf pour
  Unjoinable
- Les Studs, Inlet, ou Universal créeront chacun un joint de `Class.Snap` avec
  l'une ou l'autre des deux autres surfaces (ex. Studs avec Inlet et
  Universelles)
- Les surfaces Hinge et Motor créent des instances de joint `Class.Rotate` et `Class.RotateV`

Cette fonction ne fonctionne pas si la Partie n'est pas un descendant de
`Class.Workspace`. Par conséquent, vous devez d'abord vous assurer que le modèle est parenté
to Workspace avant d'utiliser MakeJoints.

Model:MakeJoints

Parcours tous les `Class.BasePart|BaseParts` dans le `Class.Model`. Si le côté de
une partie a un SurfaceType qui peut créer un joint, il créera un joint
avec toutes les parties adjacentes.

Model:makeJoints

Model:move

location

Cet exemple démontre comment `Class.Model:MoveTo()` évite les collisions.

Un simple `Class.Model` en deux parties est créé, et sa `Class.Model.PrimaryPart`
est définie. Une grande partie d'obstruction est placée à côté.

Après 5 secondes, `Class.Model:MoveTo()` est utilisé pour diriger le modèle à se déplacer
à l'intérieur de la partie d'obstruction. Cependant, comme MoveTo ne déplacera pas un modèle à l'intérieur
 d'une obstruction, le `Class.Model` est déplacé vers le haut sur l'axe Y et placé au-dessus
de l'obstruction.


Déplace la `Class.Model.PrimaryPart|PrimaryPart` à la position donnée. Si
une partie principale n'a pas été spécifiée, la partie racine du modèle sera utilisée, mais la partie racine n'est pas déterministe et il est recommandé que vous
définissiez toujours une partie principale lors de l'utilisation de `Class.Model:MoveTo()|MoveTo()`.

S'il y a des obstructions là où le modèle doit être déplacé, comme
`Class.Terrain` ou d'autres `Class.BasePart|BaseParts`, le modèle sera
déplacé verticalement jusqu'à ce qu'il n'y ait rien sur son chemin. Si ce
comportement n'est pas souhaité, `Class.PVInstance:PivotTo()` devrait être utilisé
à la place.

Notez que la rotation n'est pas préservée lors du déplacement d'un modèle avec
`Class.Model:MoveTo()|MoveTo()`. Il est recommandé d'utiliser soit
`Class.Model:TranslateBy()|TranslateBy()` ou `Class.PVInstance:PivotTo()`
s'il est nécessaire de maintenir la rotation actuelle du modèle.

Model:MoveTo

position

Le `Datatype.Vector3` vers lequel le `Class.Model` est déplacé.

Déplace la `Class.Model.PrimaryPart|PrimaryPart` à la position donnée. Si
une partie principale n'a pas été spécifiée, la partie racine du modèle sera utilisée.

Model:moveTo

Rend ce modèle non persistant pour le joueur spécifié. Cela ne garantit pas que le modèle sera immédiatement
retiré pour le joueur ; après avoir appelé cette méthode, le modèle sera traité comme
`Enum.ModelStreamingMode|Atomic` pour ce joueur et restera présent tant qu'il est
à l'intérieur du rayon de streaming cible.

`Class.Model.ModelStreamingMode|ModelStreamingMode` doit être défini sur
`Enum.ModelStreamingMode|PersistentPerPlayer` pour que le comportement change
suite à la suppression.

Model:RemovePersistentPlayer

Le `Class.Player` pour lequel ce modèle ne sera plus persistant.

Rend ce modèle non persistant pour le joueur spécifié.
`Class.Model.ModelStreamingMode|ModelStreamingMode` doit être défini sur
`Enum.ModelStreamingMode|PersistentPerPlayer` pour que le comportement change
suite à la suppression.

Réinitialise la rotation des parties du modèle à la rotation d'identité précédemment définie,
qui se fait via la méthode `Class.Model:SetIdentityOrientation()`.

Model:ResetOrientationToIdentity

Models contain a persistent canonical scale factor, which starts out at 1
for newly created models. This function scales the model, around the pivot
location, relative to how it would look at a scale factor of 1. To
accomplish this it does two things:

- Sets the current scale factor of the model to the specified value
- Resizes and repositions all descendant Instances accordingly

The scaling of locations is done around the pivot location.

All "geometric" properties of descendant Instances will be scaled. That
obviously includes the sizes of parts, but here are some other examples of
properties which are scaled:

- The length of joints like `Class.WeldConstraint|WeldConstraints`, and
  `Class.RopeConstraint`
- Physical velocities and forces like `Class.HingeConstraint`
- Visual properties like sizes of particle emitters
- Other length properties like `Class.Sound.RollOffMinDistance`


Model:ScaleTo

newScaleFactor

Définit le facteur d'échelle du modèle, ajustant la taille et l'emplacement de
toutes les Instances descendantes de sorte qu'elles aient ce facteur d'échelle par rapport à
leurs tailles et emplacements initiaux lorsque le facteur d'échelle était de 1.

Définit la rotation d'identité du modèle donné, vous permettant de réinitialiser la
rotation de l'ensemble du modèle ultérieurement, grâce à la méthode
`ResetOrientationToIdentity`.

Model:SetIdentityOrientation

Cette fonction a été remplacée par `Class.PVInstance:PivotTo()` qui
agit comme un remplacement plus performant et ne change pas le comportement de votre code. Utilisez
`Class.PVInstance:PivotTo()` pour de nouveaux travaux et migrez vos appels existants
`Class.Model:SetPrimaryPartCFrame()` lorsque cela est possible.

Définit le `Class.BasePart.CFrame` de la `Class.Model.PrimaryPart` du modèle.
Toutes les autres parties du modèle seront également déplacées et maintiendront leur
orientation et leur décalage par rapport à la `Class.Model.PrimaryPart`.

Notez que cette fonction lancera une erreur si aucune `Class.Model.PrimaryPart`
 n'existe pour le modèle. Cela peut causer des problèmes si, par exemple, la partie principale
a jamais été définie ou a été détruite.

Model:SetPrimaryPartCFrame

cframe

Définit le `Class.BasePart.CFrame` de la `Class.Model.PrimaryPart` du modèle.
Toutes les autres parties du modèle seront également déplacées et maintiendront leur
orientation et leur décalage par rapport à la `Class.Model.PrimaryPart`.

Cet exemple démontre comment `Class.Model:TranslateBy()` ignore les collisions
et respecte l'orientation du modèle.

Un simple modèle `Class.Model` à deux parties est créé, tourné de 45 degrés sur l'axe Y,
et sa `Class.Model.PrimaryPart` est définie. Une grande partie d'obstruction est placée
à côté.

Après 5 secondes, `Class.Model:TranslateBy()` est utilisé pour diriger le modèle à
se déplacer à l'intérieur de la partie d'obstruction. Le modèle se déplacera à l'intérieur de
l'obstruction et maintiendra son orientation actuelle.


Déplace un `Class.Model` par le décalage `Datatype.Vector3` donné, préservant
l'orientation du modèle. Si une autre `Class.BasePart` ou `Class.Terrain`
est déjà présente à la nouvelle position, alors le `Class.Model` se chevauchera
avec cet objet.

La translation est appliquée dans l'espace mondial plutôt que dans l'espace objet,
ce qui signifie que même si les parties du modèle sont orientées différemment, elles se déplaceront
le long de l'axe standard.

Model:TranslateBy

delta

Le `Datatype.Vector3` par lequel traduire le `Class.Model`.

Déplace un `Class.Model` par le décalage `Datatype.Vector3` donné, préservant
l'orientation du modèle. Si une autre `Class.BasePart` ou `Class.Terrain`
est déjà présente à la nouvelle position, alors le `Class.Model` se chevauchera
avec cet objet.

Model

Définit le niveau de détail du modèle pour les expériences avec l'
[streaming](/workspace/streaming) activé. Les maillages composites ou
imposteurs ne prennent pas en charge la physique, la détection de collisions ou
la détection de rayons.

Lorsqu'il est défini sur `Enum.ModelLevelOfDetail|StreamingMesh`, un maillage
"imposteur" de résolution inférieure (maillage coloré et grossier qui entoure toutes les
tiges enfants du modèle) est rendu en dehors du rayon de streaming. Ne prend pas en charge
les textures.

Lorsqu'il est défini sur `Enum.ModelLevelOfDetail|SLIM`, un modèle **SLIM** (Modèle
Interactif Légèrement Évolutif) rend une composition de toutes les tiges enfants à
des résolutions progressivement inférieures en fonction des distances basées sur le rayon de
streaming. Cela améliore considérablement la qualité visuelle par rapport à
`Enum.ModelLevelOfDetail|StreamingMesh`.

Lorsqu'il est défini sur `Enum.ModelLevelOfDetail|Disabled` ou
`Enum.ModelLevelOfDetail|Automatic`, les maillages de résolution inférieure ne seront pas
affichés.


Model.LevelOfDetail

Définit le niveau de détail sur le modèle pour les expériences avec le streaming
d'instances activé.

Contrôle comment les `Class.Model|Models` sont diffusés et retirés lorsque le
[streaming](/workspace/streaming) des instances est activé. Le comportement
varie en fonction de l'énumération sélectionnée. N'a aucun effet lorsque le streaming n'est pas activé.

Cette propriété ne devrait être modifiée que dans Studio via la
[fenêtre des Propriétés](/studio/properties) lorsque le streaming est
enregistré, ou dans des `Class.Script|Scripts`, mais jamais dans
`Class.LocalScript|LocalScripts` (le faire peut entraîner un comportement indéfini).

Model.ModelStreamingMode

Contrôle le comportement de streaming du modèle sur `Class.Model|Models` lorsque
le streaming d'instances est activé.

Cet exemple de code crée et lance un modèle de dé, puis indique s'il
est tombé avec le côté bleu face visible. Si `Class.Model.PrimaryPart` n'était pas défini,
le pivot / la boîte de délimitation du dé tournerait, car les parties à l'intérieur de celui-ci
sont simulées physiquement pendant le lancer.

Pointe vers la partie principale du `Class.Model`. La partie principale est le
`Class.BasePart` qui sert de référence physique pour le pivot du
modèle. C'est-à-dire que lorsque des parties à l'intérieur du modèle sont déplacées à cause de la
simulation physique ou d'autres moyens, le pivot se déplacera en synchronisation avec la partie principale.

Notez que les `Class.Model|Models` n'ont pas `PrimaryPart` défini par défaut.
Si vous créez un modèle qui doit être soumis à la physique, vous
devez manuellement définir cette propriété dans Studio ou dans un script. Si la
partie principale **n'est pas** définie, le pivot restera au même endroit dans
espace mondial, même si des parties à l'intérieur du modèle sont déplacées.

Notez également que lors de la définition de cette propriété, il doit s'agir d'un `Class.BasePart`
qui est un descendant du modèle. Si vous essayez de définir
`Class.Model.PrimaryPart` à un `Class.BasePart` qui **n'est pas** un
descendant du modèle, cela sera défini sur cette partie mais réinitialisé à `nil`
lors du prochain étape de simulation &mdash; ce comportement hérité vise à soutenir
les scripts qui supposent pouvoir définir temporairement la partie principale
à un `Class.BasePart` qui n'est pas un descendant du modèle.

La règle générale pour les modèles est la suivante :

- Les modèles dont les parties sont reliées via des joints physiques tels que
  `Class.WeldConstraint|WeldConstraints` ou `Class.Motor6D|Motor6Ds`
  devraient avoir une partie principale assignée. Par exemple, les modèles
  de personnages Roblox ont leur `Class.Model.PrimaryPart` défini sur le
  **HumanoidRootPart** par défaut.
- Les modèles statiques (généralement `Class.BasePart.Anchored|Anchored`) qui restent en
  un endroit à moins qu'un script ne les déplace explicitement n'ont pas besoin d'un
  `Class.Model.PrimaryPart` et tendent à ne pas bénéficier d'en avoir un défini.

Model.PrimaryPart

La partie principale du `Class.Model`, ou `nil` si non explicitement définie.

Définir cette propriété dans la fenêtre Propriétés va mettre à l'échelle le modèle comme
si `Class.Model:ScaleTo()` avait été appelé sur lui, redimensionnant tous les Instances descendantes du modèle,
tels que les matériaux, les images, et la géométrie 3D des
parties, de sorte que le modèle ait le facteur de mise à l'échelle spécifié par rapport à sa
taille d'origine.

Cette propriété n'est disponible que dans Studio et lancera une erreur si elle est utilisée
dans un `Class.Script` ou `Class.LocalScript`. `Class.Model:ScaleTo()` et
`Class.Model:GetScale()` devraient être utilisés depuis les scripts.

Model.Scale

Propriété réservée à l'éditeur utilisée pour mettre à l'échelle le modèle autour de son pivot. Définit
cette propriété déplacera l'échelle comme si `Class.Model:ScaleTo()` avait été
appelé sur elle.

Cet exemple de code montre une fonction personnalisée pour réinitialiser le pivot d'un modèle
à la centre de la boîte englobante de ce modèle.

Cette propriété détermine où se situe le pivot d'un `Class.Model` qui
**n'a pas** de `Class.Model.PrimaryPart` défini. Si le
`Class.Model` **a** un `Class.Model.PrimaryPart|PrimaryPart`, le
pivot du `Class.Model` est égal au pivot de cette partie principale
au lieu de cela, et cette propriété `Class.Model.WorldPivot|WorldPivot` est ignorée.

Pour un `Class.Model` nouvellement créé, son pivot sera traité comme le centre
de la boîte de délimitation de son contenu jusqu'à la **première fois** que sa
propriété `Class.Model.WorldPivot` est définie. Une fois que le pivot du monde est défini pour
la première fois, il est impossible de restaurer ce comportement initial.

Le plus souvent, déplacer le modèle avec les outils Studio, ou avec des fonctions
 de mouvement de modèle telles que `Class.PVInstance:PivotTo()` et
`Class.Model:MoveTo()`, va définir le pivot du monde et ainsi mettre fin à ce nouveau
comportement du modèle.

Le but de ce comportement est de permettre au code Luau d'obtenir un pivot sensé
simplement en créant un nouveau modèle et en parentant des objets à celui-ci, évitant le
d'un paramétrage explicite de `Class.Model.WorldPivot` chaque fois que vous créez un
modèle dans le code.

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

local model = Instance.new("Model")
Workspace.BluePart.Parent = model
Workspace.RedPart.Parent = model
model.Parent = Workspace

print(model:GetPivot())  -- Actuellement égal au centre de la boîte de délimitation contenant "BluePart" et "RedPart"

model:PivotTo(CFrame.new(0, 10, 0))  -- Cela fonctionne sans avoir besoin de définir explicitement "model.WorldPivot"
```

Model.WorldPivot

Détermine où se situe le pivot d'un `Class.Model` qui **n'a pas** de
`Class.Model.PrimaryPart` défini.

Les modèles sont des objets conteneurs, ce qui signifie qu'ils regroupent des objets. Ils sont
meilleures utilisées pour contenir des collections de `Class.BasePart|BaseParts` et disposent d'un certain
nombre de fonctions qui étendent leur fonctionnalité.

Une `Class.PVInstance` est une classe abstraite qui ne peut pas être créée. Elle est la
base de tous les objets ayant une position physique dans le monde.


Cet exemple de code est un script de téléportation simple qui déplace votre personnage
10&nbsp;studs vers l'avant dans la direction dans laquelle vous faites face lorsque vous appuyez
sur la touche <kbd>F</kbd>. Cela se fait en obtenant le pivot actuel avec
`Class.PVInstance:GetPivot()` et en appelant `PVInstance|PivotTo` pour déplacer le
personnage vers l'avant.

Cette fonction obtient le pivot d'une `Class.PVInstance`. Cela est souvent utilisé
avec `Class.PVInstance:PivotTo()` pour déplacer un modèle.

`Class.Model|Models` et `Class.BasePart|BaseParts` sont tous deux
`Class.PVInstance|PVInstances` ("Instances de Vitesse de Position") et donc tous deux
ont cette fonction.


PVInstance:GetPivot

Obtient le pivot d'une `Class.PVInstance`.


Transforme la `Class.PVInstance` ainsi que tous ses descendents
`Class.PVInstance|PVInstances` de sorte que le pivot soit maintenant situé à
la `Datatype.CFrame` spécifiée. C'est la fonction principale qui devrait être
utilisée pour déplacer des `Class.Model|Models` via le scripting.

`Class.BasePart|BaseParts` sont déplacés de cette manière en ayant leur
`Datatype.CFrame` transformé par le décalage nécessaire.
Les `Class.Model|Models` sont déplacés de cette manière en ayant leur
`Class.Model.WorldPivot` transformé par le décalage nécessaire.

Notez que pour des raisons d'efficacité, les événements `Class.Object.Changed` ne sont pas
déclenchés pour la `Class.BasePart.Position|Position` et
`Class.BasePart.Orientation|Orientation` des `Class.BasePart|BaseParts`
déplacés de cette manière ; ils ne sont déclenchés que pour `Datatype.CFrame`.

Lors de l'appel de `Class.PVInstance:PivotTo()|PivotTo` sur des `Class.Model|Models`,
les décalages des pièces et modèles descendants sont mis en cache, de sorte que
les appels subséquents à `Class.PVInstance:PivotTo()|PivotTo` sur le même modèle
ne cumulent pas de dérive en virgule flottante entre les pièces composant le
modèle.

`Class.Model|Models` et `Class.BasePart|BaseParts` sont tous deux
`Class.PVInstance|PVInstances` ("Instances de Vitesse de Position") et donc tous deux
ont cette fonction.


PVInstance:PivotTo

targetCFrame

La `Datatype.CFrame` à laquelle le pivot de `Class.PVInstance` doit être égal
après l'avoir déplacé.


Transforme la `Class.PVInstance` ainsi que tous ses descendents
`Class.PVInstance|PVInstances` de sorte que le pivot soit maintenant situé à
la `Datatype.CFrame` spécifiée.


PVInstance

PVInstance.Origin

PVInstance.Pivot Offset

Classe abstraite pour tous les objets ayant une position physique dans le monde.


`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

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

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