`Class.StarterGui` est un objet conteneur conçu pour contenir
`Class.LayerCollector` tels que `Class.ScreenGui|ScreenGuis`.

Lorsqu'un `Class.Player.Character` apparaît, le contenu de leur
`Class.PlayerGui` (s'il y en a) est vidé. Les enfants de `Class.StarterGui`
sont ensuite copiés avec leurs descendants dans le `Class.PlayerGui`. Notez,
cependant, que les objets `Class.LayerCollector` tels que
`Class.ScreenGui|ScreenGuis` avec leur propriété
`Class.LayerCollector.ResetOnSpawn|ResetOnSpawn` définie sur `false` ne
seront placés dans le `Class.PlayerGui` de chaque joueur qu'une seule fois et
ne seront pas supprimés lorsque le `Class.Player` réapparaît.

`Class.StarterGui` inclut également une série de fonctions vous permettant
d'interagir avec le `Class.CoreGui`. Par exemple, `Class.StarterGui:SetCoreGuiEnabled()`
pourrait être utilisé pour désactiver des éléments du `Class.CoreGui`, et
`Class.StarterGui:SetCore()` peut effectuer une variété de fonctions y compris
la création de notifications et de messages système.

Cette méthode renvoie des données définies ou mises à disposition par les scripts de base de Roblox.
Le premier et unique paramètre est une chaîne qui sélectionne les informations à
récupérer. Les sections suivantes décrivent les chaînes et les données qu'elles
renvoient par cette fonction.

Appeler cette méthode peut produire une valeur. Beaucoup d'entre eux enregistrent également une fonction équivalente
`Class.StarterGui:SetCore()|SetCore()` (celles-ci sont marquées d'un
astérisque).

##### PointsNotificationsActive \*

Renvoie `true` si les notifications de points de joueur sont activées.

##### BadgesNotificationsActive \*

Renvoie `true` si les notifications de badges sont activées.

##### AvatarContextMenuEnabled \*

Renvoie `true` si le
[Menu Contextuel Avatar](/players/avatar-context-menu) est activé.

##### ChatActive \*

Renvoie si le chat est actif ou non. Cela est indiqué par l'état de sélection de l'icône de chat dans la barre supérieure.

##### ChatWindowSize \*

Renvoie la taille de la fenêtre de chat sous forme de `Datatype.UDim2`.

##### ChatWindowPosition \*

Renvoie la taille de la fenêtre de chat sous forme de `Datatype.UDim2`.

##### ChatBarDisabled \*

Renvoie `true` si la barre de chat est désactivée.

##### GetBlockedUserIds

Renvoie une liste de `Class.Player.UserId|UserIds` associés aux utilisateurs qui
ont été bloqués par le joueur local.

##### PlayerBlockedEvent

Renvoie un `Class.BindableEvent` qui est déclenché chaque fois qu'un joueur est bloqué
par le joueur local.

##### PlayerUnblockedEvent

Renvoie un `Class.BindableEvent` qui est déclenché chaque fois qu'un joueur est
débloqué par le joueur local.

##### PlayerMutedEvent

Renvoie un `Class.BindableEvent` qui est déclenché chaque fois qu'un joueur est muet
par le joueur local.

##### PlayerUnmutedEvent

Renvoie un `Class.BindableEvent` qui est déclenché chaque fois qu'un joueur est remis au son
par le joueur local.

##### PlayerFriendedEvent

Renvoie un `Class.BindableEvent` qui est déclenché chaque fois qu'un joueur est
ajouté par le joueur local.

##### PlayerUnfriendedEvent

Renvoie un `Class.BindableEvent` qui est déclenché chaque fois qu'un joueur est
retiré par le joueur local.

##### DevConsoleVisible \*

Renvoie `true` si la
[Console du Développeur](/studio/developer-console) est visible.

##### VRRotationIntensity

Renvoie une chaîne décrivant la sensibilité de rotation de la caméra en VR : `Low`,
`High` et `Smooth`. Cela ne sera pas disponible à moins que
`Class.VRService.VREnabled` soit `true`.

StarterGui:GetCore

parameterName

Le nom du paramètre principal à récupérer, tel que
`"PointsNotificationsActive"` ou `"ChatActive"`.


La valeur associée au nom du paramètre principal spécifié, dont
type dépend du paramètre interrogé.


Renvoie une variable qui a été spécifiée par un script de base de Roblox.

L'exemple ci-dessous afficherait si la liste des joueurs est visible pour le
LocalPlayer.


Cette fonction renvoie si le `Enum.CoreGuiType` donné est activé, ou
s'il a été désactivé en utilisant `Class.StarterGui:SetCoreGuiEnabled()`. Cette
fonction doit être appelée sur le client.

Notez que définir `"TopbarEnabled"` sur `false` via
`Class.StarterGui:SetCore()|SetCore()` masque tous
`Enum.CoreGuiType|CoreGuiTypes` mais n'affecte pas le résultat de cette
fonction.

StarterGui:GetCoreGuiEnabled

coreGuiType

Si le `Enum.CoreGuiType` donné est activé.

Renvoie si le `Enum.CoreGuiType` donné est activé, ou s'il a été
désactivé en utilisant `Class.StarterGui:SetCoreGuiEnabled()`.

Cette méthode (à ne pas confondre avec
`Class.StarterGui:SetCoreGuiEnabled()|SetCoreGuiEnabled()`) expose une
variété de fonctionnalités définies par les scripts de base de Roblox, telles que l'envoi
de notifications, l'activation des notifications pour les badges/points, la définition d'un
callback pour le bouton de réinitialisation, ou l'activation de la barre supérieure.

Le premier paramètre est une chaîne qui sélectionne la fonctionnalité avec laquelle
l'appel interagira. Il peut être nécessaire d'appeler cette méthode plusieurs
times en utilisant `Global.LuaGlobals.pcall()` au cas où le script de base respectif
n'a pas encore été chargé (ou s'il a été complètement désactivé).

