Dieses Codebeispiel enthält ein einfaches Beispiel, wie der lokale Spieler's
`PlayerMouse` mit der Funktion `Class.Player:GetMouse()` in
 einem `LocalScript` abgerufen werden kann. Dieser Code sollte in einem `LocalScript`
 in `StarterPlayerScripts` platziert werden.

Der PlayerMouse verhält sich identisch zum `Class.Mouse` Objekt, das mit
`Class.Tool.Equipped` erhalten wird. Er kann von
`Class.LocalScript|LocalScripts` über die lokale Spieler-
`Class.Player:GetMouse()` Methode aufgerufen werden. Sowohl PlayerMouse als auch `Class.Mouse` sind
veraltete APIs, die durch `Class.UserInputService` ersetzt wurden.

Der einzige Unterschied zwischen dem PlayerMouse und dem `Class.Mouse` Objekt besteht darin,
dass der PlayerMouse über die `Class.Player:GetMouse()` Methode erhalten werden kann.

In den meisten Fällen wird Entwicklern geraten, den neuen `Class.UserInputService` zu verwenden.
Dennoch bleiben die PlayerMouse und Mouse Objekte aus mehreren Gründen unterstützt.
Siehe [Input und Kamera](/input) für weitere Informationen
zur Anpassung von Eingaben in deiner Erfahrung.


PlayerMouse

Der PlayerMouse verhält sich identisch zum `Class.Mouse` Objekt, das mit
`Class.Tool.Equipped` erhalten wird. Sowohl PlayerMouse als auch `Class.Mouse` sind
veraltete APIs, die durch `Class.UserInputService` ersetzt wurden.


**Mouse** wurde durch `Class.UserInputService` und `Class.ContextActionService` ersetzt, die einen breiteren Anwendungsbereich abdecken, funktional umfangreicher sind und **plattformsübergreifende** Muster besser unterstützen. Es bleibt unterstützt aufgrund seiner weit verbreiteten Nutzung, aber Sie sollten ernsthaft in Erwägung ziehen, diese Alternativen zu verwenden.

Das **Mouse**-Objekt beherbergt verschiedene APIs für Zeiger, hauptsächlich für Tasten und Raycasting. Es kann über `Class.Player:GetMouse()` aufgerufen werden, welches am `Class.Players.LocalPlayer` in einem `Class.LocalScript` aufgerufen wird. Es wird auch durch das Ereignis `Class.Tool.Equipped` übergeben.

- Es ist besonders bekannt für die `Class.Mouse.Icon|Icon`-Eigenschaft, die das Erscheinungsbild des Cursors ändert.
- Es raycastet fortlaufend die Position der Bildschirmmaus in die 3D-Welt mithilfe der `Class.Mouse.TargetFilter|TargetFilter`-Eigenschaft und speichert die Ergebnisse des Raycasts in den Eigenschaften `Class.Mouse.Hit|Hit`, `Class.Mouse.Target|Target` und `Class.Mouse.TargetSurface|TargetSurface`. Diese können für einfache Fälle nützlich sein, aber `Class.WorldRoot:Raycast()` sollte in komplizierteren [Raycasting](/workspace/raycasting)-Szenarien verwendet werden.
- `Class.Plugin|Plugins` können `Class.Plugin:GetMouse()` verwenden, um eine `Class.PluginMouse` zu erhalten, die sich ähnlich verhält.

```lua
-- Von einem LocalScript aus:
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
-- Setzen des Mauszeigers
mouse.Icon = "rbxasset://SystemCursors/Wait"
```
Hinweis:

- Dieses Objekt steuert/beschränkt die Bewegung des Zeigers nicht. Dazu siehe `Class.UserInputService.MouseBehavior` und `Class.UserInputService.MouseDeltaSensitivity`.
- Wenn zwei Funktionen mit demselben Eingabeereignis verbunden sind, wie z.B. `Class.Mouse.Button1Down|Button1Down`, werden **beide** Funktionen ausgeführt, wenn das Ereignis ausgelöst wird. Es gibt kein Konzept der Weitergabe von Eingaben, da Ereignisse dieses Verhalten nicht unterstützen. `Class.ContextActionService` hat jedoch dieses Verhalten über `Class.ContextActionService:BindAction()|BindAction`.
- Auch wenn eine Maus auf allen Plattformen möglicherweise nicht verfügbar ist, funktioniert Mouse weiterhin auf Mobilgeräten (Berührung) und Konsolen (Gamepad), die normalerweise keine Mäuse oder Zeigerhardware haben. Für explizite plattformübergreifende Verhaltensweisen verwenden Sie `Class.UserInputService` und `Class.ContextActionService`.

Siehe [Input and Camera](/input) für weitere Informationen zu benutzerdefinierten Eingaben in Ihrer Erfahrung.

Dieses Ereignis wird ausgelöst, wenn der Spieler die linke Maustaste drückt. Beachten Sie, dass dies von einem `Class.Tool` aus zugänglich ist; zum Beispiel, wenn es in einem `Class.LocalScript` platziert ist, gibt der folgende Code `Button1Down` aus, wann immer die linke Maustaste gedrückt wird.

```lua
local tool = script.Parent  -- Stellen Sie sicher, dass dies ein Tool-Objekt ist

tool.Equipped:Connect(function(mouse)
	mouse.Button1Down:Connect(function()
		print("Button1Down")
	end)
end)
```
Sie können die Position der Maus im Welt-Raum herausfinden und ob sie auf ein `Class.BasePart` zeigt, indem Sie die Eigenschaften `Class.Mouse.Hit|Hit` und `Class.Mouse.Target|Target` verwenden.

Mouse.Button1Down

Wird ausgelöst, wenn die linke Maustaste gedrückt wird.

Dieses Ereignis wird ausgelöst, wenn der Spieler die linke Maustaste loslässt. Beachten Sie, dass dies von einem `Class.Tool` aus zugänglich ist; zum Beispiel, wenn es in einem `Class.LocalScript` platziert ist, gibt der folgende Code `Button1Up` aus, wann immer die linke Maustaste losgelassen wird.

```lua
local tool = script.Parent  -- Stellen Sie sicher, dass dies ein Tool-Objekt ist

tool.Equipped:Connect(function(mouse)
	mouse.Button1Up:Connect(function()
		print("Button1Up")
	end)
end)
```
Sie können die Position der Maus im Welt-Raum herausfinden und ob sie auf ein `Class.BasePart` zeigt, indem Sie die Eigenschaften `Class.Mouse.Hit|Hit` und `Class.Mouse.Target|Target` verwenden.

Mouse.Button1Up

Wird ausgelöst, wenn die linke Maustaste losgelassen wird.

Dieses Ereignis wird ausgelöst, wenn der Spieler die rechte Maustaste drückt. Beachten Sie, dass dies von einem `Class.Tool` aus zugänglich ist; zum Beispiel, wenn es in einem `Class.LocalScript` platziert ist, gibt der folgende Code `Button2Down` aus, wann immer die rechte Maustaste gedrückt wird.

```lua
local tool = script.Parent  -- Stellen Sie sicher, dass dies ein Tool-Objekt ist

tool.Equipped:Connect(function(mouse)
	mouse.Button2Down:Connect(function()
		print("Button2Down")
	end)
end)
```
Sie können die Position der Maus im Welt-Raum herausfinden und ob sie auf ein `Class.BasePart` zeigt, indem Sie die Eigenschaften `Class.Mouse.Hit|Hit` und `Class.Mouse.Target|Target` verwenden.

Mouse.Button2Down

Wird ausgelöst, wenn die rechte Maustaste gedrückt wird.

Dieses Ereignis wird ausgelöst, wenn der Spieler die rechte Maustaste loslässt. Beachten Sie, dass dies von einem `Class.Tool` aus zugänglich ist; zum Beispiel, wenn es in einem `Class.LocalScript` platziert ist, gibt der folgende Code `Button2Up` aus, wann immer die rechte Maustaste losgelassen wird.

```lua
local tool = script.Parent  -- Stellen Sie sicher, dass dies ein Tool-Objekt ist

tool.Equipped:Connect(function(mouse)
	mouse.Button2Up:Connect(function()
		print("Button2Up")
	end)
end)
```
Sie können die Position der Maus im Welt-Raum herausfinden und ob sie auf ein `Class.BasePart` zeigt, indem Sie die Eigenschaften `Class.Mouse.Hit|Hit` und `Class.Mouse.Target|Target` verwenden.

Mouse.Button2Up

Wird ausgelöst, wenn die rechte Maustaste losgelassen wird.

