ให้การเข้าถึงโปรแกรมมิ่งไปยังข้อมูลประสิทธิภาพพื้นฐานของเครื่องมือ
[Scene Analysis](/performance-optimization/scene-analysis) ของเครื่องมือ


คืนค่าหน่วยความจำของคลิปอนิเมชันที่โหลดแล้ว ซึ่งสินทรัพย์เดียวกันที่แชร์โดยหลาย
Animator จะปรากฏเพียงครั้งเดียว พร้อมกับเจ้าของทั้งหมดที่ระบุไว้

#### รากของพจนานุกรม

| คีย์        | ประเภท   | คำอธิบาย                                                      |
| ---------- | ------ | ---------------------------------------------------------------- |
| `Name`     | string | เป็น `"AnimationMemory"` เสมอ                                      |
| `Size`     | number | หน่วยความจำทั้งหมดที่โหลดคลิปในหน่วยบิต                               |
| `Children` | array  | อาร์เรย์ของรายการคลิปและอาจมีกลุ่มโมเดลที่ไม่มีข้อมูล               |

#### รายการคลิป

แต่ละเด็กใน `Children` เป็นรายการคลิปหรือกลุ่ม "not in data model"
(ดูด้านล่าง)

| คีย์       | ประเภท   | คำอธิบาย                                                 |
| --------- | ------ | ----------------------------------------------------------- |
| `Name`    | string | หมายเลข ID ของสินทรัพย์ (เช่น `"rbxassetid://111"`).                   |
| `Size`    | number | หน่วยความจำคลิปในหน่วยบิต                                      |
| `AssetId` | string | สตริง ID ของสินทรัพย์ (ค่าเดียวกันกับ `Name`).                 |
| `Owners`  | array  | อาร์เรย์ของรายการเจ้าของสำหรับ Animator ทั้งหมดที่เล่นคลิปนี้. |

#### รายการเจ้าของ

| คีย์         | ประเภท   | คำอธิบาย                                                                  |
| ----------- | ------ | ---------------------------------------------------------------------------- |
| `Name`      | string | เส้นทางเต็มไปยัง Animator ที่เป็นเจ้าของ (เช่น `"Workspace.NPC.Humanoid.Animator"`). |
| `ClassName` | string | ชื่อคลาสของเจ้าของ (เช่น `"Animator"`).                                 |

#### กลุ่ม "Not in data model"

คลิปจาก Animator ที่ถือโดย Lua เท่านั้น (ไม่ได้พ่อแม่ในข้อมูลโมเดล) จะ
ถูกรวบรวมเป็นรายการกลุ่มเดียว

| คีย์        | ประเภท   | คำอธิบาย                                   |
| ---------- | ------ | --------------------------------------------- |
| `Name`     | string | เป็น `"Not In DataModel"` เสมอ                  |
| `Size`     | number | ผลรวมของบิตคลิปในกลุ่มนี้                     |
| `Children` | array  | อาร์เรย์ของรายการคลิป (โครงสร้างเดียวกันด้านบน). |

#### ตัวอย่าง

```lua
{
  Name = "AnimationMemory",
  Size = 1048576,
  Children = {
    { Name = "rbxassetid://111", Size = 32768, AssetId = "rbxassetid://111",
      Owners = {
        { Name = "Workspace.Player.Humanoid.Animator", ClassName = "Animator" },
    }},
    { Name = "rbxassetid://444", Size = 65536, AssetId = "rbxassetid://444",
      Owners = {
        { Name = "Workspace.NPC1.Humanoid.Animator", ClassName = "Animator" },
        { Name = "Workspace.NPC2.Humanoid.Animator", ClassName = "Animator" },
    }},
    { Name = "Not In DataModel", Size = 32768, Children = {
        { Name = "rbxassetid://555", Size = 32768, AssetId = "rbxassetid://555",
          Owners = {
            { Name = "Animator", ClassName = "Animator" },
        }},
    }},
  }
}
```


SceneAnalysisService:GetAnimationMemoryAsync

ต้นไม้พจนานุกรมของหน่วยความจำคลิปอนิเมชันที่โหลดแล้ว โดยการทำซ้ำคลิป


คืนค่าหน่วยความจำของสินทรัพย์เสียงที่โหลดแล้ว โดยการทำซ้ำตามหมายเลข ID สินทรัพย์ สินทรัพย์ที่เจ้าของมีพ่อแม่เดียวกันจะถูกจัดระเบียบใต้เส้นทางนั้น —
แบนราบเมื่อมีเด็กคนเดียว และซ้อนเมื่อมีหลายคน สินทรัพย์ที่เจ้าของครอบคลุมพ่อแม่ที่แตกต่างจะปรากฏเป็นรายการที่แชร์พร้อมกับอาร์เรย์ `Owners`.

#### รากของพจนานุกรม

| คีย์        | ประเภท   | คำอธิบาย                                             |
| ---------- | ------ | ------------------------------------------------------- |
| `Name`     | string | เป็น `"AudioMemory"` เสมอ                                 |
| `Size`     | number | หน่วยความจำเสียงที่โหลดทั้งหมดในหน่วยบิต                     |
| `Children` | array  | ผสมจากรายการแบนกลุ่มพ่อแม่ และรายการที่แชร์                |

#### การเข้าถึงสินทรัพย์แบน

จะถูกสร้างเมื่อพ่อแม่มีเด็กเสียงเพียงคนเดียวเท่านั้น.

| คีย์       | ประเภท   | คำอธิบาย                                          |
| --------- | ------ | ---------------------------------------------------- |
| `Name`    | string | เส้นทางอินสแตนซ์เต็ม (เช่น `"Workspace.Map.BGMusic"`). |
| `Size`    | number | หน่วยความจำสินทรัพย์ในหน่วยบิต                                |
| `AssetId` | string | ID ของสินทรัพย์เสียง                                    |

#### กลุ่มพ่อแม่

จะถูกสร้างเมื่อพ่อแม่มีเด็กเสียงหลายคน.

| คีย์        | ประเภท   | คำอธิบาย                                                        |
| ---------- | ------ | ------------------------------------------------------------------ |
| `Name`     | string | เส้นทางพ่อแม่ (เช่น `"Workspace.Map.SFX"`).                          |
| `Size`     | number | ผลรวมของบิตสินทรัพย์เด็ก                                          |
| `Children` | array  | อาร์เรย์ของรายการสินทรัพย์แบน (แต่ละรายการมี `Name`, `Size`, `AssetId`). |

#### รายการสินทรัพย์ที่แชร์

จะถูกสร้างเมื่อเจ้าของสินทรัพย์อยู่ภายใต้พ่อแม่ที่แตกต่าง.

| คีย์       | ประเภท   | คำอธิบาย                                 |
| --------- | ------ | ------------------------------------------- |
| `Name`    | string | หมายเลข ID ของสินทรัพย์.                               |
| `Size`    | number | หน่วยความจำสินทรัพย์ในหน่วยบิต.                      |
| `AssetId` | string | สตริง ID ของสินทรัพย์ (ค่าเดียวกันกับ `Name`). |
| `Owners`  | array  | อาร์เรย์ของรายการเจ้าของ.                     |

#### รายการเจ้าของ

| คีย์         | ประเภท   | คำอธิบาย                                            |
| ----------- | ------ | ------------------------------------------------------ |
| `Name`      | string | เส้นทางอินสแตนซ์เต็ม (เช่น `"Workspace.Zone1.Ambient"`). |
| `ClassName` | string | `"Sound"` หรือ `"AudioPlayer"`.                          |

#### ตัวอย่าง

```lua
{
  Name = "AudioMemory",
  Size = 5242880,
  Children = {
    -- เสียงเดี่ยวภายใต้พ่อแม่เฉพาะ (แบน)
    { Name = "Workspace.Map.BGMusic", Size = 2097152,
      AssetId = "rbxassetid://111" },

    -- เสียงหลายรายการภายใต้พ่อแม่เดียวกัน (กลุ่ม)
    { Name = "Workspace.Map.SFX", Size = 1048576, Children = {
        { Name = "Workspace.Map.SFX.Explosion", Size = 524288, AssetId = "rbxassetid://222" },
        { Name = "Workspace.Map.SFX.Gunshot",   Size = 524288, AssetId = "rbxassetid://333" },
    }},

    -- สินทรัพย์ที่แชร์ (เจ้าของอยู่ในตำแหน่งต่างกัน)
    { Name = "rbxassetid://444", Size = 2097152, AssetId = "rbxassetid://444",
      Owners = {
        { Name = "Workspace.Zone1.Ambient", ClassName = "Sound" },
        { Name = "Workspace.Zone2.Ambient", ClassName = "Sound" },
    }},
  }
}
```


SceneAnalysisService:GetAudioMemoryAsync

ต้นไม้พจนานุกรมของหน่วยความจำสินทรัพย์เสียงที่โหลดแล้ว โดยการทำซ้ำตามหมายเลข
ID สินทรัพย์.


คืนค่าจำนวนอินสแตนซ์ตามหมวดหมู่และคลาสจากต้นไม้ข้อมูลโมเดล
ทำการสแกนทายาทของ Workspace, Players, Lighting, MaterialService,
ReplicatedFirst, ReplicatedStorage, ServerScriptService, ServerStorage,
StarterGui, StarterPack, StarterPlayer, Teams, SoundService, และ
TextChatService แต่ละอินสแตนซ์จะถูกจัดประเภทตามหมวดหมู่
ด้านล่างนี้ตามลำดับชั้นคลาสของมัน

#### รากของพจนานุกรม

| คีย์        | ประเภท   | คำอธิบาย                                       |
| ---------- | ------ | ------------------------------------------------- |
| `Name`     | string | เป็น `"InstanceComposition"` เสมอ                   |
| `Size`     | number | จำนวนอินสแตนซ์รวมทั้งหมดในทุกบริการที่สแกน                  |
| `Children` | array  | อาร์เรย์ของรายการหมวดหมู่.                        |

#### รายการหมวดหมู่

| คีย์        | ประเภท   | คำอธิบาย                       |
| ---------- | ------ | --------------------------------- |
| `Name`     | string | ชื่อหมวดหมู่ (ดูตารางด้านล่าง).  |
| `Size`     | number | จำนวนอินสแตนซ์ทั้งหมดในหมวดหมู่นี้. |
| `Children` | array  | อาร์เรย์ของรายการคลาส.           |

#### รายการคลาส (ใบ)

| คีย์    | ประเภท   | คำอธิบาย                                            |
| ------ | ------ | ------------------------------------------------------ |
| `Name` | string | ชื่อคลาส (เช่น `"Part"`, `"Script"`, `"Frame"`). |
| `Size` | number | จำนวนอินสแตนซ์ของคลาสนี้.                     |

#### หมวดหมู่

