Une `Class.UIListLayout` positionne des éléments UI frères en rangées ou en colonnes dans le conteneur UI parent, en fonction de la `Class.UIListLayout.FillDirection|FillDirection`. Les propriétés `Class.GuiObject.Position|Position` et `Class.GuiObject.Rotation|Rotation` de chaque `Class.GuiObject` frère sont soit ignorées, soit remplacées par la mise en page de la liste, tandis que chaque frère conserve sa `Class.GuiObject.Size|Size` définie à moins que la mise en page ne soit configurée pour utiliser une mise en page flexible. Voir [Listes et mises en page flexibles](/ui/list-flex-layouts) pour plus d'informations.

<img src="../../../assets/engine-api/classes/UIListLayout/FillDirection.png"
width="720" alt="UIListLayouts illustrant FillDirection de horizontal ou vertical." />

Pour contrôler l'ordre de mise en page des frères, définissez `Class.UIListLayout.SortOrder|SortOrder` à `Enum.SortOrder.Name` ou `Enum.SortOrder.LayoutOrder`, puis renommez les frères dans un ordre alphanumérique ou définissez leur valeur `Class.GuiObject.LayoutOrder|LayoutOrder`, respectivement. `Class.UIListLayout` réorganisera automatiquement les éléments lorsque des éléments sont ajoutés/supprimés, ou si le `Class.Instance.Name|Name` d'un frère ou le `Class.GuiObject.LayoutOrder|LayoutOrder` change.

<img src="../../../assets/engine-api/classes/UIListLayout/SortOrder.png"
width="720" alt="Exemples de mise en page de liste illustrant le tri numérique LayoutOrder ou le tri alphanumérique Name." />