Dieses Beispiel zeigt, wie Mausereignisse in jedem Frame übergeben werden

Wird bei jedem Herzschlag ausgelöst, bei dem die Maus nicht an ein anderes Mausereignis übergeben wird.

Hinweis: Dieses Ereignis sollte nicht verwendet werden, um festzustellen, wann die Maus still steht. Da es bei jedem Herzschlag ausgelöst wird, wird es zwischen `Class.Mouse.Move`-Ereignissen ausgelöst.

Für Informationen, wie Sie das `Class.Mouse`-Objekt erhalten, siehe bitte die Seite `Class.Mouse`.

Entwickler können die Position der Maus im Welt-Raum herausfinden und ob sie auf ein `Class.BasePart` zeigt, indem sie die Eigenschaften `Class.Mouse.Hit` und `Class.Mouse.Target` verwenden.

Hinweis: Es wird empfohlen, dass Entwickler anstelle des `Class.Mouse`-Objekts in neuen Projekten `Class.UserInputService` verwenden.

Mouse.Idle

Wird bei jedem Herzschlag ausgelöst, bei dem die Maus nicht an ein anderes Mausereignis übergeben wird.

Das folgende Beispiel, vorausgesetzt, dass 'mouse' definiert wurde, würde die Taste ausgeben, die
gedrückt wurde (z. B. "q"), zusammen mit dem ASCII-Wert für diese Taste (z. B. 113).

This event fires when a Key is pressed, with the passed argument being the
key that was pressed.

Note:

- Not all keys generate this event. However, you can get around this with
  a few of the keys, "/" for example, by using the `Class.Mouse.KeyUp`
  event.
- Some keys generate the same string as other keys.
- It's possible for the string to be empty (possibly due to "\0" key
  code).


Mouse.KeyDown

Wird ausgelöst, wenn eine Taste gedrückt wird.

Mouse.keyDown

Das folgende Beispiel, vorausgesetzt, dass 'mouse' definiert ist, würde die Taste ausgeben, die
losgelassen wurde (z.B. "q") zusammen mit dem ASCII-Wert für diese Taste (z.B. 113).

Dieses Ereignis wird ausgelöst, wenn eine Taste losgelassen wird, wobei das übergebene Argument die
Taste ist, die losgelassen wurde.

Hinweis:

- Nicht alle Tasten erzeugen dieses Ereignis. Sie können jedoch bei einigen Tasten, z. B. "/",
  um nichts herumkommen, indem Sie das 
  [[API:Class/Mouse/KeyUp|KeyUp]]-Ereignis verwenden.
- Einige Tasten erzeugen denselben String wie andere Tasten.
- Es ist möglich, dass der String leer ist (möglicherweise aufgrund des "\\0"-Tastencodes).


Mouse.KeyUp

Feuert, wenn eine Taste losgelassen wird.


Das folgende Beispiel ermöglicht es dem `Class.Players.LocalPlayer|lokalen Spieler`,
Teile mit ihrer Maus zu bewegen.

Wenn der Spieler die linke Maustaste über einem Teil drückt, ist dieses Teil das
`Class.Mouse.Target|Ziel der Maus` und wird zum _Punkt_. Bis der Spieler
seine linke Maustaste loslässt, wird dieses Teil zur Weltposition der Maus
bewegt, wenn der Spieler seine Maus bewegt.

Beachten Sie, dass die `Class.Mouse.TargetFilter`-Eigenschaft es dem Code
ermöglicht, das bewegte Teil zu ignorieren, wenn die Weltposition der Maus bestimmt wird.

Der Code sollte wie erwartet funktionieren, wenn er in einem `LocalScript` platziert wird.

Wird ausgelöst, wenn die Maus bewegt wird.

Beachten Sie, dass dieses Ereignis ausgelöst wird, wenn die Mausposition aktualisiert wird, therefore
wird es wiederholt ausgelöst, während sie bewegt wird.

Für Informationen zur Erlangung des `Class.Mouse`-Objekts siehe die
`Class.Mouse`-Seite.

Entwickler können die Position der Maus im Weltmaßstab herausfinden und prüfen,
ob sie auf irgendein `Class.BasePart` zeigt, indem sie die Eigenschaften `Class.Mouse.Hit` und
`Class.Mouse.Target` verwenden.

```
mouse.Move:Connect(function()
	local position = mouse.Hit.p
	local target = mouse.Target
	print(target, position)
end)
```
Beachten Sie, dass Entwicklern empfohlen wird, `Class.UserInputService` anstelle
seines `Class.Mouse`-Objekts in neuen Arbeiten zu verwenden.


Mouse.Move

Wird ausgelöst, wenn die Maus bewegt wird.


Das folgende Beispiel geht davon aus, dass Sie bereits die Maus des Spielers erhalten haben (und
sie als Variable namens 'mouse' gesetzt haben), sei es durch die Verwendung von `Class.Tool`,
`Class.HopperBin` oder der Methode `Class.Player:GetMouse()`. Es wird ausgeben
"Rad ging nach hinten!", wenn der Spieler nach hinten scrollt.

Das WheelBackward-Ereignis feuert, wenn das Mausrad nach hinten gescrollt wird.
Mögliche Verwendungen für dieses Ereignis umfassen das Umschalten des Ziels eines Gewehrs in einem
Ego-Shooter (FPS) oder das Zoomen der Kamera des Spielers.

Dies kann zusammen mit dem Vorwärtslaufereignis
`Class.Mouse.WheelForward` verwendet werden.

Für Informationen zur Erlangung des `Class.Mouse`-Objekts siehe die
`Class.Mouse`-Seite.

Beachten Sie, dass Entwicklern empfohlen wird, `Class.UserInputService` anstelle
seines `Class.Mouse`-Objekts in neuen Arbeiten zu verwenden.


Mouse.WheelBackward

Feuert, wenn das Mausrad nach hinten gescrollt wird.


Das folgende Beispiel geht davon aus, dass Sie bereits die Maus des Spielers erhalten haben (und
sie als Variable namens 'mouse' gesetzt haben), entweder durch die Verwendung eines `Tools`, `HopperBin`
oder die Methode `Class.Player:GetMouse()`. Es wird "Rad ging vorwärts!"
ausgeben, wenn der Spieler nach vorne scrollt.

Das WheelForward-Ereignis feuert, wenn das Mausrad nach vorne gescrollt wird.
Mögliche Verwendungen für dieses Ereignis umfassen das Umschalten des Ziels eines Gewehrs in einem
Ego-Shooter (FPS) oder das Zoomen der Kamera des Spielers.

Dies kann zusammen mit dem Rückwärtslaufereignis
`Class.Mouse.WheelBackward` verwendet werden.

Für Informationen zur Erlangung des `Class.Mouse`-Objekts siehe die
`Class.Mouse`-Seite.

Beachten Sie, dass Entwicklern empfohlen wird, `Class.UserInputService` anstelle
seines `Class.Mouse`-Objekts in neuen Arbeiten zu verwenden.


Mouse.WheelForward

Feuert, wenn das Mausrad nach vorne gescrollt wird.


Mouse

Der Code in diesem Beispiel, wenn er innerhalb eines `LocalScript` in
`StarterPlayerScripts` platziert wird, zieht einen roten Laserstrahl zwischen dem Kopf
des Charakters und `Class.Mouse.Hit` zu jeder Zeit.

Beachten Sie, dass dieser Strahl direkt durch Hindernisse in der dritten Person geht,
da das Raycasting der `Mouse` von der `Class.Workspace.CurrentCamera` und nicht vom
Kopf durchgeführt wird.

Der folgende Code visualisiert den Unterschied zwischen `Class.Mouse.Hit` und
`Class.Mouse.Origin`. Um dies zu tun, verwendet der Code die
`Datatype.Vector3` Positionen der Treffer- und Ursprungs-`Datatype.CFrame` Werte
mit `.p`.

Der Unterschied besteht darin, dass der Ursprung "woher die Maus kam" (ihr Ursprung)
ist und der Treffer die Position ist, an der die Maus trifft (wenn der Spieler
die Maus drückt).

Dieses Beispiel visualisiert auch, dass der Mausursprung der Position der
`CurrentCamera` sehr ähnlich ist, indem die Magnitude (Entfernung) zwischen
den beiden Positionen ausgegeben wird.

Diese Eigenschaft gibt den `Datatype.CFrame` der Mausposition im 3D-Raum an. Beachten Sie, dass `Class.Mouse.TargetFilter` und dessen Nachkommen ignoriert werden.

Entwickler können die Position von Hit so erhalten:

