Este exemplo de código inclui um breve trecho que cria uma grande explosão no
jogo em 0, 10, 0.

Uma Explosão aplica força a `Class.BasePart|BaseParts` dentro do
`Class.Explosion.BlastRadius|BlastRadius`. Essa força quebra
`Class.JointInstance|JointInstances` e
`Class.WeldConstraint|WeldConstraints` entre partes e mata
personagens `Class.Humanoid` não protegidos por um `Class.ForceField`.
`Class.Constraint|Constraints` não será quebrado por uma explosão.

Se uma `Class.Explosion` estiver aninhada em qualquer lugar no modelo de dados enquanto a
experiência estiver em execução, ela dispara imediatamente e, dentro de alguns segundos, ela
se torna desanexada. Ela não é destruída com `Class.Instance:Destroy()` neste
caso, então conexões não são desconectadas e o pai não é
bloqueado. Como com todas as instâncias, manter uma referência forte a uma `Class.Explosion`
evitará que ela seja coletada como lixo.

Note que uma `Class.Explosion` deve ser um descendente de `Class.Workspace` para
que os visuais da explosão sejam reproduzidos e os efeitos físicos/danosos tenham um
impacto.

#### Efeitos da Explosão

`Class.Humanoid|Humanoids` são mortos por explosões, já que a explosão quebra
a articulação do pescoço do modelo `Class.Model` do personagem. Aninhar um `Class.ForceField` a um
modelo protegerá todos os seus filhos do efeito de morte da explosão.

Se você não deseja que as articulações entre `Class.BasePart|BaseParts` sejam quebradas, ou
se deseja implementar sua própria fórmula para danificar
`Class.Humanoid|Humanoids`, é recomendável que você defina
`Class.Explosion.DestroyJointRadiusPercent|DestroyJointRadiusPercent` para 0 e
use o evento `Class.Explosion.Hit|Hit` para lidar com o resultado da explosão.

Explosões também podem ser configuradas para danificar `Class.Terrain`, criando crateras,
conforme configurado através da propriedade `Class.Explosion.ExplosionType|ExplosionType`.

Note que o efeito de uma explosão **não** é interrompido por obstáculos,
o que significa que partes/terreno protegidos atrás de outras partes/terreno ainda serão
afetados.


Este exemplo contém uma função simples que cria uma explosão personalizada. A
explosão personalizada não quebrará articulações, pois Explosion.DestroyJointRadiusPercent
é igual a 0. Isso significa que Humanoides não serão instantaneamente mortos, pois suas articulações
do pescoço não são quebradas. Neste exemplo, explosion.BlastPressure é igual a zero para
não aplicar força ou danificar o terreno, mas isso pode ser alterado.

O evento Explosion.Hit é usado para ouvir contatos. Uma vez que o contato foi realizado,
o código procurará o modelo pai da BasePart atingido pela
explosão. Se esse modelo existir, não tiver sido danificado e tiver um
Humanoid, o dano será aplicado com base na distância da origem da explosão.

Dispara quando a `Class.Explosion` atinge um `Class.BasePart` dentro de seu
`Class.Explosion.BlastRadius`. Retorna a parte atingida junto com a
distância da parte em relação a `Class.Explosion.Position`.

Note que o efeito de uma `Class.Explosion` não é interrompido por
obstáculos, isso significa que partes protegidas atrás de outras partes ainda serão atingidas,
mesmo que a `Class.BasePart` que elas estão protegidas atrás esteja ancorada.

Este evento também será disparado quando `Class.Explosion.BlastPressure` for igual a
zero. Isso significa que os desenvolvedores podem programar seu próprio comportamento personalizado para
explosões eliminando a influência da explosão sobre
`Class.BasePart|BaseParts` e `Class.Terrain`.

Note que este evento será disparado para cada `Class.BasePart` atingido. Isso significa
que pode ser disparado várias vezes para o mesmo personagem jogador (já que o
modelo `Class.Model` do personagem é composto por várias partes). Por essa razão, ao lidar com
danos personalizados usando o evento `Class.Explosion.Hit`, é recomendável implementar uma verificação para ver se o personagem já foi atingido pela
`Class.Explosion`.


Explosion.Hit

part

O `Class.BasePart` atingido pela `Class.Explosion`.


distance

A distância do impacto em relação a `Class.Explosion.Position`.


