 `Class.UIListLayout` จัดตำแหน่งองค์ประกอบ UI ที่เป็นพี่น้องในแถวหรือคอลัมน์ภายใน
คอนเทนเนอร์ UI หลัก โดยอิงจาก
`Class.UIListLayout.FillDirection|FillDirection` คุณสมบัติ
`Class.GuiObject.Position|Position` และ `Class.GuiObject.Rotation|Rotation`
ของแต่ละ `Class.GuiObject` ที่เป็นพี่น้องจะถูกเพิกเฉยหรือลบล้าง
โดยการจัดเรียงรายการ ขณะที่แต่ละพี่น้องจะยังคงรักษา
`Class.GuiObject.Size|Size` ที่กำหนดไว้ของมัน นอกจากว่า
การจัดเรียงจะถูกตั้งค่าให้ใช้การจัดเรียงแบบยืดหยุ่น
ดู [List and Flex Layouts](/ui/list-flex-layouts) สำหรับ
ข้อมูลเพิ่มเติม

<img src="../../../assets/engine-api/classes/UIListLayout/FillDirection.png"
width="720" alt="UIListLayouts แสดงการอธิบาย FillDirection ของแนวนอน
หรือแนวตั้ง." />

เพื่อควบคุมลำดับการจัดเรียงของพี่น้อง ให้ตั้งค่า
`Class.UIListLayout.SortOrder|SortOrder` เป็น `Enum.SortOrder.Name` หรือ
`Enum.SortOrder.LayoutOrder` แล้วเปลี่ยนชื่อพี่น้องในลำดับอัลฟาเบตหรือ
ตั้งค่าค่า `Class.GuiObject.LayoutOrder|LayoutOrder` ของพวกเขา
ตามลำดับ `Class.UIListLayout` จะจัดเรียงซ้ำโดยอัตโนมัติเมื่อมีการ
เพิ่มหรือลบองค์ประกอบ หรือถ้าชื่อ `Class.Instance.Name|Name` หรือ
`Class.GuiObject.LayoutOrder|LayoutOrder` ของพี่น้องมีการเปลี่ยนแปลง

<img src="../../../assets/engine-api/classes/UIListLayout/SortOrder.png"
width="720" alt="ตัวอย่างการจัดเรียงแสดงการเรียงลำดับ LayoutOrder ตามหมายเลข
หรือตามชื่อแบบอัลฟาเบต." />

