Agit comme un `Class.Folder` pour les objets `Class.ReflectionMetadataClass`.


ReflectionMetadataClasses

Un objet interne qui ne peut pas être utilisé par les développeurs.


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

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

Démontre la détection des changements dans l'ascendance 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 la propriété `Class.Instance.Parent` de l'objet ou de l'un de
ses ancêtres est modifiée.

Cet événement inclut deux paramètres : `child` fait référence à l'`Class.Instance`
dont le `Class.Instance.Parent` a été réellement modifié, tandis que `parent` fait
référence au nouveau `Class.Instance.Parent` de cette instance.

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

Instance.AncestryChanged

child

L'`Class.Instance` dont le `Class.Instance.Parent` a été modifié.

parent

Le nouveau `Class.Instance.Parent` de l'`Class.Instance` dont
le `Class.Instance.Parent` a été modifié.

Se déclenche lorsque la propriété `Class.Instance.Parent` de l'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,
incluant lorsque qu'un attribut est défini sur `nil`. Le nom de l'attribut modifié
est passé à la fonction connectée.

Par exemple, l'extrait de 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
event qui se déclenche lorsque qu'un attribut spécifié change.

Instance.AttributeChanged

attribute

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

Se déclenche chaque fois qu'un attribut est modifié sur l'`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é à cette `Class.Instance`.

Notez que, lors de l'utilisation de cette méthode sur un client pour détecter les 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 de se répliquer 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 été répliqués encore
	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

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

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é retiré de cet `Class.Instance`.

Retiré fait référence à lorsque le parent d'un objet est changé de cet
`Class.Instance` à quelque chose d'autre que cet `Class.Instance`. Notez que cet
event se déclenchera également lorsqu'un enfant est détruit (en utilisant
`Class.Instance:Destroy()`) car la fonction de destruction met le parent d'un objet
en `nil`.

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

Voir aussi `Class.Instance.ChildAdded`.

Instance.ChildRemoved

Se déclenche après qu'un enfant a été retiré de cet `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é à l'`Class.Instance`.

Comme il se déclenche pour chaque descendant, parenté d'un objet à la
`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 la
`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é à l'`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 de l'`Class.Instance`
change de sorte qu'un **descendant** ne sera 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** le retrait du descendant, le parent du
descendant restera inchangé au moment de l'occurrence de cet événement. Si le
descendant est aussi 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 avec le descendant en premier,
suivi de ses descendants.

##### Avertissement

Cet événement se déclenche avec l'objet descendant qui est en train d'être retiré.
Essayer de changer le `Class.Instance.Parent|Parent` du descendant en
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'a pas encore eu lieu
	-- 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

L'`Class.Instance` qui est en train d'être retiré.

Se déclenche immédiatement avant qu'un descendant de l'`Class.Instance` ne soit retiré.

Cet exemple démontre comment, lors de l'utilisation du comportement de signaux immédiats, une instance en cours de destruction reste en place jusqu'à ce que la fonction connectée se bloque.

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

L'`Class.Instance` ne sera jamais supprimé de la mémoire tant qu'une fonction connectée
l'utilise encore. Cependant, si la fonction suspend à un moment donné,
l'`Class.Instance` et ses descendants seront mis en parent à `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 l'`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 l'`Class.Instance` ou l'un de ses ancêtres est 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'un `Class.Instance` dans Studio, comme la suppression manuelle
à travers l'[Explorateur](/studio/explorer) ou via un plugin,
l'`Class.Instance` n'est pas détruit. Au lieu de cela, le parent est défini sur `nil`
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()`.

Cet événement se déclenche chaque fois qu'une propriété de style est modifiée sur l'instance,
incluant lorsque qu'une propriété est définie 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("Propriétés de style changées")
end

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

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

Instance.childAdded