Dispara quando a `Class.Explosion` atinge um `Class.BasePart` dentro de seu
`Class.Explosion.BlastRadius`. Retorna a parte atingida junto com a
distância da parte em relação a `Class.Explosion.Position`.


Explosion

Usado para determinar a quantidade de força aplicada a
`Class.BasePart|BaseParts` capturados no `Class.Explosion.BlastRadius`.

Atualmente, esse nível de força aplicada não varia com base na distância de
`Class.Explosion.Position`. `BaseParts` não ancorados acelerarão igualmente
longe da origem, independentemente da distância, contanto que estejam dentro do
raio de explosão.

A pressão da explosão determina a aceleração das partes devido a uma
explosão. Não determina o grau em que as articulações são quebradas.
Quando `Class.Explosion.DestroyJointRadiusPercent` é igual a 1, todas as articulações
entre partes no `Class.Explosion.BlastRadius` serão destruídas
desde que a BlastPressure seja maior que 0.

A BlastPressure também não determina a quantidade de dano causado a
`Class.Terrain`. Desde que a BlastPressure seja maior que 0 e
`Class.Explosion.ExplosionType` não esteja definido como Enum.ExplosionType.NoCraters,
o tamanho da cratera criada é determinado exclusivamente pelo
`Class.Explosion.BlastRadius`.

Definir a BlastPressure para 0 elimina o efeito da explosão e é
útil quando os desenvolvedores desejam programar seu próprio comportamento personalizado para
explosões usando o evento `Class.Explosion.Hit`.


Explosion.BlastPressure

Usado para determinar a quantidade de força aplicada a
`Class.BasePart|BaseParts` capturados no `Class.Explosion.BlastRadius`.


Esta propriedade determina o raio da `Class.Explosion`, em studs.
Esta propriedade aceita qualquer valor entre 0 e 100.

Este raio determina a área de efeito da explosão, não o tamanho
dos visuais da explosão. O tamanho do efeito visual da explosão
é o mesmo, independentemente do BlastRadius (mesmo se o BlastRadius for 0).

`Class.BasePart|BaseParts` dentro do BlastRadius serão afetados pela
explosão. Ou seja, se `Class.Explosion.BlastPressure` for maior que 0,
força será aplicada às partes. O grau em que as articulações são quebradas
dentro do BlastRadius depende de
`Class.Explosion.DestroyJointRadiusPercent`. `Class.Explosion.Hit` será
acionado para cada `Class.BasePart` dentro do raio.

`Class.BasePart|BaseParts` são considerados dentro do
`Class.Explosion.BlastRadius` mesmo se estiverem apenas parcialmente dentro do alcance.


Explosion.BlastRadius

Esta propriedade determina o raio da `Class.Explosion`, em studs.
Este raio determina a área de efeito da explosão, não o tamanho
dos visuais da explosão.


Este exemplo inclui uma demonstração de como as explosões podem ser feitas não letais para
personagens jogadores.

Usado para definir a proporção do `Class.Explosion.BlastRadius`, entre 0
e 1, dentro da qual todas as articulações serão destruídas. Qualquer coisa fora dessa
faixa apenas terá a força da `Class.Explosion` aplicada a ela.

Por exemplo, se `Class.Explosion.BlastRadius` for definido como 100 e
DestroyJointRadiusPercent for definido como 0.5, qualquer articulação dentro de um raio de 50
studs seria quebrada. Qualquer articulação entre os intervalos de 50 e 100 studs
não seria destruída, mas a força da `Class.Explosion` ainda seria aplicada ao
`Class.BasePart|BaseParts`.

Esta propriedade permite que os desenvolvedores tornem `Class.Explosion|Explosions`
"não letais" para `Class.Humanoid|Humanoids` definindo
DestroyJointRadiusPercent para 0. Isso significa que a articulação do pescoço não será
quebrada quando os personagens entrarem em contato com a `Class.Explosion`.


Explosion.DestroyJointRadiusPercent

Usado para definir a proporção do `Class.Explosion.BlastRadius`, entre 0
e 1, dentro da qual todas as articulações serão destruídas. Qualquer coisa fora dessa
faixa apenas terá a força da `Class.Explosion` aplicada a ela.


Este exemplo de código inclui um exemplo de como a propriedade Explosion.ExplosionType
pode ser usada para impedir que Explosões danifiquem o terreno. É
recomendado definir o ExplosionType como NoCraters no momento da
instância da Explosão, mas se isso não for prático, o código abaixo funcionará.