```
local position = mouse.Hit.Position
```
Hit wird oft von `Class.Tool|Tools` verwendet, um eine Waffe in Richtung der Maus im Drittpersonen-Modus abzufeuern.

Entwickler, die nach dem `Class.BasePart` suchen, auf den die Maus zeigt, sollten `Class.Mouse.Target` verwenden.

#### Wie wird Mouse.Hit berechnet?

Die Position des Hit CFrame wird als Schnittpunkt zwischen dem internen `Datatype.Ray` der Maus (eine erweiterte Version von `Class.Mouse.UnitRay`) und einem Objekt im 3D-Raum (z.B. einem Teil) berechnet.

Die Orientierung des Hit CFrame entspricht der Richtung des `Class.Mouse.UnitRay`.

```
local unitRayDirection = mouse.UnitRay.Direction
local mouseHitDirection = mouse.Hit.lookVector
-- unitRayDirection ≈ mouseHitDirection
-- die Vektoren sind ungefähr gleich
```
Hinweis: Die Roll-Achse der `Class.Workspace.CurrentCamera` wird nicht verwendet, wenn die Orientierung des Hit `Datatype.CFrame` berechnet wird.

Der interne Strahl der Maus erstreckt sich über 1.000 Studs. Wenn die Maus nicht auf ein Objekt im 3D-Raum zeigt (zum Beispiel, wenn sie in den Himmel zeigt), wird diese Eigenschaft 1.000 Studs von der `Class.Workspace.CurrentCamera` entfernt sein.

Mouse.Hit

Der `Datatype.CFrame` der Mausposition im 3D-Raum.

Mouse.hit

Dieses Beispiel ändert das Mauszeichen von `Class.Players.LocalPlayer`, sodass es wie ein
drachenbild aussieht.


**Icon** ist ein Property, das das Bild bestimmt, das als Zeiger verwendet wird. Wenn
es leer ist, wird ein standardmäßiger Pfeil verwendet. Während der Cursor über einem
`Class.GuiButton` schwebt, wird dieses Property vorübergehend ignoriert.

Um den Cursor vollständig auszublenden, **verwenden Sie** kein transparentes Bild –
setzen Sie stattdessen `Class.UserInputService.MouseIconEnabled` auf false.

Um das Benutzermaus-Icon in Erlebnissen zu holen/einzustellen, sollten Sie
`Class.UserInputService.MouseIcon` verwenden. `Class.Mouse.Icon` wird veraltet
sein, nachdem die neue API für Plugins zum Setzen des Mauszeigers veröffentlicht wurde.

##### Gestaltung eines Cursors

Die folgenden Richtlinien können nützlich sein, wenn Sie Ihre eigenen Mauszeiger
erstellen:

- Die Dimensionen des verwendeten Bildes bestimmen die Größe des Cursors.
- Die Dimensionen des Bildes sollten 256 Pixel in keiner Achse überschreiten.
- Das **Zentrum** des Bildes ist der Punkt, an dem Maus-Eingaben erfolgen.
- Das standardmäßige Mausbild ist 64x64 Pixel groß, wobei die Maus 17x24
  Pixel Platz einnimmt.

##### System-Cursor

Wenn Sie einen `Class.PluginMouse` verwenden, der von `Class.Plugin:GetMouse()` erhalten wurde,
können Sie die folgenden Symbole ähnlich wie Ihre Systemstandardsymbole verwenden,
wie Hände, Pfeile, I-Balken usw. Sie können diese mit GUI-Events verwenden
wie `Class.GuiObject.MouseEnter|MouseEnter`,
`Class.GuiObject.MouseLeave|MouseLeave` und
`Class.GuiButton.MouseButton1Down|MouseButton1Down`, um eine
konsistente Studio-Erfahrung beim Interagieren mit bestimmten Arten von GUI
Komponenten bereitzustellen. Beachten Sie, dass diese nur für Studio-Plugins funktionieren; sie werden nicht
für andere `Class.Mouse`-Objekte funktionieren.

<table>
    <thead>
        <tr>
            <th>Aussehen*</th>
            <th>Asset</th>
            <th>Vorgeschlagene Verwendung</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Pointer.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Arrow</code></td>
            <td>Standardklick und Auswahl.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-PointingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/PointingHand</code></td>
            <td>Über einem aktiven Link/Knopf schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-OpenHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/OpenHand</code></td>
            <td>Über einem ziehbaren Element schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-GrabbingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/ClosedHand</code></td>
            <td>Ein Element ziehen.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-IBeam.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/IBeam</code></td>
            <td>Über einem Textfeld schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNS.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNS</code></td>
            <td>Über einem vertikalen Größenanpassungsgriff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeEW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeEW</code></td>
            <td>Über einem horizontalen Größenanpassungsgriff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNESW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNESW</code></td>
            <td>Über einem Eck-Größenanpassungsgriff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNWSE.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNWSE</code></td>
            <td>Über einem Eck-Größenanpassungsgriff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeAll.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeAll</code></td>
            <td>Über einem multidirektionalen Größenanpassungsgriff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitV.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitNS</code></td>
            <td>Über einem vertikalen "Getrennt"-Griff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitH.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitEW</code></td>
            <td>Über einem horizontalen "Getrennt"-Griff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Forbidden.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Forbidden</code></td>
            <td>Über einem gesperrten/verbotenen Element schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Wait.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Wait</code></td>
            <td>Zeigt an, dass eine Aktion im Gange ist.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Busy.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Busy</code></td>
            <td>Zeigt an, dass das System beschäftigt ist.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Crosshair.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Cross</code></td>
            <td>Über einem Punktauswahlbereich schwebend.</td>
        </tr>
    </tbody>
</table>

<figcaption>* Diese Darstellungen sind Annäherungen – das tatsächliche Aussehen hängt von Ihrem Betriebssystem ab.</figcaption>


Mouse.Icon

Die Inhalts-ID des Bildes, das als `Class.Mouse`-Symbol verwendet wird.


**Icon** ist ein Property, das das Bild bestimmt, das als Zeiger verwendet wird. Wenn
es leer ist, wird ein standardmäßiger Pfeil verwendet. Während der Cursor über einem
`Class.GuiButton` schwebt, wird dieses Property vorübergehend ignoriert. Dieses Property
unterstützt nur Asset-URIs.

Um den Cursor vollständig auszublenden, **verwenden Sie** kein transparentes Bild –
setzen Sie stattdessen `Class.UserInputService.MouseIconEnabled` auf false.

Um das Benutzermaus-Icon in Erlebnissen zu holen/einzustellen, sollten Sie
`Class.UserInputService.MouseIcon` verwenden. `Class.Mouse.Icon` wird veraltet
sein, nachdem die neue API für Plugins zum Setzen des Mauszeigers veröffentlicht wurde.

##### Gestaltung eines Cursors

Die folgenden Richtlinien können nützlich sein, wenn Sie Ihre eigenen Mauszeiger
erstellen:

- Die Dimensionen des verwendeten Bildes bestimmen die Größe des Cursors.
- Die Dimensionen des Bildes sollten 256 Pixel in keiner Achse überschreiten.
- Das **Zentrum** des Bildes ist der Punkt, an dem Maus-Eingaben erfolgen.
- Das standardmäßige Mausbild ist 64x64 Pixel groß, wobei die Maus 17x24
  Pixel Platz einnimmt.

##### System-Cursor

Wenn Sie einen `Class.PluginMouse` verwenden, der von `Class.Plugin:GetMouse()` erhalten wurde,
können Sie die folgenden Symbole ähnlich wie Ihre Systemstandardsymbole verwenden,
wie Hände, Pfeile, I-Balken usw. Sie können diese mit GUI-Events verwenden
wie `Class.GuiObject.MouseEnter|MouseEnter`,
`Class.GuiObject.MouseLeave|MouseLeave` und
`Class.GuiButton.MouseButton1Down|MouseButton1Down`, um eine
konsistente Studio-Erfahrung beim Interagieren mit bestimmten Arten von GUI
Komponenten bereitzustellen. Beachten Sie, dass diese nur für Studio-Plugins funktionieren; sie werden nicht
für andere `Class.Mouse`-Objekte funktionieren.