Cette méthode applique une étiquette à l'instance, sans effet si l'étiquette est
déjà appliquée. L'ajout d'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 perdues si le
  serveur ajoute ou supprime ultérieurement 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 judicieux de nettoyer cela (déconnecter,
  définir sur `nil`, etc.) lorsqu'elle n'est plus nécessaire pour une étiquette. Faites cela lors de
  l'appel à `Class.Instance:RemoveTag()`, de l'appel à
  `Class.Instance:Destroy()`, ou dans une fonction connectée à un signal
  retourné par `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

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

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

-- Ajoutez quelques é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()` soit `Class.Instance:GetDescendants()` pour
parcourir ces enfants/descendants et sélectionner ce qu'il faut détruire. Par
exemple, l'extrait 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é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 se référera à 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éer une copie d'une instance et de tous ses descendants, en ignorant les instances
qui ne sont pas `Class.Instance.Archivable|Archivable`.

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` sur `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 non nécessaires est important, car des objets et
connexions inutiles dans un endroit consomment de la mémoire ce qui peut mener à de
sérieux problèmes de performance au fil du temps.

Comme meilleure pratique, après avoir appelé `Destroy()` sur un objet, définissez toutes
gles variables faisant référence à l'objet (ou à ses descendants) sur `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 ça :
print(part.Name)  --> "Hello, world"
-- Faites ceci pour empêcher la ligne ci-dessus de fonctionner :
part = nil
```
Une fois qu'une `Class.Instance` a été détruite par cette méthode, elle ne peut pas être
réutilisée car la propriété `Class.Instance.Parent` est verrouillée. Pour
**temporirement** retirer un objet au lieu de le détruire, définissez
`Class.Instance.Parent|Parent` sur `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` de l'instance à `nil`, verrouille la
propriété `Class.Instance.Parent`, déconnecte toutes les connexions et appelle
`Destroy()` sur tous les enfants.

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` immédiat et remonte vers le `Class.DataModel`. Si aucun
ancêtre correspondant n'est trouvé, elle renvoie `nil`.

L'extrait de code suivant trouvera 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,
veuillez consulter `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 className donné.

Cette méthode fonctionne vers le haut, ce qui signifie qu'elle commence au
`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 consiste à 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,
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 className donné.

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

Cette méthode fonctionne vers le haut, ce qui signifie qu'elle commence au
`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 de classe. 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`, qu'il soit un `Class.WedgePart`, un `Class.MeshPart` ou un `Class.Part`.

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

Instance:FindFirstAncestorWhichIsA

Renvoie le premier ancêtre de l'`Class.Instance` pour lequel
`Class.Object:IsA()` renvoie vrai pour le className 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érifier l'existence d'un objet

`FindFirstChild()` est nécessaire si vous avez besoin de vérifier qu'un objet existe
avant de continuer. Tenter d'indexer un enfant par son nom à l'aide de 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 consiste à utiliser `FindFirstChild()` pour d'abord vérifier `Part`,
ensuite 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 identique à celui
d'une propriété de son `Class.Instance.Parent|Parent`. Lors de l'utilisation de l'opérateur point, les propriétés ont la priorité sur les enfants s'ils partagent un 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`, pas à l'instance enfant `Class.Folder`. Un avantage d'utiliser
`Class.Instance:FindFirstChild()|FindFirstChild()` est que l'introduction de nouvelles propriétés ne
met pas en danger 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 devez éviter de l'appeler dans
du code dépendant de la performance, comme dans des boucles serrées ou des fonctions connectées
a `Class.RunService.Heartbeat` et `Class.RunService.PreRender`. Au lieu de cela,
stockez le résultat dans une variable ou envisagez d'utiliser
`Class.Instance.ChildAdded|ChildAdded` ou
`Class.Instance:WaitForChild()|WaitForChild()` pour détecter quand un enfant d'un
donné nom devient disponible.

Instance:FindFirstChild

recursive

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

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

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


Instance:FindFirstChildOfClass

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

Renvoie le premier enfant de la `Class.Instance` pour lequel
`Class.Object:IsA()` renvoie vrai pour le `className` donné.

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

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

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

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


Instance:FindFirstChildWhichIsA

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

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

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

Instance:FindFirstDescendant

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

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

Instance:GetActor

Renvoie le `Class.Actor` associé à l'Instance, s'il y en a un.

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

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

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

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

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

##### Voir aussi

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

Instance:GetAttribute

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

Renvoie la valeur qui a été attribuée au nom de l'attribut donné.

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

Il est généralement préférable d'utiliser cette méthode plutôt que de se connecter à
`Class.Object.Changed|Changed` avec une fonction qui vérifie le nom de l'attribut. Des appels successifs à cette méthode sur le même objet avec le même
nom d'attribut renvoient le même événement.

L'extrait de code suivant renvoie un signal qui déclenche la fonction
`attributeChanged()` lorsque l'attribut `InitialPosition` de la partie change :

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

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

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

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

Instance:GetAttributeChangedSignal

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

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

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

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

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

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

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

for name, value in part:GetAttributes() do
	print(name .. " = " .. value)
end
```
Voir aussi `Class.Instance:GetAttribute()` qui renvoie la valeur qui a été
attribuée au nom d'attribut donné.