| หมวดหมู่           | ประเภทตัวแทน                                                                 |
| ------------------ | ------------------------------------------------------------------------------------ |
| 3D Objects         | BasePart, Model, Camera                                                              |
| Physics            | Attachment, Constraint, JointInstance, WeldConstraint, ControllerManager, SensorBase |
| UI                 | GuiBase, BasePlayerGui, UIBase, ProximityPrompt, ClickDetector, TextChannel          |
| Lights             | Light                                                                                |
| PostProcessing     | PostEffect, Highlight, Atmosphere, Sky, Clouds                                       |
| Scripts            | LuaSourceContainer, BindableEvent, RemoteEvent, RemoteFunction                       |
| Audio              | Sound, SoundEffect, AudioPlayer, Wire, SoundGroup, AudioEmitter                      |
| Animation          | Animator, AnimationController, Animation, KeyframeSequence, IKControl                |
| Values             | ValueBase                                                                            |
| Character          | CharacterAppearance, Humanoid, HumanoidDescription, BaseWrap, FaceControls           |
| Textures           | FaceInstance, SurfaceAppearance, MaterialVariant                                     |
| Meshes             | DataModelMesh                                                                        |
| Particles          | ParticleEmitter, Fire, Trail, Beam, Explosion                                        |
| Services & Storage | Player, Folder, Configuration                                                        |
| Misc               | Tool, Backpack, Team, ForceField, PathfindingModifier, PackageLink, HapticEffect     |
| Unclassified       | สิ่งใดที่ไม่ตรงตามข้างต้น                                                      |

#### ตัวอย่าง

```lua
{
  Name = "InstanceComposition",
  Size = 12450,
  Children = {
    { Name = "3D Objects", Size = 5200, Children = {
        { Name = "Part", Size = 3100 },
        { Name = "MeshPart", Size = 1800 },
        { Name = "Model", Size = 300 },
    }},
    { Name = "UI", Size = 2100, Children = {
        { Name = "Frame", Size = 900 },
        { Name = "TextLabel", Size = 700 },
        { Name = "UIListLayout", Size = 500 },
    }},
  }
}
```


SceneAnalysisService:GetInstanceCompositionAsync

ต้นไม้พจนานุกรมของจำนวนอินสแตนซ์ที่จัดกลุ่มตามหมวดหมู่และชื่อคลาส.


คืนค่าการใช้หน่วยความจำของ Luau VM ต่อสคริปต์ในหน่วยบิต สคริปต์จะถูกจัดกลุ่ม
แรกโดยบริการที่มีอยู่ (ได้มาจากส่วนแรกของเส้นทางจุด) จากนั้นแยกออกเป็น
กลุ่มย่อย `"ModuleScripts"` และ `"Scripts"` ตามประเภทอินสแตนซ์.

#### รากของพจนานุกรม

| คีย์        | ประเภท   | คำอธิบาย                        |
| ---------- | ------ | ---------------------------------- |
| `Name`     | string | เป็น `"ScriptMemory"` เสมอ           |
| `Size`     | number | หน่วยความจำ Luau VM รวมในหน่วยบิต.     |
| `Children` | array  | อาร์เรย์ของรายการหมวดหมู่บริการ. |

#### รายการหมวดหมู่บริการ

| คีย์        | ประเภท   | คำอธิบาย                                                                  |
| ---------- | ------ | ---------------------------------------------------------------------------- |
| `Name`     | string | ชื่อบริการ (เช่น `"ServerScriptService"`, `"ReplicatedStorage"`).          |
| `Size`     | number | ผลรวมของหน่วยความจำทั้งหมดของสคริปต์ในบริการนี้, ในหน่วยบิต.                          |
| `Children` | array  | หนึ่งหรือสองรายการกลุ่มประเภทสคริปต์ (`"ModuleScripts"` และ/หรือ `"Scripts"`). |

#### รายการกลุ่มประเภทสคริปต์

| คีย์        | ประเภท   | คำอธิบาย                                        |
| ---------- | ------ | -------------------------------------------------- |
| `Name`     | string | เป็น `"ModuleScripts"` หรือ `"Scripts"`.           |
| `Size`     | number | ผลรวมของหน่วยความจำสำหรับสคริปต์ในกลุ่มนี้, ในหน่วยบิต. |
| `Children` | array  | อาร์เรย์ของการเข้าถึงสคริปต์แต่ละรายการ.                |

#### รายการสคริปต์ (ใบ)

| คีย์    | ประเภท   | คำอธิบาย                                                            |
| ------ | ------ | ---------------------------------------------------------------------- |
| `Name` | string | เส้นทางจุดถึงสคริปต์ (เช่น `"ServerScriptService.Shared.Utils"`). |
| `Size` | number | หน่วยความจำที่ใช้โดยสคริปต์นี้, ในหน่วยบิต.                             |

#### ตัวอย่าง

```lua
{
  Name = "ScriptMemory",
  Size = 8388608,
  Children = {
    { Name = "ServerScriptService", Size = 524288, Children = {
        { Name = "ModuleScripts", Size = 409600, Children = {
            { Name = "ServerScriptService.Shared.Utils", Size = 204800 },
            { Name = "ServerScriptService.Shared.Config", Size = 204800 },
        }},
        { Name = "Scripts", Size = 114688, Children = {
            { Name = "ServerScriptService.MainScript", Size = 114688 },
        }},
    }},
    { Name = "ReplicatedStorage", Size = 262144, Children = {
        { Name = "ModuleScripts", Size = 262144, Children = {
            { Name = "ReplicatedStorage.SharedModule", Size = 262144 },
        }},
    }},
  }
}
```


SceneAnalysisService:GetScriptMemoryAsync

ต้นไม้พจนานุกรมของหน่วยความจำ Luau VM ต่อสคริปต์ที่จัดกลุ่มตามบริการ
และประเภทสคริปต์.


คืนค่าจำนวนสามเหลี่ยมและการเรียกใช้งานการวาดตามการส่งออก ซึ่งมาจาก
ข้อมูลประสิทธิภาพ `StatsService` แตกต่างจากคำขออื่น ๆ จะใช้พจนานุกรม `Sizes`
(พร้อมกับคีย์ `Triangles` และ `Drawcalls`) แทนที่จะเป็นฟิลด์ `Size` เดียว การส่งออกประเภทการวาดที่มีจำนวนสามเหลี่ยมเป็นศูนย์และไม่  
มีการเรียกใช้งานการวาดจะถูกละเว้น

#### รากของพจนานุกรม

| คีย์        | ประเภท       | คำอธิบาย                                                            |
| ---------- | ---------- | ---------------------------------------------------------------------- |
| `Name`     | string     | เป็น `"TriangleComposition"` เสมอ                                        |
| `Sizes`    | dictionary | `{ Triangles: number, Drawcalls: number }` — ผลรวมทั่วทุกการส่งออก. |
| `Children` | array      | อาร์เรย์ของรายการการส่งออกประเภทการวาด.                                          |

#### รายการการส่งออก (ใบ)

| คีย์     | ประเภท       | คำอธิบาย                                               |
| ------- | ---------- | --------------------------------------------------------- |
| `Name`  | string     | ประเภทการส่งออก (ดูตารางด้านล่าง).                       |
| `Sizes` | dictionary | `{ Triangles: number, Drawcalls: number }` สำหรับการส่งออกนี้. |

#### ประเภทการส่งออก

| ชื่อ               | คำอธิบาย                    |
| ------------------ | ------------------------------ |
| Opaque             | รูปทรงที่ทึบ                    |
| Transparent        | รูปทรงที่โปร่งใส                  |
| Terrain            | ดินแดนที่มีทีวี/เรียบ           |
| Grass              | การตกแต่งหญ้าของดินแดน           |
| UI                 | UI แบบพื้นที่หน้าจอ               |
| Decal              | การเรนเดอร์เดคัล                |
| Cloud              | เมฆที่มีปริมาตร                     |
| GenericPostProcess | การประมวลผลหลังจากทั่วไป        |
| SSAO               | การปิดกั้นที่อยู่ในพื้นที่หน้าจอ |
| DOF                | ความลึกของเขต                   |
| Particles          | ระบบอนุภาค                      |
| Sky                | Skybox                         |
| Shadows            | การเรนเดอร์แผนที่เงา           |
| Undefined          | ไม่มีการจัดประเภท                  |

#### ตัวอย่าง

```lua
{
  Name = "TriangleComposition",
  Sizes = { Triangles = 245000, Drawcalls = 1200 },
  Children = {
    { Name = "Opaque",      Sizes = { Triangles = 180000, Drawcalls = 800 } },
    { Name = "Transparent", Sizes = { Triangles = 25000,  Drawcalls = 150 } },
    { Name = "Shadows",     Sizes = { Triangles = 30000,  Drawcalls = 200 } },
    { Name = "UI",          Sizes = { Triangles = 10000,  Drawcalls = 50  } },
  }
}
```


SceneAnalysisService:GetTriangleCompositionAsync

ต้นไม้พจนานุกรมของจำนวนสามเหลี่ยมและการเรียกใช้งานการวาดที่ถูกแยกตาม
ประเภทการส่งออก.


คืนค่ารายการที่ Luau ถือไว้แต่ไม่อยู่ในโมเดลข้อมูลอีกต่อไป เมื่อจัดกลุ่มตาม
สคริปต์เจ้าบ้าน แต่ละอินสแตนซ์ที่ไม่มีพ่อแม่จะมีการติดตามกลับไปยังสคริปต์ที่
ถือการอ้างอิง.

อินสแตนซ์ที่ไม่มีพ่อแม่ซึ่งถูกทำเครื่องหมายสำหรับการเก็บขยะแต่ยังไม่ได้\นลบจะถูกแสดงเป็นการชั่วคราวด้วยพ่อแม่ `Unknown`. สิ่งนี้เป็นผลลัพธ์จาก
วิธีที่การเก็บขยะตั้งใจให้ทำงานและไม่บ่งบอกถึงปัญหาใดๆ.

#### รากของพจนานุกรม

| คีย์        | ประเภท   | คำอธิบาย                          |
| ---------- | ------ | ------------------------------------ |
| `Name`     | string | เป็น `"UnparentedInstances"` เสมอ      |
| `Size`     | number | จำนวนทั้งหมดของอินสแตนซ์ที่ไม่มีพ่อแม่. |
| `Children` | array  | อาร์เรย์ของรายการสคริปต์เจ้าของ.        |

#### รายการสคริปต์เจ้าของ

| คีย์        | ประเภท   | คำอธิบาย                                                                                 |
| ---------- | ------ | ------------------------------------------------------------------------------------------- |
| `Name`     | string | เส้นทางสคริปต์ (เช่น `"ServerScriptService.Gameplay.Combat"`) หรือ `"(unknown)"` หากไม่สามารถติดตามได้. |
| `Size`     | number | จำนวนของอินสแตนซ์ที่ไม่มีพ่อแม่ที่ถือโดยสคริปต์นี้.                                          |
| `Children` | array  | อาร์เรย์ของรายการคลาส.                                                                     |

