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

Démontre `Class.Actor:BindToMessage()`.


Cette méthode est utilisée pour lier un rappel Luau à un message avec le
sujet spécifié. Lorsqu'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ériel_.

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.

Actor:BindToMessage

topic

Le sujet utilisé pour identifier le type de message.

function

Le rappel Luau à invoquer lorsqu'un message avec le sujet spécifié est
reçu. Le rappel reçoit le contenu du message comme arguments.


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

Démontre `Class.Actor:BindToMessageParallel()`.


Cette méthode est utilisée pour lier un rappel Luau à un message avec le
sujet spécifié. Lorsqu'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 _parallèle_.

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.

Actor:BindToMessageParallel

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

Puisqu'un seul acteur 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 des détails sur la réception
d'un message envoyé en utilisant `Class.Actor:SendMessage()|SendMessage()`.

Notez que les arguments de message sont **passés par copie** à travers les frontières de la VM Luau,
non 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.

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 inclut une fonction de base qui prend une table d'objets
et les parenthèses 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 démontre la création manuelle de joints sur deux parties qui sont
sœurs du script (PartA et PartB). Il crée des joints sur deux parties 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

Démontre `Class.Model:GetBoundingBox()`.


Cette fonction renvoie une description d'un volume qui contient tous les enfants `Class.BasePart` dans un `Class.Model`. L'orientation du volume est basée sur l'orientation du `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 englobante et un `Datatype.Vector3` représentant sa taille. La taille peut être inexacte à l'exécution si des contraintes physiques agissent sur les parties à l'intérieur du `Class.Model`.

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


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 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 modèle de 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 s'assurer 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 dé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 à l'Espace de travail,
la partie inférieure tomberait sur la Plaque de base.

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 établie 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 modèle à deux parties `Class.Model` 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
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 à deux parties `Class.Model` 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 vers le haut. Si `Class.Model.PrimaryPart` n'était pas défini,
le pivot / la boîte englobante 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
au centre de la boîte englobante de ce modèle.


Cette propriété détermine où se trouve 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 à la place, et cette propriété `Class.Model.WorldPivot|WorldPivot` est ignorée.

Pour un `Class.Model` nouvellement créé, son pivot sera considéré comme le centre de la boîte englobante de son contenu jusqu'à la **première fois** que sa propriété `Class.Model.WorldPivot` est définie. Une fois que le pivot mondial 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 de Studio, ou avec des fonctions de mouvement de modèle telles que `Class.PVInstance:PivotTo()` et `Class.Model:MoveTo()`, définira le pivot mondial et mettra ainsi 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 ainsi la nécessité de définir explicitement `Class.Model.WorldPivot` chaque fois que vous créez un modèle dans le code.


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

Le `Datatype.CFrame` en espace mondial du pivot de l'instance.


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

Propriété réservée à l'éditeur, affichée dans la fenêtre des propriétés de Studio comme **Position
Origine** et **Orientation Origine** sous **Transformation**. Sa valeur est
le `Datatype.CFrame` en espace mondial du pivot de l'instance ; le lire
renvoie le même `Datatype.CFrame` que `Class.PVInstance:GetPivot()`. Il
n'a pas de valeur stockée propre et reflète toujours le pivot actuel.

Le définir à partir de la fenêtre des propriétés déplace l'ensemble de l'instance afin que son
pivot se trouve à la nouvelle `Datatype.CFrame`, tout comme
`Class.PVInstance:PivotTo()`. L'édition via la fenêtre des propriétés
désactive temporairement `Class.WeldConstraint|WeldConstraints` pour d'autres
objets lors du déplacement ; `PivotTo` ne modifie pas les joints.

Non disponible pour les scripts ; utilisez `Class.PVInstance:GetPivot()` et
`Class.PVInstance:PivotTo()` à l'exécution à la place.


PVInstance.Origin

Propriété réservée à l'éditeur qui lit et définit le `Datatype.CFrame` mondial du
pivot de `Class.PVInstance`, déplaçant l'ensemble de l'instance lorsqu'il est modifié
à partir de la fenêtre des propriétés de Studio.


Propriété réservée à l'éditeur, affichée dans la fenêtre des propriétés de Studio comme **Position
Pivot** et **Orientation Pivot** sous **Pivot**. C'est le
`Datatype.CFrame` du pivot par rapport au cadre propre de l'instance.

Le modifier à partir de la fenêtre des propriétés déplace le pivot par rapport à l'
instance tout en laissant l'instance en place, contrairement à `Origine`, qui déplace
l'ensemble de l'instance. Pour un `Class.BasePart`, le décalage par défaut est le
`Datatype.CFrame` d'identité, donc le pivot coïncide avec le centre de la pièce.
Pour un `Class.Model`, cette propriété n'apparaît que lorsque le modèle a un
`Class.Model.PrimaryPart|PrimaryPart` ; elle reflète alors et modifie le
`Class.BasePart.PivotOffset|PivotOffset` de cette pièce, et
`Class.Model:GetPivot()` fait un alias du pivot de la pièce principale.

Non disponible pour les scripts ; les scripts lisent et écrivent l'équivalent via
la classe concrète, comme `Class.BasePart.PivotOffset`.