Instance:GetAttributes

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

Renvoie un dictionnaire des attributs de l'instance.

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

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

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

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

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

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

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


Instance:GetChildren

Un tableau contenant les enfants de l'instance.

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

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

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

Instance:GetDebugId

scopeLength

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

GetDescendants est souvent utilisé pour faire quelque chose à tous les descendants qui sont un type particulier d'objet. Le code dans cet exemple utilise GetDescendants et `Class.Instance:IsA()` pour trouver toutes les pièces dans l'espace de travail et les rend vertes.

Cette méthode d'objet renvoie un tableau qui contient tous les descendants
de cet objet. Contrairement à `Class.Instance:GetChildren()`, qui ne renvoie que
les enfants immédiats d'un objet, cette méthode trouve chaque enfant de l'objet,
chaque enfant de ces enfants, et ainsi de suite.

Notez que le tableau renvoyé **n'est pas** trié dans un ordre particulier, donc
un tri manuel (par exemple en utilisant `Library.table.sort()`) est conseillé pour
trier les descendants renvoyés par cette méthode. Considérez également la
méthode `Class.Instance:QueryDescendants()|QueryDescendants()` pour interroger
les descendants par combinaison de sélecteurs et de combinateurs.


Instance:GetDescendants

Un tableau contenant les descendants de l'instance.

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

Cet exemple de code démontre le comportement de `Class.Instance:GetFullName()`.
Il montre comment la fonction se comporte lorsqu'elle est appelée sur un objet qui n'est pas dans la
hiérarchie `DataModel`, et il montre également comment la valeur de retour n'échappe pas
aux caractères spéciaux.

Cet exemple de code réimplémente la fonction `Class.Instance:GetFullName()` en
Lua.

Renvoie une chaîne décrivant l'ascendance de l'instance. La chaîne est une
concaténation de la `Class.Instance.Name|Name` de l'objet et de ses
ancêtres, séparés par des points. Le `Class.DataModel` (`game`) n'est pas
pris en compte. Par exemple, une `Class.Part` dans le `Class.Workspace` peut
renvoyer `Class.Workspace.Part`.

Lorsqu'elle est appelée sur une `Class.Instance` qui n'est pas un descendant du
`Class.DataModel`, cette méthode considère tous les ancêtres jusqu'à et y compris
le plus haut sans `Class.Instance.Parent|Parent`.

Cette méthode est utile pour l'enregistrement et le débogage. Vous ne devriez pas tenter de
analyser la chaîne renvoyée pour une opération utile ; cette méthode n'échappe pas aux points
(ou à tout autre symbole) dans les noms d'objets. En d'autres termes,
bien que sa sortie semble souvent être un identifiant Luau valide, ce n'est pas
garantit.


Instance:GetFullName

Renvoie une chaîne décrivant la parenté de l'instance.

Cette méthode renvoie la valeur stylisée ou explicitement modifiée de la
propriété spécifiée, ou sinon la valeur de la propriété par défaut si elle n'a pas été
stylisée/modifiée. Cela diffère légèrement de l'accès à la valeur de la propriété
directement, comme `[GuiObject].Rotation`, qui renvoie la valeur de la propriété par défaut ou
modifiée.

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

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

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

-- Référence à un bouton
local button = HUDContainer:FindFirstChildWhichIsA("TextButton")

print(button:GetStyled("Rotation")) --> 0 (valeur par défaut)
print(button.Rotation) --> 0 (valeur par défaut)

-- Appliquer une rotation via la propriété de règle de style
rule:SetProperty("Rotation", 30)

print(button:GetStyled("Rotation")) --> 30 (valeur stylisée basée sur la règle)
print(button.Rotation) --> 0 (valeur par défaut)

-- Modifier/écraser explicitement la propriété stylisée
button.Rotation = 45