#### รายการคลาส (ใบ)

| คีย์    | ประเภท   | คำอธิบาย                                                                  |
| ------ | ------ | ---------------------------------------------------------------------------- |
| `Name` | string | ชื่อคลาสของอินสแตนซ์ที่ไม่มีพ่อแม่ (เช่น `"Part"`, `"Frame"`, `"Sound"`). |
| `Size` | number | จำนวนของอินสแตนซ์ที่ไม่มีพ่อแม่ของคลาสนี้จากสคริปต์เจ้าบ้านนี้.           |

#### ตัวอย่าง

```lua
{
  Name = "UnparentedInstances",
  Size = 47,
  Children = {
    { Name = "ServerScriptService.Gameplay.Combat", Size = 30, Children = {
        { Name = "Part", Size = 22 },
        { Name = "Attachment", Size = 8 },
    }},
    { Name = "(unknown)", Size = 17, Children = {
        { Name = "Frame", Size = 12 },
        { Name = "Sound", Size = 5 },
    }},
  }
}
```


SceneAnalysisService:GetUnparentedInstancesAsync

ต้นไม้พจนานุกรมของอินสแตนซ์ที่ไม่มีพ่อแม่ที่จัดกลุ่มตามสคริปต์เจ้าบ้าน
ที่ถือการอ้างอิง.


SceneAnalysisService

`Instance` เป็นคลาสพื้นฐานสำหรับคลาสทั้งหมดในลำดับชั้นคลาส Roblox
ซึ่งสามารถเป็นส่วนหนึ่งของต้นไม้ `Class.DataModel`.

ไม่สามารถสร้างวัตถุ `Instance` รากโดยตรงได้ แต่สร้างวัตถุผ่านโค้ด
ด้วยคอนสตรัคเตอร์พิเศษ `Datatype.Instance.new()` โดยใช้
ชื่อของคลาสเป็นพารามิเตอร์และส่งคืนวัตถุที่สร้างขึ้น.

แสดงให้เห็นถึงการตรวจจับการเปลี่ยนแปลงในเชิงสืบพรรณของอินสแตนซ์ โดยการเชื่อมต่อกับ
`Class.Instance.AncestryChanged` event.

พารต์ ChangingPart จะถูกตั้งค่า Parent เป็นค่าที่แตกต่างกันในช่วงเวลา พ่อแม่ของ
พารต์ คือบรรพบุรุษของพารต์ ดังนั้น `Class.Instance.AncestryChanged` event
จะถูกเรียกใช้เมื่อมันเปลี่ยนแปลง.

เกิดขึ้นเมื่อมีการเปลี่ยนสถานะของอินสแตนซ์นี้ หรือลูกหลานของมัน.

คุณสามารถใช้เหตุการณ์นี้เพื่อติดตามการลบของอินสแตนซ์ใน Studio,
เช่นการลบด้วยตนเองใน Explorer หรือผ่านโปรแกรมเสริม หากคุณต้องการตรวจจับเมื่อใดที่อินสแตนซ์ถูกทำลายโดยการเรียกใช้ `Class.Instance:Destroy()`,
ให้ใช้เหตุการณ์ `Class.Instance.Destroying` แทน.

Instance.AncestryChanged

child

อินสแตนซ์ที่มีการเปลี่ยนแปลงสมบัติ `Class.Instance.Parent|Parent`, ซึ่งอาจเป็นอินสแตนซ์นี้หรือบรรพบุรุษที่ไกลกว่านี้, **ไม่**จำเป็นต้องเป็นอินสแตนซ์ที่เชื่อมต่ออยู่.

parent

พ่อแม่ใหม่ของพารามิเตอร์ `child`.

เกิดขึ้นเมื่อมีการเปลี่ยนแปลงสมบัติ `Class.Instance.Parent` ของวัตถุหรือบรรพบุรุษของมัน.

เหตุการณ์นี้เกิดขึ้นเมื่อใดก็ตามที่มีการเปลี่ยนแปลงในคุณสมบัติในอินสแตนซ์,
รวมถึงเมื่อมีการตั้งค่าคุณสมบัติให้เป็น `nil`. ชื่อของคุณสมบัติที่มีการเปลี่ยนแปลง
จะถูกส่งไปยังฟังก์ชันที่เชื่อมต่อ.

ตัวอย่างเช่น โค้ดต่อไปนี้เชื่อมต่อฟังก์ชัน `attributeChanged()`
เพื่อให้ทำงานเมื่อมีการเปลี่ยนแปลงในคุณสมบัติต่างๆ ของชิ้นส่วน:

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

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "changed")
end

part.AttributeChanged:Connect(attributeChanged)
```
ดูเพิ่มเติมที่ `Class.Instance:GetAttributeChangedSignal()` ซึ่งจะส่งคืนเหตุการณ์ที่เกิดขึ้นเมื่อคุณสมบัติที่เฉพาะเจาะจงเปลี่ยนแปลง.

Instance.AttributeChanged

attribute

ชื่อของคุณสมบัติที่มีการเปลี่ยนแปลง.

เกิดขึ้นเมื่อใดก็ตามที่มีการเปลี่ยนแปลงในคุณสมบัติของ `Class.Instance`.

โค้ดนี้จะแสดงชื่อของวัตถุเมื่อถูกเพิ่มเข้าไปใน Workspace:

เกิดขึ้นหลังจากที่วัตถุถูกเพิ่มเข้าไปใน `Class.Instance` นี้.

หมายเหตุ ถ้าใช้วิธีนี้บนไคลเอนต์เพื่อตรวจจับวัตถุที่สร้างโดยเซิร์ฟเวอร์
จำเป็นที่จะต้องใช้ `Class.Instance:WaitForChild()` เมื่อต้องการทำดัชนีลูกหลานของวัตถุเหล่านี้ เนื่องจากวัตถุและลูกหลานของมัน
ไม่ได้รับประกันว่าจะถูกทำซ้ำจากเซิร์ฟเวอร์ไปยังไคลเอนต์พร้อมกัน ตัวอย่างเช่น:

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

Workspace.ChildAdded:Connect(function(child)
	-- ใช้ WaitForChild() เนื่องจากลูกหลานอาจยังไม่ถูกทำซ้ำ
	local head = child:WaitForChild("Head")
end)
```
หมายเหตุ เหตุการณ์นี้ทำงานเฉพาะกับลูกหลานโดยตรงของ `Class.Instance` สำหรับเหตุการณ์ที่บันทึกลูกหลานทั้งหมด ให้ใช้ `Class.Instance.DescendantAdded`.

ดูเพิ่มเติมที่ `Class.Instance.ChildRemoved`.

Instance.ChildAdded

อินสแตนซ์ `Class.Instance` ที่ถูกเพิ่ม.

เกิดขึ้นหลังจากที่วัตถุถูกเพิ่มเข้าไปใน `Class.Instance` นี้.

Instance.childAdded

สคริปต์นี้จะแสดงชื่อของวัตถุเมื่อถูกลบออกจาก
Workspace:

เกิดขึ้นหลังจากที่ลูกหลานถูกลบออกจาก `Class.Instance` นี้.

'ได้ถูกลบ' หมายถึงเมื่อพ่อแม่ของวัตถุมีการเปลี่ยนจาก `Class.Instance` นี้เป็นสิ่งอื่นนอกจาก `Class.Instance` นี้ หมายเหตุ เหตุการณ์นี้จะเกิดขึ้นเมื่อมีการทำลายลูกหลานด้วย (การใช้
`Class.Instance:Destroy()`) เนื่องจากฟังก์ชันการทำลายจะตั้งค่าวัตถุให้มีพ่อแม่เป็น `nil`.

เหตุการณ์นี้ทำงานเฉพาะกับลูกหลานโดยตรงของ `Class.Instance` สำหรับเหตุการณ์ที่บันทึกลูกหลานทั้งหมด ให้ใช้ `Class.Instance.DescendantRemoving`.

ดูเพิ่มเติมที่ `Class.Instance.ChildAdded`.

Instance.ChildRemoved

อินสแตนซ์ `Class.Instance` ที่ถูกลบ.

เกิดขึ้นหลังจากที่ลูกหลานถูกลบออกจาก `Class.Instance` นี้.

ตัวอย่างต่อไปนี้จะแสดงชื่อของวัตถุใดๆ ที่ถูกเพิ่มเข้าไปใน
Workspace:

เหตุการณ์นี้เกิดขึ้นหลังจากที่มีการเพิ่มลูกหลานใน `Class.Instance`.

เนื่องจากเหตุการณ์นี้จะเกิดขึ้นสำหรับทุกลูกหลาน การตั้งค่าวัตถุให้เป็นลูกหลานของ `Class.Instance` จะทำให้เกิดเหตุการณ์นี้สำหรับวัตถุและลูกหลานของมันแต่ละตัว.

หากคุณสนใจเฉพาะ **ลูกหลานโดยตรง** ของ `Class.Instance` ให้ใช้ `Class.Instance.ChildAdded` แทน.

ดูเพิ่มเติมที่ `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

เกิดขึ้นหลังจากที่มีการเพิ่มลูกหลานใน `Class.Instance`.

ตัวอย่างต่อไปนี้แสดงผลชื่อของสิ่งที่ถูกลูกหลานเมื่อมันถูกลบออก
จาก Workspace:

เหตุการณ์นี้เกิดขึ้น **โดยทันที** ก่อนที่พ่อแม่ `Class.Instance`
จะมีการเปลี่ยนแปลงเช่นนั้นทำให้ **ลูกหลาน** ของอินสแตนซ์จะไม่เป็นลูกปัจจุบันอีกต่อไป `Class.Instance:Destroy()|Destroy()` จะเปลี่ยน `Class.Instance.Parent|Parent` ของอินสแตนซ์ให้เป็น `nil`, ดังนั้นการเรียกใช้วิธีนี้บนลูกหลานของพ่อแม่จะทำให้เหตุการณ์นี้เกิดขึ้น.

เนื่องจากเหตุการณ์นี้เกิดขึ้น **ก่อน** การลบลูกหลาน พ่อแม่ของลูกหลานจะไม่เปลี่ยนแปลงในช่วงเวลาของเหตุการณ์นี้ หากลูกหลานนั้นเป็น **ลูกโดยตรง** ของพ่อแม่ เหตุการณ์นี้จะเกิดขึ้นก่อน `Class.Instance.ChildRemoved`.

หากลูกหลานมีลูกของมันเอง เหตุการณ์นี้จะเกิดขึ้นเมื่อมีการเริ่มต้นลูกหลานก่อน,
ตามด้วยลูกหลานของมัน.

#### การเตือน

เหตุการณ์นี้จะเกิดขึ้นกับวัตถุลูกหลานที่ถูกลบ.
การตั้งค่า `Class.Instance.Parent|Parent` ของลูกหลานให้เป็นอย่างอื่นจะล้มเหลว ด้านล่างเป็นตัวอย่างที่แสดงสิ่งนี้:

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

Workspace.DescendantRemoving:Connect(function(descendant)
	-- อย่าปรับเปลี่ยนพ่อแม่ของลูกหลานในฟังก์ชันนี้!
	-- เหตุการณ์นี้เกิดขึ้นเพราะว่าพ่อแม่ถูกปรับเปลี่ยน, และการเปลี่ยนแปลงยังเกิดขึ้นไม่ได้
	-- ดังนั้นการเปลี่ยนแปลงพ่อแม่เช่นนี้จึงเป็นเรื่องที่ไม่เหมาะสม:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```
