Uma `Class.UIListLayout` posiciona elementos de UI irmãos em linhas ou colunas dentro do contêiner UI pai, com base no `Class.UIListLayout.FillDirection|FillDirection`. As propriedades `Class.GuiObject.Position|Position` e `Class.GuiObject.Rotation|Rotation` de cada `Class.GuiObject` irmão são ignoradas ou substituídas pelo layout da lista, enquanto cada irmão mantém seu `Class.GuiObject.Size|Size` definido, a menos que o layout esteja configurado para utilizar um layout flex. Veja [List and Flex Layouts](/ui/list-flex-layouts) para mais informações.

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

Para controlar a ordem de layout dos irmãos, defina `Class.UIListLayout.SortOrder|SortOrder` como `Enum.SortOrder.Name` ou `Enum.SortOrder.LayoutOrder`, depois renomeie os irmãos em ordem alfanumérica ou defina seu valor `Class.GuiObject.LayoutOrder|LayoutOrder`, respectivamente. `Class.UIListLayout` irá automaticamente reorganizar os elementos quando elementos forem adicionados/removidos, ou se o `Class.Instance.Name|Name` de um irmão ou o `Class.GuiObject.LayoutOrder|LayoutOrder` mudarem.

<img src="../../../assets/engine-api/classes/UIListLayout/SortOrder.png"
width="720" alt="Exemplos de layout de lista ilustrando ordenação numérica de LayoutOrder ou ordenação alfanumérica de Name." />