Esta propriedade determina como a `Class.Explosion` interagirá com
`Class.Terrain`. É um valor Enum.ExplosionType e pode ser definido como uma
das três opções.

- **NoCraters** - Explosões não danificarão o Terreno
- **Craters** - Explosões criarão crateras no Terreno
- **CratersAndDebris** - Redundante, se comporta da mesma forma que Craters

Se ExplosionType estiver definido para criar crateras no `Class.Terrain`, o raio
da cratera será aproximadamente igual ao `Class.Explosion.BlastRadius`.
Crateras são criadas em todos os materiais de `Class.Terrain`, exceto água. O
tamanho da cratera não é influenciado pelo material, embora alguns
materiais criem bordas mais ásperas do que outros.


Explosion.ExplosionType

Esta propriedade determina como a `Class.Explosion` interagirá com
`Class.Terrain`. Usado para definir se explosões causarão danos ao
terreno ou não.


Explosion.LocalTransparencyModifier

Esta propriedade é a posição do centro da `Class.Explosion`. É
definida no espaço do mundo e não é influenciada pelo pai da `Class.Explosion`.

`Class.BasePart|BaseParts` serão influenciados pela `Class.Explosion` se
estiverem dentro de `Class.Explosion.BlastRadius` studs da posição da explosão.

O efeito de uma explosão é instantâneo. Isso significa que, embora a
posição de uma explosão possa ser alterada após ter sido definida, ela não pode
afetar duas áreas diferentes. Depois que uma explosão foi "detonada",
logo após a aninhada a um descendente do `Class.Workspace`, não fará isso novamente. Em alguns casos, o efeito visual da explosão
pode se mover, mas não terá efeito.

Por essa razão, uma nova explosão deve ser criada se o desenvolvedor quiser
que uma explosão apareça em uma posição diferente.


Explosion.Position

Esta propriedade é a posição do centro da `Class.Explosion`. É
definida no espaço do mundo e não é influenciada pelo pai da `Class.Explosion`.


Um valor entre 0 e 1 que controla a velocidade do efeito de partículas. Em
1, funciona na velocidade normal, em 0.5 funciona na metade da velocidade e em 0
congela o tempo.


Explosion.TimeScale

Valor entre 0 e 1 que controla a velocidade do efeito de partículas.


Este exemplo inclui uma função que criará uma Explosão, mas substituirá os
visuais padrão da Explosão pelos de um ParticleEmitter.

Esta propriedade determina se o efeito visual de uma
`Class.Explosion` é mostrado ou não.

Quando Visível é definido como falso, a explosão ainda afetará
`Class.BasePart|BaseParts` no seu `Class.Explosion.BlastRadius`, a única
diferença é que não será vista.

Um uso para esta propriedade seria para um desenvolvedor criar seus próprios
efeitos de explosão personalizados usando um `Class.ParticleEmitter`, enquanto retém
a funcionalidade padrão da `Class.Explosion`.


Explosion.Visible

Esta propriedade determina se o efeito visual de uma
`Class.Explosion` é mostrado ou não.


Aplica força a `Class.BasePart|BaseParts` dentro do `Class.Explosion.BlastRadius`.
Quebra `Class.JointInstance|JointInstances` e
`Class.WeldConstraint|WeldConstraints` entre partes e mata
personagens `Class.Humanoid` não protegidos por um `Class.ForceField`.


`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, levando o
nome da classe como parâmetro e retornando o objeto criado.

Demonstra a detecção de mudanças na ancestralidade de uma instância conectando-se ao evento `Class.Instance.AncestryChanged`.

O Parent de ChangingPart é definido para valores diferentes ao longo do tempo. O pai da parte é o ancestral da parte, portanto, o evento `Class.Instance.AncestryChanged` será acionado sempre que mudar.

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

Este evento inclui dois parâmetros: `child` refere-se ao `Class.Instance`
cujo `Class.Instance.Parent` foi realmente alterado, enquanto `parent` refere-se
à nova `Class.Instance.Parent` desta instância.

Você pode usar este evento para rastrear a exclusão de uma instância no Studio,
como a exclusão manual no Explorer ou através 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

O `Class.Instance` cuja `Class.Instance.Parent` foi alterada.

parent

O novo `Class.Instance.Parent` do `Class.Instance` cuja
`Class.Instance.Parent` foi alterada.

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

Este evento é acionado sempre que qualquer atributo é alterado na instância,
incluindo quando um atributo é definido como `nil`. O nome do atributo
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 da parte 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 dado muda.

Instance.AttributeChanged

attribute

Aciona 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 para replicar 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 replicado ainda
	local head = child:WaitForChild("Head")
end)
```
Observe que este evento opera apenas para filhos imediatos da
`Class.Instance`. Para um evento que captura todos os descendentes, use
`Class.Instance.DescendantAdded`.

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