<table>
    <thead>
        <tr>
            <th>Aussehen*</th>
            <th>Asset</th>
            <th>Vorgeschlagene Verwendung</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Pointer.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Arrow</code></td>
            <td>Standardklick und Auswahl.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-PointingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/PointingHand</code></td>
            <td>Über einem aktiven Link/Knopf schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-OpenHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/OpenHand</code></td>
            <td>Über einem ziehbaren Element schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-GrabbingHand.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/ClosedHand</code></td>
            <td>Ein Element ziehen.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-IBeam.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/IBeam</code></td>
            <td>Über einem Textfeld schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNS.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNS</code></td>
            <td>Über einem vertikalen Größenanpassungsgriff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeEW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeEW</code></td>
            <td>Über einem horizontalen Größenanpassungsgriff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNESW.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNESW</code></td>
            <td>Über einem Eck-Größenanpassungsgriff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeNWSE.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeNWSE</code></td>
            <td>Über einem Eck-Größenanpassungsgriff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeAll.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SizeAll</code></td>
            <td>Über einem multidirektionalen Größenanpassungsgriff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitV.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitNS</code></td>
            <td>Über einem vertikalen "Getrennt"-Griff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-ResizeSplitH.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/SplitEW</code></td>
            <td>Über einem horizontalen "Getrennt"-Griff schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Forbidden.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Forbidden</code></td>
            <td>Über einem gesperrten/verbotenen Element schwebend.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Wait.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Wait</code></td>
            <td>Zeigt an, dass eine Aktion im Gange ist.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Busy.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Busy</code></td>
            <td>Zeigt an, dass das System beschäftigt ist.</td>
        </tr>
        <tr>
            <td><img src="../../../assets/misc/Mouse-Icon-Crosshair.png" width="30" /></td>
            <td><code>rbxasset://SystemCursors/Cross</code></td>
            <td>Über einem Punktauswahlbereich schwebend.</td>
        </tr>
    </tbody>
</table>

<figcaption>* Diese Darstellungen sind Annäherungen – das tatsächliche Aussehen hängt von Ihrem Betriebssystem ab.</figcaption>


Mouse.IconContent

Der Inhalt des Bildes, das als `Class.Mouse`-Symbol verwendet wird. Unterstützt nur
Asset-URIs.


Das Ursprungs-`Class.Mouse`-Property ist ein `Datatype.CFrame`, das angibt, wo die
Maus ihren Ursprung hat. Es ist an der
`Class.Workspace.CurrentCamera` positioniert und auf die 3D-Position der Maus
ausgerichtet.

`Class.Mouse.UnitRay` beginnt an der gleichen Position wie Origin und erstreckt
sich über einen Stud in die gleiche Richtung.

```lua
local unitRay = mouse.UnitRay
local origin = mouse.Origin
-- unitRay.Direction = origin.p
-- unitRay.Direction ≈ origin.lookVector
```
Für die Position der `Class.Mouse` im 3D-Raum siehe `Class.Mouse.Hit`.


Mouse.Origin

Ein `Datatype.CFrame`, das an der `Class.Workspace.CurrentCamera` positioniert ist und
darauf ausgerichtet ist, wo sich die Maus im 3D-Raum befindet.


Wenn in einem `LocalScript` in `StarterPlayerScripts` platziert, ändert der folgende Code
 die `Class.BasePart.BrickColor` jedes `BasePart`, auf das der Spieler klickt,
 wie den Spawnpunkt oder die Basisplatte.


Diese Eigenschaft bestimmt ein Objekt, das von der Maus ignoriert wird, wenn `Class.Mouse.Hit` und `Class.Mouse.Target` berechnet werden. Die Nachkommen des Objekts werden ebenfalls ignoriert, sodass es möglich ist, mehrere Objekte zu ignorieren, solange sie Nachkommen des Objekts sind, auf das diese Eigenschaft gesetzt wird. Diese Eigenschaft ist nützlich, um Modelle mit speziellen Effekten oder Dekorationen herauszufiltern, die `Class.Mouse.Hit` oder `Class.Mouse.Target` nicht beeinflussen sollten.

Diese Eigenschaft kann auf jede `Class.Instance` oder `nil` gesetzt werden, zum Beispiel:

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

local player = Players.LocalPlayer
local mouse = player:GetMouse()
mouse.TargetFilter = Workspace.Model
```
Beachten Sie, dass das `Class.Player.Character|Character` des `Class.Players.LocalPlayer` von der Maus automatisch ignoriert wird.

Mouse.Target

Das Objekt im 3D-Raum, auf das die `Class.Mouse|mouse` zeigt.


Mouse.target

Dieses Property bestimmt ein Objekt, das von der Maus ignoriert werden soll,
wenn `Class.Mouse.Hit` und `Class.Mouse.Target` berechnet werden. Die
Nachkommen des Objekts werden ebenfalls ignoriert, sodass es möglich ist,
mehrere Objekte zu ignorieren, solange sie Nachkommen des Objekts sind,
auf das dieses Property gesetzt ist. Dieses Property ist nützlich, wenn
Modelle mit speziellen Effekten oder Dekorationen gefiltert werden sollen,
die `Class.Mouse.Hit` oder `Class.Mouse.Target` nicht beeinflussen sollten.

Dieses Property kann auf jede `Class.Instance` oder `nil` gesetzt werden, zum Beispiel:

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

local player = Players.LocalPlayer
local mouse = player:GetMouse()
mouse.TargetFilter = Workspace.Model
```
Beachten Sie, dass das `Class.Player.Character|Character` des
`Class.Players.LocalPlayer` von der Maus automatisch ignoriert wird.


Mouse.TargetFilter

Bestimmt ein Objekt (und seine Nachkommen), das ignoriert werden soll, wenn
`Class.Mouse.Hit` und `Class.Mouse.Target` bestimmt werden.


Der Code in diesem Beispiel, wenn er in einem `LocalScript` innerhalb von
`StarterPlayerScripts` platziert wird, setzt die Oberfläche jedes `BasePart`, auf das geklickt wird, auf eine
zufällige Oberfläche.

Dieses Property zeigt auf die `Enum.NormalId` der `Class.BasePart`-Oberfläche,
auf die die Maus zeigt. Dieses Property stammt von der
Weltposition der Maus (`Class.Mouse.Hit`) und dem Teil, auf das die
Maus zeigt (`Class.Mouse.Target`).

Dieses Property ist nicht aussagekräftig, wenn die Maus nicht auf einem Teil
zeigt, zum Beispiel wenn die Maus auf den Himmel zeigt. In diesem Fall
ist dieses Property momentan auf 'Right' gesetzt. Überprüfen Sie vor der Verwendung dieses
Properties, dass das Ziel der Maus nicht `nil` ist.

```lua
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
-- Überprüfen, ob ein Teil existiert, auf das die Maus zeigt
if mouse.Target then
	print("Die Maus zeigt auf die " .. mouse.TargetSurface.Name .. " Seite von " .. mouse.Target.Name)
else
	print("Die Maus zeigt auf nichts.")
end
```


Mouse.TargetSurface

Zeigt auf die `Enum.NormalId` der Oberfläche des `Class.BasePart`, auf die die
Maus zeigt.


Die UnitRay-Eigenschaft ist ein `Datatype.Ray`, der auf die Position der Maus
im 3D-Raum (beschrieben durch `Class.Mouse.Hit`) gerichtet ist. Er stammt von
`Class.Camera.CFrame|CFrame` der `Class.Workspace.CurrentCamera`.
Wie alle Einheitsstrahlen hat er eine Distanz von 1.

```lua
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local mouse = player:GetMouse()
print(mouse.UnitRay.Direction.Magnitude) -- Immer 1
```


Mouse.UnitRay

Ein `Datatype.Ray`, der auf die Weltposition der Maus gerichtet ist und
von der Weltposition der `Class.Workspace.CurrentCamera` ausgeht.


Dieses Codebeispiel zeigt, wie Sie einen `Datatype.Vector2` erstellen können, der
die Position des `Mouse`-Objekts auf dem Bildschirm darstellt (`Class.Mouse.X|X()` und
`Class.Mouse.Y|Y()`) und die Größe des Bildschirms selbst
(`Class.Mouse.ViewSizeX|ViewSizeX()` und `Class.Mouse.ViewSizeY|ViewSizeY()`).
Damit können Sie die Position der Maus auf dem Bildschirm normalisieren,
so dass die obere linke Ecke direkt unter der oberen Leiste auf (0, 0) abgebildet wird
und die untere rechte Ecke auf (1, 1) abgebildet wird. Diese normalisierte Position
wird berechnet und ausgegeben, während sich die Maus bewegt, indem das
`Class.Mouse.Move|Move()`-Ereignis verwendet wird.

Die ViewSizeX-Eigenschaft beschreibt die horizontale Komponente der Größe des
Spiel-Fensters in Pixeln.


Mouse.ViewSizeX

Beschreibt die Breite des Spielefensters in Pixel.