การเว้นระยะระหว่างพี่น้องจะถูกควบคุมผ่านคุณสมบัติ
`Class.UIListLayout.Padding|Padding` และการห่อภายในขอบเขตของคอนเทนเนอร์
หลักผ่านบูลีน `Class.UIListLayout.Wraps|Wraps` การจัดแนวของพี่น้องภายใน
คอนเทนเนอร์หลักจะถูกควบคุมผ่าน
`Class.UIListLayout.HorizontalAlignment|HorizontalAlignment` และ
`Class.UIListLayout.VerticalAlignment|VerticalAlignment` นอกจากว่า
การจัดเรียงจะถูกตั้งค่าให้ใช้
[การจัดเรียงแบบยืดหยุ่น](/ui/list-flex-layouts#flex-layouts)

โปรดทราบว่ามีผลกระทบด้านประสิทธิภาพในการใช้
[การจัดเรียงที่เปิดใช้งานยืดหยุ่น](/ui/list-flex-layouts#flex-layouts)
เนื่องจากการคำนวณเพิ่มเติมจะต้องทำเพื่อคำนวณขนาดพื้นฐานที่ยืดหยุ่น ขนาดที่ยืดหยุ่น และการห่อบรรทัด การยืดหยุ่นจะเปิดใช้งานใน `Class.UIListLayout` เมื่อคุณสมบัติ
ต่อไปนี้ถูกตั้งค่า หรือหากพี่น้อง `Class.GuiObject` ใดๆ มี
`Class.UIFlexItem` ซึ่งเป็นบิดา:

- `Class.UIListLayout.HorizontalFlex|HorizontalFlex` และ/หรือ
  `Class.UIListLayout.VerticalFlex|VerticalFlex` **ไม่ได้** ตั้งค่าเป็น
  `Enum.UIFlexAlignment.None`.
- `Class.UIListLayout.ItemLineAlignment|ItemLineAlignment` **ไม่ได้** ตั้งค่าเป็น
  `Enum.ItemLineAlignment.Automatic`.
- `Class.UIListLayout.Wraps|Wraps` เป็น `true`.


UIListLayout

เมื่อการจัดเรียงรายการของ `Class.UIListLayout.FillDirection|FillDirection` ถูกตั้งค่าเป็น
`Enum.FillDirection.Horizontal` คุณสมบัติ
`Class.UIListLayout.HorizontalFlex|HorizontalFlex` ระบุวิธีการแจกจ่าย
พื้นที่แนวนอนเพิ่มเติมในคอนเทนเนอร์หลัก.

<table size="small">
  <thead>
    <tr>
      <th>การตั้งค่า</th>
      <th>พฤติกรรมของพี่น้อง</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>Enum.UIFlexAlignment.None|None</code></td>
      <td>ไม่มีพฤติกรรมยืดหยุ่น; พี่น้องจะรักษาความกว้างที่กำหนดไว้ของพวกเขา.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.Fill|Fill</code></td>
      <td>พี่น้องปรับขนาดโดยแนวนอนเพื่อเติมเต็มคอนเทนเนอร์หลักทั้งหมด โดยจะละเมิดความกว้างที่กำหนดไว้ของพวกเขา จำนวนพี่น้องในแถวจะคงเดิม; ตัวอย่างเช่น หากมีพี่น้องสามคนเข้ากับความกว้างของคอนเทนเนอร์ใต้การตั้งค่า <code>Enum.UIFlexAlignment.None|None</code> สามคนนี้จะปรับขนาดเพื่อเติมเต็มความกว้างทั้งหมด.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceAround|SpaceAround</code></td>
      <td>พี่น้องยังคงรักษาความกว้างที่กำหนดไว้ของพวกเขา เว้นระยะเท่าๆ กันที่ด้านทั้งสองข้างของแต่ละพี่น้อง.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceBetween|SpaceBetween</code></td>
      <td>พี่น้องยังคงรักษาความกว้างที่กำหนดไว้ของพวกเขา เว้นระยะเท่าๆ กัน <b>ระหว่าง</b> พี่น้อง แต่ไม่มีพื้นที่เพิ่มเติมที่ถูกเพิ่ม <b>รอบๆ</b> พี่น้อง.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceEvenly|SpaceEvenly</code></td>
      <td>พี่น้องยังคงรักษาความกว้างที่กำหนดไว้ของพวกเขา เว้นระยะเท่าๆ กันทั้ง <b>ระหว่าง</b> และ <b>รอบๆ</b> พี่น้อง.</td>
    </tr>
  </tbody>
</table>

<img src="../../../assets/engine-api/classes/UIListLayout/HorizontalFlex-Options.png" width="800" alt="ตัวอย่าง UIListLayout แสดงให้เห็นว่าแต่ละตัวเลือก HorizontalFlex ส่งผลต่อขนาดและการเว้นระยะของวัตถุ UI ที่เป็นพี่น้องอย่างไร." />

##### พฤติกรรมข้ามทิศทาง

ในการจัดเรียงแบบ **แนวตั้ง** (`Class.UIListLayout.FillDirection|FillDirection` ตั้งค่าเป็น
`Enum.FillDirection.Vertical`) คุณสมบัติ
`Class.UIListLayout.HorizontalFlex|HorizontalFlex` ระบุวิธีการแจกจ่ายพี่น้องใน
**ทิศทางข้ามแนวนอน** ในการจัดเรียงเช่นนั้น การตั้งค่าเป็น `Enum.UIFlexAlignment.Fill` จะทำให้พี่น้อง
เติมเต็มพื้นที่แนวนอนทั้งหมด ขณะที่การเว้นระยะในแนวตั้งจะปฏิบัติตาม
`Class.UIListLayout.VerticalFlex|VerticalFlex`.

<img src="../../../assets/engine-api/classes/UIListLayout/HorizontalFlex-Cross-Direction.png" width="720" alt="แผนภาพแสดงวิธีที่ HorizontalFlex ส่งผลต่อขนาดแนวนอนของวัตถุ UI ที่เป็นพี่น้องเมื่อทิศทางการเติมของ UIListLayout ถูกตั้งค่าเป็นแนวตั้ง." />

##### การโต้ตอบกับ AutomaticSize

ถ้า `Class.GuiObject.AutomaticSize` ถูกเปิดใช้งานสำหรับเด็กของ
`Class.UIListLayout` ใน `Class.UIListLayout.FillDirection|FillDirection` จะถูกตีความว่า
"พื้นฐานการยืดอัตโนมัติ" และจะกำหนดขนาดของ `Class.GuiObject`
จากที่สามารถขยายหรือหดได้.

ถ้า `Class.GuiObject.AutomaticSize` ถูกเปิดใช้งานสำหรับเด็กของ
`Class.UIListLayout` ใน **ทิศทางข้าม** จะถูกตีความว่า
"ขนาดข้ามอัตโนมัติ" และจะกำหนดขนาดขั้นต่ำที่จำเป็นในการรองรับ
เนื้อหาของเด็กทั้งหมดในทิศทางข้าม.


UIListLayout.HorizontalFlex

ควบคุมว่าจะแจกจ่ายพื้นที่แนวนอนเพิ่มเติมอย่างไร


ใน [เลย์เอาต์แบบยืดหยุ่น](/ui/list-flex-layouts#flex-layouts) กำหนด
การจัดแนวใน **ทิศทางข้าม** ของพี่น้องภายในแถว ดู
`Enum.ItemLineAlignment` สำหรับตัวอย่างเชิงภาพ.

<table size="small">
  <thead>
    <tr>
      <th>การตั้งค่า</th>
      <th>พฤติกรรมของพี่น้อง</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>Enum.ItemLineAlignment.Automatic|Automatic</code></td>
      <td>จัดแนวพี่น้องของเลย์เอาต์หรือบิดเฉพาะ <code>Class.UIFlexItem</code> ให้กับ <code>Class.UIListLayout.HorizontalAlignment|HorizontalAlignment</code> หรือ <code>Class.UIListLayout.VerticalAlignment|VerticalAlignment</code> ขึ้นอยู่กับ <code>Class.UIListLayout.FillDirection|FillDirection</code>.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.Start|Start</code></td>
      <td>จัดแนวพี่น้องของเลย์เอาต์หรือบิดเฉพาะ <code>Class.UIFlexItem</code> ให้กับด้าน <b>บน</b> ของแถวในการเติมแนวนอนหรือให้กับด้าน <b>ซ้าย</b> ของแถวในการเติมแนวตั้ง.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.Center|Center</code></td>
      <td>จัดแนวพี่น้องของเลย์เอาต์หรือบิดเฉพาะ <code>Class.UIFlexItem</code> ให้กับ <b>กลาง</b> ของแถวไม่ว่าจะเป็นการเติมแนวนอนหรือแนวตั้ง.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.End|End</code></td>
      <td>จัดแนวพี่น้องของเลย์เอาต์หรือบิดเฉพาะ <code>Class.UIFlexItem</code> ให้กับด้าน <b>ล่าง</b> ของแถวในการเติมแนวนอนหรือให้กับด้าน <b>ขวา</b> ของแถวในการเติมแนวตั้ง.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.Stretch|Stretch</code></td>
      <td>ยืดพี่น้องของเลย์เอาต์หรือบิดเฉพาะ <code>Class.UIFlexItem</code> เพื่อเติมเต็มทั้งทิศทางข้ามของแถวไม่ว่าจะเป็นการเติมแนวนอนหรือแนวตั้ง.</td>
    </tr>
  </tbody>
</table>

<img src="../../../assets/engine-api/classes/UIListLayout/ItemLineAlignment.png" width="720" alt="ตัวอย่างตัวเลือกสำหรับ ItemLineAlignment ในทิศทางการเติมแนวนอน." />


UIListLayout.ItemLineAlignment

ในเลย์เอาต์แบบยืดหยุ่นกำหนดการจัดแนวใน **ทิศทางข้าม** ของพี่น้อง
ภายในแถว.


กำหนดจำนวนพื้นที่ว่างระหว่างแต่ละองค์ประกอบ ว่าจะตั้งเป็น
สเกล (เปอร์เซ็นต์ของขนาดของพ่อในทิศทางปัจจุบัน) หรือเป็น
ออฟเซต (ค่าว่างคงที่ที่คล้ายกับขนาดพิกเซล).


UIListLayout.Padding

จำนวนพื้นที่ว่างระหว่างแต่ละองค์ประกอบ.


เมื่อการจัดเรียงรายการของ `Class.UIListLayout.FillDirection|FillDirection` ถูกตั้งค่าเป็น
`Enum.FillDirection.Vertical` คุณสมบัติ
`Class.UIListLayout.VerticalFlex|VerticalFlex` ระบุวิธีการแจกจ่าย
พื้นที่แนวตั้งเพิ่มเติมในคอนเทนเนอร์หลัก.

<table size="small">
  <thead>
    <tr>
      <th>การตั้งค่า</th>
      <th>พฤติกรรมของพี่น้อง</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>Enum.UIFlexAlignment.None|None</code></td>
      <td>ไม่มีพฤติกรรมยืดหยุ่น; พี่น้องจะรักษาความสูงที่กำหนดไว้ของพวกเขา.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.Fill|Fill</code></td>
      <td>พี่น้องปรับขนาดโดยแนวตั้งเพื่อเติมเต็มคอนเทนเนอร์หลักทั้งหมด โดยจะละเมิดความสูงที่กำหนดไว้ของพวกเขา จำนวนพี่น้องในคอลัมน์จะคงเดิม; ตัวอย่างเช่น หากมีพี่น้องสามคนเข้ากับความสูงของคอนเทนเนอร์ใต้การตั้งค่า <code>Enum.UIFlexAlignment.None|None</code> สามคนนี้จะปรับขนาดเพื่อเติมเต็มความสูงทั้งหมด.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceAround|SpaceAround</code></td>
      <td>พี่น้องยังคงรักษาความสูงที่กำหนดไว้ของพวกเขา เว้นระยะเท่าๆ กันที่ด้านทั้งสองข้างของแต่ละพี่น้อง.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceBetween|SpaceBetween</code></td>
      <td>พี่น้องยังคงรักษาความสูงที่กำหนดไว้ของพวกเขา เว้นระยะเท่าๆ กัน <b>ระหว่าง</b> พี่น้อง แต่ไม่มีพื้นที่เพิ่มเติมที่ถูกเพิ่ม <b>รอบๆ</b> พี่น้อง.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceEvenly|SpaceEvenly</code></td>
      <td>พี่น้องยังคงรักษาความสูงที่กำหนดไว้ของพวกเขา เว้นระยะเท่าๆ กันทั้ง <b>ระหว่าง</b> และ <b>รอบๆ</b> พี่น้อง.</td>
    </tr>
  </tbody>
</table>

<img src="../../../assets/engine-api/classes/UIListLayout/VerticalFlex-Options.png" width="800" alt="ตัวอย่าง UIListLayout แสดงให้เห็นว่าแต่ละตัวเลือก VerticalFlex ส่งผลต่อขนาดและการเว้นระยะของวัตถุ UI ที่เป็นพี่น้องอย่างไร." />

##### พฤติกรรมข้ามทิศทาง

ในการจัดเรียงแบบ **แนวนอน** (`Class.UIListLayout.FillDirection|FillDirection` ตั้งค่าเป็น
`Enum.FillDirection.Horizontal`) คุณสมบัติ
`Class.UIListLayout.VerticalFlex|VerticalFlex` ระบุวิธีการแจกจ่ายพี่น้องใน
**ทิศทางข้ามแนวตั้ง** ในการจัดเรียงเช่นนั้น การตั้งค่าเป็น `Enum.UIFlexAlignment.Fill` จะทำให้พี่น้อง
เติมเต็มพื้นที่แนวตั้งทั้งหมด ขณะที่การเว้นระยะในแนวนอนจะปฏิบัติตาม
`Class.UIListLayout.HorizontalFlex|HorizontalFlex`.

<img src="../../../assets/engine-api/classes/UIListLayout/VerticalFlex-Cross-Direction.png" width="720" alt="แผนภาพแสดงวิธีที่ VerticalFlex ส่งผลต่อขนาดแนวตั้งของวัตถุ UI ที่เป็นพี่น้องเมื่อทิศทางการเติมของ UIListLayout ถูกตั้งค่าเป็นแนวนอน." />

##### การโต้ตอบกับ AutomaticSize

ถ้า `Class.GuiObject.AutomaticSize` ถูกเปิดใช้งานสำหรับเด็กของ
`Class.UIListLayout` ใน `Class.UIListLayout.FillDirection|FillDirection` จะถูกตีความว่า
"พื้นฐานการยืดอัตโนมัติ" และจะกำหนดขนาดของ `Class.GuiObject`
จากที่สามารถขยายหรือหดได้.

ถ้า `Class.GuiObject.AutomaticSize` ถูกเปิดใช้งานสำหรับเด็กของ
`Class.UIListLayout` ใน **ทิศทางข้าม** จะถูกตีความว่า
"ขนาดข้ามอัตโนมัติ" และจะกำหนดขนาดขั้นต่ำที่จำเป็นในการรองรับ
เนื้อหาของเด็กทั้งหมดในทิศทางข้าม.


UIListLayout.VerticalFlex

ควบคุมว่าจะแจกจ่ายพื้นที่แนวตั้งเพิ่มเติมอย่างไร.


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

<img src="../../../assets/engine-api/classes/UIListLayout/Wraps.png" width="800" alt="แผนภาพแสดงว่าการห่อส่งผลต่อการกระจายของพี่น้องภายในขอบเขตของคอนเทนเนอร์หลักอย่างไร." />


UIListLayout.Wraps

ควบคุมว่าพี่น้องภายในคอนเทนเนอร์หลักจะห่อหรือไม่.


จัดตำแหน่งองค์ประกอบ UI ที่เป็นพี่น้องในแถวหรือคอลัมน์ภายใน
คอนเทนเนอร์ UI หลัก


คลาสพื้นฐานสำหรับเลย์เอาต์ UI สไตล์กริด。


ตัวอย่างโค้ดนี้แสดงการจัดเรียงข้อมูลโดยใช้
`Class.UIGridStyleLayout.SortOrder` และ `Class.GuiObject.LayoutOrder`.

วิธีการ ApplyLayout บังคับให้จัดเรียงองค์ประกอบ UI น้องใหม่
ในกรณีที่เกณฑ์การจัดเรียงอาจเปลี่ยนแปลง (เช่น เมื่อตั้งค่า
`Class.UIGridStyleLayout.SortOrder` เป็น Custom และ
พฤติกรรมของ `Class.UIGridStyleLayout:SetCustomSortFunction()` เปลี่ยนไป).
การจัดเรียงใหม่จะเกิดขึ้นโดยอัตโนมัติเมื่อมีการเพิ่ม/ลบองค์ประกอบ UI
หรือชื่อ `Class.Instance.Name` หรือ `Class.GuiObject.LayoutOrder`
มีการเปลี่ยนแปลง。

วิธีที่องค์ประกอบ UI น้องถูกจัดเรียงขึ้นอยู่กับ
การใช้งานของคลาสนามธรรมนี้ กล่าวคือ คลาสคอนกรีต
เช่น `Class.UIListLayout` หรือ `Class.UIGridLayout` เป็นผู้รับผิดชอบในการ
จัดตำแหน่งองค์ประกอบจริง。


UIGridStyleLayout:ApplyLayout

บังคับการจัดเรียงเลย์เอาต์ขององค์ประกอบ UI น้อง。


วิธีการนี้ถูกเลิกใช้งานแล้ว ใช้ `Class.UIGridStyleLayout.SortOrder`
แทน。

ฟังก์ชันจะต้องมีพารามิเตอร์สองตัว (แต่ละตัวจะเป็น `Class.Instance`
ลูกเพื่อเปรียบเทียบ) และคืนค่า true หาก a มานำหน้ากว่า b\,
มิฉะนั้นให้คืนค่า false กล่าวคือ ใช้ฟังก์ชันนี้ในลักษณะเดียวกับที่คุณจะใช้
ฟังก์ชันที่กำหนดเอง การจัดเรียงจะต้องมีลักษณะเฉพาะ มิฉะนั้น
การจัดเรียงจะล้มเหลวและย้อนคืนไปยังลำดับชื่อ。


UIGridStyleLayout:SetCustomSortFunction

function

ตั้งค่าฟังก์ชันที่ใช้ในการกำหนดลำดับขององค์ประกอบเมื่อ SortOrder
ตั้งค่าเป็น Custom。


UIGridStyleLayout

คุณสมบัติ **AbsoluteContentSize** ของ `Class.UIGridStyleLayout`
แสดงว่ามีพื้นที่เท่าไรที่องค์ประกอบของกริดใช้ รวมถึง
พาดโดยกริดที่สร้างขึ้น คุณสมบัตินี้มีประโยชน์โดยเฉพาะในการ
ปรับขนาดคอนเทนเนอร์ของกริด เช่น `Class.Frame|Frames` เพื่อให้มั่นใจว่า
มันจะไม่ใหญ่กว่ากริดเอง。

คุณสมบัตินี้จะอัปเดตทันทีที่ถูกอ่าน จะไม่เกิดเหตุการณ์
`Class.Object.Changed` ทันทีหลังจากที่ UI เปลี่ยนแปลง แต่ถ้า
ค่าได้รับการอ่าน มันจะเป็นค่าปัจจุบันและเหตุการณ์ `Class.Object.Changed`
จะเกิดขึ้นในขั้นตอนการเรนเดอร์ถัดไป。


UIGridStyleLayout.AbsoluteContentSize

ขนาดที่แท้จริงของพื้นที่ที่ถูกใช้โดยเลย์เอาต์กริด。


คุณสมบัติ **FillDirection** กำหนดแกนที่วัตถุ UI
ถูกจัดเรียง `Enum.FillDirection.Horizontal` จัดเรียงวัตถุจากซ้าย
ไปขวา ในขณะที่ `Enum.FillDirection.Vertical` จัดเรียงวัตถุจากบนไป
ล่าง หากต้องการย้อนกลับองค์ประกอบ เช่น จัดเรียงจากขวาไปซ้าย คุณต้อง
ย้อนกลับการจัดเรียง; เช่น โดยการทำให้ค่าของวัตถุ UI ลูก
`Class.GuiObject.LayoutOrder` ติดลบเมื่อ
`Class.UIGridStyleLayout.SortOrder` ถูกตั้งค่าเป็น
`Enum.SortOrder.LayoutOrder`。

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


UIGridStyleLayout.FillDirection

กำหนดแกนที่วัตถุ UI ถูกจัดเรียง。


คุณสมบัติ **HorizontalAlignment** กำหนดการจัดแนวแกน **X**
ของกริดขององค์ประกอบ UI คล้ายกับ `Class.TextLabel.TextXAlignment`
ที่ทำกับ `Class.TextLabel.Text`。


UIGridStyleLayout.HorizontalAlignment

กำหนดการจัดแนวระดับแนวนอนขององค์ประกอบ UI ภายใน
องค์ประกอบแม่。


คุณสมบัติ **SortOrder** กำหนดลำดับที่วัตถุ UI ลูก
ถูกวางในเลย์เอาต์。

สำหรับ `Enum.SortOrder.LayoutOrder` มีการจัดเรียงแบบเพิ่มขึ้นบน
คุณสมบัติ `Class.GuiObject.LayoutOrder|LayoutOrder` ของวัตถุ UI ลูก ถ้า
สองลูกมีค่า `Class.GuiObject.LayoutOrder|LayoutOrder` เดียวกัน
ลูกที่ถูกเพิ่มเข้ามาก่อนจะมีความสำคัญมากกว่า。

สำหรับ `Enum.SortOrder.Name` จะมีการจัดเรียงแบบอัลฟาเบติกบน
`Class.Instance.Name` ของวัตถุ UI ลูก。

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


UIGridStyleLayout.SortOrder

กำหนดลำดับที่วัตถุ UI ลูกถูกวางในเลย์เอาต์。


คุณสมบัติ **VerticalAlignment** กำหนดการจัดแนวแกน **Y** ของ
กริดขององค์ประกอบ UI คล้ายกับ `Class.TextLabel.TextYAlignment` ทำ
กับ `Class.TextLabel.Text`。


UIGridStyleLayout.VerticalAlignment

กำหนดการจัดแนวแนวตั้งขององค์ประกอบ UI ภายใน
องค์ประกอบแม่。


คลาสพื้นฐานสำหรับคลาสจัดเรียง UI.


UILayout

คลาสพื้นฐานสำหรับคลาสข้อจำกัดและเลย์เอาต์ UI; สืบทอดมาจาก
`Class.UIBase`。

UIComponent

คลาสพื้นฐานสำหรับคลาสข้อจำกัดและเลย์เอาต์ UI。

`Class.UIBase` เป็นคลาสพื้นฐานสำหรับเลย์เอาท์ UI และคลาสข้อจำกัด。


UIBase

`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

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

Instance

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

/reference/engine/classes/UIListLayout.yaml