O preenchimento entre irmãos é controlado pela propriedade `Class.UIListLayout.Padding|Padding`, e o empilhamento dentro dos limites do contêiner pai é controlado pela booleana `Class.UIListLayout.Wraps|Wraps`. O alinhamento dos irmãos dentro do contêiner pai é controlado através de `Class.UIListLayout.HorizontalAlignment|HorizontalAlignment` e `Class.UIListLayout.VerticalAlignment|VerticalAlignment`, a menos que o layout esteja configurado para utilizar um [layout flex](/ui/list-flex-layouts#flex-layouts).

Observe que há implicações de desempenho ao usar um layout de lista [flexível](/ui/list-flex-layouts#flex-layouts), uma vez que cálculos extras são necessários para calcular tamanhos de base flex, tamanhos flexíveis e quebras de linha. O flex é ativado em um `Class.UIListLayout` quando as seguintes propriedades estão definidas ou se qualquer `Class.GuiObject` irmão tem um `Class.UIFlexItem` como pai:

- `Class.UIListLayout.HorizontalFlex|HorizontalFlex` e/ou `Class.UIListLayout.VerticalFlex|VerticalFlex` **não** estão definidos como `Enum.UIFlexAlignment.None`.
- `Class.UIListLayout.ItemLineAlignment|ItemLineAlignment` **não** está definido como `Enum.ItemLineAlignment.Automatic`.
- `Class.UIListLayout.Wraps|Wraps` é `true`.


UIListLayout

Quando o `Class.UIListLayout.FillDirection|FillDirection` do layout da lista está definido como `Enum.FillDirection.Horizontal`, a propriedade `Class.UIListLayout.HorizontalFlex|HorizontalFlex` especifica como distribuir espaço extra horizontal no contêiner pai.

<table size="small">
  <thead>
    <tr>
      <th>Configuração</th>
      <th>Comportamento do Irmão</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>Enum.UIFlexAlignment.None|None</code></td>
      <td>Sem comportamento flex; os irmãos mantêm sua largura definida.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.Fill|Fill</code></td>
      <td>Os irmãos redimensionam horizontalmente para preencher todo o contêiner pai, substituindo sua largura definida. O número de irmãos em uma linha permanece inalterado; por exemplo, se três irmãos cabem horizontalmente na largura do contêiner sob a configuração <code>Enum.UIFlexAlignment.None|None</code>, aqueles três irmãos redimensionarão para preencher toda a largura.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceAround|SpaceAround</code></td>
      <td>Os irmãos mantêm sua largura definida. Espaçamento igual é adicionado em ambos os lados de cada irmão.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceBetween|SpaceBetween</code></td>
      <td>Os irmãos mantêm sua largura definida. Espaçamento igual é adicionado <b>entre</b> os irmãos, mas nenhum espaço adicional é adicionado <b>ao redor</b> dos irmãos.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceEvenly|SpaceEvenly</code></td>
      <td>Os irmãos mantêm sua largura definida. Espaçamento igual é adicionado tanto <b>entre</b> quanto <b>ao redor</b> dos irmãos.</td>
    </tr>
  </tbody>
</table>

<img src="../../../assets/engine-api/classes/UIListLayout/HorizontalFlex-Options.png" width="800" alt="Exemplos de UIListLayout mostrando como cada opção de HorizontalFlex afeta o tamanho e espaçamento dos objetos de UI irmãos." />

##### Comportamento de Direção Cruzada

Em layouts de lista **verticais** (`Class.UIListLayout.FillDirection|FillDirection` definido como
`Enum.FillDirection.Vertical`), a propriedade `Class.UIListLayout.HorizontalFlex|HorizontalFlex` especifica como distribuir os irmãos na **direção cruzada horizontal**. Em tais layouts, uma configuração de `Enum.UIFlexAlignment.Fill` faz com que os irmãos preencham todo o espaço horizontal enquanto o espaçamento vertical adere ao `Class.UIListLayout.VerticalFlex|VerticalFlex`.

<img src="../../../assets/engine-api/classes/UIListLayout/HorizontalFlex-Cross-Direction.png" width="720" alt="Diagrama mostrando como HorizontalFlex afeta o tamanho horizontal dos objetos de UI irmãos quando a direção de preenchimento do UIListLayout está configurada como vertical." />

##### Interação de AutomaticSize

Se `Class.GuiObject.AutomaticSize` estiver ativado para um filho do `Class.UIListLayout` na
`Class.UIListLayout.FillDirection|FillDirection`, ele é interpretado como "base flex automática" e define o tamanho do `Class.GuiObject` do qual pode crescer ou encolher.

Se `Class.GuiObject.AutomaticSize` estiver ativado para um filho do `Class.UIListLayout` na **direção cruzada**, ele é interpretado como "tamanho cruzado automático" e define o tamanho mínimo necessário para conter todo o conteúdo do filho na direção cruzada.


UIListLayout.HorizontalFlex

Controla como distribuir espaço extra horizontal.


Em um [layout flex](/ui/list-flex-layouts#flex-layouts), define o alinhamento **na direção cruzada** dos irmãos dentro de uma linha. Veja `Enum.ItemLineAlignment` para exemplos visuais.

<table size="small">
  <thead>
    <tr>
      <th>Configuração</th>
      <th>Comportamento do Irmão</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>Enum.ItemLineAlignment.Automatic|Automatic</code></td>
      <td>Alinha os irmãos do layout ou o <code>Class.UIFlexItem</code> específico ao <code>Class.UIListLayout.HorizontalAlignment|HorizontalAlignment</code> ou <code>Class.UIListLayout.VerticalAlignment|VerticalAlignment</code> do layout, dependendo do seu <code>Class.UIListLayout.FillDirection|FillDirection</code>.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.Start|Start</code></td>
      <td>Alinha os irmãos do layout ou o <code>Class.UIFlexItem</code> específico ao <b>topo</b> da linha em um preenchimento horizontal ou à <b>esquerda</b> da linha em um preenchimento vertical.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.Center|Center</code></td>
      <td>Alinha os irmãos do layout ou o <code>Class.UIFlexItem</code> específico ao <b>centro</b> da linha em um preenchimento horizontal ou vertical.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.End|End</code></td>
      <td>Alinha os irmãos do layout ou o <code>Class.UIFlexItem</code> específico à <b>parte inferior</b> da linha em um preenchimento horizontal ou à <b>direita</b> da linha em um preenchimento vertical.</td>
    </tr>
    <tr>
      <td><code>Enum.ItemLineAlignment.Stretch|Stretch</code></td>
      <td>Estica os irmãos do layout ou o <code>Class.UIFlexItem</code> específico para preencher toda a direção cruzada da linha em um preenchimento horizontal ou vertical.</td>
    </tr>
  </tbody>
</table>

<img src="../../../assets/engine-api/classes/UIListLayout/ItemLineAlignment.png" width="720" alt="Exemplos de opções para ItemLineAlignment em uma direção de preenchimento horizontal." />


UIListLayout.ItemLineAlignment

Em um layout flex, define o alinhamento **na direção cruzada** dos irmãos dentro de uma linha.


Determina a quantidade de espaço livre entre cada elemento, definido como uma escala (porcentagem do tamanho do pai na direção atual) ou um deslocamento (valor de espaçamento estático semelhante ao tamanho em pixels).


UIListLayout.Padding

Quantidade de espaço livre entre cada elemento.


Quando o `Class.UIListLayout.FillDirection|FillDirection` do layout da lista está definido como `Enum.FillDirection.Vertical`, a propriedade `Class.UIListLayout.VerticalFlex|VerticalFlex` especifica como distribuir espaço extra vertical no contêiner pai.

<table size="small">
  <thead>
    <tr>
      <th>Configuração</th>
      <th>Comportamento do Irmão</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td><code>Enum.UIFlexAlignment.None|None</code></td>
      <td>Sem comportamento flex; os irmãos mantêm sua altura definida.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.Fill|Fill</code></td>
      <td>Os irmãos redimensionam verticalmente para preencher todo o contêiner pai, substituindo sua altura definida. O número de irmãos em uma coluna permanece inalterado; por exemplo, se três irmãos cabem verticalmente na altura do contêiner sob a configuração <code>Enum.UIFlexAlignment.None|None</code>, aqueles três irmãos redimensionarão para preencher toda a altura.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceAround|SpaceAround</code></td>
      <td>Os irmãos mantêm sua altura definida. Espaçamento igual é adicionado em ambos os lados de cada irmão.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceBetween|SpaceBetween</code></td>
      <td>Os irmãos mantêm sua altura definida. Espaçamento igual é adicionado <b>entre</b> os irmãos, mas nenhum espaço adicional é adicionado <b>ao redor</b> dos irmãos.</td>
    </tr>
    <tr>
      <td><code>Enum.UIFlexAlignment.SpaceEvenly|SpaceEvenly</code></td>
      <td>Os irmãos mantêm sua altura definida. Espaçamento igual é adicionado tanto <b>entre</b> quanto <b>ao redor</b> dos irmãos.</td>
    </tr>
  </tbody>
</table>

<img src="../../../assets/engine-api/classes/UIListLayout/VerticalFlex-Options.png" width="800" alt="Exemplos de UIListLayout mostrando como cada opção de VerticalFlex afeta o tamanho e espaçamento dos objetos de UI irmãos." />

##### Comportamento de Direção Cruzada

Em layouts de lista **horizontais** (`Class.UIListLayout.FillDirection|FillDirection` definido como
`Enum.FillDirection.Horizontal`), a propriedade `Class.UIListLayout.VerticalFlex|VerticalFlex` especifica como distribuir os irmãos na **direção cruzada vertical**. Em tais layouts, uma configuração de `Enum.UIFlexAlignment.Fill` faz com que os irmãos preencham todo o espaço vertical enquanto o espaçamento horizontal adere ao `Class.UIListLayout.HorizontalFlex|HorizontalFlex`.

<img src="../../../assets/engine-api/classes/UIListLayout/VerticalFlex-Cross-Direction.png" width="720" alt="Diagrama mostrando como VerticalFlex afeta o tamanho vertical dos objetos de UI irmãos quando a direção de preenchimento do UIListLayout está configurada como horizontal." />

##### Interação de AutomaticSize

Se `Class.GuiObject.AutomaticSize` estiver ativado para um filho do `Class.UIListLayout` na
`Class.UIListLayout.FillDirection|FillDirection`, ele é interpretado como "base flex automática" e define o tamanho do `Class.GuiObject` do qual pode crescer ou encolher.

Se `Class.GuiObject.AutomaticSize` estiver ativado para um filho do `Class.UIListLayout` na **direção cruzada**, ele é interpretado como "tamanho cruzado automático" e define o tamanho mínimo necessário para conter todo o conteúdo do filho na direção cruzada.


UIListLayout.VerticalFlex

Controla como distribuir espaço extra vertical.


Controla se os irmãos dentro do contêiner pai se empilham em outra linha quando seu tamanho padrão excede a largura/altura dos limites do contêiner.

<img src="../../../assets/engine-api/classes/UIListLayout/Wraps.png" width="800" alt="Diagrama mostrando como Wraps afeta como os irmãos são distribuídos dentro dos limites do contêiner pai." />


UIListLayout.Wraps

Controla se os irmãos dentro do contêiner pai se empilham.


Posiciona elementos de UI irmãos em linhas ou colunas dentro do contêiner UI pai.


A classe base para layouts de UI estilo grade.


Este exemplo de código demonstra a classificação de dados usando
`Class.UIGridStyleLayout.SortOrder` e `Class.GuiObject.LayoutOrder`.

O método ApplyLayout força os elementos de UI irmãos a serem readaptados no
caso de os critérios de ordenação poderem ter mudado (como quando
`Class.UIGridStyleLayout.SortOrder` é configurado para Custom, e o
comportamento de `Class.UIGridStyleLayout:SetCustomSortFunction()` mudou).
A readaptação acontece automaticamente quando elementos de UI são adicionados/removidos,
ou quando seu `Class.Instance.Name` ou `Class.GuiObject.LayoutOrder` mudam.

A forma como os elementos de UI irmãos são dispostos depende da
implementação desta classe abstrata. Em outras palavras, uma classe concreta
como `Class.UIListLayout` ou `Class.UIGridLayout` é responsável pela
disposição real dos elementos.


UIGridStyleLayout:ApplyLayout

Força o re-layout de elementos de UI irmãos.


Este método está obsoleto. Use `Class.UIGridStyleLayout.SortOrder`
em vez disso.

A função deve receber dois argumentos (cada um será um `Class.Instance`
filho a ser comparado) e retornar verdadeiro se a vem antes de b, caso contrário retorno
falso. Em outras palavras, use esta função da mesma forma que você usaria uma '
função. A ordenação deve ser determinística, caso contrário, a ordenação falhará
e cairá de volta para a ordem pelo nome.


UIGridStyleLayout:SetCustomSortFunction

function

Define a função usada para determinar a ordem dos elementos quando SortOrder
está configurado para Custom.


UIGridStyleLayout

A propriedade **AbsoluteContentSize** de um `Class.UIGridStyleLayout`
revela quanto espaço os elementos da grade estão ocupando, incluindo
qualquer preenchimento criado pela grade. Esta propriedade é particularmente útil para
ajustar contêineres de grades, como `Class.Frame|Frames`, para garantir que eles
não sejam maiores do que a própria grade.

Esta propriedade é atualizada assim que é lida. Ela não acionará um
evento `Class.Object.Changed` imediatamente após a UI ter mudado, mas se
o valor for lido, ele se tornará atual e um evento `Class.Object.Changed`
será acionado na próxima etapa de renderização.


UIGridStyleLayout.AbsoluteContentSize

O tamanho absoluto do espaço ocupado pelo layout da grade.


A propriedade **FillDirection** determina o eixo no qual os elementos de UI
são dispostos. `Enum.FillDirection.Horizontal` organiza objetos da esquerda
para a direita, enquanto `Enum.FillDirection.Vertical` organiza objetos de cima para
baixo. Para inverter elementos, como organizar da direita para a esquerda, você precisará
inverter a ordenação; por exemplo, negando os valores de
`Class.GuiObject.LayoutOrder` dos objetos de UI-filho quando
`Class.UIGridStyleLayout.SortOrder` estiver configurado para
`Enum.SortOrder.LayoutOrder`.

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


UIGridStyleLayout.FillDirection

Determina o eixo no qual os objetos de UI são dispostos.


A propriedade **HorizontalAlignment** determina o alinhamento ao longo do eixo **X**
dos elementos de UI da grade, assim como `Class.TextLabel.TextXAlignment`
faz com `Class.TextLabel.Text`.


UIGridStyleLayout.HorizontalAlignment

Determina o alinhamento horizontal dos elementos de UI dentro do elemento pai.


A propriedade **SortOrder** determina a ordem em que os objetos de UI-filho
são colocados em um layout.

Para `Enum.SortOrder.LayoutOrder`, uma ordenação ascendente é usada na
propriedade `Class.GuiObject.LayoutOrder|LayoutOrder` dos objetos de UI-filho. Se
dois filhos compartilharem o mesmo `Class.GuiObject.LayoutOrder|LayoutOrder`,
o que foi adicionado primeiro ao objeto pai tem preferência.

Para `Enum.SortOrder.Name`, uma ordenação alfanumérica é usada na
propriedade `Class.Instance.Name` dos objetos de UI-filho.

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


UIGridStyleLayout.SortOrder

Determina a ordem em que os objetos de UI-filho são colocados em um layout.


A propriedade **VerticalAlignment** determina o alinhamento ao longo do eixo **Y**
da grade de elementos de UI, assim como `Class.TextLabel.TextYAlignment` faz
com `Class.TextLabel.Text`.


UIGridStyleLayout.VerticalAlignment

Determina o alinhamento vertical dos elementos de UI dentro do elemento pai.


A classe base para classes de layout de UI.


UILayout

Uma classe base para classes de restrição e layout de UI; herda de
`Class.UIBase`.


UIComponent

Uma classe base para classes de restrição e layout de UI.


`Class.UIBase` é a classe base para classes de layout e restrição de UI.


UIBase

`Instance` é a classe base para todas as classes na hierarquia de classes do Roblox
que podem fazer parte da árvore `Class.DataModel`.

Não é possível criar diretamente objetos `Instance` raiz, mas o construtor especial
`Datatype.Instance.new()` cria objetos via código, recebendo o
nome da classe como um parâmetro e retornando o objeto criado.

Demonstra como detectar mudanças na ancestralidade de uma instância conectando-se ao
`Class.Instance.AncestryChanged` evento.

O Parent do ChangingPart é definido para valores diferentes ao longo do tempo. O pai da
peça é o ancestral da peça, então o evento `Class.Instance.AncestryChanged`
será acionado sempre que mudar.


Dispara quando esta instância é reparentada ou quando qualquer um de seus
ancestrais é reparentado.

Você pode usar este evento para rastrear a exclusão de uma instância no
Studio, como exclusão manual no Explorer ou por meio de um plugin. Se
você precisar detectar quando uma instância é destruída usando
`Class.Instance:Destroy()`, use o evento `Class.Instance.Destroying`
em vez disso.

Instance.AncestryChanged

child

A instância cuja propriedade `Class.Instance.Parent|Parent` foi alterada,
que pode ser esta instância ou um ancestral mais distante, **não**
necessariamente a instância à qual o manipulador está conectado.

parent

Dispara quando a propriedade `Class.Instance.Parent` deste objeto ou um de
seus ancestrais é alterada.

Este evento dispara sempre que qualquer atributo é alterado na instância,
 incluindo quando um atributo é definido como `nil`. O nome do atribuito que foi
alterado é passado para a função conectada.

Por exemplo, o seguinte trecho de código conecta a função
`attributeChanged()` para disparar sempre que um dos atributos do
objeto muda:

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

local part = Workspace.Part

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

part.AttributeChanged:Connect(attributeChanged)
```
Veja também `Class.Instance:GetAttributeChangedSignal()` que retorna um
evento que dispara quando um atributo específico é alterado.

Instance.AttributeChanged

attribute

Dispara sempre que um atributo é alterado na `Class.Instance`.

Este trecho imprime os nomes dos objetos à medida que são adicionados ao Workspace:

Dispara após um objeto ser parentado a esta `Class.Instance`.

Observe que, ao usar este método em um cliente para detectar objetos
criados pelo servidor, é necessário usar `Class.Instance:WaitForChild()` ao
indexar os descendentes desses objetos. Isso ocorre porque o objeto e seus
descendentes não são garantidos a serem replicados do servidor para o cliente
simultaneamente. Por exemplo:

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

Workspace.ChildAdded:Connect(function(child)
	-- Use WaitForChild() já que os descendentes podem não ter sido replicados ainda
	local head = child:WaitForChild("Head")
end)
```
Observe que este evento opera apenas para filhos imediatos do
`Class.Instance`. Para um evento que captura todos os descendentes, use
`Class.Instance.DescendantAdded`.

Veja também `Class.Instance.ChildRemoved`.

Instance.ChildAdded

Dispara após um objeto ser parentado a esta `Class.Instance`.

Instance.childAdded

Este trecho imprime os nomes dos objetos à medida que são removidos do
Workspace:

Dispara após um filho ser removido deste `Class.Instance`.

Removido refere-se a quando o pai de um objeto é alterado de
este `Class.Instance` para algo diferente deste `Class.Instance`. Observe que,
este evento também disparará quando um filho for destruído (usando
`Class.Instance:Destroy()`), já que a função de destruição define o pai de um objeto como `nil`.

Este evento opera apenas para filhos imediatos do `Class.Instance`.
Para um evento que captura todos os descendentes, use
`Class.Instance.DescendantRemoving`.

Veja também `Class.Instance.ChildAdded`.

Instance.ChildRemoved

Dispara após um filho ser removido deste `Class.Instance`.

Este exemplo a seguir imprimirá o nome de qualquer objeto que for adicionado ao
Espaço de Trabalho:

Este evento dispara após um descendente ser adicionado à `Class.Instance`.

Como ele dispara para cada descendente, parentear um objeto à
`Class.Instance` fará com que o evento dispare para este objeto e todos os seus
descendentes individualmente.

Se você está apenas preocupado com os **filhos diretos** do
`Class.Instance`, use `Class.Instance.ChildAdded` em vez disso.

Veja também `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

Dispara após um descendente ser adicionado à `Class.Instance`.

O seguinte exemplo imprime o nome de qualquer descendente enquanto está sendo removido
do Workspace:

Este evento dispara **imediatamente antes** de o pai `Class.Instance`
ser alterado de forma que uma instância **descendente** não será mais um
descendente. `Class.Instance:Destroy()|Destroy()` altera o
`Class.Instance.Parent|Parent` de uma instância para `nil`, então chamar esse método em um
descendente do pai fará com que este evento dispare.

Como este evento dispara **antes** da remoção do descendente, o pai do
descendente permanecerá inalterado no momento da disparação deste evento. Se o
descendente também for um **filho direto** do pai, este evento disparará
antes de `Class.Instance.ChildRemoved`.

Se um descendente tiver filhos, este evento dispara primeiro com o descendente,
seguido por seus descendentes.

#### Aviso

Este evento dispara com o objeto descendente que está sendo removido.
Tentar definir o `Class.Instance.Parent|Parent` do descendente para
algo diferente falhará. Abaixo está um exemplo que demonstra isso:

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

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Não manipule o pai do descendente nesta função!
	-- Este evento dispara POR CAUSA de a parentagem ter sido manipulada, e a alteração
	-- ainda não aconteceu
	-- Portanto, é problemático alterar o pai assim:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```
Veja também `Class.Instance.DescendantAdded|DescendantAdded`.

Instance.DescendantRemoving

O `Class.Instance` que está sendo removido.

Dispara imediatamente antes de um descendente do `Class.Instance` ser removido.

Este exemplo demonstra como, ao usar o comportamento de sinal Imediato, uma
Instância sendo destruída permanece no lugar até que a função conectada faça yield.


Este exemplo demonstra como, ao usar o comportamento de sinal Deferred, uma Instância
é destruída antes que o sinal seja acionado.


O `Class.Instance` nunca será excluído da memória enquanto uma função conectada
estiver ainda usando-o. No entanto, se a função pausar em algum momento,
o `Class.Instance` e seus descendentes serão parentados para `nil`.

Se a propriedade `Class.Workspace.SignalBehavior` estiver definida como
`Enum.SignalBehavior.Immediate`, este evento dispara imediatamente antes do
`Class.Instance` ou um de seus ancestrais ser destruído com
`Class.Instance:Destroy()`.

Se a propriedade `Class.Workspace.SignalBehavior` estiver definida como
`Enum.SignalBehavior.Deferred`, este evento dispara no próximo
ponto de retomar, que será após o `Class.Instance` ou um de seus
ancestrais serem destruídos com `Class.Instance:Destroy()`.

Com o comportamento `Enum.SignalBehavior.Deferred|Deferred`, conectar um script
ao seu próprio evento `Class.Instance.Destroying` é problemático, já que o script
será destruído antes que o callback possa ser chamado (o que significa que não
será executado).

Ao excluir um `Class.Instance` no Studio, como excluir manualmente
por meio do [Explorer](/studio/explorer) ou por meio de um plugin,
o `Class.Instance` não é destruído. Em vez disso, o pai é definido como `nil`
que você pode rastrear com `Class.Instance.AncestryChanged`.

Instance.Destroying

Dispara imediatamente antes (ou é adiado até depois) da instância ser
 destruída através de `Class.Instance:Destroy()`.

Este evento dispara sempre que qualquer propriedade de estilo é alterada na instância,
incluindo quando uma propriedade é definida como `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("Propriedades de estilo alteradas")
end

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

Instance.StyledPropertiesChanged

Dispara sempre que qualquer propriedade de estilo é alterada na instância, incluindo
quando uma propriedade é definida como `nil`.

Este método aplica uma tag à instância, sem efeito se a tag já estiver
aplicada. Adicionar uma tag com sucesso acionará um sinal criado por
`Class.CollectionService:GetInstanceAddedSignal()` com a tag fornecida.

#### Avisos

- As tags de uma instância que foram adicionadas do lado do cliente serão
  descartadas se o servidor posteriormente adicionar ou remover uma tag nessa
  instância, porque o servidor replica todas as tags juntas e
  sobrepõe as tags anteriores.

- Ao marcar uma instância, é comum que alguns recursos sejam usados para
dar funcionalidade à tag, por exemplo, conexões de eventos ou tabelas.
  Para evitar vazamentos de memória, é uma boa ideia limpar esses recursos
enquanto não forem mais necessários para uma tag. Faça isso ao
  chamar `Class.Instance:RemoveTag()`, chamando
  `Class.Instance:Destroy()`, ou em uma função conectada a um sinal
  retornado por `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

A função filhos retorna um array dos filhos do objeto.

Instance:children

Este método destrói todos os filhos e descendentes de uma instância.

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

-- Adiciona alguns brilhos
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
```
Se você não desejar destruir **todos** os filhos e descendentes, use
`Class.Instance:GetChildren()` ou `Class.Instance:GetDescendants()` para
desloopar esses filhos/descendentes e selecionar o que deve ser destruído. Por
exemplo, o seguinte exemplo de código destruirá todos os`Class.BasePart|BaseParts`
descendentes de um `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

Este método destrói todos os filhos de uma instância.

Demonstra como clonar um modelo usando `Class.Instance:Clone()`.

`Clone()` cria uma cópia de uma instância e todos os seus descendentes,
ignorando todas as instâncias que não são
`Class.Instance.Archivable|Archivable`. A cópia da instância raiz é
retornada por este método e seu `Class.Instance.Parent|Parent` é definido como
`nil`. Observe que, se a própria instância tiver
`Class.Instance.Archivable|Archivable` definido como `false`, este método
retornará `nil`.

Se uma propriedade de referência, como `Class.ObjectValue.Value`, estiver definida em uma
instância clonada, o valor da propriedade da cópia depende do valor do
original:

- Se uma propriedade de referência se referir a uma instância que também foi
  clonada, a cópia se referirá à cópia.
- Se uma propriedade de referência se referir a uma instância que **não** foi clonada,
  o mesmo valor é mantido na cópia.

Instance:Clone

Cria uma cópia de uma instância e todos os seus descendentes, ignorando instâncias
que não são `Class.Instance.Archivable|Archivable`.

Instance:clone

Demonstra a destruição de uma Parte usando a função `Class.Instance:Destroy()`.

Esta função é a maneira correta de descartar objetos que não são mais
necessários.


Define a propriedade `Class.Instance.Parent` como `nil`, tranca a
propriedade `Class.Instance.Parent`, desconecta todas as conexões e chama
`Destroy()` em todos os filhos. Este método é a maneira correta de descartar
objetos que não são mais necessários.

Descartar objetos desnecessários é importante, uma vez que objetos e
conexões desnecessárias em um lugar ocupam memória que pode levar a sérios problemas de
desempenho ao longo do tempo.

Como uma boa prática, após chamar `Destroy()` em um objeto, defina qualquer
variável que referencia o objeto (ou seus descendentes) como `nil`. Isso
impede que seu código acesse qualquer coisa relacionada ao objeto.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- Não faça isso:
print(part.Name)  --> "Hello, world"
-- Faça isso para evitar que a linha acima funcione:
part = nil
```
Uma vez que uma `Class.Instance` tenha sido destruída por este método, não pode ser
reutilizada porque a propriedade `Class.Instance.Parent` é trancada. Para
remover **temporariamente** um objeto em vez de destruí-lo, defina
`Class.Instance.Parent|Parent` como `nil`. Por exemplo:

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

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Para destruir um objeto após um tempo determinado, use
`Class.Debris:AddItem()`.

Instance:Destroy

Define a propriedade `Class.Instance.Parent` como `nil`, tranca a
propriedade `Class.Instance.Parent`, desconecta todas as conexões e chama
`Destroy()` em todos os filhos.

Instance:destroy

Retorna o primeiro ancestral da `Class.Instance` cujo
`Class.Instance.Name` é igual ao nome fornecido.

Este método funciona para cima, o que significa que começa no
`Class.Instance.Parent` imediato da instância e sobe em direção ao
`Class.DataModel`. Se nenhum ancestral correspondente for encontrado, retorna
`nil`.

O seguinte trecho de código encontraria o primeiro ancestral do objeto
chamado `Car`.

```
local car = object:FindFirstAncestor("Car")
```
Para variantes deste método que encontram ancestrais de uma classe específica,
veja `Class.Instance:FindFirstAncestorOfClass()` e
`Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

Retorna o primeiro ancestral da `Class.Instance` cujo
`Class.Instance.Name` é igual ao nome fornecido.

Retorna o primeiro ancestral da `Class.Instance` cujo
`Class.Object.ClassName` é igual ao nome da classe fornecida.

Este método funciona para cima, o que significa que começa no
`Class.Instance.Parent` imediato da instância e sobe em direção ao
`Class.DataModel`. Se nenhum ancestral correspondente for encontrado, retorna `nil`.

Um uso comum deste método é encontrar o `Class.Model` a que um
`Class.BasePart` pertence. Por exemplo:

```
local model = part:FindFirstAncestorOfClass("Model")
```
Este método é uma variante de `Class.Instance:FindFirstAncestor()` que
verifica a propriedade `Class.Object.ClassName` em vez de
`Class.Instance.Name`. `Class.Instance:FindFirstAncestorWhichIsA()` também
existe, usando o método `Class.Object:IsA()` em vez disso para respeitar a
herança de classe.

Instance:FindFirstAncestorOfClass

className

O `Class.Object.ClassName` a ser procurado.

Retorna o primeiro ancestral da `Class.Instance` cujo
`Class.Object.ClassName` é igual ao nome da classe fornecida.

Retorna o primeiro ancestral da `Class.Instance` para quem
`Class.Object:IsA()` retorna verdadeiro para o nome da classe fornecida.

Este método funciona para cima, o que significa que começa no
`Class.Instance.Parent` imediato da instância e sobe em direção ao
`Class.DataModel`. Se nenhum ancestral correspondente for encontrado, retorna
`nil`.

Diferente de `Class.Instance:FindFirstAncestorOfClass()`, este método usa
`Class.Object:IsA()` que respeita a herança de classe. Por exemplo:

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
Portanto, o seguinte exemplo de código retornará o primeiro
ancestral `Class.BasePart`, independentemente de ser um `Class.WedgePart`,
`Class.MeshPart` ou `Class.Part`.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```
Veja também `Class.Instance:FindFirstAncestor()`.

Instance:FindFirstAncestorWhichIsA

Retorna o primeiro ancestral da `Class.Instance` para quem
`Class.Object:IsA()` retorna verdadeiro para o nome da classe fornecida.

O abaixo procurará no Workspace por um objeto chamado "Brick". Se encontrado, ele
mudará o nome do objeto para "Foo".

Retorna o primeiro filho da `Class.Instance` com o nome fornecido, ou
`nil` se não existir tal filho. Se o argumento opcional `recursive` for
`true`, este método busca todos os descendentes em vez de apenas os
filhos imediatos da `Class.Instance`.

#### Verificando a Existência de um Objeto

`FindFirstChild()` é necessário se você precisa verificar se um objeto existe
antes de continuar. Tentar indexar um filho pelo nome usando o operador de ponto
gera um erro se o filho não existir.

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

-- A linha a seguir gera um erro se a parte não existir no workspace
Workspace.Part.Transparency = 0.5
```
Uma abordagem melhor é usar `FindFirstChild()` para primeiro verificar o `Part`,
seguido de uma instrução `if` para executar o código que precisa dele.

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

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

#### Encontrando um Filho Cujo Nome Corresponde a uma Propriedade

Às vezes o `Class.Instance.Name|Name` de um objeto é o mesmo que o de uma
propriedade do seu `Class.Instance.Parent|Parent`. Ao usar o operador de ponto,
propriedades têm precedência sobre filhos se compartilharem um nome.

No exemplo a seguir, uma `Class.Folder` chamada `Color` é adicionada a um
`Class.Part`, que também tem a propriedade `Class.Part.Color`. Observe que
`part.Color` se refere ao valor da propriedade `Datatype.Color3`, não à instância do filho
`Class.Folder`. Uma vantagem de usar
`Class.Instance:FindFirstChild()|FindFirstChild()` é que a introdução de novas
propriedades não impõe risco ao seu código.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- A propriedade
local c2 = part:FindFirstChild("Color")  -- A pasta filha
```

#### Notas de Desempenho

`Class.Instance:FindFirstChild()|FindFirstChild()` leva cerca de 20% mais
com tempo do que usar o operador de ponto e quase 8 vezes mais do que apenas armazenar
uma referência a um objeto. Portanto, você deve evitar chamá-lo em
código dependente de desempenho, como em loops apertados ou funções conectadas
a `Class.RunService.Heartbeat` e `Class.RunService.PreRender`. Em vez disso,
estocou o resultado em uma variável, ou considere usar
`Class.Instance.ChildAdded|ChildAdded` ou
`Class.Instance:WaitForChild()|WaitForChild()` para detectar quando um filho de um
dado nome se torna disponível.

Instance:FindFirstChild

recursive

Se a busca deve ser realizada recursivamente.

Retorna o primeiro filho da `Class.Instance` encontrado com o nome fornecido.

Instance:findFirstChild

Retorna o primeiro filho da `Class.Instance` cuja
`Class.Object.ClassName|ClassName` é igual ao `className` fornecido.
Diferente de `Class.Instance:FindFirstChildWhichIsA()`, este método só
retorna objetos cuja classe corresponde ao `className`, ignorando a herança
de classe. Se nenhum filho correspondente for encontrado, este método
retorna `nil`.

Instance:FindFirstChildOfClass

Retorna o primeiro filho da `Class.Instance` cuja
`Class.Object.ClassName|ClassName` é igual ao nome da classe fornecida.

Retorna o primeiro filho da `Class.Instance` para quem
`Class.Object:IsA()` retorna verdadeiro para o nome da classe fornecida.

Se nenhum filho correspondente for encontrado, este método retorna `nil`. Se o argumento
o opcional recursivo for `true`, este método busca todos os descendentes em vez
apenas dos filhos imediatos da `Class.Instance`.

Diferente de `Class.Instance:FindFirstChildOfClass()`, este método usa
`Class.Object:IsA()` que respeita a herança de classe. Por exemplo:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Portanto, o seguinte exemplo de código retornará o primeiro
filho `Class.BasePart`, independentemente de ser um `Class.WedgePart`,
`Class.MeshPart` ou `Class.Part`.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```
Desenvolvedores que procuram um filho pelo nome devem usar
`Class.Instance:FindFirstChild()` em vez disso.

Instance:FindFirstChildWhichIsA

Retorna o primeiro filho da `Class.Instance` para quem
`Class.Object:IsA()` retorna verdadeiro para o nome da classe fornecida.

Retorna o primeiro descendente encontrado com o dado `Class.Instance.Name`.

Este método está desabilitado e não pode ser usado. Para encontrar o primeiro descendente
 de uma instância, considere usar o parâmetro `recursive` em
 `Class.Instance:FindFirstChild()` em vez disso.

Instance:FindFirstDescendant

Retorna o primeiro descendente encontrado com o dado `Class.Instance.Name`.

Se a `Class.Instance` for um `Class.Actor`, o próprio `Class.Actor` é
retornado. Caso contrário, seu ancestral `Class.Actor` mais próximo é retornado. Se nenhum
ancestral for um `Class.Actor`, o resultado é `nil`.

Instance:GetActor

Retorna o `Class.Actor` associado à Instância, se houver.

Este método retorna o valor que foi atribuído ao nome do atributo fornecido. Se
nenhum atributo foi atribuído, `nil` é retornado.

Por exemplo, o seguinte trecho de código define e depois obtém o valor do
atributo `InitialPosition` da instância:

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

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

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

#### Veja Também

- `Class.Instance:SetAttribute()` que define o atributo com o nome fornecido
  para o valor fornecido.
- `Class.Instance:GetAttributes()` que retorna um dicionário de pares chave-valor
  para cada um dos atributos da instância.

Instance:GetAttribute

O nome do atributo que está sendo recuperado.

O valor que foi atribuído ao nome do atributo fornecido. Se nenhum
atributo foi atribuído, `nil` é retornado.

Retorna o valor que foi atribuído ao nome do atributo fornecido.

Este método retorna um evento que se comporta exatamente como o
evento `Class.Object.Changed|Changed`, exceto que ele só é acionado quando o
atributo específico fornecido muda; efetivamente é similar a
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` mas
para atributos.

É geralmente uma boa ideia usar este método em vez de uma conexão para
`Class.Object.Changed|Changed` com uma função que verifica o nome do atributo.
Chamadas subsequentes para este método no mesmo objeto com o mesmo
nome de atributo retornam o mesmo evento.

O seguinte exemplo de código retorna um sinal que dispara a função
`attributeChanged()` quando o atributo `InitialPosition` da parte muda:

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

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

local function attributeChanged()
	print("Atributo alterado")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```
Veja também `Class.Instance.AttributeChanged` que é acionado sempre que qualquer
atributo é alterado na instância.

Instance:GetAttributeChangedSignal

O nome do atributo especificado para o qual o sinal de mudança está
sendo retornado.

Um evento que é acionado quando o atributo fornecido muda.

Retorna um evento que é acionado quando o atributo fornecido muda.

Este método retorna um dicionário de pares chave-valor para cada atributo
onde a chave é o nome do atributo e o valor é um valor não-nulo.

Por exemplo, o seguinte trecho de código exibe os atributos
 e valores de uma instância:

```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
```
Veja também `Class.Instance:GetAttribute()` que retorna o valor que foi
atribuído ao nome do atributo fornecido.

Instance:GetAttributes

Um dicionário de pares string → variante para cada atributo onde a
string é o nome do atributo e a variante é um valor não-nulo.

Retorna um dicionário dos atributos da instância.

O abaixo imprimiria o nome de todos os objetos atualmente no Workspace quando executado.

Retorna um array (uma tabela indexada numericamente) contendo todos os
filhos diretos da instância, ou cada `Class.Instance` cujo
`Class.Instance.Parent|Parent` é igual ao objeto. O array pode ser
iterado usando um loop numérico ou genérico:

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

-- Exemplo de loop numérico
local children = Workspace:GetChildren()
for i = 1, #children do
	local child = children[i]
	print(child.Name .. " é filho número " .. i)
end
```

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

-- Exemplo de loop genérico
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " é filho número " .. i)
end
```
Observe que o array retornado **não** é ordenado em nenhuma ordem particular, então
uma ordenação manual (por exemplo, usando `Library.table.sort()`) é recomendada para
ordenar os filhos retornados por este método.

Veja também o método `Class.Instance:GetDescendants()|GetDescendants()`.

Instance:GetChildren

Um array contendo os filhos da instância.

Retorna um array contendo todos os filhos da instância.

Instance:getChildren

Retorna uma string codificada do ID de depuração usado internamente pelo Roblox. Observe que:

- Este item é protegido. Tentar usá-lo em um `Class.Script` ou
  `Class.LocalScript` causará um erro.
- Um ID de depuração é um ID usado em processos de depuração. Ele permite que um depurador leia
  cada instrução antes que um aplicativo a processe. Todos os objetos no
  Roblox agem como processos e cada execução de instruções (ou 'código')
pode ser depurada se necessário.
- Isso pode ser útil para plugins que precisam distinguir objetos similares
de um ao outro (como objetos que compartilham o mesmo nome).

Instance:GetDebugId

scopeLength

Retorna uma string codificada do ID de depuração usado internamente pelo Roblox.

GetDescendants é frequentemente usado para fazer algo com todos os descendentes que são de um
tipo específico de objeto. O código neste exemplo usa GetDescendants e
`Class.Instance:IsA()` para encontrar todas as partes no workspace e as torna
verdes.

Este método de objeto retorna um array que contém todos os descendentes
 daquele objeto. Diferente de `Class.Instance:GetChildren()`, que só retorna
 os filhos imediatos de um objeto, este método encontra cada filho do
 objeto, cada filho desses filhos, e assim por diante.

Observe que o array retornado **não** é ordenado em nenhuma ordem particular, então
uma ordenação manual (por exemplo, usando `Library.table.sort()`) é recomendada para
ordenar os descendentes retornados por este método. Também considere o
método `Class.Instance:QueryDescendants()|QueryDescendants()` para consultar
descendentes por uma combinação de seletores e combinadores.

Instance:GetDescendants

Um array contendo os descendentes da instância.

Retorna um array contendo todos os descendentes da instância.

Este exemplo de código demonstra o comportamento de `Class.Instance:GetFullName()`.
Ele mostra como a função se comporta ao ser chamada em um objeto que não está na
hierarquia `DataModel`, e também mostra como o valor de retorno não escapa
caracteres especiais.

Este exemplo de código reimplementa a função `Class.Instance:GetFullName()` em
Lua.

Retorna uma string descrevendo a ancestralidade da instância. A string é uma
concatenação do `Class.Instance.Name|Name` do objeto e seus
ancestrais, separados por pontos. O `Class.DataModel` (`game`) não
é considerado. Por exemplo, um `Class.Part` no `Class.Workspace` pode
retornar `Class.Workspace.Part`.

Quando chamado em uma `Class.Instance` que não é um descendente do
`Class.DataModel`, este método considera todos os ancestrais até e incluindo
o mais alto que não tenha um `Class.Instance.Parent|Parent`.

Este método é útil para registro e depuração. Você não deve tentar
analisar a string retornada para qualquer operação útil; este método não
escapa pontos (ou qualquer outro símbolo) em nomes de objetos. Em outras palavras,
embora sua saída frequentemente pareça ser um identificador Luau válido, não é
garantido.

Instance:GetFullName

Retorna uma string descrevendo a ancestralidade da instância.

Este método retorna o valor estilizado ou explicitamente modificado da
propriedade especificada, ou o valor padrão da propriedade se não tiver sido
estilizado/modificado. Isso difere ligeiramente do acesso ao valor da propriedade
diretamente, como `[GuiObject].Rotation`, que retorna o valor padrão ou
modificado da propriedade.

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

-- Referência a um botão
local button = HUDContainer:FindFirstChildWhichIsA("TextButton")

print(button:GetStyled("Rotation")) --> 0 (valor padrão)
print(button.Rotation) --> 0 (valor padrão)

-- Aplique rotação através da propriedade da regra de estilo
rule:SetProperty("Rotation", 30)

print(button:GetStyled("Rotation")) --> 30 (valor estilizado com base na regra)
print(button.Rotation) --> 0 (valor padrão)

-- Modificar/substituir explicitamente propriedade estilizada
button.Rotation = 45

print(button:GetStyled("Rotation")) --> 45 (valor modificado)
print(button.Rotation) --> 45 (valor modificado)
```

Instance:GetStyled

selector

Selecionador opcional para a pseudo instância que você está mirando na
instância.

O valor estilizado ou explicitamente modificado da propriedade especificada, ou
 o valor padrão da propriedade se não tiver sido estilizado/modificado.

Retorna o valor estilizado ou explicitamente modificado da propriedade especificada,
ou o valor padrão da propriedade se não tiver sido estilizado/modificado.

Este método retorna um evento que se comporta exatamente como o
evento `Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged`,
exceto que ele só é acionado quando a propriedade de estilo dada muda. É
geralmente uma boa ideia usar este método em vez de uma conexão para
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` com uma
função que verifica o nome da propriedade. Chamadas subsequentes a esse método
no mesmo objeto com o mesmo nome de propriedade retornam o mesmo evento.

Observe que este evento não passará argumentos para uma função conectada,
sendo necessário ler o valor da propriedade alterada diretamente dentro de um
script.

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

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

local function stylePropertyChanged()
	print("A propriedade de estilo mudou!")
end

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

Instance:GetStyledPropertyChangedSignal

property

Nome da propriedade de estilo para a qual escutar mudanças.

Evento que é acionado quando a propriedade de estilo dada muda.

Este método retorna um array das tags aplicadas à dada instância, como
strings. Você pode adicionar tags tanto no Studio na
[Propriedades](/studio/properties) quanto em tempo de execução com
`Class.Instance:AddTag()|AddTag()`.

Este método é útil quando você deseja fazer algo com várias tags em
uma instância ao mesmo tempo. No entanto, é ineficiente usar este método para
verificar a existência de uma única tag; em vez disso, use
`Class.Instance:HasTag()|HasTag()` para verificar por uma tag específica.

Instance:GetTags

Obtém um array de todas as tags aplicadas à instância.

Este método retorna `true` se a tag fornecida foi adicionada ao
objeto. Você pode adicionar tags tanto no Studio na
[Propriedades](/studio/properties) quanto em tempo de execução com
`Class.Instance:AddTag()|AddTag()`.

Instance:HasTag

Verifica se a instância tem uma tag dada.

Demonstra como determinar se uma instância é o antepassado de outra usando
`Class.Instance:IsAncestorOf()`

Workspace e SpawnLocation são antepassados do decalque de SpawnLocation.
Workspace é um antepassado de SpawnLocation.

SpawnLocation e seu decalque são descendentes do Workspace, não antepassados.
Decalque é um descendente de SpawnLocation, não um antepassado.


Retorna verdadeiro se uma `Class.Instance` é um ancestral do dado
descendente.

Uma `Class.Instance` é considerada o ancestral de um objeto se o
`Class.Instance.Parent` do objeto ou um de seus pais
`Class.Instance.Parent` estiver definido como a `Class.Instance`.

Veja também, `Class.Instance:IsDescendantOf()`.

Instance:IsAncestorOf

Verdadeiro se a `Class.Instance` é um ancestral do dado descendente.

Retorna verdadeiro se uma `Class.Instance` é um ancestral do dado
descendente.

Retorna `true` se uma `Class.Instance` é um descendente do dado
ancestral.

Observe que `IsDescendantOf()` não pode ser usado com um parâmetro `nil` para
verificar se um objeto foi removido.

Veja também `Class.Instance:IsAncestorOf()`.

Instance:IsDescendantOf

ancestor

Verdadeiro se a `Class.Instance` é um descendente do dado ancestral.

Retorna `true` se uma `Class.Instance` é um descendente do dado
ancestral.

Instance:isDescendantOf

Este método indica se uma propriedade específica foi modificada a partir
 do padrão instanciado por código. Se chamado em uma instância recém-criada via
código (`Datatype.Instance.new()`), este método retornará `false`. Se
chamado em um objeto recém-criado por fluxos de trabalho do Studio, como
 a inserção da janela [Explorer](/studio/explorer), o resultado pode
 mudar.

Por exemplo, consultar a
`Class.TextLabel.BackgroundColor3|BackgroundColor3` propriedade de um
`Class.TextLabel` inserido via janela [Explorer](/studio/explorer)
retornará `true`, mas consultar a mesma propriedade de um `Class.TextLabel`
 criada através de `Datatype.Instance.new()` retornará `false`, supondo que não
outras alterações tenham sido feitas ao seu
`Class.TextLabel.BackgroundColor3|BackgroundColor3`.

Observe que este método só retorna resultados úteis para serviços e
instâncias criáveis pelo usuário. Valores de retorno para propriedades populadas por
sistema de instâncias como `Class.PackageLink` têm comportamento indefinido.

Além disso, observe que se este método retornar `true`, a estilização **não** afetará
 a propriedade porque a modificação explícita de uma propriedade tem precedência sobre
 a estilização dela. Para redefinir uma propriedade para seu padrão instanciado por código
e permitir que a estilização a afete, use
`Class.Instance:ResetPropertyToDefault()|ResetPropertyToDefault()`.

Instance:IsPropertyModified

Retorna `true` se o valor armazenado na propriedade especificada não é igual
o padrão instanciado por código.

Instance

`Instance` é a classe base para todas as classes na hierarquia de classes do Roblox
que podem fazer parte da árvore `Class.DataModel`.

/reference/engine/classes/UIListLayout.yaml