Die ViewSizeY-Eigenschaft beschreibt die vertikale Komponente der Größe des
Spiel-Fensters in Pixeln. Diese Länge umfasst auch den Platz, der von der
topbar verwendet wird.


Mouse.ViewSizeY

Beschreibt die Höhe des Spielefensters in Pixel.


Bei der Erkennung von Änderungen in der Mausposition auf dem Bildschirm wird
empfohlen, `Class.ContextActionService:BindAction()` mit
`Enum.UserInputType.MouseMovement` oder
`Class.UserInputService.InputChanged` zu verwenden, die beide die Position der
Maus mit der `Class.InputObject.Position|Position` (einem
`Datatype.Vector3`) eines `Class.InputObject` beschreiben, anstatt dieses und
verwandte Properties zu verwenden.

Die X-Eigenschaft beschreibt die horizontale Komponente der Mausposition
auf dem Bildschirm. Die Position wird in Pixeln relativ zur oberen linken
Ecke, unter der Topbar, gemessen. Dieses Property kann in Verbindung mit
`Class.Mouse.Y` verwendet werden, um ein `Datatype.Vector2` zu erzeugen, das die
tatsächliche Mausposition darstellt:

```lua
local position = Vector2.new(mouse.X, mouse.Y)
```
Dieses Property feuert nicht `Class.Object.Changed|Changed` oder das Signal,
das von
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal` zurückgegeben wird. Verwenden Sie stattdessen
das `Class.Mouse.Move`-Ereignis.


Mouse.X

Beschreibt die X (horizontale) Komponente der Mausposition auf dem
Bildschirm.


Bei der Erkennung von Änderungen in der Mausposition auf dem Bildschirm wird
empfohlen, `Class.ContextActionService:BindAction()` mit
`Enum.UserInputType.MouseMovement` oder
`Class.UserInputService.InputChanged` zu verwenden, die beide die Position der
Maus mit der `Class.InputObject.Position|Position` (einem
`Datatype.Vector3`) eines `Class.InputObject` beschreiben, anstatt dieses und
verwandte Properties zu verwenden.

Die Y-Eigenschaft beschreibt die vertikale Komponente der Mausposition auf
dem Bildschirm. Die Position wird in Pixeln relativ zur oberen linken
Ecke, unter der Topbar, gemessen. Dieses Property kann in Verbindung mit
`Class.Mouse.X` verwendet werden, um ein `Datatype.Vector2` zu erzeugen, das die
tatsächliche Mausposition darstellt:

```lua
local position = Vector2.new(mouse.X, mouse.Y)
```
Dieses Property feuert nicht `Class.Object.Changed|Changed` oder das Signal,
das von
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal` zurückgegeben wird. Verwenden Sie stattdessen
das `Class.Mouse.Move`-Ereignis.


Mouse.Y

Beschreibt die Y (vertikale) Komponente der Mausposition auf dem Bildschirm.


Veraltetes Objekt, das Mitglieder enthält, die für Zeiger-Eingaben nützlich sind.

`Instance` ist die Basisklasse für alle Klassen in der Roblox-Klassenhierarchie, die Teil des `Class.DataModel`-Baumes sein können.

Es ist nicht möglich, direkt Root-`Instance`-Objekte zu erstellen, aber der spezielle `Datatype.Instance.new()`-Konstruktor erstellt Objekte über Code, indem er den Namen der Klasse als Parameter entgegennimmt und das erstellte Objekt zurückgibt.

Demonstriert das Erkennen von Änderungen an der Abstammung einer Instanz, indem man sich mit dem
`Class.Instance.AncestryChanged` Ereignis verbindet.

Der Parent des ChangingPart wird im Laufe der Zeit auf verschiedene Werte gesetzt. Der Parent des
Teils ist der Vorfahr des Teils, sodass das `Class.Instance.AncestryChanged` Ereignis
ausgelöst wird, wann immer es sich ändert.


Wird ausgelöst, wenn diese Instanz umgegliedert wird oder wenn einer ihrer Vorfahren
umgegliedert wird.

Sie können dieses Ereignis verwenden, um das Löschen einer Instanz im Studio zu verfolgen,
wie z.B. das manuelle Löschen im Explorer oder über ein Plugin. Wenn Sie erkennen müssen,
wann eine Instanz mit `Class.Instance:Destroy()` gelöscht wird, verwenden Sie stattdessen das
event `Class.Instance.Destroying`.

Instance.AncestryChanged

child

Die Instanz, deren `Class.Instance.Parent|Parent`-Eigenschaft sich geändert hat,
was diese Instanz oder einen weiter entfernten Vorfahren sein kann, **nicht**
unbedingt die Instanz, an die der Handler verbunden ist.

parent

Der neue Elternteil des `child`-Parameters.

Wird ausgelöst, wenn die `Class.Instance.Parent`-Eigenschaft dieses Objekts oder einer
seiner Vorfahren geändert wird.

Dieses Ereignis wird ausgelöst, wenn ein beliebiges Attribut auf der Instanz geändert wird,
auch wenn ein Attribut auf `nil` gesetzt wird. Der Name des geänderten Attributs wird an die
verbundene Funktion übergeben.

Zum Beispiel verbindet der folgende Code-Schnipsel die Funktion `attributeChanged()`
musikalisch, um zu feuern, wenn sich eines der Attribute des Parts ändert:

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

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "geändert")
end

part.AttributeChanged:Connect(attributeChanged)
```
Siehe auch `Class.Instance:GetAttributeChangedSignal()`, das ein Ereignis zurückgibt,
das ausgelöst wird, wenn ein bestimmtes angegebenes Attribut geändert wird.

Instance.AttributeChanged

attribute

Der Name des Attributs, das geändert wurde.

Wird ausgelöst, wenn ein Attribut auf der `Class.Instance` geändert wird.

Dieses Snippet druckt die Namen von Objekten aus, während sie zum Workspace hinzugefügt werden:

Wird ausgelöst, nachdem ein Objekt zu dieser `Class.Instance` hinzugefügt wurde.

Hinweis, beim Verwenden dieser Methode auf einem Client, um Objekte zu erkennen, die vom
Server erstellt wurden, ist es notwendig, `Class.Instance:WaitForChild()` zu verwenden, wenn
man auf die Nachkommen dieses Objekts zugreift. Dies liegt daran, dass das Objekt und seine
Nachkommen nicht garantiert gleichzeitig vom Server zum Client repliziert werden. Zum Beispiel:

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

Workspace.ChildAdded:Connect(function(child)
	-- Verwenden Sie WaitForChild(), da Nachkommen möglicherweise noch nicht repliziert wurden
	local head = child:WaitForChild("Head")
end)
```
Hinweis, dieses Ereignis funktioniert nur für unmittelbare Kinder der `Class.Instance`.
Für ein Ereignis, das alle Nachkommen erfasst, verwenden Sie `Class.Instance.DescendantAdded`.

Siehe auch `Class.Instance.ChildRemoved`.

Instance.ChildAdded

Die `Class.Instance`, die hinzugefügt wurde.

Wird ausgelöst, nachdem ein Objekt zu dieser `Class.Instance` hinzugefügt wurde.

Instance.childAdded

Dieser Ausschnitt druckt die Namen von Objekten, während sie aus dem
Workspace entfernt werden:

Wird ausgelöst, nachdem ein Kind aus dieser `Class.Instance` entfernt wurde.

Entfernt bezieht sich darauf, wenn der Elternteil eines Objekts von dieser
`Class.Instance` auf etwas anderes als diese `Class.Instance` geändert wird. Hinweis, diese
Ereignis wird auch ausgelöst, wenn ein Kind gelöscht wird (unter Verwendung von
`Class.Instance:Destroy()`), da die Löschfunktion den Elternteil eines Objekts auf `nil`
setzt.

Dieses Ereignis funktioniert nur für unmittelbare Kinder der `Class.Instance`.
Für ein Ereignis, das alle Nachkommen erfasst, verwenden Sie
`Class.Instance.DescendantRemoving`.

Siehe auch `Class.Instance.ChildAdded`.

Instance.ChildRemoved

Die `Class.Instance`, die entfernt wurde.

Wird ausgelöst, nachdem ein Kind aus dieser `Class.Instance` entfernt wurde.

Das folgende Beispiel gibt den Namen jedes Objekts aus, das zum
Arbeitsbereich hinzugefügt wird:

Dieses Ereignis wird ausgelöst, nachdem ein Nachkomme zur `Class.Instance` hinzugefügt wurde.

Da es für jeden Nachkommen ausgelöst wird, wird durch das Hinzufügen eines Objekts zur
`Class.Instance` das Ereignis für dieses Objekt und alle seine Nachkommen individuell ausgelöst.