print(button:GetStyled("Rotation")) --> 45 (valeur modifiée)
print(button.Rotation) --> 45 (valeur modifiée)
```

Instance:GetStyled

La valeur stylisée ou explicitement modifiée de la propriété spécifiée, ou
sinon la valeur de la propriété par défaut si elle n'a pas été stylisée/modifiée.

Renvoie la valeur stylisée ou explicitement modifiée de la propriété spécifiée,
ou sinon la valeur de la propriété par défaut si elle n'a pas été stylisée/modifiée.

Cette méthode renvoie un événement qui se comporte exactement comme l'événement
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged`,
sauf qu'il se déclenche uniquement lorsque la propriété de style donnée change. Il est
généralement préférable d'utiliser cette méthode plutôt que de se connecter à
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` avec une
fonction qui vérifie le nom de la propriété. Des appels successifs à cette méthode sur
le même objet avec le même nom de propriété renvoient le même événement.

Notez que cet événement ne passera aucun argument à une fonction connectée,
ce qui signifie que la valeur de la propriété modifiée doit être lue directement
dans un script.

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

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

local function stylePropertyChanged()
	print("Propriété de style changée !")
end

meterBar:GetStyledPropertyChangedSignal("AnchorPoint"):Connect(stylePropertyChanged)
```

Instance:GetStyledPropertyChangedSignal

property

Nom de la propriété de style pour laquelle écouter les changements.

Événement qui se déclenche lorsque la propriété de style donnée change.

Cette méthode renvoie un tableau des étiquettes appliquées à l'instance donnée, sous
forme de chaînes. Vous pouvez ajouter des étiquettes soit dans Studio dans la
fenêtre [Propriétés](/studio/properties) ou à l'exécution avec
`Class.Instance:AddTag()|AddTag()`.

Cette méthode est utile lorsque vous souhaitez effectuer une opération avec plusieurs étiquettes sur
une instance à la fois. Cependant, il est inefficace d'utiliser cette méthode pour
vérifier l'existence d'une seule étiquette ; utilisez plutôt
`Class.Instance:HasTag()|HasTag()` pour vérifier une étiquette spécifique.

Instance:GetTags

Obtenir un tableau de toutes les étiquettes appliquées à l'instance.

Cette méthode renvoie `true` si l'étiquette fournie a été ajoutée à l'objet.
Vous pouvez ajouter des étiquettes soit dans Studio dans la
fenêtre [Propriétés](/studio/properties) ou à l'exécution avec
`Class.Instance:AddTag()|AddTag()`.

Instance:HasTag

Vérifiez si l'instance possède une étiquette donnée.

Démonstration de la détermination si une instance est l'ancêtre d'une autre en utilisant `Class.Instance:IsAncestorOf()`

Workspace et SpawnLocation sont des ancêtres du décalque de SpawnLocation.
Workspace est un ancêtre de SpawnLocation.

SpawnLocation et son décalque sont des descendants de Workspace, pas des ancêtres.
Le décalque est un descendant de SpawnLocation, pas un ancêtre.

Renvoie vrai si un `Class.Instance` est un ancêtre du descendant donné.

Un `Class.Instance` est considéré comme l'ancêtre d'un objet si
le `Class.Instance.Parent` de l'objet ou l'un de ses parents
`Class.Instance.Parent` est défini sur le `Class.Instance`.

Voir également, `Class.Instance:IsDescendantOf()`.

Instance:IsAncestorOf

Vrai si le `Class.Instance` est un ancêtre du descendant donné.

Renvoie vrai si un `Class.Instance` est un ancêtre du descendant donné.

Renvoie `true` si un `Class.Instance` est un descendant de l'ancêtre donné.

Notez que `IsDescendantOf()` ne peut pas être utilisé avec un paramètre `nil` pour
vérifier si un objet a été supprimé.

Voir également `Class.Instance:IsAncestorOf()`.

Instance:IsDescendantOf

ancestor

Vrai si le `Class.Instance` est un descendant de l'ancêtre donné.

Renvoie `true` si un `Class.Instance` est un descendant de l'ancêtre donné.

Cette méthode indique si une propriété spécifique a été modifiée par rapport à
la valeur par défaut instanciée par le code. Si elle est appelée sur une instance nouvellement créée via
le code (`Datatype.Instance.new()`), cette méthode renverra `false`. Si
elle est appelée sur un objet nouvellement créé par des flux de travail de Studio tels que
l'insertion dans la fenêtre [Explorer](/studio/explorer), le résultat peut
être différent.