Le remplissage entre les frères est contrôlé par la propriété `Class.UIListLayout.Padding|Padding`, et l'emballage dans les limites du conteneur parent par le booléen `Class.UIListLayout.Wraps|Wraps`. L'alignement des frères dans le conteneur parent est contrôlé par `Class.UIListLayout.HorizontalAlignment|HorizontalAlignment` et `Class.UIListLayout.VerticalAlignment|VerticalAlignment`, à moins que la mise en page ne soit configurée pour utiliser une [mise en page flexible](/ui/list-flex-layouts#flex-layouts).

Notez qu'il y a des implications de performance à utiliser une mise en page de liste [flexible](/ui/list-flex-layouts#flex-layouts), car des calculs supplémentaires sont nécessaires pour calculer les tailles de base flexibles, les tailles flexibles, et l'enveloppement des lignes. Flex est activé sur un `Class.UIListLayout` lorsque les propriétés suivantes sont définies, ou si un frère `Class.GuiObject` a un parent `Class.UIFlexItem` :

- `Class.UIListLayout.HorizontalFlex|HorizontalFlex` et/ou `Class.UIListLayout.VerticalFlex|VerticalFlex` **ne sont pas** définis sur `Enum.UIFlexAlignment.None`.
- `Class.UIListLayout.ItemLineAlignment|ItemLineAlignment` **n'est pas** défini sur `Enum.ItemLineAlignment.Automatic`.
- `Class.UIListLayout.Wraps|Wraps` est `true`.


UIListLayout

Lorsque la `Class.UIListLayout.FillDirection|FillDirection` de la mise en page de la liste est définie sur `Enum.FillDirection.Horizontal`, la propriété `Class.UIListLayout.HorizontalFlex|HorizontalFlex` spécifie comment distribuer l'espace horizontal supplémentaire dans le conteneur parent.

<table size="small">
  <thead>
    <tr>
      <th>Paramètre</th>
      <th>Comportement des frères</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>Enum.UIFlexAlignment.None|None</code></td>
      <td>Aucun comportement flexible ; les frères maintiennent leur largeur définie.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.Fill|Fill</code></td>
      <td>Les frères redimensionnent horizontalement pour remplir l'ensemble du conteneur parent, remplaçant leur largeur définie. Le nombre de frères dans une rangée reste inchangé ; par exemple, si trois frères s'adaptent horizontalement dans la largeur du conteneur sous le paramètre <code>Enum.UIFlexAlignment.None|None</code>, ces trois frères se redimensionneront pour remplir toute la largeur.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceAround|SpaceAround</code></td>
      <td>Les frères maintiennent leur largeur définie. Un espacement égal est ajouté des deux côtés de chaque frère.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceBetween|SpaceBetween</code></td>
      <td>Les frères maintiennent leur largeur définie. Un espacement égal est ajouté <b>entre</b> les frères, mais aucun espace supplémentaire n'est ajouté <b>autour</b> des frères.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceEvenly|SpaceEvenly</code></td>
      <td>Les frères maintiennent leur largeur définie. Un espacement égal est ajouté à la fois <b>entre</b> et <b>autour</b> des frères.</td>
    </tr>
  </tbody>
</table>

<img src="../../../assets/engine-api/classes/UIListLayout/HorizontalFlex-Options.png" width="800" alt="Exemples de UIListLayout montrant comment chaque option HorizontalFlex affecte la taille et l'espacement des objets UI frères." />

##### Comportement de la direction croisée

Dans les mises en page de liste **verticales** (`Class.UIListLayout.FillDirection|FillDirection` définie sur `Enum.FillDirection.Vertical`), la propriété `Class.UIListLayout.HorizontalFlex|HorizontalFlex` spécifie comment distribuer les frères dans la **direction croisée horizontale**. Dans de telles mises en page, un paramètre de `Enum.UIFlexAlignment.Fill` fait en sorte que les frères remplissent tout l'espace horizontal tandis que l'espacement vertical respecte `Class.UIListLayout.VerticalFlex|VerticalFlex`.

<img src="../../../assets/engine-api/classes/UIListLayout/HorizontalFlex-Cross-Direction.png" width="720" alt="Diagramme montrant comment HorizontalFlex affecte la taille horizontale des objets UI frères lorsque la direction de remplissage de UIListLayout est définie sur vertical." />

##### Interaction avec AutomaticSize

Si `Class.GuiObject.AutomaticSize` est activé pour un enfant de la `Class.UIListLayout` dans la `Class.UIListLayout.FillDirection|FillDirection`, il est interprété comme "base flexible automatique" et définit la taille de la `Class.GuiObject` à partir de laquelle elle peut croître ou rétrécir.

Si `Class.GuiObject.AutomaticSize` est activé pour un enfant de la `Class.UIListLayout` dans la **direction croisée**, il est interprété comme "taille croisée automatique" et définit la taille minimale nécessaire pour contenir tout le contenu de l'enfant dans la direction croisée.


UIListLayout.HorizontalFlex

Contrôle comment distribuer l'espace horizontal supplémentaire.


Dans une [mise en page flexible](/ui/list-flex-layouts#flex-layouts), définit l'alignement **dans la direction croisée** des frères dans une ligne. Voir `Enum.ItemLineAlignment` pour des exemples visuels.

<table size="small">
  <thead>
    <tr>
      <th>Paramètre</th>
      <th>Comportement des frères</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>Enum.ItemLineAlignment.Automatic|Automatic</code></td>
      <td>Aligne les frères de la mise en page ou le parent `<code>Class.UIFlexItem</code>` spécifique sur l'<code>Class.UIListLayout.HorizontalAlignment|HorizontalAlignment</code> ou le `<code>Class.UIListLayout.VerticalAlignment|VerticalAlignment</code>`, en fonction de sa <code>Class.UIListLayout.FillDirection|FillDirection</code>.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.Start|Start</code></td>
      <td>Aligne les frères de la mise en page ou le parent `<code>Class.UIFlexItem</code>` spécifique en haut de la ligne dans un remplissage horizontal ou à gauche de la ligne dans un remplissage vertical.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.Center|Center</code></td>
      <td>Aligne les frères de la mise en page ou le parent `<code>Class.UIFlexItem</code>` spécifique au centre de la ligne dans un remplissage horizontal ou vertical.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.End|End</code></td>
      <td>Aligne les frères de la mise en page ou le parent `<code>Class.UIFlexItem</code>` spécifique en bas de la ligne dans un remplissage horizontal ou à droite de la ligne dans un remplissage vertical.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.Stretch|Stretch</code></td>
      <td>Étire les frères de la mise en page ou le parent `<code>Class.UIFlexItem</code>` spécifique pour remplir toute la direction croisée de la ligne dans un remplissage horizontal ou vertical.</td>
    </tr>
  </tbody>
</table>

<img src="../../../assets/engine-api/classes/UIListLayout/ItemLineAlignment.png" width="720" alt="Exemples d'options pour ItemLineAlignment dans une direction de remplissage horizontal." />


UIListLayout.ItemLineAlignment

Dans une mise en page flexible, définit l'alignement **dans la direction croisée** des frères dans une ligne.


Détermine le montant d'espace libre entre chaque élément, défini soit par une échelle (pourcentage de la taille du parent dans la direction actuelle) soit par un décalage (valeur d'espacement statique similaire à la taille en pixels).


UIListLayout.Padding

Montant d'espace libre entre chaque élément.


Lorsque la `Class.UIListLayout.FillDirection|FillDirection` de la mise en page de la liste est définie sur `Enum.FillDirection.Vertical`, la propriété `Class.UIListLayout.VerticalFlex|VerticalFlex` spécifie comment distribuer l'espace vertical supplémentaire dans le conteneur parent.

<table size="small">
  <thead>
    <tr>
      <th>Paramètre</th>
      <th>Comportement des frères</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>Enum.UIFlexAlignment.None|None</code></td>
      <td>Aucun comportement flexible ; les frères maintiennent leur hauteur définie.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.Fill|Fill</code></td>
      <td>Les frères redimensionnent verticalement pour remplir l'ensemble du conteneur parent, remplaçant leur hauteur définie. Le nombre de frères dans une colonne reste inchangé ; par exemple, si trois frères s'adaptent verticalement dans la hauteur du conteneur sous le paramètre <code>Enum.UIFlexAlignment.None|None</code>, ces trois frères se redimensionneront pour remplir toute la hauteur.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceAround|SpaceAround</code></td>
      <td>Les frères maintiennent leur hauteur définie. Un espacement égal est ajouté des deux côtés de chaque frère.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceBetween|SpaceBetween</code></td>
      <td>Les frères maintiennent leur hauteur définie. Un espacement égal est ajouté <b>entre</b> les frères, mais aucun espace supplémentaire n'est ajouté <b>autour</b> des frères.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceEvenly|SpaceEvenly</code></td>
      <td>Les frères maintiennent leur hauteur définie. Un espacement égal est ajouté à la fois <b>entre</b> et <b>autour</b> des frères.</td>
    </tr>
  </tbody>
</table>

<img src="../../../assets/engine-api/classes/UIListLayout/VerticalFlex-Options.png" width="800" alt="Exemples de UIListLayout montrant comment chaque option VerticalFlex affecte la taille et l'espacement des objets UI frères." />

##### Comportement de la direction croisée

Dans les mises en page de liste **horizontales** (`Class.UIListLayout.FillDirection|FillDirection` définie sur `Enum.FillDirection.Horizontal`), la propriété `Class.UIListLayout.VerticalFlex|VerticalFlex` spécifie comment distribuer les frères dans la **direction croisée verticale**. Dans de telles mises en page, un paramètre de `Enum.UIFlexAlignment.Fill` fait en sorte que les frères remplissent tout l'espace vertical tandis que l'espacement horizontal respecte `Class.UIListLayout.HorizontalFlex|HorizontalFlex`.

<img src="../../../assets/engine-api/classes/UIListLayout/VerticalFlex-Cross-Direction.png" width="720" alt="Diagramme montrant comment VerticalFlex affecte la taille verticale des objets UI frères lorsque la direction de remplissage de UIListLayout est définie sur horizontal." />

##### Interaction avec AutomaticSize

Si `Class.GuiObject.AutomaticSize` est activé pour un enfant de la `Class.UIListLayout` dans la `Class.UIListLayout.FillDirection|FillDirection`, il est interprété comme "base flexible automatique" et définit la taille de la `Class.GuiObject` à partir de laquelle elle peut croître ou rétrécir.

Si `Class.GuiObject.AutomaticSize` est activé pour un enfant de la `Class.UIListLayout` dans la **direction croisée**, il est interprété comme "taille croisée automatique" et définit la taille minimale nécessaire pour contenir tout le contenu de l'enfant dans la direction croisée.


UIListLayout.VerticalFlex

Contrôle comment distribuer l'espace vertical supplémentaire.


Contrôle si les frères dans le conteneur parent s'enroulent à une autre ligne lorsque leur taille par défaut dépasse la largeur/hauteur des limites du conteneur.

<img src="../../../assets/engine-api/classes/UIListLayout/Wraps.png" width="800" alt="Diagramme montrant comment Wraps affecte la distribution des frères dans les limites du conteneur parent." />


UIListLayout.Wraps

Contrôle si les frères dans le conteneur parent s'enroulent.


Positionne des éléments UI frères en rangées ou en colonnes dans le conteneur UI parent.


La classe de base pour les mises en page d'interface utilisateur de style grille.


Cet exemple de code démontre le tri des données en utilisant
`Class.UIGridStyleLayout.SortOrder` et `Class.GuiObject.LayoutOrder`.

La méthode ApplyLayout force les éléments UI frères à être repositionnés en
cas où les critères de tri pourraient avoir changé (comme lorsque
`Class.UIGridStyleLayout.SortOrder` est défini sur Custom, et que le
comportement `Class.UIGridStyleLayout:SetCustomSortFunction()` a changé).
Les repositionnements se produisent automatiquement lorsque des éléments UI sont ajoutés/enlevés, ou
que leur `Class.Instance.Name` ou `Class.GuiObject.LayoutOrder` changent.

La manière dont les éléments UI frères sont disposés dépend de l'implémentation de cette classe abstraite. En d'autres termes, une classe concrète
comme `Class.UIListLayout` ou `Class.UIGridLayout` est responsable du
vrai positionnement des éléments.


UIGridStyleLayout:ApplyLayout

Forcer le nouveau placement des éléments UI frères.


Cette méthode est obsolète. Utilisez `Class.UIGridStyleLayout.SortOrder`
à la place.

La fonction doit prendre deux arguments (chacun sera un enfant `Class.Instance`
à comparer), et retourner true si a vient avant b, sinon retourner
false. En d'autres termes, utilisez cette fonction de la même manière que vous utiliseriez une '
function. Le tri doit être déterministe, sinon le tri échouera
et reviendra à l'ordre par nom.


UIGridStyleLayout:SetCustomSortFunction

function

Définit la fonction utilisée pour déterminer l'ordre des éléments lorsque SortOrder
est défini sur Custom.


UIGridStyleLayout

La propriété **AbsoluteContentSize** d'un `Class.UIGridStyleLayout`
révèle combien d'espace les éléments de la grille occupent, y compris
le padding créé par la grille. Cette propriété est particulièrement utile pour
dimensionner les conteneurs de grilles tels que `Class.Frame|Frames` pour s'assurer qu'ils
ne soient pas plus grands que la grille elle-même.

Cette propriété se met à jour dès qu'elle est lue. Elle ne déclenchera pas un
event `Class.Object.Changed` immédiatement après le changement de l'interface utilisateur, mais si
the value is read, it will become current and a `Class.Object.Changed`
event will fire on the next render step.


UIGridStyleLayout.AbsoluteContentSize

La taille absolue de l'espace occupé par la mise en page de la grille.


La propriété **FillDirection** détermine l'axe selon lequel les éléments UI
sont disposés. `Enum.FillDirection.Horizontal` arrange les objets de gauche
a droite, tandis que `Enum.FillDirection.Vertical` arrange les objets de haut en
bas. Pour inverser les éléments, comme pour les disposer de droite à gauche, vous devrez
inverser le tri ; par exemple en niant les valeurs `Class.GuiObject.LayoutOrder` des objets
de l'interface utilisateur lorsque
`Class.UIGridStyleLayout.SortOrder` est défini sur
`Enum.SortOrder.LayoutOrder`.

<img src="../../../assets/engine-api/classes/UIListLayout/FillDirection.png" width="720" />


UIGridStyleLayout.FillDirection

Détermine l'axe selon lequel les objets UI sont disposés.


La propriété **HorizontalAlignment** détermine l'alignement de l'axe **X**
des éléments d'interface utilisateur, tout comme `Class.TextLabel.TextXAlignment`
le fait avec `Class.TextLabel.Text`.


UIGridStyleLayout.HorizontalAlignment

Détermine l'alignement horizontal des éléments UI au sein de l'élément
de parent.


La propriété **SortOrder** détermine l'ordre dans lequel les objets UI enfants
sont placés dans une mise en page.

Pour `Enum.SortOrder.LayoutOrder`, un tri ascendant est utilisé sur la
propriété `Class.GuiObject.LayoutOrder|LayoutOrder` des objets UI enfants. Si
deux enfants partagent le même `Class.GuiObject.LayoutOrder|LayoutOrder`,
celui qui a été ajouté en premier à l'objet parent a la priorité.

Pour `Enum.SortOrder.Name`, un tri alphanumérique est utilisé sur le
`Class.Instance.Name` des objets UI enfants.

<img src="../../../assets/engine-api/classes/UIListLayout/SortOrder.png" width="720" />


UIGridStyleLayout.SortOrder

Détermine l'ordre dans lequel les objets UI enfants sont placés dans une mise en page.


La propriété **VerticalAlignment** détermine l'alignement de l'axe **Y**
des éléments d'interface utilisateur, tout comme `Class.TextLabel.TextYAlignment` le fait
avec `Class.TextLabel.Text`.


UIGridStyleLayout.VerticalAlignment

Détermine l'alignement vertical des éléments UI au sein de l'élément
de parent.


La classe de base pour les classes de mise en page UI.


UILayout

Une classe de base pour les classes de contraintes et de mise en page UI ; hérite de
`Class.UIBase`.


UIComponent

Une classe de base pour les classes de contraintes et de mise en page UI.


`Class.UIBase` est la classe de base pour les classes de mise en page et de contrainte UI.


UIBase

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

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

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

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


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

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

Instance.AncestryChanged

child

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

parent

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

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

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

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

local part = Workspace.Part

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

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

Instance.AttributeChanged

attribute

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

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

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

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

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

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

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

Voir aussi `Class.Instance.ChildRemoved`.

Instance.ChildAdded

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

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

Instance.childAdded

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

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

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

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

Voir aussi `Class.Instance.ChildAdded`.

Instance.ChildRemoved

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

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

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

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

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

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

Voir aussi `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

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

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

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

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

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

#### Avertissement

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

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

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

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

Instance.DescendantRemoving

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

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

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


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


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

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

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

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

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

Instance.Destroying

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

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

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

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

local function stylePropertyChanged()
	print("Les propriétés de style ont changé")
end

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

Instance.StyledPropertiesChanged

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

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

#### Avertissements

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

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

Instance:AddTag

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

Instance:children

Renvoie un tableau des enfants de l'objet.

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

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

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

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

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

part:ClearAllChildren()

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

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

local model = Workspace:FindFirstChild("TestModel")

for _, descendant in model:GetDescendants() do
	if descendant:IsA("BasePart") then
		descendant:Destroy()
	end
end
```

Instance:ClearAllChildren

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

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

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

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

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

Instance:Clone

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

Instance:clone

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

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


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

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

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

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

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

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

Instance:Destroy

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

Instance:destroy

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

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

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

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

Instance:FindFirstAncestor

name

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

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

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

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

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

Instance:FindFirstAncestorOfClass

className

Le `Class.Object.ClassName` à rechercher.

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

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

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

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

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

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

Instance:FindFirstAncestorWhichIsA

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

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

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

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

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

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

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

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

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

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

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

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

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

#### Remarques de performance

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

Instance:FindFirstChild

recursive

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

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

Instance:findFirstChild

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

Instance:FindFirstChildOfClass

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

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

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

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

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

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

Instance:FindFirstChildWhichIsA

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

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

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

Instance:FindFirstDescendant

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

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

Instance:GetActor

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

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

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

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

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

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

#### Voir aussi

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

Instance:GetAttribute

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

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

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

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

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

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

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

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

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

Instance:GetAttributeChangedSignal

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

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

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

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

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

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

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

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

Instance:GetAttributes

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

Renvoie un dictionnaire des attributs de l'instance.

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

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

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

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

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

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

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

Instance:GetChildren

Un tableau contenant les enfants de l'instance.

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

Instance:getChildren

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

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

Instance:GetDebugId

scopeLength

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

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 de l'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,
tous les enfants de ces enfants, et ainsi de suite.

Notez que le tableau retourné n'est **pas** trié dans un ordre particulier, donc
le tri manuel (par exemple à l'aide de `Library.table.sort()`) est conseillé pour
trier les descendants renvoyés par cette méthode. Envisagez également la
méthode `Class.Instance:QueryDescendants()|QueryDescendants()` pour interroger
les descendants par une 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 du `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, un `Class.Part` dans le `Class.Workspace` peut
renvoyer `Class.Workspace.Part`.

Lorsqu'elle est appelée sur un `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 la journalisation et le débogage. Vous ne devriez pas
essayer d'analyser la chaîne renvoyée pour toute opération utile ; cette méthode ne
échappe pas les 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, cela ne
est pas garanti.

Instance:GetFullName

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

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

```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 stylée basée sur la règle)
print(button.Rotation) --> 0 (valeur par défaut)

-- Modifier/dépasser explicitement la propriété stylée
button.Rotation = 45

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

Instance:GetStyled

selector

Sélecteur optionnel pour l'instance pseudo que vous ciblez sur l'instance.

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

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

Cette méthode renvoie un événement qui se comporte exactement comme le
événement `Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged`,
excepté qu'il ne se déclenche que lorsque la propriété de style donnée change. Il est
généralement recommandé d'utiliser cette méthode plutôt qu'une connexion à
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` avec une
fonction qui vérifie le nom de la propriété. Des appels subséquents à 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,
ainsi la valeur de la propriété changé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 à la donnée instance, sous forme
de chaînes. Vous pouvez ajouter des étiquettes soit dans Studio dans la fenêtre
[Propriétés](/studio/properties) ou lors de l'exécution avec
`Class.Instance:AddTag()|AddTag()`.

Cette méthode est utile lorsque vous souhaitez faire quelque chose avec
plusieurs étiquettes sur une instance en une seule 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

Obtient 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 lors de l'exécution avec
`Class.Instance:AddTag()|AddTag()`.

Instance:HasTag

Vérifie si l'instance a une étiquette donnée.

Démontre comment déterminer 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 donné
descendant.

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

Voir aussi, `Class.Instance:IsDescendantOf()`.

Instance:IsAncestorOf

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

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

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 de `nil` pour
vérifier si un objet a été supprimé.

Voir aussi `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é.

Instance

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

/reference/engine/classes/UIListLayout.yaml