Wenn Sie sich nur um die **direkten Kinder** der `Class.Instance` kümmern,
verwenden Sie stattdessen `Class.Instance.ChildAdded`.

Siehe auch `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

Wird ausgelöst, nachdem ein Nachkomme zur `Class.Instance` hinzugefügt wurde.

Das folgende Beispiel gibt den Namen eines Nachkommens aus, während er entfernt wird
aus dem Workspace:

Dieses Ereignis wird **sofort bevor** der Elternteil `Class.Instance`
so geändert wird, dass eine **Nachkomme**-Instanz nicht mehr eine
Nachkomme ist. `Class.Instance:Destroy()|Destroy()` ändert den `Class.Instance.Parent|Parent`
 in `nil`, sodass der Aufruf dieser Methode auf einen Nachkommen des Elternteils dazu
führt, dass dieses Ereignis ausgelöst wird.

Da dieses Ereignis **vor** der Entfernung des Nachkommens ausgelöst wird, wird
zu diesem Zeitpunkt der Elternteil des Nachkommens unverändert bleiben. Wenn der
Nachkomme auch ein **direktes Kind** des Elternteils ist, wird dieses Ereignis vor
`Class.Instance.ChildRemoved` ausgelöst.

Wenn ein Nachkomme Kinder hat, wird dieses Ereignis zuerst mit dem Nachkommen ausgelöst,
gefolgt von seinen Nachkommen.

#### Warnung

Dieses Ereignis wird mit dem Nachkommenobjekt ausgelöst, das entfernt wird.
Der Versuch, den `Class.Instance.Parent|Parent` des Nachkommens auf
irgendetwas anderes zu setzen, wird fehlschlagen. Unten finden Sie ein Beispiel, das dies demonstriert:

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

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Manipulieren Sie den Elternteil des Nachkommens in dieser Funktion nicht!
	-- Dieses Ereignis wird AUSGELÖST, WEIL der Elternteil manipuliert wurde, und die Änderung hat noch nicht stattgefunden
	-- Daher ist es problematisch, den Elternteil so zu ändern:
	descendant.Parent = game
end)

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

Instance.DescendantRemoving

Wird sofort ausgelöst, bevor ein Nachkomme der `Class.Instance` entfernt wird.

Dieses Beispiel zeigt, wie ein Instanz, wenn das Immediate-Signalverhalten verwendet wird,
bei der Zerstörung an Ort und Stelle bleibt, bis die verbundene Funktion anhalten muss.


In diesem Beispiel wird demonstriert, wie eine Instanz zerstört wird, bevor das Signal ausgelöst wird, wenn das Deferred-Signalverhalten verwendet wird.


Die `Class.Instance` wird niemals aus dem Speicher gelöscht, während eine verbundene
Funktion sie noch verwendet. Wenn die Funktion jedoch zu irgendeinem Zeitpunkt ausgibt,
werden die `Class.Instance` und ihre Nachkommen auf `nil` umgegliedert.

Wenn die Eigenschaft `Class.Workspace.SignalBehavior` auf
`Enum.SignalBehavior.Immediate` gesetzt ist, wird dieses Ereignis sofort ausgelöst,
bevor die `Class.Instance` oder einer ihrer Vorfahren mit `Class.Instance:Destroy()` zerstört wird.

Wenn die Eigenschaft `Class.Workspace.SignalBehavior` auf
`Enum.SignalBehavior.Deferred` gesetzt ist, wird dieses Ereignis am nächsten Wiederaufnahme-
Punkt ausgelöst, was nach der Zerstörung von `Class.Instance` oder einem ihrer Vorfahren mit
`Class.Instance:Destroy()` sein wird.

Mit dem Verhalten `Enum.SignalBehavior.Deferred|Deferred` ist es problematisch,
ein Skript mit seinem eigenen `Class.Instance.Destroying`-Ereignis zu verbinden, da das
Skript zerstört wird, bevor der Callback aufgerufen werden kann (was bedeutet, dass es nicht ausgeführt wird).

Beim Löschen einer `Class.Instance` im Studio, wie z.B. beim manuellen Löschen über den
[Explorer](/studio/explorer) oder über ein Plugin, wird die `Class.Instance`
nicht gelöscht. Stattdessen wird der Elternteil auf `nil` gesetzt,
wobei Sie dies mit `Class.Instance.AncestryChanged` verfolgen können.

Instance.Destroying

Wird sofort ausgelöst, bevor (oder wird auf nachher verschoben) die Instanz
über `Class.Instance:Destroy()` zerstört wird.

Dieses Ereignis wird ausgelöst, wenn eine beliebige Stil-Eigenschaft auf der Instanz geändert wird,
auch wenn eine Eigenschaft auf `nil` gesetzt wird.

```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("Gestylte Eigenschaften geändert")
end

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

Instance.StyledPropertiesChanged

Wird ausgelöst, wenn eine beliebige Stil-Eigenschaft auf der Instanz geändert wird,
auch wenn eine Eigenschaft auf `nil` gesetzt wird.

Diese Methode wendet ein Tag auf die Instanz an, ohne Wirkung, wenn das Tag bereits angewendet wurde. Das erfolgreiche Hinzufügen eines Tags löst ein Signal aus, das von `Class.CollectionService:GetInstanceAddedSignal()` mit dem angegebenen Tag erstellt wurde.

#### Warnungen

- Die Tags einer Instanz, die clientseitig hinzugefügt wurden, werden verworfen, wenn der Server später ein Tag auf dieser Instanz hinzufügt oder entfernt, da der Server alle Tags zusammen repliziert und vorherige Tags überschreibt.

- Wenn Sie eine Instanz taggen, ist es üblich, dass einige Ressourcen verwendet werden, um dem Tag seine Funktionalität zu verleihen, zum Beispiel Ereignisverbindungen oder Tabellen. Um Speicherverluste zu vermeiden, ist es eine gute Idee, diese aufzuräumen (trennen, auf `nil` setzen usw.), wenn sie für ein Tag nicht mehr benötigt werden. Tun Sie dies beim Aufruf von `Class.Instance:RemoveTag()`, beim Aufruf von `Class.Instance:Destroy()` oder in einer Funktion, die mit einem Signal verbunden ist, das von `Class.CollectionService:GetInstanceRemovedSignal()` zurückgegeben wurde.

Instance:AddTag

Die Kinderfunktion gibt ein Array der Kinder des Objekts zurück.

Instance:children

Gibt ein Array der Kinder des Objekts zurück.

Diese Methode zerstört alle Kinder und Nachkommen einer Instanz.

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

-- Füge ein paar Funkeln hinzu
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

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

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

part:ClearAllChildren()