Par exemple, interroger la propriété
`Class.TextLabel.BackgroundColor3|BackgroundColor3` d'un
`Class.TextLabel` inséré via l'[Explorer](/studio/explorer)
renverra `true`, mais interroger la même propriété d'un `Class.TextLabel`
créé via `Datatype.Instance.new()` renverra `false`, en supposant qu'aucun
autre changement n'ait été effectué sur son
`Class.TextLabel.BackgroundColor3|BackgroundColor3`.

Notez que si cette méthode renvoie `true`, le style **n'affectera pas** la
propriété car la modification explicite d'une propriété prend le pas sur son
style. Pour réinitialiser une propriété à sa valeur par défaut instanciée par le code et permettre
son stylisme, utilisez
`Class.Instance:ResetPropertyToDefault()|ResetPropertyToDefault()`.


Instance:IsPropertyModified

Booléen indiquant si la propriété est modifiée par rapport à son
valeur par défaut instanciée par le code.


Renvoie `true` si la valeur stockée dans la propriété spécifiée n'est pas
égale à la valeur par défaut instanciée par le code.


Cette méthode d'objet renvoie un tableau qui contient les descendants de cet
objet correspondant à la chaîne `selector` fournie. La chaîne `selector` peut
inclure plusieurs sélecteurs et combinatoires pour correspondre à des caractéristiques telles
que le nom de classe, le nom d'instance, les relations hiérarchiques, ainsi que
les valeurs spécifiques des propriétés et attributs d'instance. La grammaire du `selector`
est similaire à celle utilisée dans `Class.StyleRule` avec seulement quelques
différences concernant quelles parties de la grammaire sont prises en charge ou non.

##### Sélecteurs

<table>
<thead>
  <tr>
    <th>Sélecteur</th>
    <th>Description</th>
    <th>Exemples</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td><code>ClassName</code></td>
    <td>Correspond aux instances de la classe spécifiée dans une relation
<code>Class.Object:IsA()</code>.</td>
    <td><code>SpotLight</code><br /><code>ImageButton</code><br /><code>Part</code></td>
  </tr>
  <tr>
    <td><code>.Tag</code></td>
    <td>Correspond aux instances marquées avec une étiquette
<code>Class.CollectionService</code>.</td>
    <td><code>.Fruit</code><br /><code>.IntenseLight</code></td>
  </tr>
  <tr>
    <td><code>#Name</code></td>
    <td>Correspond aux instances d'un <code>Class.Instance.Name</code>
specific.</td>
    <td><code>#RedTree</code><br /><code>#CloseButton</code></td>
  </tr>
  <tr>
    <td><code>[property = value]</code></td>
    <td>Correspond aux instances qui ont la propriété spécifiée et que cette propriété a la
valeur spécifiée. Des valeurs booléennes, numériques et de chaîne sont prises en charge. Des lettres,
nombres, <code>_</code> et <code>-</code> peuvent être utilisés sans mettre la valeur entre
guillemets.
    </td>
    <td><code>[CanCollide = false]</code><br />
    <code>[Brightness = "0.5"]</code><br />
    <code>[Name = Folder10]</code><br />
    <code>[Name = "Part.10"]</code></td>
  </tr>
  <tr>
    <td width="30%"><code>[$attribute = value]</code></td>
    <td>Correspond aux instances qui ont l'attribut spécifié et que cet attribut a la
valeur spécifiée. Les mêmes limitations s'appliquent que pour les sélecteurs de propriété.</td>
    <td width="30%"><code>[$MyAttribute = 10]</code></td>
  </tr>
</tbody>
</table>

Notez que les sélecteurs peuvent être combinés. Par exemple,
`Model.Apple[$Kind = "Red"][$State = 4]` correspondra aux instances qui sont une
`Class.Model` avec une étiquette `Apple` définie et qui ont un attribut `Kind`
évalué à la chaîne `"Red"` ainsi qu'un attribut `State` évalué à `4`.

##### Combinatoires