Le tableau suivant décrit les chaînes qui peuvent être acceptées comme premier
paramètre. Les paramètres qui devraient suivre dépendent de la fonctionnalité
toutefois utilisé et sont décrits dans des sous-tableaux.

##### ChatActive

Contrôle si le chat est actif.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>active</code></td>
    <td>boolean</td>
    <td>(obligatoire)</td>
    <td>Détermine si le chat doit être actif.</td>
  </tr>
  </tbody>
</table>

##### PointsNotificationsActive

Contrôle si les notifications pour les points de joueur gagnés apparaîtront.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>active</code></td>
    <td>boolean</td>
    <td>(obligatoire)</td>
    <td>Détermine si les notifications pour les points de joueur gagnés apparaîtront.</td>
  </tr>
  </tbody>
</table>

##### BadgesNotificationsActive

Contrôle si les notifications pour les badges gagnés apparaîtront.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
      </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>active</code></td>
    <td>boolean</td>
    <td>(obligatoire)</td>
    <td>Détermine si les notifications pour les badges gagnés apparaîtront.</td>
  </tr>
  </tbody>
</table>

##### ResetButtonCallback

Détermine le comportement, le cas échéant, du bouton de réinitialisation donné un booléen ou un
`Class.BindableEvent` à déclencher lorsque le joueur demande à réinitialiser.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
		</thead>
    <tbody>
	<tr>
    <td><code>enabled</code></td>
    <td>boolean</td>
    <td>(obligatoire)</td>
    <td>Détermine si le bouton de réinitialisation conserve son comportement par défaut.</td>
  </tr>
	<tr>
    <td colspan="4"><b>OU</b></td>
  </tr>
	<tr>
    <td><code>callback</code></td>
    <td><code>Class.BindableEvent</code></td>
    <td>(obligatoire)</td>
    <td>Un <code>Class.BindableEvent</code> à déclencher lorsque le joueur confirme qu'il veut réinitialiser.</td>
  </tr>
  </tbody>
</table>

##### ChatMakeSystemMessage