ดูเพิ่มเติมที่ `Class.Instance.DescendantAdded|DescendantAdded`.

Instance.DescendantRemoving

อินสแตนซ์ `Class.Instance` ที่กำลังจะถูกลบ.

เกิดขึ้นโดยทันทีเมื่อมีการลบลูกหลานของ `Class.Instance`.

ตัวอย่างนี้แสดงให้เห็นว่า เมื่อใช้พฤติกรรมของสัญญาณทันที อินสแตนซ์ที่ถูกทำลายจะยังคงอยู่ในตำแหน่งจนกว่าฟังก์ชันที่เชื่อมโยงจะหยุด.

ตัวอย่างนี้แสดงให้เห็นว่าเมื่อใช้พฤติกรรมสัญญาณ Deferred\, อินสแตนซ์
จะถูกทำลายก่อนที่สัญญาณจะถูกเรียกใช้งาน


อินสแตนซ์ `Class.Instance` จะไม่มีวันถูกลบจากหน่วยความจำในขณะที่ฟังก์ชันที่เชื่อมต่อยังใช้งานมันอยู่ อย่างไรก็ตาม หากฟังก์ชันที่เชื่อมต่อนี้ทำให้ระงับที่ใดที่หนึ่ง,
`Class.Instance` และลูกหลานของมันจะถูกตั้งค่าให้พ่อแม่เป็น `nil`.

หากสมบัติ `Class.Workspace.SignalBehavior` ถูกตั้งค่าเป็น `Enum.SignalBehavior.Immediate`, เหตุการณ์นี้จะเกิดขึ้นโดยทันที ก่อนที่
`Class.Instance` หรือบรรพบุรุษของมันจะถูกทำลายด้วย `Class.Instance:Destroy()`.

หากสมบัติ `Class.Workspace.SignalBehavior` ถูกตั้งค่าเป็น `Enum.SignalBehavior.Deferred`, เหตุการณ์นี้จะเกิดขึ้นที่จุดการกลับคืนถัดไป,
ซึ่งจะอยู่หลังจาก `Class.Instance` หรือ มารดาของมันถูกทำลายด้วย `Class.Instance:Destroy()`.

ด้วยพฤติกรรม `Enum.SignalBehavior.Deferred|Deferred`, การเชื่อมต่อสคริปต์เข้ากับเหตุการณ์ `Class.Instance.Destroying` ของมันเองเป็นเรื่องที่น่ากังวล,
เพราะสคริปต์จะถูกทำลายก่อนที่การเรียกกลับจะถูกเรียกใช้ (หมายความว่ามันจะไม่ได้ถูกดำเนินการ).

เมื่อทำการลบ `Class.Instance` ใน Studio เช่นโดยการลบด้วยตนเองผ่าน
[Explorer](/studio/explorer) หรือผ่านปลั๊กอิน,
`Class.Instance` จะไม่ได้ถูกทำลาย. แทนที่จะถูกตั้งค่าเป็น `nil`
ที่คุณสามารถติดตามด้วย `Class.Instance.AncestryChanged`.

Instance.Destroying

เกิดขึ้นทันที (หรือถูกเลื่อนออกไปหลังจาก) ที่อินสแตนซ์ถูกทำลายผ่าน `Class.Instance:Destroy()`.

เหตุการณ์นี้เกิดขึ้นเมื่อมีการเปลี่ยนแปลงในคุณสมบัติสไตล์ใดๆ ของอินสแตนซ์,
รวมถึงเมื่อมีการตั้งค่าคุณสมบัติเป็น `nil`.

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

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

local function stylePropertyChanged()
	print("Styled properties changed")
end

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

Instance.StyledPropertiesChanged

เกิดขึ้นเมื่อมีการเปลี่ยนแปลงในคุณสมัติสไตล์ใดๆ ของอินสแตนซ์ รวมถึงเมื่อมีการตั้งค่าคุณสมบัติเป็น `nil`.

วิธีการนี้นำแท็กไปใช้กับอินสแตนซ์, จะไม่มีผลหากแท็กนั้นถูกนำไปใช้แล้ว.
การเพิ่มแท็กสำเร็จจะส่งสัญญาณที่สร้างโดย
`Class.CollectionService:GetInstanceAddedSignal()` พร้อมแท็กที่กำหนด.

#### คำเตือน

- แท็กของอินสแตนซ์ที่เพิ่มในด้านไคลเอนต์จะถูกลบออกหาก
  เซิร์ฟเวอร์เพิ่มหรือลบแท็กในอินสแตนซ์นั้นในภายหลังเพราะเซิร์ฟเวอร์
  จะทำการจำลองแท็กทั้งหมดและเขียนทับแท็กก่อนหน้า.

- เมื่อแท็กอินสแตนซ์, เป็นเรื่องปกติว่าทรัพยากรบางอย่างจะถูกใช้เพื่อ
  ให้แท็กมีฟังก์ชัน, ตัวอย่างเช่นการเชื่อมต่อเหตุการณ์หรือตาราง.
  เพื่อป้องกันการรั่วไหลของหน่วยความจำ, เป็นความคิดที่ดีที่จะทำความสะอาด
  (ตัดการเชื่อมต่อ, ตั้งค่าเป็น `nil`, เป็นต้น) เมื่อไม่ต้องการใช้งานแล้ว
  สำหรับแท็กนี้. ทำเช่นนี้เมื่อเรียกใช้ `Class.Instance:RemoveTag()`, ทำการ
  `Class.Instance:Destroy()`, หรือในฟังก์ชันที่เชื่อมต่อกับสัญญาณที่ส่งกลับโดย
  `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

นำแท็กไปใช้กับอินสแตนซ์.

ฟังก์ชันลูกส่งคืนอาร์เรย์ของลูกของวัตถุ.

Instance:children

อาร์เรย์ของวัตถุ/อินสแตนซ์ลูก.

ส่งคืนอาร์เรย์ของลูกของวัตถุ.

วิธีการนี้ทำลายลูกทั้งหมดของอินสแตนซ์และทายาท.

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

-- เพิ่มเลเวลเวชิก
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
```
หากคุณไม่ต้องการทำลาย **ทั้งหมด** ลูกและทายาท, ใช้
`Class.Instance:GetChildren()` หรือ `Class.Instance:GetDescendants()` เพื่อ
วนรอบลูก/ทายาทเหล่านั้นและเลือกสิ่งที่จะทำลาย. สำหรับตัวอย่างโค้ด,
โปรดดูโค้ดด้านล่างจะทำลาย `Class.BasePart|BaseParts` ทั้งหมดที่
ลงมาจาก `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

วิธีการนี้ทำลายลูกทั้งหมดของอินสแตนซ์.

แสดงการโคลนโมเดลโดยใช้ `Class.Instance:Clone()`.

`Clone()` สร้างสำเนาของอินสแตนซ์และทายาททั้งหมด,
โดยละเว้นอินสแตนซ์ทั้งหมดที่ไม่ใช่
`Class.Instance.Archivable|Archivable`. สำเนาของอินสแตนซ์รากจะ
ถูกส่งกลับโดยวิธีนี้และคุณสมัติ `Class.Instance.Parent|Parent` จะถูกตั้งเป็น
`nil`. หมายเหตุว่าหากอินสแตนซ์ดังกล่าวถูกตั้งค่า
`Class.Instance.Archivable|Archivable` เป็น `false`, วิธีนี้จะส่งคืน `nil`.

หากคุณสมบัติอ้างอิงเช่น `Class.ObjectValue.Value` ถูกตั้งค่าในอินสแตนซ์ที่ถูกโคลน,
ค่าของคุณสมบัติของการคัดลอกจะขึ้นอยู่กับค่าเดิม:

- หากคุณสมบัติอ้างอิงอ้างถึงอินสแตนซ์ที่ **ถูก** โคลน,
  การคัดลอกจะอ้างถึงการคัดลอก.
- หากคุณสมบัติอ้างอิงอ้างถึงอินสแตนซ์ที่ **ไม่** โคลน,
  ค่าจะถูกเก็บรักษาในคัดลอก.

Instance:Clone

สร้างสำเนาของอินสแตนซ์และทายาททั้งหมด, โดยละเว้นอินสแตนซ์
ที่ไม่ใช่ `Class.Instance.Archivable|Archivable`.

Instance:clone

แสดงให้เห็นถึงการทำลาย Part โดยใช้ฟังก์ชัน `Class.Instance:Destroy()`。

ฟังก์ชันนี้คือวิธีที่ถูกต้องในการกำจัดวัตถุที่ไม่ต้องการอีกต่อไป。


ตั้งค่าคุณสมัติ `Class.Instance.Parent` เป็น `nil`, ล็อค
คุณสมมิ `Class.Instance.Parent`, ตัดการเชื่อมต่อทั้งหมด, และเรียก
`Destroy()` บนลูกทั้งหมด. วิธีการนี้คือวิธีที่ถูกต้องในการกำจัด
วัตถุที่ไม่จำเป็นแล้ว.

การกำจัดวัตถุที่ไม่จำเป็นเป็นสิ่งสำคัญ, เนื่องจากวัตถุและ
การเชื่อมต่อที่ไม่จำเป็นในสถานที่ใช้หน่วยความจำซึ่งสามารถ
นำไปสู่ปัญหาด้านประสิทธิภาพที่รุนแรงเมื่อเวลาผ่านไป.

ในฐานะที่เป็นแนวทางที่ดีหลังจากเรียกใช้ `Destroy()` บนวัตถุ,
ตั้งค่าตัวแปรที่อ้างถึงวัตถุ (หรือลูกหลานของมัน) เป็น `nil`. สิ่งนี้ป้องกันไม่ให้โค้ดของคุณเข้าถึงบางสิ่งเกี่ยวกับวัตถุ.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- อย่าทำสิ่งนี้:
print(part.Name)  --> "Hello, world"
-- ทำเช่นนี้เพื่อป้องกันให้บรรทัดด้านบนไม่ทำงาน:
part = nil
```
เมื่อ `Class.Instance` ถูกทำลายโดยวิธีนี้, จะไม่สามารถใช้ใหม่ได้เพราะว่าคุณสมมิ `Class.Instance.Parent`
ถูกล็อค. เพื่อ **ชั่วคราว** ลบวัตถุแทนการทำลายมัน, ตั้งค่า
`Class.Instance.Parent|Parent` เป็น `nil`. ตัวอย่างเช่น:

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

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
เพื่อทำลายวัตถุหลังจากเวลาที่กำหนด, ใช้
`Class.Debris:AddItem()`.