<table>
<thead>
  <tr>
    <th>Combinatoire</th>
    <th>Description</th>
    <th>Exemples</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td><code>&gt;</code></td>
    <td>Correspond aux instances qui sont des <b>enfants directs</b> des filtres précédents.</td>
    <td><code>Part &gt; .SwordHandle</code></td>
  </tr>
  <tr>
    <td><code>&gt;&gt;</code></td>
    <td>Correspond aux instances qui sont des <b>descendants</b> des filtres précédents.</td>
    <td><code>Model &gt;&gt; .TreeOnFire</code></td>
  </tr>
  <tr>
    <td width="10%"><code>,</code></td>
    <td>Spécifie une liste de plusieurs sélecteurs indépendants pour la requête de descendants.</td>
    <td width="50%"><code>Part.TagA, Part[$UseForce = true]</code></td>
  </tr>
</tbody>
</table>

Notez que le premier filtre par défaut est un combinatoire de descendants `>>`. Si le
sélecteur commence par un `>`, seuls les enfants sont visités ; par exemple
`>Part.Apple` sélectionne les <b>enfants directs</b> qui sont un `Class.Part` et
ont une étiquette `Apple`.

Le combinatoire par défaut peut également être spécifié explicitement, donc
`>>SpotLight.Red` est identique à `SpotLight.Red`.

Seuls les éléments correspondant au filtre sont placés dans le tableau. Par exemple,
`>#ExistingChild, >#MissingChild, >#AnotherExistingChild` renverra un
tableau avec deux éléments et il n'y aura pas de `nil` pour l'enfant manquant.


Instance:QueryDescendants

selector

Chaîne de sélecteur utilisée pour filtrer les éléments.

Un tableau d'instances (vide si rien ne correspond au sélecteur).

Le code suivant démontre comment une partie peut être réajoutée au DataModel
après avoir été supprimée :

Cette méthode définit le `Class.Instance.Parent` de l'objet sur `nil`, et fait
de même pour tous ses descendants.

Si l'objet est référencé avant d'être supprimé, il est possible de
récupérer l'objet à un moment ultérieur.

Instance:Remove

Définit le `Parent` de l'objet sur `nil`, et fait de même pour tous ses
descendants.

Cette méthode supprime une étiquette d'une instance. Elle ne générera pas d'erreur si
l'objet n'a pas d'étiquette. La suppression réussie d'une étiquette déclenchera un
signal créé par `Class.CollectionService:GetInstanceRemovedSignal()`
avec l'étiquette donnée.

Notez qu'en étiquetant 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 judicieux de nettoyer cela
(déconnecter, définir sur `nil`, etc.) lorsqu'il n'est plus nécessaire pour une étiquette.

Instance:RemoveTag

Réinitialise une propriété à sa valeur par défaut. Par exemple, appeler
`ResetPropertyToDefault("Rotation")` sur un `Class.TextLabel` est équivalent
à définir son `Class.TextLabel.Rotation|Rotation` à `0` (la valeur par défaut de la propriété).
Cette méthode peut être utilisée pour s'assurer que la stylisation va écraser
la valeur par défaut de cette propriété.

Instance:ResetPropertyToDefault

Réinitialise une propriété à sa valeur par défaut.

Cette méthode définit l'attribut avec le nom donné à la valeur donnée. Si
la valeur donnée est `nil`, l'attribut sera supprimé, puisque `nil` est
renvoyé par défaut.

Par exemple, l'extrait de code suivant définit l'attribut `InitialPosition` de l'instance
à `Datatype.Vector3|Vector3.new(0, 10, 0)` :

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