Affiche un message formaté dans le chat. Utiliser cette méthode nécessite que le
`Class.TextChatService.ChatVersion` de l'expérience soit défini sur
`Enum.ChatVersion|LegacyChatService`, bien que le chat hérité soit
**déprécié** et que l'utilisation soit déconseillée. Pour les expériences utilisant le
actuel `Class.TextChatService`, référez-vous à
`Class.TextChannel:DisplaySystemMessage()`.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
      </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>configTable</code></td>
    <td>dictionnaire</td>
    <td>(obligatoire)</td>
    <td>Un dictionnaire d'informations décrivant le message (voir ci-dessous).</td>
  </tr>
  </tbody>
</table>

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>Text</code></td>
    <td>string</td>
    <td>(obligatoire)</td>
    <td>Le message à afficher.</td>
  </tr>
	<tr>
    <td><code>Color</code></td>
    <td><code>Datatype.Color3</code></td>
    <td><code>Datatype.Color3.fromRGB(255, 255, 243)</code></td>
    <td>Couleur du texte du message.</td>
  </tr>
	<tr>
    <td><code>Font</code></td>
    <td><code>Enum.Font</code></td>
    <td><code>SourceSansBold</code></td>
    <td>Police du message.</td>
  </tr>
	<tr>
    <td><code>TextSize</code></td>
    <td>integer</td>
    <td><code>18</code></td>
    <td>Taille du texte du message.</td>
  </tr>
  </tbody>
</table>

##### SendNotification

Provoque l'apparition d'une notification non intrusive en bas à droite de l'écran. La notification peut avoir jusqu'à deux boutons.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
  <tbody>
	<tr>
    <td><code>configTable</code></td>
    <td>dictionnaire</td>
    <td>(obligatoire)</td>
    <td>Un dictionnaire d'informations décrivant la notification (voir ci-dessous).</td>
  </tr>
  </tbody>
</table>

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>Title</code></td>
    <td>string</td>
    <td>(obligatoire)</td>
    <td>Le titre de la notification.</td>
  </tr>
	<tr>
    <td><code>Text</code></td>
    <td>string</td>
    <td>(obligatoire)</td>
    <td>Le texte principal de la notification.</td>
  </tr>
	<tr>
    <td><code>Icon</code></td>
    <td>string</td>
    <td></td>
    <td>L'image à afficher avec la notification.</td>
  </tr>
	<tr>
    <td><code>Duration</code></td>
    <td>number</td>
    <td><code>5</code></td>
    <td>Durée (en secondes) pendant laquelle la notification doit rester visible.</td>
  </tr>
	<tr>
    <td><code>Callback</code></td>
    <td><code>Class.BindableFunction</code></td>
    <td></td>
    <td>Un <code>Class.BindableFunction</code> qui devrait être invoqué avec le texte du bouton pressé par le joueur.</td>
  </tr>
	<tr>
    <td><code>Button1</code></td>
    <td>string</td>
    <td></td>
    <td>Le texte à afficher sur le premier bouton.</td>
  </tr>
	<tr>
    <td><code>Button2</code></td>
    <td>string</td>
    <td></td>
    <td>Le texte à afficher sur le deuxième bouton.</td>
  </tr>
  </tbody>
</table>

##### TopbarEnabled

Détermine si la barre supérieure est affichée. Désactiver la barre supérieure désactivera également
tous les `Class.CoreGui|CoreGuis` tels que le chat, l'inventaire, et
la liste des joueurs (par exemple, ceux définis avec
`Class.StarterGui:SetCoreGuiEnabled()|SetCoreGuiEnabled`).

Lorsque désactivée, la région que la barre supérieure occupait auparavant capturera toujours
les événements de souris ; cependant, les boutons placés là ne répondront pas aux clics.
L'origine de l'espace GUI sera toujours décalée de 36 pixels du haut de l'écran.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>enabled</code></td>
    <td>boolean</td>
    <td>(obligatoire)</td>
    <td>Détermine si la barre supérieure doit être visible.</td>
  </tr>
</tbody>
</table>

##### DevConsoleVisible

Détermine si la
[Console de Développeurs](/studio/developer-console) est visible.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>visibility</code></td>
    <td>boolean</td>
    <td>(obligatoire)</td>
    <td>Détermine si la console est visible.</td>
  </tr>
</tbody>
</table>

##### PromptSendFriendRequest