Instance.ChildAdded

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

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

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

Removido refere-se a quando o pai de um objeto é mudado de
`Class.Instance` para algo diferente de `Class.Instance`. Observe que este
evento também será disparado 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 da `Class.Instance`.
Para um evento que captura todos os descendentes, use
`Class.Instance.DescendantRemoving`.

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

Instance.ChildRemoved

Aciona após um filho ser removido desta `Class.Instance`.

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

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

Como é acionado para cada descendente, parentar um objeto à
`Class.Instance` acionará o evento para este objeto e todos os seus
descendentes individualmente.

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

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

Instance.DescendantAdded

descendant

Aciona 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** que o `Class.Instance` pai
mude de forma que uma instância **descendente** não será mais um
descendente. `Class.Instance:Destroy()|Destroy()` muda 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 não será alterado no momento em que este evento disparar. 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 com o descendente primeiro,
seguido de 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 PORQUE o pai foi manipulado, e a mudança ainda não ocorreu
	-- 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

A `Class.Instance` que está sendo removida.

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

Este exemplo demonstra como, ao usar o comportamento de sinal imediato, uma Instância sendo destruída permanece em seu lugar até que a função conectada ceda.

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

A `Class.Instance` nunca será excluída da memória enquanto uma função conectada
estiver usando-a. No entanto, se a função suspender em algum ponto,
a `Class.Instance` e seus descendentes serão colocados como pai em `nil`.

Se a propriedade `Class.Workspace.SignalBehavior` estiver definida como
`Enum.SignalBehavior.Immediate`, este evento dispara imediatamente antes do
`Class.Instance` ou de 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 retomada,
que será depois que o `Class.Instance` ou um de seus ancestrais for
removido com `Class.Instance:Destroy()`.

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

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

Instance.Destroying

Dispara imediatamente antes (ou é adiado até depois) da instância ser
removida via `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`.

Instance.childAdded

Este método aplica uma tag à instância, sem efeito se a tag já tiver
sido 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
dropadas se o servidor adicionar ou remover uma tag daquela instância mais
tarde, porque o servidor replica todas as tags juntas e sobrescreve as
tags anteriores.

- Ao marcar uma instância, é comum que alguns recursos sejam usados para
fornecer a funcionalidade da tag, por exemplo, conexões de eventos ou tabelas.
Para evitar vazamentos de memória, é uma boa ideia limpar isso (desconectar,
configurar como `nil`, etc.) quando não for mais necessário para uma tag.
Faça isso ao chamar `Class.Instance:RemoveTag()`, ao chamar
`Class.Instance:Destroy()`, ou em uma função conectada a um sinal
retornado por `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

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("Filhos:", #part:GetChildren())  --> Filhos: 3

part:ClearAllChildren()

print("Filhos:", #part:GetChildren())  --> Filhos: 0
```
Se você não deseja destruir **todos** os filhos e descendentes, use
`Class.Instance:GetChildren()` ou `Class.Instance:GetDescendants()` para
iterar sobre esses filhos/descendentes e selecionar o que deseja destruir. 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 de 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 instância em si 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 foi **também** 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`.

Demonstra como destruir 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`, bloqueia a
propriedade `Class.Instance.Parent`, desconecta todas as conexões e chama
`Destroy()` em todos os filhos. Este método é a maneira adequada de descartar
objetos que não são mais necessários.

Descartar objetos desnecessários é importante, pois objetos e conexões
não utilizados em um lugar consomem memória, o que pode levar a sérios
problemas de desempenho ao longo do tempo.

Como melhor prática, após chamar `Destroy()` em um objeto, defina quaisquer
variáveis que referenciam o objeto (ou seus descendentes) como `nil`. Isso
previne que seu código acesse qualquer coisa relacionada ao objeto.

```lua
local part = Instance.new("Part")
part.Name = "Olá, mundo"
part:Destroy()
-- Não faça isso:
print(part.Name)  --> "Olá, mundo"
-- Faça isso para evitar que a linha acima funcione:
part = nil
```
Uma vez que uma `Class.Instance` foi destruída por este método, ela não pode
ser reutilizada porque a propriedade `Class.Instance.Parent` está bloqueada. 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 definido, use
`Class.Debris:AddItem()`.