PVInstance.Pivot Offset

Propriété réservée à l'éditeur qui affiche et modifie le `Datatype.CFrame`
du pivot par rapport à l'instance, ne déplaçant que le pivot et laissant l'instance
en place.


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

Se déclenche lorsque cette instance est reparentée ou lorsque l'un de ses ancêtres est
reparenté.

Vous pouvez utiliser cet événement pour suivre la suppression d'une instance dans Studio,
such as la suppression manuelle dans l'Explorateur ou via un plugin. Si vous avez besoin
de détecter quand une instance est détruite en utilisant `Class.Instance:Destroy()`,
utilisez l'événement `Class.Instance.Destroying` à la place.


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 éloigné, **pas**
nécessairement l'instance à laquelle le gestionnaire est connecté.


parent

Le nouveau parent du paramètre `child`.


Se déclenche lorsque la propriété `Class.Instance.Parent` de cet objet ou de l'un de
ses ancêtres est modifiée.


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

Par exemple, le code suivant connecte la fonction `attributeChanged()`
pour se déclencher 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, "a changé")
end

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


Instance.AttributeChanged

attribute

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


Se déclenche chaque fois qu'un attribut est modifié sur le `Class.Instance`.


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

Se déclenche après qu'un objet a été parenté à ce `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
`Class.Instance`. Pour un événement qui capture tous les descendants, utilisez
`Class.Instance.DescendantAdded`.

Voir aussi `Class.Instance.ChildRemoved`.


Instance.ChildAdded

Le `Class.Instance` qui a été ajouté.


Se déclenche après qu'un objet a été parenté à ce `Class.Instance`.


Instance.childAdded

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

Se déclenche après qu'un enfant a été supprimé de ce `Class.Instance`.

Supprimé fait référence au moment où le parent d'un objet est changé de ce
`Class.Instance` à autre chose que ce `Class.Instance`. Notez que cet
evenement se déclenchera également lorsqu'un enfant est détruit (en utilisant
`Class.Instance:Destroy()`) car la fonction de destruction définit le parent d'un objet
à `nil`.

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

Voir aussi `Class.Instance.ChildAdded`.


Instance.ChildRemoved

Le `Class.Instance` qui a été supprimé.


Se déclenche après qu'un enfant a été supprimé de ce `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é au `Class.Instance`.

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

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

Voir aussi `Class.Instance.DescendantRemoving`.


Instance.DescendantAdded

descendant

Se déclenche après qu'un descendant a été ajouté au `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'un **descendant** ne soit plus un descendant. `Class.Instance:Destroy()|Destroy()` change le `Class.Instance.Parent|Parent` d'une instance à `nil`, donc appeler cette méthode sur un
descendant du parent fera déclencher cet événement.

Puisque cet événement se déclenche **avant** la suppression du descendant, le parent du
descendant restera inchangé au moment de ce déclenchement. 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,
suivi de 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
quelque chose d'autre échouera. Voici un exemple qui démontre cela :

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

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Ne manipulez pas 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

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


Se déclenche immédiatement avant qu'un descendant du `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.

Le `Class.Instance` ne sera jamais supprimé de la mémoire tant qu'une fonction connectée
l'utilise encore. Cependant, si la fonction se suspend à un moment donné,
le `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 ne 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 reprise,
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
a 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'un `Class.Instance` dans Studio, comme la suppression manuelle
via l'[Explorateur](/studio/explorer) ou via un plugin,
le `Class.Instance` n'est pas détruit. Au lieu de cela, le parent est défini sur `nil`
ce que vous pouvez suivre avec `Class.Instance.AncestryChanged`.


Instance.Destroying

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


Démontre `Class.Instance.StyledPropertiesChanged`.


Cet événement se déclenche chaque fois qu'une propriété de style est modifiée sur l'instance,
notamment lorsque qu'une propriété est définie sur `nil`.


Instance.StyledPropertiesChanged

Se 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. Ajouter une étiquette avec succès 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 certaines 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 ces ressources (déconnecter,
  définir à `nil`, etc.) lorsqu'elles ne sont plus nécessaires pour une étiquette. Faites cela lors
  de l'appel à `Class.Instance:RemoveTag()`, lors de l'appel à
  `Class.Instance:Destroy()`, ou dans une fonction connectée à un signal
  retourné par `Class.CollectionService:GetInstanceRemovedSignal()`.


Instance:AddTag

L'étiquette à appliquer à l'instance.


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 et descendants d'une instance.

```
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 ce qu'il faut détruire. Par
exemple, le 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
retourné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épend de la
valeur de l'original :

- 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

Une copie de l'instance, ou `nil` si l'instance n'est pas
`Class.Instance.Archivable|Archivable`.


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 sérieux problèmes de performance au fil du temps.

En tant que bonne pratique après avoir appelé `Destroy()` sur un objet, définissez toutes
les variables référencant 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 faites pas 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 certain temps, 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 au `Class.Instance.Parent`
immediat de l'instance et remonte vers le `Class.DataModel`. Si aucun ancêtre correspondant n'est trouvé, elle renvoie `nil`.

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

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


Instance:FindFirstAncestor

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


Instance

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