Instance:Destroy

ตั้งค่าคุณสมัติ `Class.Instance.Parent` เป็น `nil`, ล็อค
คุณสมมิ `Class.Instance.Parent` , ตัดการเชื่อมต่อทั้งหมด, และเรียก
`Destroy()` บนลูกทั้งหมด.

Instance:destroy

ส่งคืนบรรพบุรุษแรกของ `Class.Instance` ซึ่ง
`Class.Instance.Name` มีค่าเท่ากับชื่อที่กำหนด.

วิธีนี้ทำงานไปข้างบน, หมายถึงมันเริ่มที่
`Class.Instance.Parent` ที่ใกล้ที่สุดของอินสแตนซ์และทำงานขึ้นไปยัง
`Class.DataModel`. หากไม่พบบรรพบุรุษที่ตรงกัน, จะส่งคืน `nil`.

โค้ดส่วนลดถัดไปจะค้นหาบรรพบุรุษแรกของวัตถุที่
มีชื่อว่า `Car`.

```
local car = object:FindFirstAncestor("Car")
```
สำหรับรุ่นของวิธีนี้ที่ค้นหาบรรพบุรุษของคลาสเฉพาะ,
โปรดดู `Class.Instance:FindFirstAncestorOfClass()` และ
`Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

ชื่อ `Class.Instance.Name` ที่จะถูกค้นหา.

คลาส `Class.Instance` ที่พบ.

ส่งคืนบรรพบุรุษแรกของ `Class.Instance` ซึ่ง
`Class.Instance.Name` มีค่าเท่ากับชื่อที่กำหนด.

ส่งคืนบรรพบุรุษแรกของ `Class.Instance` ซึ่ง
`Class.Object.ClassName` มีค่าเท่ากับ className ที่กำหนด.

วิธีนี้ทำงานไปข้างบน, หมายถึงมันเริ่มที่
`Class.Instance.Parent` ที่ใกล้ที่สุดและทำงานขึ้นไปยัง
`Class.DataModel`. หากไม่พบบรรพบุรุษที่ตรงกัน, จะส่งคืน `nil`.

การใช้งานทั่วไปของวิธีนี้คือการค้นหา `Class.Model` ที่
`Class.BasePart` เป็นของ. เช่น:

```
local model = part:FindFirstAncestorOfClass("Model")
```
วิธีนี้เป็นรูปแบบหนึ่งของ `Class.Instance:FindFirstAncestor()`
ที่ตรวจสอบคุณสมบัติ `Class.Object.ClassName` แทนที่จะใช้
`Class.Instance.Name`. `Class.Instance:FindFirstAncestorWhichIsA()` ยังมี,
โดยใช้วิธี `Class.Object:IsA()` แทนเพื่อให้เคารพการสืบทอดคลาส.

Instance:FindFirstAncestorOfClass

className

ชื่อ `Class.Object.ClassName` ที่จะถูกค้นหา.

ส่งคืนบรรพบุรุษแรกของ `Class.Instance` ซึ่ง
`Class.Object.ClassName` มีค่าเท่ากับ className ที่กำหนด.

ส่งคืนบรรพบุรุษแรกของ `Class.Instance` ซึ่ง
`Class.Object:IsA()` ส่งคืน true สำหรับ className ที่กำหนด.

วิธีนี้ทำงานไปข้างบน, หมายถึงมันเริ่มที่
`Class.Instance.Parent` ที่ใกล้ที่สุดของอินสแตนซ์และทำงานขึ้นไปยัง
`Class.DataModel`. หากไม่พบบรรพบุรุษที่ตรงกัน, จะส่งคืน `nil`.

แตกต่างจาก `Class.Instance:FindFirstAncestorOfClass()`, วิธีนี้ใช้
`Class.Object:IsA()` ซึ่งเคารพการสืบทอดของคลาส. ตัวอย่าง:

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
ดังนั้นโค้ดส่วนลดต่อไปนี้จะส่งคืนบรรพบุรุษแรก
`Class.BasePart`, ไม่ว่าจะเป็น `Class.WedgePart`,
`Class.MeshPart` หรือ `Class.Part`.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```
ดูด้วย `Class.Instance:FindFirstAncestor()`.

Instance:FindFirstAncestorWhichIsA

ส่งคืนบรรพบุรุษแรกของ `Class.Instance` ซึ่ง
`Class.Object:IsA()` ส่งคืน true สำหรับ className ที่กำหนด.

ด้านล่างนี้จะค้นหาใน Workspace สำหรับวัตถุชื่อ "Brick" หากพบ,
จะเปลี่ยนชื่อของวัตถุเป็น "Foo".

ส่งคืนลูกแรกของ `Class.Instance` ที่มีชื่อที่กำหนด, หรือ
`nil` ถ้าไม่มีลูกดังกล่าวอยู่. หากพารามิเตอร์ `recursive` เป็น
`true`, วิธีนี้ค้นหาทายาททั้งหมดแทนที่จะเป็นเพียงลูกทันทีของ `Class.Instance`.

#### ตรวจสอบการมีอยู่ของวัตถุ

`FindFirstChild()` เป็นสิ่งจำเป็นหากคุณต้องการตรวจสอบว่าวัตถุมีอยู่
ก่อนที่จะดำเนินการต่อ. การพยายามระบุลูกตามชื่อโดยใช้โอเปอเรเตอร์จุดจะเกิดข้อผิดพลาดหากลูกไม่มีอยู่.

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

-- บรรทัดถัดไปจะเกิดข้อผิดพลาดหากส่วนไม่มีอยู่ในเวิร์กสเปซ
Workspace.Part.Transparency = 0.5
```
วิธีที่ดีกว่าคือการใช้ `FindFirstChild()` เพื่อตรวจสอบ `Part` ก่อน,
จากนั้นใช้คำสั่ง `if` เพื่อรันโค้ดที่ต้องการมัน.

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

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

#### การค้นหาลูกที่มีชื่อที่ตรงกันกับคุณสมบัติ

บางครั้ง `Class.Instance.Name|Name` ของวัตถุมีชื่อเดียวกันกับ
คุณสมบัติของ `Class.Instance.Parent|Parent` ของมัน. เมื่อใช้โอเปอเรเตอร์จุด,
คุณสมบัติจะมีความสำคัญเหนือกว่าลูกหากมีชื่อเดียวกัน.

ในตัวอย่างต่อไปนี้, `Class.Folder` ที่เรียกว่า `Color` ถูกเพิ่มไปยัง
`Class.Part`, ซึ่งยังมีคุณสมบัติ `Class.Part.Color`. โปรดสังเกตว่า
`part.Color` อ้างอิงไปยังค่าคุณสมบัติ `Datatype.Color3`, ไม่ใช่
to `Class.Folder` ลูก. ข้อดีของการใช้
`Class.Instance:FindFirstChild()|FindFirstChild()` คือการนำเสนอของ
คุณสมบัติใหม่ไม่ได้เป็นความเสี่ยงในโค้ดของคุณ.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- คุณสมบัติ
local c2 = part:FindFirstChild("Color")  -- โฟลเดอร์ลูก
```

#### หมายเหตุด้านประสิทธิภาพ

`Class.Instance:FindFirstChild()|FindFirstChild()` ใช้เวลาประมาณ 20% นานกว่าการใช้โอเปอเรเตอร์จุด
และเกือบ 8 เท่าของระยะเวลาที่ต้องการเพียงแค่เก็บอ้างอิงไปยังวัตถุ.
ดังนั้น, คุณควรหลีกเลี่ยงการเรียกใช้ในโค้ดที่ขึ้นอยู่กับประสิทธิภาพเช่นในลูปแน่นหรือฟังก์ชัน
ที่เชื่อมต่อกับ `Class.RunService.Heartbeat` และ `Class.RunService.PreRender`. แทน, ขอแนะนำให้เก็บผลลัพธ์ในตัวแปร,
หรือพิจารณาใช้ `Class.Instance.ChildAdded|ChildAdded` หรือ
`Class.Instance:WaitForChild()|WaitForChild()` เพื่อตรวจจับเมื่อเด็กของ
ชื่อที่กำหนดพร้อมใช้งาน.

Instance:FindFirstChild

recursive

ว่า การค้นหาควรดำเนินการแบบ recursive หรือไม่.

ส่งคืนลูกแรกของ `Class.Instance` ที่ถูกพบที่มีชื่อที่กำหนด.

Instance:findFirstChild

ส่งคืนลูกแรกของ `Class.Instance` ที่มี
`Class.Object.ClassName|ClassName` เท่ากับ `className` ที่กำหนด.
แตกต่างจาก `Class.Instance:FindFirstChildWhichIsA()`, วิธีนี้จะส่งคืน
วัตถุที่มีคลาสตรงตาม `className`, ไม่สนใจการสืบทอดคลาส. หากไม่พบลูก
ที่ตรงกัน, วิธีนี้จะส่งคืน `nil`.

Instance:FindFirstChildOfClass

ส่งคืนลูกแรกของ `Class.Instance` ที่มี
`Class.Object.ClassName|ClassName` เท่ากับชื่อคลาสที่กำหนด.

ส่งคืนลูกแรกของ `Class.Instance` ที่มี
`Class.Object:IsA()` ส่งคืน true สำหรับ className ที่กำหนด.

หากไม่พบลูกที่ตรงกัน, วิธีนี้จะส่งคืน `nil`. หากพารามิเตอร์
recursive เป็น true, วิธีนี้ค้นหาทายาททั้งหมดแทนที่จะเป็นเพียงลูกตรงๆ ของ `Class.Instance`.