Instance:Destroy

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

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

Este método funciona para cima, ou seja, começa no `Class.Instance.Parent`
imediato da instância e vai para cima até o `Class.DataModel`. Se nenhum
ancestral correspondente for encontrado, ele 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,
consulte `Class.Instance:FindFirstAncestorOfClass()` e
`Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

Retorna o primeiro ancestral do `Class.Instance` cujo
`Class.Instance.Name` é igual ao nome dado.

Retorna o primeiro ancestral da `Class.Instance` cujo
`Class.Object.ClassName` é igual ao `className` dado.

Este método funciona para cima, ou seja, começa no `Class.Instance.Parent`
imediato da instância e vai para cima até o `Class.DataModel`. Se nenhum
ancestral correspondente for encontrado, ele 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()` para respeitar a
herança de classes.

Instance:FindFirstAncestorOfClass

className

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

Retorna o primeiro ancestral do `Class.Instance` cujo
`Class.Object.ClassName` é igual ao className dado.

Retorna o primeiro ancestral da `Class.Instance` para o qual
`Class.Object:IsA()` retorna verdadeiro para o `className` dado.

Este método funciona para cima, ou seja, começa no `Class.Instance.Parent`
imediato da instância e vai para cima até o `Class.DataModel`. Se nenhum
ancestral correspondente for encontrado, ele retorna `nil`.

Diferente de `Class.Instance:FindFirstAncestorOfClass()`, este método usa
`Class.Object:IsA()` que respeita a herança de classes. 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")
```
Consulte também `Class.Instance:FindFirstAncestor()`.

Instance:FindFirstAncestorWhichIsA

Retorna o primeiro ancestral do `Class.Instance` para quem
`Class.Object:IsA()` retorna verdadeiro para o className dado.

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 dado ou
`nil` se nenhum desses filhos existir. Se o argumento opcional `recursive` for
`true`, este método pesquisa em todos os descendentes em vez de apenas nos
filhos imediatos da `Class.Instance`.

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

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

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

-- A linha a seguir resulta em erro se a parte não existir no workspace
Workspace.Part.Transparency = 0.5
```
Uma abordagem melhor é usar `FindFirstChild()` para primeiro verificar se `Part` existe,
then usar uma declaraçã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 Combina com 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 ponto,
as propriedades têm prioridade sobre os filhos se compartilharem um nome.

No exemplo a seguir, uma `Class.Folder` chamada `Color` é adicionada a um
`Class.Part`, que também possui a propriedade `Class.Part.Color`. Note que
`part.Color` se refere ao valor da propriedade `Datatype.Color3`, e não à instância
filha `Class.Folder`. Um benefício de usar
`Class.Instance:FindFirstChild()|FindFirstChild()` é que a
introdução de novas propriedades não impõe um 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
longo do que usar o operador ponto e quase 8 vezes mais longo do que simplesmente
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
ao `Class.RunService.Heartbeat` e `Class.RunService.PreRender`. Em vez disso,
lembre-se do resultado em uma variável ou considere usar
`Class.Instance.ChildAdded|ChildAdded` ou
`Class.Instance:WaitForChild()|WaitForChild()` para detectar quando um filho com um
dado nome se torna disponível.

Instance:FindFirstChild

O `Class.Instance.Name` a ser pesquisado.

recursive

Se a busca deve ou não ser realizada recursivamente.

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

Retorna o primeiro filho da `Class.Instance` cujo
`Class.Object.ClassName|ClassName` é igual ao `className` dado.
Diferente de `Class.Instance:FindFirstChildWhichIsA()`, este método somente
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` cujo
`Class.Object.ClassName|ClassName` é igual ao nome da classe dada.

Retorna o primeiro filho da `Class.Instance` para o qual
`Class.Object:IsA()` retorna verdadeiro para o `className` dado.

Se nenhum filho correspondente for encontrado, este método retorna `nil`. Se o argumento
opcional recursive for verdadeiro, este método pesquisa todos os descendentes em vez de
somente os 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 buscam 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 className dado.

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

Este método está desativado 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 o `Class.Instance` é um `Class.Actor`, o próprio `Class.Actor`
especificado é retornado. Caso contrário, seu ancestral mais próximo `Class.Actor`
é 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 da
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 dado para o valor dado.
- `Class.Instance:GetAttributes()` que retorna um dicionário de pares chave-valor para cada um dos atributos da instância.

Instance:GetAttribute

O valor que foi atribuído ao nome do atributo dado. 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
`Class.Object.Changed|Changed`, exceto que é disparado apenas quando o
atributo específico dado muda; efetivamente é semelhante ao
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` mas
para atributos.