local part = Workspace.Part
part:SetAttribute("InitialPosition", Vector3.new(0, 10, 0))
```

##### Limitations

Exigences et restrictions sur les noms :

- Les noms ne peuvent utiliser que des caractères alphanumériques.
  - Vous pouvez également inclure des points, des tirets, des barres obliques et des underscores.
- Aucun espace ou symbole unique (comme @, ~, !) n'est autorisé.
- Les chaînes doivent comporter 100 caractères ou moins.
- Les noms ne peuvent pas commencer par **RBX** sauf si l'appelant est un
  script de base Roblox (réservé à Roblox).

Lors de l'essai de définition d'un attribut à un type non pris en charge, une erreur sera
levée.

##### Voir aussi

- `Class.Instance:GetAttribute()` qui renvoie la valeur qui a été
  attribuée au nom d'attribut donné.
- `Class.Instance:GetAttributes()` qui renvoie un dictionnaire de paires clé-valeur
  pour chacun des attributs de l'instance.

Instance:SetAttribute

value

La valeur à définir pour l'attribut spécifié.

Définit l'attribut avec le nom donné à la valeur donnée.

Le code suivant attend qu'une instance nommée "Part" soit ajoutée à
Workspace.

Renvoie l'enfant de l'`Class.Instance` avec le nom donné. Si l'enfant
n'existe pas, il mettra le fil courant en attente jusqu'à ce qu'il le fasse. Si
le paramètre `timeOut` est spécifié, cette méthode se terminera après le
nombre spécifié de secondes et renverra `nil`.

##### Usage principal

`Class.Instance:WaitForChild()|WaitForChild()` est extrêmement important lors de
la rédaction de code exécuté par le client dans un `Class.LocalScript`. Le moteur Roblox
ne garantit pas le temps ou l'ordre dans lequel les objets sont
répliqués du serveur au client. De plus, si une expérience a `Class.Workspace.StreamingEnabled` défini sur true,
les `Class.BasePart|BaseParts` qui sont loin du personnage du joueur
peuvent ne pas être diffusés au client, provoquant la rupture des scripts
lors de l'indexation d'objets qui n'existent pas encore sur le client.

##### Remarques

- Cette méthode ne met pas en attente si un enfant avec le nom donné existe
  lorsque l'appel est effectué.
- `Class.Instance:FindFirstChild()` est une alternative plus efficace à
  `Class.Instance:WaitForChild()|WaitForChild()` pour les objets qui sont
  supposés exister.
- Si un appel à cette méthode dépasse 5 secondes sans renvoyer, et aucun
  paramètre `timeOut` n'est spécifié, un avertissement sera imprimé dans la
  sortie indiquant que le thread peut se bloquer indéfiniment.

Instance:WaitForChild

childName

timeOut

Un paramètre de délai d'attente optionnel.

Renvoie l'enfant de l'`Class.Instance` avec le nom donné. Si l'enfant
n'existe pas, il mettra le fil actuel en attente jusqu'à ce qu'il le fasse.

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

Instance:children

Renvoie un tableau des enfants de l'objet.

Instance:clone

Instance:destroy

Instance:findFirstChild

Instance:getChildren

Instance:isDescendantOf

Instance:remove

Instance

Cette propriété détermine si l'instance doit être incluse lors de la publication ou de la sauvegarde de l'expérience,
ou lorsque `Class.Instance:Clone()|Clone()` est appelé sur l'un des ancêtres de l'instance. Appeler
`Class.Instance:Clone()|Clone()` directement sur une instance renverra `nil`
s'il s'agit **pas** de `Class.Instance.Archivable|Archivable`.

Copier un objet dans Studio à l'aide des options **Dupliquer** ou **Copier**/**Coller**
ignorera sa propre propriété `Class.Instance.Archivable|Archivable`
et mettra `Class.Instance.Archivable|Archivable` à `true` pour la copie.

```
local part = Instance.new("Part")
print(part:Clone())  --> Part
part.Archivable = false
print(part:Clone())  --> nil
```

Instance.Archivable

Détermine si un `Class.Instance` et ses descendants peuvent être clonés à l'aide de
`Class.Instance:Clone()`, et peuvent être sauvegardés/publicés.

L'ensemble des capacités autorisées pour être utilisées pour des scripts à l'intérieur de cette
instance. Pour que les capacités prennent effet, la propriété `Class.Instance.Sandboxed`
doit être activée.

Cette propriété est utilisée par une fonctionnalité expérimentale. Voir
[capabilités des scripts](/scripting/capabilities) pour plus de
détails.

Instance.Capabilities

L'ensemble des capacités autorisées pour être utilisées pour des scripts à l'intérieur de ce
conteneur.

Un identifiant non unique de l'`Class.Instance`. Les noms sont utilisés pour organiser
hierarchie des objets, permettant également aux scripts d'accéder à
des objets spécifiques. Le nom d'une instance ne peut pas dépasser 100 caractères en
longueur.

Le nom d'un objet est souvent utilisé pour accéder à l'objet via l'arborescence
données modèle à l'aide des méthodes suivantes :

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

local baseplate = Workspace.Baseplate
local baseplate = Workspace["Baseplate"]
local baseplate = Workspace:FindFirstChild("BasePlate")
```
Pour rendre un objet accessible à l'aide de l'opérateur point (`.`), son
nom doit commencer par un underscore ou une lettre, et le reste du nom ne peut
contenir que des lettres, chiffres ou underscores (aucun autre caractère
spécial). Si le nom d'un objet ne respecte pas cette syntaxe, il ne sera pas
accessible via l'opérateur point et Luau n'interprétera pas son nom
comme un identifiant.