แตกต่างจาก `Class.Instance:FindFirstChildOfClass()`, วิธีนี้ใช้
`Class.Object:IsA()` ซึ่งเคารพการสืบทอดคลาส. ตัวอย่าง:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
ดังนั้นโค้ดส่วนลดต่อไปนี้จะส่งคืนลูกแรก
`Class.BasePart`, ไม่ว่าจะเป็น `Class.WedgePart`,
`Class.MeshPart` หรือ `Class.Part`.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```
นักพัฒนาที่กำลังมองหาลูกตามชื่อควรใช้
`Class.Instance:FindFirstChild()` แทน.

Instance:FindFirstChildWhichIsA

ส่งคืนลูกแรกของ `Class.Instance` ที่มี
`Class.Object:IsA()` ส่งคืน true สำหรับ className ที่กำหนด.

ส่งคืนทายาทแรกที่ถูกพบที่มี `Class.Instance.Name` ที่กำหนด.

วิธีนี้ถูกปิดใช้งานและไม่สามารถนำมาใช้ได้. เพื่อค้นหาทายาทแรก
ของอินสแตนซ์, ขอแนะนำให้ใช้พารามิเตอร์ `recursive` บน
`Class.Instance:FindFirstChild()` แทน.

Instance:FindFirstDescendant

ชื่อ `Class.Instance.Name` ที่ค้นหา.

ส่งคืนทายาทแรกที่ถูกพบที่มี `Class.Instance.Name` ที่กำหนด.

หาก `Class.Instance` เป็น `Class.Actor`, จะส่งคืน `Class.Actor` เอง. มิฉะนั้น, บรรพบุรุษที่ใกล้ที่สุดของมันจะถูกส่งคืน. หากไม่มี
บรรพบุรุษเป็น `Class.Actor`, ผลลัพธ์คือ `nil`.

Instance:GetActor

คลาส `Class.Actor` ที่พบ.

ส่งคืน `Class.Actor` ที่เกี่ยวข้องกับอินสแตนซ์, หากมี.

วิธีการนี้ส่งคืนค่าที่ถูกกำหนดให้กับชื่อ
คุณสมบัติที่กำหนด. หากยังไม่มีคุณสมบัติถูกกำหนด, จะส่งคืน `nil`.

ตัวอย่างเช่น, โค้ดด้านล่างตั้งค่าและจากนั้นอ่านค่าของ
คุณสมบัติ `InitialPosition` ของอินสแตนซ์:

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

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

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

#### ดูเพิ่มเติม

- `Class.Instance:SetAttribute()` ซึ่งตั้งค่าคุณสมบัติด้วยชื่อที่กำหนด
  เป็นค่าที่กำหนด.
- `Class.Instance:GetAttributes()` ซึ่งส่งคืนพจนานุกรมของคีย์-ค่า
  คู่สำหรับแต่ละคุณสมบัติของอินสแตนซ์.

Instance:GetAttribute

ชื่อของคุณสมบัติที่ถูกเรียกคืน.

ค่าที่ถูกกำหนดให้กับชื่อคุณสมบัติที่กำหนด. หากยังไม่มี
คุณสมบัติถูกกำหนด, จะส่งคืน `nil`.

ส่งคืนค่าที่ถูกกำหนดให้กับชื่อคุณสมบัติที่กำหนด.

วิธีการนี้ส่งคืนเหตุการณ์ที่ทำงานคล้ายกับ
เหตุการณ์ `Class.Object.Changed|Changed`, เว้นแต่จะเกิดขึ้นเฉพาะเมื่อ
คุณสมบัติที่กำหนดเปลี่ยนแปลง; มีความคล้ายคลึงกันกับ
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` แต่
สำหรับคุณสมบัติ.

โดยทั่วไปแล้ว, มันเป็นความคิดที่ดีที่จะใช้วิธีนี้แทนการเชื่อมต่อ
กับ `Class.Object.Changed|Changed` ด้วยฟังก์ชันที่ตรวจสอบชื่อคุณสมบัติ.
การเรียกใช้ในครั้งถัดไปให้กับวิธีนี้บนวัตถุที่เหมือนกันด้วยชื่อคุณสมบัติที่เหมือนกันจะส่งคืนเหตุการณ์เดียวกัน.

ตัวอย่างโค้ดด้านล่างจะส่งคืนสัญญาณที่ส่ง
ฟังก์ชัน `attributeChanged()` เมื่อคุณสมบัติ `InitialPosition`
ของส่วนเปลี่ยนแปลง:

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

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

local function attributeChanged()
	print("Attribute changed")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```
ดูด้วย `Class.Instance.AttributeChanged` ซึ่งจะถูกเรียกทุกครั้งที่มีการเปลี่ยนแปลงคุณสมบัติใดๆ
บนอินสแตนซ์.

Instance:GetAttributeChangedSignal

ชื่อของคุณสมบัติที่ระบุซึ่งการสัญญาณการเปลี่ยนแปลงกำลังถูกส่งคืน.

เหตุการณ์ที่เกิดขึ้นเมื่อคุณสมบัติที่กำหนดเปลี่ยนแปลง.

ส่งคืนเหตุการณ์ที่ถูกเรียกใช้เมื่อมีการเปลี่ยนแปลงคุณสมบัติที่กำหนด.

วิธีการนี้ส่งคืนพจนานุกรมของคีย์-ค่าคู่สำหรับแต่ละคุณสมบัติ
ซึ่งคีย์คือชื่อของคุณสมบัติและค่าคือค่าที่ไม่เป็น `nil`.

ตัวอย่าง, โค้ดต่อไปนี้จะแสดงคุณสมบัติ
ของอินสแตนซ์และค่าของมัน:

```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
```
ดูด้วย `Class.Instance:GetAttribute()` ซึ่งส่งคืนค่าที่ได้รับ
การกำหนดให้กับชื่อคุณสมบัติที่กำหนด.

Instance:GetAttributes

พจนานุกรมของคู่ค่าจริงสำหรับแต่ละคุณสมบัติซึ่ง
สายอักขระคือชื่อของคุณสมบัติและเวอร์จินเป็นค่าที่ไม่เป็น `nil`.

ส่งคืนพจนานุกรมของคุณสมบัติของอินสแตนซ์.

ด้านล่างนี้จะแสดงชื่อของวัตถุทั้งหมดที่อยู่ใน Workspace ขณะทำการรัน

ส่งคืนอาร์เรย์ (ตารางที่มีดัชนีตัวเลข) ที่ประกอบไปด้วยลูกทั้งหมด
ของอินสแตนซ์โดยตรง, หรือ `Class.Instance` ทุกตัวที่
`Class.Instance.Parent|Parent` เท่ากับวัตถุ. อาร์เรย์สามารถวนรอบได้ด้วยการใช้ลูปเชิงตัวเลขหรือทั่วไป:

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

-- ตัวอย่างลูปเชิงตัวเลข
local children = Workspace:GetChildren()
for i = 1, #children do
	local child = children[i]
	print(child.Name .. " is child number " .. i)
end
```

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

-- ตัวอย่างลูปทั่วไป
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " is child number " .. i)
end
```
โปรดทราบว่าอาร์เรย์ที่ส่งคืน **ไม่ได้** ถูกจัดเรียงในลำดับใด ๆ,
ดังนั้นการจัดเรียงด้วยตนเอง (เช่นใช้ `Library.table.sort()`) ถือว่าเป็นการแนะนำในการ
จัดเรียงเด็กที่ส่งคืนโดยวิธีนี้.

ดูด้วยวิธี `Class.Instance:GetDescendants()|GetDescendants()`.

Instance:GetChildren

อาร์เรย์ที่ประกอบไปด้วยเด็กของอินสแตนซ์.

ส่งคืนอาร์เรย์ซึ่งประกอบไปด้วยลูกทั้งหมดของอินสแตนซ์.

Instance:getChildren

ส่งคืนสตริงรหัสของหมายเลขดีบักที่ใช้ภายในโดย Roblox. หมายเหตุว่า:

- รายการนี้ถูกป้องกัน. การพยายามใช้ใน `Class.Script` หรือ
  `Class.LocalScript` จะก่อให้เกิดข้อผิดพลาด.
- หมายเลขดีบักคือหมายเลขที่ใช้ในกระบวนการดีบัก.
  มันช่วยให้ดีบักเกอร์สามารถอ่านแต่ละคำแนะนำก่อนที่แอปพลิเคชันจะทำการประมวลผลมัน.
  วัตถุทั้งหมดใน Roblox ทำงานเหมือนกระบวนการและแต่ละรันคำแนะนำ (หรือ 'โค้ด')
  ที่สามารถดีบักได้หากจำเป็น.
- สิ่งนี้อาจเป็นประโยชน์สำหรับปลั๊กอินที่ต้องการแยกแยะวัตถุที่คล้ายกันกัน (เช่น วัตถุที่มีชื่อเดียวกัน).

Instance:GetDebugId

scopeLength

ความยาวของขอบเขต.

ส่งคืนสตริงรหัสของหมายเลขดีบักที่ใช้ภายในโดย Roblox.

GetDescendants มักถูกใช้เพื่อทำสิ่งต่าง ๆ กับทายาททั้งหมดที่เป็น
ประเภทของวัตถุที่เฉพาะเจาะจง โค้ดในตัวอย่างนี้ใช้ GetDescendants และ
`Class.Instance:IsA()` เพื่อหาเนื้อหาทั้งหมดใน Workspace และเปลี่ยน
ให้เป็นสีเขียว.

วิธีการนี้ส่งคืนอาร์เรย์ที่ประกอบด้วยทายาททั้งหมดยกเว้น
จากนั้น ร่วมถึงเด็กทุกคนของเด็ก, และเช่นนั้น.

โปรดทราบว่าอาร์เรย์ที่ส่งคืน **ไม่ได้** ถูกจัดเรียงในลำดับใด ๆ,
ดังนั้นการจัดเรียงด้วยตนเอง (เช่นใช้ `Library.table.sort()`) ถือว่าเป็นการแนะนำในการ
จัดเรียงทายาทที่ส่งคืนโดยวิธีนี้. อีกทั้งพิจารณา
วิธีการ `Class.Instance:QueryDescendants()|QueryDescendants()` เพื่อตรวจสอบทายาท
ผ่านการรวมกันของตัวเลือกและคู่บันทึก.

Instance:GetDescendants

อาร์เรย์ที่ประกอบด้วยทายาทของอินสแตนซ์.

ส่งคืนอาร์เรย์ซึ่งประกอบด้วยทายาททั้งหมดของอินสแตนซ์.

ตัวอย่างโค้ดนี้แสดงพฤติกรรมของ `Class.Instance:GetFullName()`.
มันแสดงให้เห็นว่าฟังก์ชันทำงานอย่างไรเมื่อถูกเรียกใช้บนวัตถุที่ไม่อยู่ใน
โครงสร้าง `DataModel` และยังแสดงให้เห็นว่าค่าที่ส่งกลับไม่หลบ
อักขระพิเศษ.

ตัวอย่างโค้ดนี้นำเสนอการทำงานของฟังก์ชัน `Class.Instance:GetFullName()` ใหม่ใน
Lua.

ส่งคืนสตริงที่อธิบายถึงต้นกำเนิดของอินสแตนซ์. สตริงคือการ
เชื่อมต่อของ `Class.Instance.Name|Name` ของวัตถุและบรรพบุรุษของมัน,
แยกโดยจุด. `Class.DataModel` (`game`) ไม่ถูกนำมาพิจารณา. ตัวอย่างเช่น, `Class.Part`
ใน `Class.Workspace` อาจส่งคืน `Class.Workspace.Part`.

เมื่อเรียกใช้ใน `Class.Instance` ที่ไม่ใช่ทายาทของ
`Class.DataModel`, วิธีนี้จะพิจารณาบรรพบุรุษทั้งหมดจนถึงและรวมถึง
บรรพบุรุษที่สูงที่สุดที่ไม่มี `Class.Instance.Parent|Parent`.

วิธีนี้มีประโยชน์สำหรับการบันทึกและการดีบัก. ไม่ควรพยายามที่จะ
วิเคราะห์สตริงที่ส่งคืนเพื่อใช้ในทางที่เป็นประโยชน์ใด ๆ; วิธีนี้ไม่ได้
หลีกเลี่ยงจุด (หรืออักขระอื่น ๆ) ในชื่อของวัตถุ. กล่าวอีกนัยหนึ่ง,
ถึงแม้ว่าผลลัพธ์ของมันมักถูกมองว่าเป็นตัวระบุ Luau ที่ถูกต้อง, แต่มันไม่รับประกันได้.

Instance:GetFullName

ชื่อเต็มของ `Class.Instance`.

ส่งคืนสตริงที่อธิบายถึงต้นกำเนิดของอินสแตนซ์.

วิธีการนี้ส่งคืนค่าที่ถูกจัดรูปแบบหรือแก้ไขอย่างชัดเจนของคุณสมบัติที่กำหนด,
หรือค่าดีพอถ้ายังไม่ได้มีการจัดรูปแบบ/แก้ไข. วิธีนี้มีความแตกต่างเล็กน้อยจากการเข้าถึงค่าคุณสมบัติ
โดยตรง, เช่น `[GuiObject].Rotation`, ซึ่งส่งคืนค่าดีฟอลต์หรือค่าส่งออกที่แก้ไขของคุณสมบัติ.

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

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

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

-- การอ้างถึงปุ่ม
local button = HUDContainer:FindFirstChildWhichIsA("TextButton")

print(button:GetStyled("Rotation")) --> 0 (ค่าดีฟอลต์)
print(button.Rotation) --> 0 (ค่าดีฟอลต์)

-- ใช้การหมุนผ่านคุณสมบัติของกฎ
rule:SetProperty("Rotation", 30)

print(button:GetStyled("Rotation")) --> 30 (ค่าส่งออกที่จัดรูปแบบจากกฎ)
print(button.Rotation) --> 0 (ค่าดีฟอลต์)

-- แก้ไข/แทนที่คุณสมบัติที่จัดรูปแบบ
button.Rotation = 45

print(button:GetStyled("Rotation")) --> 45 (ค่าที่แก้ไข)
print(button.Rotation) --> 45 (ค่าที่แก้ไข)
```