Invite le joueur actuel à envoyer une demande d'ami au
`Class.Player` donné.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(obligatoire)</td>
    <td>Le joueur auquel la demande d'ami doit être envoyée.</td>
  </tr>
</tbody>
</table>

##### PromptUnfriend

Invite le joueur actuel à retirer un `Class.Player` donné de leur
liste d'amis.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(obligatoire)</td>
    <td>Le joueur qui doit être déconnecté.</td>
  </tr>
</tbody>
</table>

##### PromptBlockPlayer

Invite le joueur actuel à bloquer le `Class.Player` donné.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(obligatoire)</td>
    <td>Le joueur qui doit être bloqué.</td>
  </tr>
  </tbody>
</table>

##### PromptUnblockPlayer

Invite le joueur actuel à débloquer le `Class.Player` donné.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
 </thead>
 <tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(obligatoire)</td>
    <td>Le joueur qui doit être débloqué.</td>
  </tr>
  </tbody>
</table>

##### AvatarContextMenuEnabled

Détermine si le
[Menu Contextuel de l'Avatar](/players/avatar-context-menu) est activé.

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>enabled</code></td>
    <td>boolean</td>
    <td>(obligatoire)</td>
    <td>Détermine si le menu contextuel est activé.</td>
  </tr>
</tbody>
</table>

##### AvatarContextMenuTarget

Ouvre de force le
[Menu Contextuel de l'Avatar](/players/avatar-context-menu).

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(obligatoire)</td>
    <td>Le joueur sur lequel le menu contextuel sera ouvert.</td>
  </tr>
</tbody>
</table>

##### AddAvatarContextMenuOption

Ajoute une option au
[Menu Contextuel de l'Avatar](/players/avatar-context-menu).

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>option</code></td>
    <td><code>Enum.AvatarContextMenuOption</code></td>
    <td>(obligatoire)</td>
    <td>Option à ajouter.</td>
  </tr>
	<tr>
    <td colspan="4"><b>OU</b></td>
  </tr>
	<tr>
    <td><code>option</code></td>
    <td>table</td>
    <td>(obligatoire)</td>
    <td>Une table à deux éléments, où le premier est le nom de l'action personnalisée, et le second est un <code>Class.BindableEvent</code> qui sera déclenché lorsqu'un joueur a été sélectionné lorsque l'option a été activée.</td>
  </tr>
</tbody>
</table>

##### RemoveAvatarContextMenuOption

Supprime une option du
[Menu Contextuel de l'Avatar](/players/avatar-context-menu). L'argument
`option` doit être le même que celui utilisé avec
`"AddAvatarContextMenuOption"` (voir ci-dessus).

<table size="small">
	<thead>
		<tr>
			<th>Nom</th>
			<th>Type</th>
			<th>Par défaut</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>option</code></td>
    <td>Variant</td>
    <td>(obligatoire)</td>
    <td>La même valeur fournie à <b>AddAvatarContextMenuOption</b>.</td>
  </tr>
  </tbody>
</table>

##### AvatarContextMenuTheme

Configure le
[Menu Contextuel de l'Avatar](/players/avatar-context-menu) personnalisable qui est une
fonctionnalité optionnelle qui permet une interaction sociale simple entre joueurs via
des actions personnalisées, telles que l'initiation d'échanges, de combats, et plus encore. Pour plus
d'infos sur comment personnaliser son thème, voir l'article sur le
[Menu Contextuel de l'Avatar](/players/avatar-context-menu).

##### CoreGuiChatConnections

Met en place une connexion de passerelle liée entre le bouton de chat de la barre supérieure
`Class.CoreGui` et le système de chat hérité. Le deuxième paramètre doit être un
table de `Class.BindableEvent|BindableEvents` et
`Class.BindableFunction|BindableFunctions`.

StarterGui:SetCore

Sélectionne la fonctionnalité avec laquelle l'appel interagira.

value

Une table de `Class.BindableEvent|BindableEvents` et
`Class.BindableFunction|BindableFunctions`.

Vous permet d'effectuer certaines interactions avec les scripts de base de Roblox.

Cette fonction définit si l'élément `Class.CoreGui` associé au
given `Enum.CoreGuiType` est activé ou désactivé.

La barre supérieure ne peut pas être désactivée à l'aide de cette fonction. Pour la désactiver, définissez
`"TopbarEnabled"` sur `false` en utilisant `Class.StarterGui:SetCore()`.

StarterGui:SetCoreGuiEnabled

enabled

Si l'on doit activer ou désactiver le `Enum.CoreGuiType` donné.

Définit si l'élément `Class.CoreGui` associé au
`Enum.CoreGuiType` donné est activé ou désactivé.

StarterGui

Si `true`, la propriété `Class.GuiObject.ClipsDescendants|ClipsDescendants`
d'un `Class.GuiObject` coupe ses descendants **rotatés**.

StarterGui.ClipsDescendantsSupportsRotation

Détermine si la propriété `Class.GuiObject.ClipsDescendants|ClipsDescendants`
d'un `Class.GuiObject` coupe les descendants **rotatés**.

Permet à `Class.StarterGui` de traiter les entrées comme le font `Class.PlayerGui` et
`Class.CoreGui`. La valeur par défaut est `false`.

StarterGui.ProcessUserInput

Permet à ce service de traiter les entrées comme le font `Class.PlayerGui` et
`Class.CoreGui`.

Si défini sur true, chaque enfant parenté au `Class.StarterGui` sera
cloné dans le `Class.PlayerGui` d'un joueur lorsque le personnage de ce joueur est
réapparu.

Si l'un des enfants est un PlayerGui et que sa propriété PlayerGui
est définie sur false, il ne sera pas cloné.

StarterGui.ResetPlayerGuiOnSpawn

Détermine si chaque enfant parenté au StarterGui sera cloné
dans le PlayerGui d'un joueur lorsque le personnage de ce joueur est réapparu.

Cette propriété détermine si la mise en page du texte de droite à gauche (RTL) est
appliquée au texte des `Class.GuiObject|GuiObjects` dans l'expérience,
ce qui est nécessaire pour afficher correctement les langues écrites de droite à gauche, telles
que l'arabe et l'hébreu.

La valeur par défaut est `Enum.RtlTextSupport.Default`. Les deux
`Enum.RtlTextSupport.Default` et `Enum.RtlTextSupport.Enabled` activent la prise en charge de la mise en page du texte RTL,
 tandis que `Enum.RtlTextSupport.Disabled` la désactive.


StarterGui.RtlTextSupport

Contrôle si la mise en page du texte de droite à gauche (RTL) est activée pour le texte dans
`Class.GuiObject|GuiObjects` tout au long de l'expérience.


Cette propriété définit le mode d'orientation d'écran préféré pour les utilisateurs de
devices mobiles. Pour les différents modes disponibles, voir
`Enum.ScreenOrientation`.

Par défaut, cette propriété est définie sur
`Enum.ScreenOrientation.Sensor|Sensor`, ce qui signifie que l'expérience est
displayée en fonction de la meilleure correspondance avec l'orientation actuelle de l'appareil,
soit paysage (gauche/droite) soit portrait.

Lorsqu'un `Class.Player` rejoint l'expérience sur un appareil mobile, cette
propriété détermine l'orientation de départ de l'appareil et définit
le `Class.PlayerGui.ScreenOrientation` de ce joueur en conséquence. Vous pouvez également obtenir
l'orientation d'écran actuelle du joueur via
`Class.PlayerGui.CurrentScreenOrientation`, utile lors de l'utilisation de l'un des
paramètres "capteur" `Enum.ScreenOrientation`.

Notez que changer cette propriété ne changera pas l'orientation de l'écran
pour les `Class.Player|Players` déjà dans l'expérience. Pour changer l'
orientation d'un joueur existant, utilisez sa
`Class.PlayerGui.ScreenOrientation` propriété.

StarterGui.ScreenOrientation

Définit le mode d'orientation d'écran par défaut pour les utilisateurs de dispositifs mobiles.

Cette propriété détermine si le contenu de `Class.StarterGui` est
visible dans Studio.

StarterGui.ShowDevelopmentGui

Détermine si le contenu de `Class.StarterGui` est visible dans
Studio.

Cette propriété détermine si le curseur virtuel de la manette, qui permet
aux joueurs de déplacer un pointeur sur les `Class.GuiObject|GuiObjects` à l'écran en utilisant
une manette, est activé.

La valeur par défaut est `Enum.VirtualCursorMode.Default`. La définir sur
`Enum.VirtualCursorMode.Enabled` active le curseur virtuel et
`Enum.VirtualCursorMode.Disabled` le désactive. Lorsqu'un joueur est en VR,
le curseur virtuel est toujours actif, quelle que soit la valeur de cette propriété.


StarterGui.VirtualCursorMode

Contrôle si le curseur virtuel de la manette est activé pour naviguer
`Class.GuiObject|GuiObjects` avec une manette.


Un conteneur pour les objets `Class.LayerCollector` à copier dans le
`Class.PlayerGui` de `Class.Player|Players`. Fournit également un ensemble de
fonctions pour interagir avec le `Class.CoreGui`.

`BasePlayerGui` est une classe abstraite dont héritent toutes les classes de stockage de dessin de GUI.

Tous les GUIs retournés par `Class.BasePlayerGui:GetGuiObjectsAtPosition()` sont
'clonés' par la fonction locale `highlightAsFrame()`, qui crée un `Frame`
GUI positionné au-dessus du GUI spécifié, semi-transparent et ayant la
même `Class.GuiBase2d.AbsoluteSize` et `Class.GuiBase2d.AbsolutePosition`.

Ces surlignages sont ajoutés au `ScreenGui` HighlightsContainer dans le
dossier Highlight du dossier PlayerGui du joueur. Les deux sont créés par le
exemple de code. Tous les GUIs de surlignage sont `Class.Instance:Destroy()`és chaque fois que
`highlightGui()` s'exécute.

Notez que le `Class.ScreenGui.DisplayOrder` de HighlightContainer est 99999, un
grand nombre, de sorte qu'il est peu probable qu'un autre GUI soit rendu au-dessus des
GUIs de surlignage.


Prend une position d'écran et retourne une liste de toutes les instances de `Class.GuiObject`
qui occupent cette position d'écran, triées dans l'ordre où elles apparaissent à l'écran, de haut en bas, comme le premier et le dernier index,
respectivement. Le cas d'utilisation principal est d'obtenir des objets GUI sous la souris du joueur
ou les entrées tactiles pour permettre la sélection ou le surlignage.

Puisque les classes enfants de `Class.BasePlayerGui` héritent de cette fonction, elle
peut être appelée par des classes conteneurs telles que `Class.PlayerGui` et
`Class.StarterGui`.

BasePlayerGui:GetGuiObjectsAtPosition

La position **X** à l'écran par rapport au coin supérieur gauche après
the GUI inset est appliqué (voir `Class.GuiService:GetGuiInset()`).

La position **Y** à l'écran par rapport au coin supérieur gauche après
the GUI inset est appliqué (voir `Class.GuiService:GetGuiInset()`).

Une table des instances `Class.GuiObject` qui occupent l'espace
affiché donné.

Renvoie une liste de toutes les instances `Class.GuiObject` occupant le donné


BasePlayerGui

`BasePlayerGui` est une classe abstraite dont héritent les classes de stockage de dessin de GUI.

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

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


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

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

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

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


Instance.AncestryChanged

child

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


parent

Le nouveau parent du paramètre `child`.


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


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

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

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

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "a changé")
end

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


Instance.AttributeChanged

attribute

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


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


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

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

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

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

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

Voir aussi `Class.Instance.ChildRemoved`.


Instance.ChildAdded

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


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


Instance.childAdded

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

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

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

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

Voir aussi `Class.Instance.ChildAdded`.


Instance.ChildRemoved

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


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


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

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

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

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

Voir aussi `Class.Instance.DescendantRemoving`.


Instance.DescendantAdded

descendant

Se déclenche après qu'un descendant a été ajouté au `Class.Instance`.


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

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

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

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

#### Avertissement

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

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

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

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


Instance.DescendantRemoving

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


Se déclenche immédiatement avant qu'un descendant du `Class.Instance` ne soit supprimé.


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

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

Le `Class.Instance` ne sera jamais supprimé de la mémoire tant qu'une fonction connectée
l'utilise encore. Cependant, si la fonction se suspend à un moment donné,
le `Class.Instance` et ses descendants seront parentés à `nil`.

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

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

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

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


Instance.Destroying

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


Démontre `Class.Instance.StyledPropertiesChanged`.


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


Instance.StyledPropertiesChanged

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


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

#### Avertissements

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

- Lors de l'étiquetage d'une instance, il est courant que certaines ressources soient utilisées pour
donner à l'étiquette sa fonctionnalité, par exemple des connexions d'événements ou des tables.
  Pour éviter les fuites de mémoire, il est bon de nettoyer ces ressources (déconnecter,
  définir à `nil`, etc.) lorsqu'elles ne sont plus nécessaires pour une étiquette. Faites cela lors
  de l'appel à `Class.Instance:RemoveTag()`, lors de l'appel à
  `Class.Instance:Destroy()`, ou dans une fonction connectée à un signal
  retourné par `Class.CollectionService:GetInstanceRemovedSignal()`.


Instance:AddTag

L'étiquette à appliquer à l'instance.


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


Instance:children

Renvoie un tableau des enfants de l'objet.


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

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

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

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

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

part:ClearAllChildren()

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

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

local model = Workspace:FindFirstChild("TestModel")

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


Instance:ClearAllChildren

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


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

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

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

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


Instance:Clone

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


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


Instance:clone

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

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

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

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

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

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

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

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


Instance:Destroy

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


Instance:destroy

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

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

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

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


Instance:FindFirstAncestor

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`
immediat de l'instance 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,
en utilisant la méthode `Class.Object:IsA()` à la place pour respecter l'héritage de classe.


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 qui
`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`
immediat de l'instance 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, le 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 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 nom 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. Tenter d'indexer un enfant par son nom en utilisant l'opérateur point
provoque 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`,
puis 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 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 si elles 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`, et non à l'instance 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
```

#### Notes de performance

`Class.Instance:FindFirstChild()|FindFirstChild()` prend environ 20 % de temps en plus
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
nom donné devient disponible.


Instance:FindFirstChild

recursive

Que la recherche doit être effectuée de manière récursive 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 de classe. 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 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 l'`Class.Instance`.

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

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Par conséquent, le 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 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 l'`Class.Instance` est un `Class.Actor`, le `Class.Actor` lui-même est
renvoyé. Sinon, son ancêtre `Class.Actor` le plus proche 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, le 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é 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 l'événement
`Class.Object.Changed|Changed`, sauf qu'il ne se déclenche que lorsque
l'attribut donné change ; en effet, il est similaire à
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` mais
pour les attributs.

Il est généralement bon d'utiliser cette méthode au lieu d'une connexion à
`Class.Object.Changed|Changed` avec une fonction qui vérifie le nom de l'attribut. Les appels suivants à 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é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 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, le 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é
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 `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.


Instance:getChildren

Renvoie une chaîne codée de l'ID de débogage utilisé 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
  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é 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. 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
considéré. 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 tenter de
analyser la chaîne renvoyée pour une 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, ce n'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 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 direct à la valeur de la propriété,
comme `[GuiObject].Rotation`, qui renvoie la valeur par défaut ou
modifiée de la propriété.


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
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 la valeur par défaut de la propriété si elle n'a pas été stylée/modifiée.


Démontre `Class.Instance:GetStyledPropertyChangedSignal()`.


Cette méthode renvoie un événement qui se comporte exactement comme l'événement
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged`,
sauf qu'il ne se déclenche que lorsque la propriété de style donnée change. Il est
généralement bon d'utiliser cette méthode au lieu d'une connexion à
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` avec une
fonction qui vérifie le nom de la propriété. Les appels suivants à 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,
la valeur de la propriété changée doit donc être lue directement dans un
script.


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.


Renvoie un événement qui se déclenche lorsque la propriété de style donnée change sur l'instance.


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 faire quelque chose 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

Un tableau de chaînes, chacune représentant une étiquette appliquée à l'instance.


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


Instance

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


/reference/engine/classes/StarterGui.yaml