print("Children:", #part:GetChildren())  --> Children: 0
```
Wenn Sie **alle** Kinder und Nachkommen nicht zerstören möchten, verwenden Sie entweder `Class.Instance:GetChildren()` oder `Class.Instance:GetDescendants()`, um durch diese Kinder/Nachkommen zu iterieren und auszuwählen, was zerstört werden soll. Zum Beispiel wird das folgende Codesample alle `Class.BasePart|BaseParts`, die von einem `Class.Model` abgeleitet sind, zerstören:

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

Diese Methode zerstört alle Kinder einer Instanz.

Demonstriert das Klonen eines Modells mit `Class.Instance:Clone()`.

`Clone()` erstellt eine Kopie einer Instanz und aller ihrer Nachkommen und ignoriert alle Instanzen, die **nicht** `Class.Instance.Archivable|Archivable` sind. Die Kopie der Root-Instanz wird durch diese Methode zurückgegeben, und ihr `Class.Instance.Parent|Parent` wird auf `nil` gesetzt. Beachten Sie, dass, wenn die Instanz selbst auf `Class.Instance.Archivable|Archivable` auf `false` gesetzt ist, diese Methode `nil` zurückgibt.

Wenn eine Referenzeigenschaft wie `Class.ObjectValue.Value` in einer kopierten Instanz gesetzt wird, hängt der Wert der Eigenschaftn der Kopie vom Wert des Originals ab:

- Wenn eine Referenzeigenschaft auf eine Instanz verweist, die **auch** kopiert wurde, verweist die Kopie auf die Kopie.
- Wenn eine Referenzeigenschaft auf eine Instanz verweist, die **nicht** kopiert wurde, bleibt derselbe Wert in der Kopie erhalten.

Instance:Clone

Erstellt eine Kopie einer Instanz und aller ihrer Nachkommen und ignoriert Instanzen, die **nicht** `Class.Instance.Archivable|Archivable` sind.

Instance:clone

Demonstriert das Zerstören eines Parts mit der `Class.Instance:Destroy()`-Funktion.

Diese Funktion ist der richtige Weg, um Objekte zu entsorgen, die nicht mehr
benötigt werden.


Setzt die `Class.Instance.Parent`-Eigenschaft auf `nil`, sperrt die `Class.Instance.Parent`-Eigenschaft, trennt alle Verbindungen und ruft `Destroy()` für alle Kinder auf. Diese Methode ist der richtige Weg, um Objekte loszuwerden, die nicht mehr benötigt werden.

Das Entsorgen von nicht mehr benötigten Objekten ist wichtig, da unnötige Objekte und Verbindungen in einem Ort Speicher belegen können, was im Laufe der Zeit zu ernsthaften Leistungsproblemen führen kann.

Als Best Practice sollte nach dem Aufruf von `Destroy()` für ein Objekt jede Variable, die auf das Objekt (oder seine Nachkommen) verweist, auf `nil` gesetzt werden. Dies verhindert, dass Ihr Code auf etwas zugreift, das mit dem Objekt zu tun hat.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- Das nicht tun:
print(part.Name)  --> "Hello, world"
-- Dies tun, um die obige Zeile zu verhindern:
part = nil
```
Sobald ein `Class.Instance` durch diese Methode zerstört wurde, kann es nicht wiederverwendet werden, da die `Class.Instance.Parent`-Eigenschaft gesperrt ist. Um ein Objekt **vorübergehend** zu entfernen, anstatt es zu zerstören, setzen Sie `Class.Instance.Parent|Parent` auf `nil`. Zum Beispiel:

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

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Um ein Objekt nach einer bestimmten Zeit zu zerstören, verwenden Sie `Class.Debris:AddItem()`.

Instance:Destroy

Setzt die `Class.Instance.Parent`-Eigenschaft auf `nil`, sperrt die `Class.Instance.Parent`-Eigenschaft, trennt alle Verbindungen und ruft `Destroy()` für alle Kinder auf.

Instance:destroy

Gibt den ersten Vorfahren der `Class.Instance` zurück, dessen `Class.Instance.Name` gleich dem angegebenen Namen ist.

Diese Methode funktioniert aufwärts, was bedeutet, dass sie bei dem unmittelbaren `Class.Instance.Parent` der Instanz beginnt und in Richtung des `Class.DataModel` arbeitet. Wenn kein übereinstimmender Vorfahre gefunden wird, wird `nil` zurückgegeben.

Der folgende Codeausschnitt würde den ersten Vorfahren des Objekts mit dem Namen `Car` finden.

```
local car = object:FindFirstAncestor("Car")
```
Für Varianten dieser Methode, die Vorfahren einer bestimmten Klasse finden, siehe `Class.Instance:FindFirstAncestorOfClass()` und `Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

Der `Class.Instance.Name`, nach dem gesucht werden soll.

Gibt den ersten Vorfahren der `Class.Instance` zurück, dessen `Class.Instance.Name` gleich dem angegebenen Namen ist.

Gibt den ersten Vorfahren der `Class.Instance` zurück, dessen `Class.Object.ClassName` gleich dem angegebenen className ist.

Diese Methode funktioniert aufwärts, was bedeutet, dass sie bei dem unmittelbaren `Class.Instance.Parent` der Instanz beginnt und in Richtung des `Class.DataModel` arbeitet. Wenn kein übereinstimmender Vorfahre gefunden wird, wird `nil` zurückgegeben.

Ein häufiges Anwendungsbeispiel dieser Methode ist das Finden des `Class.Model`, zu dem ein `Class.BasePart` gehört. Zum Beispiel:

```
local model = part:FindFirstAncestorOfClass("Model")
```
Diese Methode ist eine Variante von `Class.Instance:FindFirstAncestor()`, die die `Class.Object.ClassName`-Eigenschaft anstelle von `Class.Instance.Name` überprüft. `Class.Instance:FindFirstAncestorWhichIsA()` existiert ebenfalls und verwendet die `Class.Object:IsA()`-Methode, um die Klassenerbschaft zu berücksichtigen.

Instance:FindFirstAncestorOfClass

className

Der `Class.Object.ClassName`, nach dem gesucht werden soll.

Gibt den ersten Vorfahren der `Class.Instance` zurück, dessen `Class.Object.ClassName` gleich dem angegebenen className ist.

Gibt den ersten Vorfahren der `Class.Instance` zurück, für den `Class.Object:IsA()` für den angegebenen className `true` zurückgibt.

Diese Methode funktioniert aufwärts, was bedeutet, dass sie bei dem unmittelbaren `Class.Instance.Parent` der Instanz beginnt und in Richtung des `Class.DataModel` arbeitet. Wenn kein übereinstimmender Vorfahre gefunden wird, wird `nil` zurückgegeben.

Im Gegensatz zu `Class.Instance:FindFirstAncestorOfClass()` verwendet diese Methode `Class.Object:IsA()`, die die Klassenerbschaft berücksichtigt. Zum Beispiel:

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
Deshalb gibt das folgende Codesample den ersten `Class.BasePart`-Vorfahren zurück, unabhängig davon, ob es sich um ein `Class.WedgePart`, `Class.MeshPart` oder `Class.Part` handelt.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```
Siehe auch `Class.Instance:FindFirstAncestor()`.

Instance:FindFirstAncestorWhichIsA

Gibt den ersten Vorfahren der `Class.Instance` zurück, für den `Class.Object:IsA()` für den angegebenen className `true` zurückgibt.

Die folgende Suche würde im Workspace nach einem Objekt mit dem Namen "Brick" suchen. Wenn es gefunden wird,
wird der Name des Objekts auf "Foo" geändert.

Gibt das erste Kind der `Class.Instance` mit dem angegebenen Namen zurück, oder `nil`, wenn kein solches Kind existiert. Wenn das optionale Argument `recursive` `true` ist, durchsucht diese Methode alle Nachkommen und nicht nur die unmittelbaren Kinder der `Class.Instance`.

#### Überprüfung der Existenz eines Objekts

`FindFirstChild()` ist erforderlich, wenn Sie überprüfen müssen, ob ein Objekt existiert, bevor Sie fortfahren. Versuchen Sie, ein Kind mit dem Namen zu indexieren, indem Sie den Punktoperator verwenden, gibt einen Fehler zurück, wenn das Kind nicht existiert.

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

-- Die folgende Zeile gibt einen Fehler zurück, wenn das Teil nicht im Arbeitsbereich existiert
Workspace.Part.Transparency = 0.5
```
Ein besserer Ansatz besteht darin, `FindFirstChild()` zu verwenden, um zunächst nach `Part` zu suchen, und dann eine `if`-Anweisung zu verwenden, um Code auszuführen, der es benötigt.

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

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

#### Finden eines Kindes, dessen Name mit einer Eigenschaft übereinstimmt

Manchmal ist der `Class.Instance.Name|Name` eines Objekts derselbe wie der einer Eigenschaft seines `Class.Instance.Parent|Parent`. Wenn der Punktoperator verwendet wird, haben die Eigenschaften Vorrang vor den Kindern, wenn sie denselben Namen haben.

Im folgenden Beispiel wird ein `Class.Folder` mit dem Namen `Color` zu einem `Class.Part` hinzugefügt, das auch die `Class.Part.Color`-Eigenschaft hat. Beachten Sie, dass `part.Color` sich auf den Wert der `Datatype.Color3`-Eigenschaft bezieht, nicht auf die untere `Class.Folder`-Instanz. Ein Vorteil der Verwendung von `Class.Instance:FindFirstChild()|FindFirstChild()` ist, dass die Einführung neuer Eigenschaften Ihr Code nicht gefährdet.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- Die Eigenschaft
local c2 = part:FindFirstChild("Color")  -- Der Kinderordner
```

#### Leistungsnotizen

`Class.Instance:FindFirstChild()|FindFirstChild()` benötigt etwa 20 % länger als die Verwendung des Punktoperators und nahezu 8-mal länger als einfach die Speicherung eines Verweises auf ein Objekt. Daher sollten Sie vermeiden, es in leistungsabhängigem Code wie in engen Schleifen oder Funktionen zu verwenden, die mit `Class.RunService.Heartbeat` und `Class.RunService.PreRender` verbunden sind. Stattdessen speichern Sie das Ergebnis in einer Variablen oder ziehen Sie in Betracht, `Class.Instance.ChildAdded|ChildAdded` oder `Class.Instance:WaitForChild()|WaitForChild()` zu verwenden, um zu erkennen, wann ein Kind eines bestimmten Namens verfügbar wird.

Instance:FindFirstChild

recursive

Ob die Suche rekursiv durchgeführt werden soll.

Gibt das erste Kind der `Class.Instance` zurück, das den angegebenen Namen hat.

Instance:findFirstChild

Gibt das erste Kind der `Class.Instance` zurück, dessen `Class.Object.ClassName|ClassName` gleich dem angegebenen `className` ist. Im Gegensatz zu `Class.Instance:FindFirstChildWhichIsA()` gibt diese Methode nur Objekte zurück, deren Klasse mit `className` übereinstimmt, wobei die Klassenerbschaft ignoriert wird. Wenn kein übereinstimmendes Kind gefunden wird, gibt diese Methode `nil` zurück.

Instance:FindFirstChildOfClass

Gibt das erste Kind der `Class.Instance` zurück, dessen `Class.Object.ClassName|ClassName` gleich dem angegebenen Klassennamen ist.

Gibt das erste Kind der `Class.Instance` zurück, für das `Class.Object:IsA()` für den angegebenen className `true` zurückgibt.

Wenn kein übereinstimmendes Kind gefunden wird, gibt diese Methode `nil` zurück. Wenn das optionale rekursive Argument `true` ist, durchsucht diese Methode alle Nachkommen und nicht nur die unmittelbaren Kinder der `Class.Instance`.

Im Gegensatz zu `Class.Instance:FindFirstChildOfClass()` verwendet diese Methode `Class.Object:IsA()`, die die Klassenerbschaft berücksichtigt. Zum Beispiel:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Daher gibt das folgende Codesample das erste `Class.BasePart`-Kind zurück, unabhängig davon, ob es sich um ein `Class.WedgePart`, `Class.MeshPart` oder `Class.Part` handelt.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```
Entwickler, die nach einem Kind mit Namen suchen, sollten stattdessen `Class.Instance:FindFirstChild()` verwenden.

Instance:FindFirstChildWhichIsA

Gibt das erste Kind der `Class.Instance` zurück, für das `Class.Object:IsA()` für den angegebenen className `true` zurückgibt.

Gibt den ersten Nachkommen mit dem gegebenen `Class.Instance.Name` zurück.

Diese Methode ist deaktiviert und kann nicht verwendet werden. Um den ersten Nachkommen einer Instanz zu finden, sollten Sie stattdessen die rekursive Option von `Class.Instance:FindFirstChild()` verwenden.

Instance:FindFirstDescendant

Gibt den ersten Nachkommen mit dem gegebenen `Class.Instance.Name` zurück.

Wenn die `Class.Instance` ein `Class.Actor` ist, wird der `Class.Actor` selbst zurückgegeben. Andernfalls wird der nächstgelegene Vorfahre `Class.Actor` zurückgegeben. Wenn kein Vorfahre ein `Class.Actor` ist, ist das Ergebnis `nil`.

Instance:GetActor

Gibt den `Class.Actor` zurück, der mit der Instanz verbunden ist, falls vorhanden.

Diese Methode gibt den Wert zurück, der dem angegebenen Attributnamen zugewiesen wurde. Wenn kein Attribut zugewiesen wurde, wird `nil` zurückgegeben.

Zum Beispiel setzt der folgende Codeausschnitt den Wert des Attributs `InitialPosition` der Instanz:

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

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

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

#### Siehe auch

- `Class.Instance:SetAttribute()`, das das Attribut mit dem angegebenen Namen auf den angegebenen Wert setzt.
- `Class.Instance:GetAttributes()`, das ein Wörterbuch mit Schlüssel-Wert-Paaren für jedes Attribut der Instanz zurückgibt.

Instance:GetAttribute

Der Name des Attributs, das abgerufen wird.

Der Wert, der dem angegebenen Attributnamen zugewiesen wurde. Wenn kein Attribut zugewiesen wurde, wird `nil` zurückgegeben.

Gibt den Wert zurück, der dem angegebenen Attributnamen zugewiesen wurde.

Diese Methode gibt ein Ereignis zurück, das sich genau wie das `Class.Object.Changed|Changed`-Ereignis verhält, mit dem Unterschied, dass es nur ausgelöst wird, wenn sich das bestimmte angegebene Attribut ändert; effektiv ist es ähnlich wie `Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()`, jedoch für Attribute.

Es ist im Allgemeinen eine gute Idee, diese Methode anstelle einer Verbindung zu `Class.Object.Changed|Changed` mit einer Funktion, die den Eigenschaftsnamen überprüft, zu verwenden. Subsequent calls to this method on the same object with the same attribute name return the same event.

Der folgende Codeausschnitt gibt ein Signal zurück, das die Funktion `attributeChanged()` auslöst, wenn sich das Attribut `InitialPosition` des Teils ändert:

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

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

local function attributeChanged()
	print("Attribut geändert")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```
Siehe auch `Class.Instance.AttributeChanged`, das ausgelöst wird, wenn sich irgendein Attribut der Instanz ändert.

Instance:GetAttributeChangedSignal

Der Name des angegebenen Attributs, für das das Änderungs-Signal zurückgegeben wird.

Ein Ereignis, das ausgelöst wird, wenn sich das angegebene Attribut ändert.

Gibt ein Ereignis zurück, das ausgelöst wird, wenn sich das angegebene Attribut ändert.

Diese Methode gibt ein Wörterbuch von Schlüssel-Wert-Paaren für jedes Attribut zurück, wobei der Schlüssel der Name des Attributs und der Wert ein Nicht-`nil`-Wert ist.

Zum Beispiel gibt der folgende Codeausschnitt die Attribute und Werte einer Instanz aus:

```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
```
Siehe auch `Class.Instance:GetAttribute()`, das den Wert zurückgibt, der dem angegebenen Attributnamen zugewiesen wurde.

Instance:GetAttributes

Ein Wörterbuch von String-zu-Variant-Paaren für jedes Attribut, wobei der String der Name des Attributs und die Variante ein Nicht-nil-Wert ist.

Gibt ein Wörterbuch der Attribute der Instanz zurück.

Das Folgende würde die Namen aller Objekte, die sich derzeit im Workspace befinden, beim Ausführen ausgeben.

Gibt ein Array (eine numerisch indizierte Tabelle) zurück, das alle direkten Kinder der Instanz enthält oder jeden `Class.Instance`, dessen `Class.Instance.Parent|Parent` gleich dem Objekt ist. Das Array kann entweder mit einer numerischen oder generischen `for`-Schleife durchlaufen werden:

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

-- Beispiel einer numerischen Schleife
local children = Workspace:GetChildren()
for i = 1, #children do
	local child = children[i]
	print(child.Name .. " ist Kind Nummer " .. i)
end
```

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

-- Beispiel einer generischen Schleife
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " ist Kind Nummer " .. i)
end
```
Beachten Sie, dass das zurückgegebene Array **nicht** in einer bestimmten Reihenfolge sortiert ist, daher wird empfohlen, es manuell zu sortieren (zum Beispiel mit `Library.table.sort()`), um die von dieser Methode zurückgegebenen Kinder zu sortieren.

Siehe auch die Methode `Class.Instance:GetDescendants()|GetDescendants()`.

Instance:GetChildren

Ein Array, das die Kinder der Instanz enthält.

Gibt ein Array zurück, das alle Kinder der Instanz enthält.

Instance:getChildren

Gibt eine codierte Zeichenfolge der Debug-ID zurück, die intern von Roblox verwendet wird. Beachten Sie, dass:

- Diese Methode ist geschützt. Ein Versuch, sie in einem `Class.Script` oder `Class.LocalScript` zu verwenden, führt zu einem Fehler.
- Eine Debug-ID ist eine ID, die in Debugging-Prozessen verwendet wird. Sie ermöglicht es einem Debugger, jede Anweisung zu lesen, bevor eine Anwendung sie verarbeitet. Alle Objekte in Roblox verhalten sich wie Prozesse und führen Anweisungen (oder 'Code') aus, die bei Bedarf debuggt werden können.
- Dies kann für Plugins hilfreich sein, die ähnliche Objekte voneinander unterscheiden müssen (zum Beispiel Objekte, die denselben Namen teilen).

Instance:GetDebugId

Gibt eine codierte Zeichenfolge der Debug-ID zurück, die intern von Roblox verwendet wird.

Instance

`Instance` ist die Basisklasse für alle Klassen in der Roblox-Klassenhierarchie, die Teil des `Class.DataModel`-Baumes sein können.

/reference/engine/classes/PlayerMouse.yaml