Instance:GetStyled

ชื่อของคุณสมบัติที่ต้องการค้นหา.

selector

ตัวเลือกพิเศษสำหรับข้อมูลเทียมที่คุณตั้งใจจะตั้งค่าวัตถุ.

ค่าที่ถูกจัดรูปแบบหรือแก้ไขอย่างชัดเจนของคุณสมบัติที่กำหนด, หรือ
ค่าดีพอถ้ายังไม่ได้มีการจัดรูปแบบ/แก้ไข.

ส่งคืนค่าที่ถูกจัดรูปแบบหรือแก้ไขอย่างชัดเจนของคุณสมบัติที่กำหนด,
หรือค่าดีพอถ้ายังไม่ได้มีการจัดรูปแบบ/แก้ไข.

วิธีการนี้ส่งคืนเหตุการณ์ที่ทำงานคล้ายกับ
เหตุการณ์ `Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged`
ยกเว้นว่ามันเกิดขึ้นเฉพาะเมื่อไม่มีการเปลี่ยนแปลงคุณสมบัตินั้น. มัน
เป็นความคิดที่ดีที่จะใช้วิธีนี้แทนการเชื่อมต่อไปยัง
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` พร้อมฟังก์ชันที่ตรวจสอบชื่อคุณสมบัติ.
การเรียกใช้การตั้งใหม่กับวิธีนี้บนวัตถุเดียวกันด้วยชื่อคุณสมบัติเดียวกันจะส่งคืนเหตุการณ์เดียวกัน.

โปรดทราบว่าเหตุการณ์นี้จะไม่ส่งอาร์กิวเมนต์ใด ๆ ให้กับฟังก์ชันที่เชื่อมต่อ,
ดังนั้นค่าของคุณสมบัติที่เปลี่ยนแปลงต้องถูกอ่านโดยตรงภายใน
สคริปต์.

```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("Style property changed!")
end

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

Instance:GetStyledPropertyChangedSignal

property

ชื่อของคุณสมบัติที่ต้องการฟังการเปลี่ยนแปลง.

วิธีการนี้ส่งคืนอาร์เรย์ของแท็กที่นำไปใช้กับอินสแตนซ์ที่กำหนด,
ในรูปแบบสตริง. คุณสามารถเพิ่มแท็กได้ทั้งใน Studio ในหน้าต่าง
[Properties](/studio/properties) หรือในขณะทำงานด้วย
`Class.Instance:AddTag()|AddTag()`.

วิธีการนี้มีประโยชน์เมื่อคุณต้องการทำบางอย่างกับแท็กหลายรายการ
บนอินสแตนซ์ในครั้งเดียว. อย่างไรก็ตาม, การใช้วิธีนี้เพื่อตรวจสอบ
การมีอยู่ของแท็กเดียวไม่ค่อยมีประสิทธิภาพ; แทน, ใช้
`Class.Instance:HasTag()|HasTag()` เพื่อตรวจสอบแท็กเฉพาะ.

Instance:GetTags

รับอาร์เรย์ของแท็กทั้งหมดที่นำไปใช้กับอินสแตนซ์.

วิธีการนี้ส่งคืน `true` หากแท็กที่ให้ไว้ถูกเพิ่มลงใน
วัตถุ. คุณสามารถเพิ่มแท็กได้ทั้งใน Studio ในหน้าต่าง
[Properties](/studio/properties) หรือในขณะทำงานด้วย
`Class.Instance:AddTag()|AddTag()`.

Instance:HasTag

ตรวจสอบว่าอินสแตนซ์มีแท็กที่กำหนดหรือไม่.

สาธิตการกำหนดว่าตัวอย่างหนึ่งเป็นบรรพบุรุษของอีกตัวอย่างหนึ่งหรือไม่ด้วย
`Class.Instance:IsAncestorOf()`

Workspace และ SpawnLocation เป็นบรรพบุรุษของ decal ของ SpawnLocation.
Workspace เป็นบรรพบุรุษของ SpawnLocation.

SpawnLocation และ decal ของมันเป็นลูกหลานของ Workspace ไม่ใช่บรรพบุรุษ.
Decal เป็นลูกหลานของ SpawnLocation ไม่ใช่บรรพบุรุษ.


ส่งคืน true หาก `Class.Instance` เป็นบรรพบุรุษของเด็กที่กำหนด.

`Class.Instance` จะถูกพิจารณาว่าเป็นบรรพบุรุษของวัตถุ
หาก `Class.Instance.Parent` ของวัตถุหรืออาจจะเป็น
`Class.Instance.Parent` ของพ่อแม่ของมันถูกตั้งค่าเป็น `Class.Instance`.

ดูเพิ่มเติม, `Class.Instance:IsDescendantOf()`.

Instance:IsAncestorOf

อินสแตนซ์ลูก `Class.Instance`.

จริงถ้ากลุ่ม `Class.Instance` เป็นบรรพบุรุษของเด็กที่กำหนด.

ส่งคืน true หาก `Class.Instance` เป็นบรรพบุรุษของเด็กที่กำหนด.

ส่งคืน `true` หาก `Class.Instance` เป็นทายาทของบรรพบุรุษที่กำหนด.

โปรดทราบว่า `IsDescendantOf()` ไม่สามารถใช้กับพารามิเตอร์ `nil`
เพื่อตรวจสอบว่าวัตถุได้ถูกลบ.

ดูเพิ่มเติม `Class.Instance:IsAncestorOf()`.

Instance:IsDescendantOf

ancestor

บรรพบุรุษ `Class.Instance`.

จริงถ้ากลุ่ม `Class.Instance` เป็นทายาทของบรรพบุรุษที่กำหนด.

ส่งคืน `true` หาก `Class.Instance` เป็นทายาทของบรรพบุรุษที่กำหนด.

Instance:isDescendantOf

วิธีการนี้แสดงให้เห็นว่าคุณสมบัติที่เฉพาะเจาะจงถูกแก้ไขจาก
ค่าที่ตั้งตามรหัส. หากเรียกใช้งานบนอินสแตนซ์ที่สร้างใหม่ผ่าน
โค้ด (`Datatype.Instance.new()`), วิธีนี้จะส่งคืน `false`. หากเรียกใช้
บนวัตถุที่สร้างใหม่โดยกระบวนการ Studio เช่น
การแทรกในหน้าต่าง [Explorer](/studio/explorer), ผลลัพธ์อาจแตกต่างกัน.

ตัวอย่างเช่น, การถามหา
`Class.TextLabel.BackgroundColor3|BackgroundColor3`
ของ `Class.TextLabel` ที่ถูกแทรกผ่านหน้าต่าง [Explorer](/studio/explorer)
จะส่งคืน `true`, แต่การถามหาในคุณสมบัติเดียวกันของ `Class.TextLabel`
ที่สร้างโดยใช้ `Datatype.Instance.new()` จะส่งคืน `false`, หากไม่มี
การเปลี่ยนแปลงอื่นใน `Class.TextLabel.BackgroundColor3|BackgroundColor3`.

หมายเหตุว่าวิธีนี้ส่งคืนผลลัพธ์ที่มีประโยชน์เฉพาะสำหรับบริการและ
อินสแตนซ์ที่สร้างขึ้นโดยผู้ใช้. ค่าที่ส่งกลับสำหรับคุณสมบัติที่สร้างขึ้นโดยระบบของ
อินสแตนซ์เช่น `Class.PackageLink` เป็นแบบพฤติกรรมที่ไม่แน่นอน.

นอกจากนี้ยังหมายเหตุว่าวิธีนี้ส่งคืน `true`, การสไตล์จะ **ไม่**
มีผลต่อคุณสมบัติเนื่องจากการแก้ไขคุณสมบัติโดยตรงจะมีลำดับความสำคัญเหนือ
การจัดรูปแบบ. เพื่อรีเซ็ตคุณสมบัติเพื่อให้กลับเป็นค่าที่ตั้งตามรหัสและอนุญาตให้
จัดรูปแบบไว้บนมัน, ให้ใช้
`Class.Instance:ResetPropertyToDefault()|ResetPropertyToDefault()`.

Instance:IsPropertyModified

ชื่อของคุณสมบัติที่ต้องการตรวจสอบ.