É geralmente uma boa ideia usar este método em vez de uma conexão com
`Class.Object.Changed|Changed` com uma função que verifica o nome do atributo.
Chamadas subsequentes a 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 mudado")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```
Consulte também `Class.Instance.AttributeChanged` que dispara sempre que qualquer
atributo é mudado 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 dado muda.

Retorna um evento que é acionado quando o atributo dado 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 imprime 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 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 toda `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 .. " é o 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 .. " é o filho número " .. i)
end
```
Note que o array **não** é ordenado em nenhuma ordem particular, então
uma ordenação manual (por exemplo, usando `Library.table.sort()`) é aconselhada para ordenar
os filhos retornados por este método.

Consulte 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.

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

- Este item é protegido. Tentar usá-lo em um `Class.Script` ou
  `Class.LocalScript` fará com que um erro ocorra.
- Um ID de depuração é um ID usado em processos de depuração. Ele permite que um depurador
  leia cada instrução antes de um aplicativo processá-lo. Todos os objetos em
  Roblox agem como processos e executam instruções (ou 'código') que podem ser
depurados se necessário.
- Isso pode ser útil para plugins que precisam distinguir objetos similares
dentre si (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
desse objeto. Diferente de `Class.Instance:GetChildren()`, que apenas retorna
os filhos imediatos de um objeto, este método encontra todos os filhos do objeto,
todos os filhos desses filhos, e assim por diante.

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, uma `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 sem 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) nos nomes dos 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 de acessar o 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 de regra de estilo
rule:SetProperty("Rotation", 30)

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

-- Modifique/substitua explicitamente a propriedade estilizada
button.Rotation = 45

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

Instance:GetStyled

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
`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 a
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` com uma
função que verifica o nome da propriedade. Chamadas subsequentes a este método no
mesmo objeto com o mesmo nome da propriedade retornam o mesmo evento.

Observe que este evento não passará nenhum argumento para uma função conectada,
do modo que o valor da propriedade mudada deve ser lido 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("Propriedade de estilo mudada!")
end

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

Instance:GetStyledPropertyChangedSignal

property

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

Evento que dispara quando a propriedade de estilo dada muda.

Este método retorna um array das tags aplicadas à instância dada, como
strings. Você pode adicionar tags seja no Studio na
janela [Propriedades](/studio/properties) ou 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 de uma só vez. 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 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 seja no Studio na
janela [Propriedades](/studio/properties) ou em tempo de execução com
`Class.Instance:AddTag()|AddTag()`.

Instance:HasTag

Verifica se a instância tem uma determinada tag.

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

Workspace e SpawnLocation são ancestrais do decalque do SpawnLocation.
Workspace é um ancestral do SpawnLocation.

SpawnLocation e seu decalque são descendentes do Workspace, não ancestrais.
Decalque é um descendente do SpawnLocation, não um ancestral.

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

Um `Class.Instance` é considerado o ancestral de um objeto se o
`Class.Instance.Parent` do objeto ou um dos pais
`Class.Instance.Parent` está definido para o `Class.Instance`.

Consulte também `Class.Instance:IsDescendantOf()`.

Instance:IsAncestorOf

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

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

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

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

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

Instance:IsDescendantOf

ancestor

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

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

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
inserção na janela do [Explorer](/studio/explorer), o resultado pode
variar.

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

Observe que se este método retornar `true`, a estilização **não** afetará a
propriedade porque modificar explicitamente uma propriedade tem prioridade sobre
estilizá-la. Para redefinir uma propriedade ao padrão instanciado por código e permitir
estilização nela, use
`Class.Instance:ResetPropertyToDefault()|ResetPropertyToDefault()`.


Instance:IsPropertyModified

Booleano que indica se a propriedade foi modificada em relação ao seu
padrão instanciado por código.


Retorna `true` se o valor armazenado na propriedade especificada não for igual
à padrão instanciada por código.


O seguinte código demonstra como uma parte pode ser adicionada novamente ao DataModel
após ser removida:

Este método define o `Class.Instance.Parent` do objeto como `nil`, e
faz o mesmo para todos os seus descendentes.

Se o objeto for referenciado antes de ser removido, é possível
recuperar o objeto em um momento posterior.

Instance:Remove

Define o `Parent` do objeto como `nil`, e faz o mesmo para todos os seus
descendentes.

Este método remove uma tag de uma instância. Não lançará um erro se
o objeto não tiver a tag. Remover uma tag com sucesso acionará um
sinal criado por `Class.CollectionService:GetInstanceRemovedSignal()`
com a tag fornecida.

Observe que ao marcar uma instância, é comum que alguns recursos sejam
usados para fornecer a funcionalidade da tag, por exemplo conexões de eventos ou
tabelas. Para evitar vazamentos de memória, é uma boa ideia limpar isso
(desconectar, definir como `nil`, etc.) quando não for mais necessário para uma tag.

Instance:RemoveTag

Redefine uma propriedade para seu valor padrão. Por exemplo, chamar
`ResetPropertyToDefault("Rotation")` em um `Class.TextLabel` é equivalente
a definir sua `Class.TextLabel.Rotation|Rotation` como `0` (o valor padrão da propriedade).
Este método pode ser usado para garantir que a estilização substituirá
este valor padrão da propriedade.

Instance:ResetPropertyToDefault

Redefine uma propriedade para seu valor padrão.

Este método define o atributo com o nome fornecido para o valor dado. Se
o valor fornecido for `nil`, o atributo será removido, uma vez que `nil` é
retornado por padrão.

Por exemplo, o seguinte trecho de código define o atributo
`InitialPosition` da instância para `Datatype.Vector3|Vector3.new(0, 10, 0)`:

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

local part = Workspace.Part
part:SetAttribute("InitialPosition", Vector3.new(0, 10, 0))
```

##### Limitações

Requisitos e restrições de nomenclatura:

- Os nomes devem usar apenas caracteres alfanuméricos.
  - Você também pode incluir pontos, hífens, barras e sublinhados.
- Nenhum espaço ou símbolo exclusivo (como @, ~, !) é permitido.
- Strings devem ter 100 caracteres ou menos.
- Nomes não podem começar com **RBX** a menos que o chamador seja um
  script central do Roblox (reservado para Roblox).

Quando tentar definir um atributo para um tipo não suportado, um erro será
lançado.

##### Veja Também

- `Class.Instance:GetAttribute()` que retorna o valor que foi atribuído
  ao nome do atributo fornecido.
- `Class.Instance:GetAttributes()` que retorna um dicionário de pares chave-valor
  para cada um dos atributos da instância.

Instance:SetAttribute

value

O valor a ser definido para o atributo especificado.

Define o atributo com o nome dado para o valor dado.

O código a seguir aguarda que uma instância chamada "Part" seja adicionada ao
Espaço de Trabalho.

Retorna o filho da `Class.Instance` com o nome dado. Se o
filho não existir, ele aguardará o thread atual até que exista. Se o
parâmetro `timeOut` for especificado, este método irá expirar após o
número especificado de segundos e retornará `nil`.

##### Uso Principal

`Class.Instance:WaitForChild()|WaitForChild()` é extremamente importante ao
trabalhar em código executado pelo cliente em um `Class.LocalScript`. O motor do Roblox
não garante o tempo ou a ordem em que os objetos são replicados do servidor para o cliente.
Além disso, se uma experiência tiver `Class.Workspace.StreamingEnabled` definido como true,
`Class.BasePart|BaseParts` que estão muito longe do personagem do jogador
podem não ser transmitidos para o cliente, potencialmente causando falhas nos scripts
ao indexar objetos que ainda não existem no cliente.

##### Notas

- Este método não aguarda se um filho com o nome dado existir quando
  a chamada for feita.
- `Class.Instance:FindFirstChild()` é uma alternativa mais eficiente a
  `Class.Instance:WaitForChild()|WaitForChild()` para objetos que se assume que
  existem.
- Se uma chamada para este método exceder 5 segundos sem retornar, e não
  um parâmetro `timeOut` tiver sido especificado, um aviso será impresso na
  saída de que o thread pode aguardar indefinidamente.

Instance:WaitForChild

childName

timeOut

Retorna o filho da `Class.Instance` com o nome fornecido. Se o
filho não existir, ele vai suspender a thread atual até que exista.

Instance

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