Si plus d'un objet avec le même nom est dans la fratrie, toute tentative de
indexer un objet par ce nom ne renverra qu'un seul des objets, similaire à
`Class.Instance:FindFirstChild()`, mais pas toujours l'objet désiré.
Si un objet spécifique doit être accessible via le code, il est recommandé
de lui donner un nom unique ou de garantir qu'aucun de ses frères ne partage le
même nom.

Voir aussi `Class.Instance:GetFullName()` pour obtenir un nom complet incluant
toute la hiérarchie de l'objet.

Instance.Name

Un identifiant non unique de l'`Class.Instance`.

La propriété `Parent` détermine le parent hiérarchique de l'`Class.Instance`. La terminologie suivante est couramment utilisée pour parler
sur la façon dont cette propriété est définie :

- Un objet est un **enfant** de, ou est **parenté à**, un autre objet lorsque
  son `Parent` est défini sur cet objet.

- Les **descendants** d'un `Class.Instance` sont les enfants de cet
  objet, ainsi que les descendants des enfants.

- Les **ancêtres** d'un `Class.Instance` sont tous les objets dont
  l'instance est un descendant.

C'est à partir de la propriété `Parent` que de nombreux autres membres de l'API obtiennent leur
nom, tels que `Class.Instance:GetChildren()|GetChildren()` et
`Class.Instance:FindFirstChild()|FindFirstChild()`. Cette propriété est également
utilisée pour gérer si un objet existe dans l'expérience ou a besoin d'être
supprimé. Tant que le parent d'un objet est dans le `Class.DataModel`, est
stocké dans une variable, ou est référencé par la propriété d'un autre objet,
l'objet reste dans l'expérience ; sinon, l'objet sera automatiquement
supprimé.

Appeler `Class.Instance:Destroy()|Destroy()` mettra le `Parent` d'un
`Class.Instance` et de tous ses descendants à `nil`, et **verrouillera**
la propriété `Parent`. Une erreur est levée lorsqu'on tente de définir le
`Parent` d'un objet détruit.

Les objets nouvellement créés à l'aide de `Datatype.Instance.new()` n'auront pas de
parent, et ne seront généralement pas visibles ou fonctionnels tant qu'un
n'est pas défini.

##### Réplication d'objet

Un objet créé par le serveur ne sera pas répliqué aux clients tant qu'il n'est pas
parenté à un objet qui est répliqué. Lors de la création d'un objet et
réglage de nombreuses propriétés, il est recommandé de définir la propriété `Parent`
**en dernier**. Cela garantit que l'objet se réplique une seule fois, au lieu de répliquer
plusieurs fois les changements de propriété.

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

-- Définir le parent du nouvel élément en dernier (recommandé)
local part = Instance.new("Part")
part.Position = Vector3.new(0, 10, 0)
part.Parent = Workspace
```
Cependant, si vous parenté des parties à un `Class.Model` dont le parent n'a pas encore été
défini, rattacher chaque partie à ce modèle est acceptable puisque le modèle
ne se serait pas répliqué.

Instance.Parent

Détermine le parent hiérarchique de l'`Class.Instance`.

Cette propriété protégeait précédemment les objets dans le service `Class.CoreGui` contre
l'altération par les utilisateurs de manière non autorisée. Elle a été obsolète
et ne fait plus rien.

Instance.RobloxLocked

Une propriété obsolète qui protégeait les objets `Class.CoreGui`.

Transforme l'instance en un **conteneur sandboxé**, une
fonctionnalité expérimentale qui limite les actions que les scripts à l'intérieur d'un conteneur particulier peuvent effectuer. Voir
[capabilités des scripts](/scripting/capabilities) pour plus de
détails.

Instance.Sandboxed

Transforme l'instance en un conteneur sandboxé.

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

/reference/engine/classes/ReflectionMetadataClasses.yaml

ReflectionMetadataClasses

Résumé

Propriétés

Méthodes

Événements

Propriétés

Méthodes

Événements

Sur cette page