boolean ที่บ่งบอกว่าคุณสมบัตินั้นได้รับการแก้ไขจาก
ค่าที่ตั้งตามรหัส.

ส่งคืน `true` หากค่าที่จัดเก็บในคุณสมบัติที่กำหนดไม่เท่ากับ
ค่าดึงการตั้งค่าตามรหัส.

วิธีของวัตถุนี้ส่งกลับอาร์เรย์ที่มีบุตรทั้งหมดของวัตถุ
ที่ตรงกับ `selector` string ที่ให้ไว้ `selector` สามารถรวม
การเลือกหลายตัวและการรวมเพื่อจับคู่ลักษณะเช่นชื่อคลาส,
ชื่ออินสแตนซ์, และความสัมพันธ์ที่เป็นลำดับชั้น, รวมถึง
ค่าที่เฉพาะเจาะจงของคุณสมบัติและแอตทริบิวต์ของอินสแตนซ์.
ไวยากรณ์ของ `selector` มีลักษณะคล้ายกับที่ใช้ใน `Class.StyleRule`,
โดยมีเพียงไม่กี่ความแตกต่างเกี่ยวกับส่วนใดของไวยากรณ์
ที่ได้รับการสนับสนุนหรือไม่.

#### การเลือก

- `ClassName` — จับคู่กับอินสแตนซ์ของคลาสที่กำหนดไว้ใน
  ความสัมพันธ์ `Class.Object:IsA()`.
- `.Tag` — จับคู่กับอินสแตนซ์ที่ถูกติดแท็กด้วยแท็ก
  ของ `Class.CollectionService`.
- `#Name` — จับคู่กับอินสแตนซ์ของ `Class.Instance.Name`
  ที่เฉพาะเจาะจง.
- `[property = value]` — จับคู่กับอินสแตนซ์ที่มีคุณสมบัติ
  ที่กำหนดและคุณสมบัตินั้นมีค่าที่กำหนด. ค่าบูลีน,
  ตัวเลข, และสตริงได้รับการสนับสนุน. ตัวอักษร, ตัวเลข,
  `_`, และ `-` สามารถใช้ได้โดยไม่ต้องใส่ค่าในเครื่องหมาย
  อัญประกาศ.
- `[$attribute]` — จับคู่กับอินสแตนซ์ที่มี
  [แอตทริบิวต์](/studio/properties#instance-attributes) ที่กำหนดไว้.
- `[$attribute = value]` — จับคู่กับอินสแตนซ์ที่มี
  แอตทริบิวต์ที่กำหนด **และ** แอตทริบิวต์นั้นมีค่าที่กำหนด.
  ข้อจำกัดเดียวกันนี้ใช้กับการเลือกคุณสมบัติ. หากต้องการตรวจสอบ
  การไม่มีแอตทริบิวต์, อย่าคิวรีเป็น `nil`; ให้ใช้
  คลาสพิเศษ `:not` เช่น `:not([$attribute])`.

การเลือกสามารถรวมกันได้. ตัวอย่างเช่น,
`Model.Apple[$Variety = Fuji][$Flavor = 4]` จะจับคู่กับอินสแตนซ์ที่เป็น
`Class.Model` ที่ติดแท็กว่า `Apple` และมีแอตทริบิวต์ `Variety`
เท่ากับ `Fuji` และแอตทริบิวต์ `Flavor` เท่ากับ `4`.

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

-- รับบุตรทั้งหมดของ MeshPart
print(Workspace:QueryDescendants("MeshPart"))

-- รับบุตรทั้งหมดที่ติดแท็กว่า "Fruit"
print(Workspace:QueryDescendants(".Fruit"))

-- รับบุตรทั้งหมดที่มีชื่อว่า "RedTree"
print(Workspace:QueryDescendants("#RedTree"))

-- รับบุตรทั้งหมดที่มีคุณสมบัติ CanCollide ตั้งค่าเป็น false
print(Workspace:QueryDescendants("[CanCollide = false]"))

-- รับบุตรทั้งหมดที่มีแอตทริบิวต์ "FuelCapacity"
print(Workspace:QueryDescendants("[$FuelCapacity]"))
-- รับบุตรทั้งหมดที่มีแอตทริบิวต์ "FuelCapacity" ตั้งค่าเป็น 75
print(Workspace:QueryDescendants("[$FuelCapacity = 75]"))
```

#### การรวม

การรวมช่วยให้คุณผสมผสานการเลือกพื้นฐานเพื่อจับคู่ความสัมพันธ์
ในลำดับชั้นที่ลึกกว่า.

- `>` — จับคู่กับอินสแตนซ์ที่เป็น **บุตรโดยตรง**
  ของการจับคู่ของฟิลเตอร์ก่อนหน้า.

- `>>` — จับคู่กับอินสแตนซ์ที่เป็น **บุตร**
  ของการจับคู่ของฟิลเตอร์ก่อนหน้า. นี่คือฟิลเตอร์แรกที่จะเลือก,
  หมายความว่า `SpotLight.Red` เป็นสิ่งเดียวกับ `>> SpotLight.Red`.

- `,` — ระบุรายการของการเลือกที่เป็นอิสระหลายรายการสำหรับ
  คิวรีบุตร. เฉพาะองค์ประกอบที่ตรงกับฟิลเตอร์จะถูกวางใน
  อาร์เรย์ที่ส่งคืน; `nil` จะไม่รวมอยู่สำหรับการไม่ตรงกันในรายการคิวรี.

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

-- รับบุตรโดยตรงของโมเดลใดๆ ที่ติดแท็กว่า "SwordPart"
print(Workspace:QueryDescendants("Model > .SwordPart"))

-- รับบุตรโดยตรงที่เป็น Part และติดแท็กว่า "Apple"
print(Workspace:QueryDescendants("> Part.Apple"))

-- รับบุตรของโมเดลใดๆ ที่มีแอตทริบิวต์ "OnFire" ตั้งค่าเป็น true
print(Workspace:QueryDescendants("Model >> [$OnFire = true]"))

-- รับบุตร MeshPart ที่ติดแท็กว่า "SwordPart" หรือมีแอตทริบิวต์ "OnFire" ตั้งค่าเป็น true
print(Workspace:QueryDescendants("MeshPart.SwordPart, MeshPart[$OnFire = true]"))
```

#### ตัวเลือกพิเศษ

- `:not(complex-selector-list)` — อนุญาตให้เลือกอินสแตนซ์ที่
  **ไม่** ตรงกับการเลือกใดๆ ข้างใน, ซึ่งมีผลเป็นการ
  ปฏิเสธการเลือก. เนื่องจากนิพจน์ภายในเป็นรายชื่อของ
  การเลือกที่ซับซ้อน, จึงสามารถกรองได้ตามเงื่อนไขหลายๆ อย่าง.

- `:has(relative-selector-list)` — อนุญาตให้เลือกอินสแตนซ์โดยพิจารณาจาก
  อินสแตนซ์ที่มีอยู่ข้างใน. รายการการเลือกจะถูกประเมิน
  เฉพาะตามอินสแตนซ์แต่ละรายการ.

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

-- รับบุตรทั้งหมดที่ไม่ใช่อินสแตนซ์ของคลาส SpotLight
print(Workspace:QueryDescendants(":not(SpotLight)"))
-- รับบุตรทั้งหมดที่ไม่ใช่อินสแตนซ์ของคลาส SpotLight หรือ PointLight
print(Workspace:QueryDescendants(":not(SpotLight, PointLight)"))
-- รับบุตรทั้งหมดที่ไม่มีแอตทริบิวต์ "OnFire"
print(Workspace:QueryDescendants(":not([$OnFire])"))
-- รับบุตรทั้งหมดยกเว้นเด็กของโมเดลที่ติดแท็กว่า "SwordPart"
print(Workspace:QueryDescendants(":not(Model > .SwordPart)"))

-- รับบุตรที่มีอินสแตนซ์ Tool เป็นบุตรของตัวเอง
print(Workspace:QueryDescendants(":has(Tool)"))
-- รับบุตร MeshPart ที่มีบุตรโดยตรงติดแท็กว่า "SwordPart"
print(Workspace:QueryDescendants("MeshPart:has(> .SwordPart)"))

-- รับบุตร MeshPart ที่มีบุตรโดยตรงที่ไม่ใช่คลาส SurfaceAppearance หรือ Texture
print(Workspace:QueryDescendants("MeshPart:has(> :not(SurfaceAppearance, Texture))"))
```


Instance:QueryDescendants

สตริงตัวเลือกที่ใช้กรององค์ประกอบ.

อาเรย์ของอินสแตนซ์ (ว่างเปล่าหากไม่มีสิ่งใดตรงกับตัวเลือก).

ส่งกลับอาร์เรย์ที่มีบุตรทั้งหมดของอินสแตนซ์ที่ตรงกับ
`selector` string.


โค้ดต่อไปนี้แสดงให้เห็นว่าส่วนหนึ่งสามารถถูกเพิ่มกลับเข้าสู่ DataModel
หลังจากถูกลบออก:

วิธีนี้กำหนด `Class.Instance.Parent` ของวัตถุเป็น `nil` และทำเช่นเดียวกันกับลูกหลานทั้งหมด.

หากมีการอ้างอิงวัตถุก่อนที่จะถูกลบ สามารถนำวัตถุกลับมาได้ในภายหลัง.

Instance:Remove

กำหนด `Parent` ของวัตถุเป็น `nil` และทำเช่นเดียวกันกับลูกหลานทั้งหมด.

Instance:remove

วิธีนี้ลบแท็กออกจากอินสแตนซ์ จะไม่สร้างข้อผิดพลาดหากวัตถุไม่มีแท็ก การลบแท็กได้สำเร็จจะทำการส่งสัญญาณที่สร้างโดย `Class.CollectionService:GetInstanceRemovedSignal()` พร้อมแท็กที่ให้ไว้.

โปรดทราบว่าเมื่อแท็กอินสแตนซ์ นอกจากจะต้องใช้ทรัพยากรบ้างเพื่อให้แท็กทำงานได้ เช่นการเชื่อมต่อเหตุการณ์หรือตาราง เพื่อป้องกันการรั่วไหลของหน่วยความจำ จึงเป็นความคิดที่ดีที่จะทำความสะอาดเมื่อไม่ต้องการใช้งานแท็กอีกต่อไป (ตัดการเชื่อมต่อ, ตั้งค่าเป็น `nil`, เป็นต้น).

Instance:RemoveTag

ลบแท็กออกจากอินสแตนซ์.

Instance

`Instance` เป็นคลาสพื้นฐานสำหรับคลาสทั้งหมดในลำดับชั้นคลาส Roblox
ซึ่งสามารถเป็นส่วนหนึ่งของต้นไม้ `Class.DataModel`.

/reference/engine/classes/SceneAnalysisService.yaml