AssetPatchSettings

AssetPatchSettings.ContentId

AssetPatchSettings.OutputPath

AssetPatchSettings.PatchId

`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 objetos `Instance` raiz diretamente, mas o construtor especial
`Datatype.Instance.new()` cria objetos via código, recebendo 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.

Dispara 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`
cuja `Class.Instance.Parent` foi realmente alterada, enquanto `parent` refere-se
ao novo `Class.Instance.Parent` desta instância.

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


Dispara quando a propriedade `Class.Instance.Parent` do 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 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 altera:

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

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

Nota, 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 têm a garantia de 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)
```
Nota, este evento opera apenas para filhos imediatos da
`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 desta `Class.Instance`.

Removido refere-se a quando o pai de um objeto é alterado de este
`Class.Instance` para algo diferente deste `Class.Instance`. Nota, 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 da `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 desta `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 dispara para cada descendente, parentar um objeto ao
`Class.Instance` irá disparar o evento para este objeto e todos os seus
descendentes individualmente.

Se você está 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

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** que o pai da `Class.Instance`
mude de forma que uma instância **descendente** não será mais uma
 descendente. `Class.Instance:Destroy()|Destroy()` muda o `Class.Instance.Parent|Parent`
de uma instância para `nil`, então chamar este 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 do disparo 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 com o descendente primeiro,
seguido por seus descendentes.

##### Aviso

Este evento dispara com o objeto descendente que está sendo removido.
Tentar alterar 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 aconteceu
	-- Portanto, é problemático mudar o pai desta forma:
	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 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.

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 suspender em algum ponto,
o `Class.Instance` e seus descendentes serão definidos como `nil`.

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

Se a propriedade `Class.Workspace.SignalBehavior` for definida como
`Enum.SignalBehavior.Deferred`, este evento será disparado no próximo ponto de
desenvolvimento, 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, pois o\script será destruído antes que o callback possa ser chamado (o que significa que ele não
 será executado).

Ao excluir um `Class.Instance` no Studio, como excluir manualmente
depois do [Explorer](/studio/explorer) ou através de um plugin,
o `Class.Instance` não é destruído. 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) que a instância é
destruída 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 mudaram")
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 disparará um sinal criado por
`Class.CollectionService:GetInstanceAddedSignal()` com a tag dada.

##### Avisos

- As tags de uma instância que foram adicionadas do lado do cliente serão ignoradas se o
  servidor adicionar ou remover mais tarde uma tag nessa instância porque o servidor
  replica todas as tags juntas e substitui as tags anteriores.

- Ao marcar uma instância, é comum que alguns recursos sejam usados para
dar à tag sua funcionalidade, por exemplo, conexões de eventos ou tabelas.
  Para evitar vazamentos de memória, é uma boa ideia limpar esses recursos
  (desconectar, definir como `nil`, etc.) quando não forem mais necessários
  para a 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 de 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")

-- Adicione algumas faíscas
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
loopear através desses filhos/descendentes e selecionar o que 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 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`, for 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 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 correta de descartar
objetos que não são mais necessários.

Descartar objetos desnecessários é importante, já que objetos e
conexões desnecessárias em um lugar consomem memória, o 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 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 = "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 um `Class.Instance` foi destruído por este método, ele não pode ser
reutilizado 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 determinado tempo, 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.


Instance:destroy

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

Este método funciona para cima, o que significa que começa no
`Class.Instance.Parent` imediato da instância e vai subindo até o
`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

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


Retorna o primeiro ancestral da `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, o que significa que começa no
`Class.Instance.Parent` imediato da instância e vai subindo até o
`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 className dado.


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

Este método funciona para cima, o que significa que começa no
`Class.Instance.Parent` imediato da instância e vai subindo até o
`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"))  --> verdadeiro
print(part:IsA("BasePart"))  --> verdadeiro
print(part:IsA("Instance"))  --> verdadeiro
```
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 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 filho desse tipo existir. Se o argumento opcional `recursive` for
`verdadeiro`, este método pesquisa 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 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 por `Part`,
e então usar 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 Coincide com uma Propriedade

Às vezes o `Class.Instance.Name|Name` de um objeto é o mesmo que o
propriedade de 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 uma
`Class.Part`, que também possui a propriedade `Class.Part.Color`. Note que
`part.Color` se refere ao valor da propriedade `Datatype.Color3`, não à instância do filho `Class.Folder`. Um benefício de usar
`Class.Instance:FindFirstChild()|FindFirstChild()` é que a
introdução de novas propriedades não impõe um risco no 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
tempo do que usar o operador ponto e quase 8 vezes mais do que simplesmente armazenar
uma referência a um objeto. Portanto, você deve evitar chamá-lo em
códigos dependentes de desempenho, como em loops apertados ou funções conectadas
a `Class.RunService.Heartbeat` e `Class.RunService.PreRender`. Em vez disso,
armazenar 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
nome dado se torna disponível.


Instance:FindFirstChild

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


recursive

Se a pesquisa deve ser conduzida recursivamente.


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


Instance:findFirstChild

Retorna o primeiro filho da `Class.Instance` cuja
`Class.Object.ClassName|ClassName` é igual ao `className` dado.
Diferente de `Class.Instance:FindFirstChildWhichIsA()`, este método só retorna
objetos cuja classe coincide com `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 dada.


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

Se nenhum filho correspondente for encontrado, este método retorna `nil`. Se o argumento opcional
recursivo for verdadeiro, este método pesquisa todos os descendentes, em vez de apenas os imediatos filhos 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")) --> verdadeiro
print(part:IsA("BasePart")) --> verdadeiro
print(part:IsA("Instance")) --> verdadeiro
```
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

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


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 `recursivo` em
`Class.Instance:FindFirstChild()` em vez disso.


Instance:FindFirstDescendant

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


Se a `Class.Instance` é um `Class.Actor`, o próprio `Class.Actor` é
retornado. Caso contrário, seu ancestral mais próximo `Class.Actor` é retornado. Se nenhum
ancestral é 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 dado. 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 dado
  para o valor dado.
- `Class.Instance:GetAttributes()` que retorna um dicionário de 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 dado. Se nenhum
atributo foi atribuído, `nil` é retornado.


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


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

É geralmente uma boa ideia usar este método em vez de uma conexão a
`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)
```
Veja 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 dispara quando o atributo dado muda.


Retorna um evento que dispara quando o atributo dado muda.


Este método retorna um dicionário de pares de 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 dado.


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 `for` 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 retornado **não** está ordenado em nenhuma ordem em particular, então
classificações manuais (por exemplo, usando `Library.table.sort()`) são recomendadas 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. Note
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 uma aplicação a processe. Todos os objetos no
  Roblox atuam como processos e cada execução de instruções (ou 'código') que pode
  ser depurada, se necessário.
- Isso pode ser útil para plugins que precisam distinguir objetos similares
  um do 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
desse objeto. Diferente de `Class.Instance:GetChildren()`, que retorna apenas
os filhos imediatos de um objeto, este método encontra cada filho do
objeto, cada filho desses filhos, e assim por diante.

Note que o array retornado **não** está ordenado em nenhuma ordem em particular, então
classificações manuais (por exemplo, usando `Library.table.sort()`) são recomendadas para
ordenar os descendentes retornados por este método. Também considere o
método `Class.Instance:QueryDescendants()|QueryDescendants()` para consultar
descendentes por meio de 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 um `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 válido do Luau, não é
garantido.


Instance:GetFullName

Retorna uma string descrevendo a ancestralidade da instância.


Este método retorna o valor modificado ou estilizado da
propriedade especificada, ou então 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)

-- Aplicar rotação através da propriedade da 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 modificado ou estilizado da propriedade especificada, ou
então o valor padrão da propriedade se não tiver sido estilizado/modificado.


Retorna o valor modificado ou estilizado da propriedade especificada,
ou então 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` evento,
exceto que ele só dispara 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 de propriedade retornam o mesmo evento.

Note que este evento não passará nenhum argumento para uma função conectada,
portanto, o valor da propriedade alterada 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("A propriedade do estilo mudou!")
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 tanto no Studio na
janela [Propriedades](/studio/properties) ou em tempo de execução com
`Class.Instance:AddTag()|AddTag()`.

Este método é útil quando você quer 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 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
janela [Propriedades](/studio/properties) ou em tempo de execução com
`Class.Instance:AddTag()|AddTag()`.


Instance:HasTag

Verifica se a instância possui uma tag dada.


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` estiver definido como o `Class.Instance`.

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

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


Instance:isDescendantOf

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

Por exemplo, consultar a
propriedade `Class.TextLabel.BackgroundColor3|BackgroundColor3` de um
`Class.TextLabel` inserido através da janela [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 nenhuma
outra alteração foi feita em seu
`Class.TextLabel.BackgroundColor3|BackgroundColor3`.

Note que se este método retornar `true`, o estilo **não** afetará a
propriedade, pois a modificação explícita de uma propriedade tem precedência sobre
estilizar. Para redefinir uma propriedade para seu valor padrão instanciado por código e permitir
estilo nela, use
`Class.Instance:ResetPropertyToDefault()|ResetPropertyToDefault()`.


Instance:IsPropertyModified

Booleano indicando 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 é igual
ao padrão instanciado por código.


Este método de objeto retorna um array que contém os descendentes desse
objeto que correspondem à string `selector` fornecida. A string `selector`
pode incluir múltiplos seletores e combinadores para corresponder a características
tais como o nome da classe, nome da instância, relações hierárquicas, bem como
valores específicos de propriedades e atributos de instâncias. A gramática do `selector`
és semelhante à que é usada em `Class.StyleRule`, com apenas algumas
diferenças em relação a quais partes da gramática são suportadas ou não.

##### Seletores

<table>
<thead>
  <tr>
    <th>Seletor</th>
    <th>Descrição</th>
    <th>Exemplos</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td><code>ClassName</code></td>
    <td>Corresponde a instâncias da classe especificada em uma <code>Class.Object:IsA()</code> relação.</td>
    <td><code>SpotLight</code><br /><code>ImageButton</code><br /><code>Part</code></td>
  </tr>
  <tr>
    <td><code>.Tag</code></td>
    <td>Corresponde a instâncias marcadas com uma tag de <code>Class.CollectionService</code>.</td>
    <td><code>.Fruit</code><br /><code>.IntenseLight</code></td>
  </tr>
  <tr>
    <td><code>#Name</code></td>
    <td>Corresponde a instâncias de um nome específico <code>Class.Instance.Name</code>.</td>
    <td><code>#RedTree</code><br /><code>#CloseButton</code></td>
  </tr>
  <tr>
    <td><code>[propriedade = valor]</code></td>
    <td>Corresponde a instâncias que têm a propriedade especificada e que essa propriedade possui o valor especificado. Valores booleanos, números e strings são suportados. Letras, números, <code>_</code> e <code>-</code> podem ser usados sem colocar o valor entre aspas.
    </td>
    <td><code>[CanCollide = false]</code><br />
    <code>[Brightness = "0.5"]</code><br />
    <code>[Name = Folder10]</code><br />
    <code>[Name = "Part.10"]</code></td>
  </tr>
  <tr>
    <td width="30%"><code>[$attribute = valor]</code></td>
    <td>Corresponde a instâncias que possuem o atributo especificado e que esse atributo possui o valor especificado. As mesmas limitações se aplicam aos seletores de propriedade.</td>
    <td width="30%"><code>[$MyAttribute = 10]</code></td>
  </tr>
</tbody>
</table>

Note que os seletores podem ser combinados. Por exemplo,
`Model.Apple[$Kind = "Red"][$State = 4]` corresponderá a instâncias que são um
`Class.Model` com uma tag `Apple` definida e que têm um atributo `Kind` equal
a string `"Red"` bem como um atributo `State` igual a `4`.

##### Combinadores

<table>
<thead>
  <tr>
    <th>Combinador</th>
    <th>Descrição</th>
    <th>Exemplos</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td><code>&gt;</code></td>
    <td>Corresponde a instâncias que são <b>filhos diretos</b> dos filtros anteriores.</td>
    <td><code>Part &gt; .SwordHandle</code></td>
  </tr>
  <tr>
    <td><code>&gt;&gt;</code></td>
    <td>Corresponde a instâncias que são <b>descendentes</b> dos filtros anteriores.</td>
    <td><code>Model &gt;&gt; .TreeOnFire</code></td>
  </tr>
  <tr>
    <td width="10%"><code>,</code></td>
    <td>Especifica uma lista de múltiplos seletores independentes para a consulta de descendentes.</td>
    <td width="50%"><code>Part.TagA, Part[$UseForce = true]</code></td>
  </tr>
</tbody>
</table>

Note que o primeiro filtro padrão é um combinador de descendente `>>`. Se o
seletor começar com um `>`, apenas filhos direto são visitados; por exemplo,
`>Part.Apple` seleciona **filhos diretos** que são um `Class.Part` e
que têm uma tag `Apple`.

O combinador padrão também pode ser especificado explicitamente, como em
`>>SpotLight.Red` é o mesmo que `SpotLight.Red`.

Somente elementos que correspondem ao filtro são colocados no array. Por exemplo,
`>#ExistingChild, >#MissingChild, >#AnotherExistingChild` retornará um
array com dois elementos e não haverá `nil` para o filho ausente.


Instance:QueryDescendants

selector

String de seletor usada para filtrar elementos.


Um array de instâncias (vazio se nada corresponder ao seletor).


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 que
recupere o objeto em um momento posterior.


Instance:Remove

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


Instance:remove

Este método remove uma tag de uma instância. Não gerará um erro se
a instância não tiver a tag. Remover uma tag com sucesso disparará um
sinal criado por `Class.CollectionService:GetInstanceRemovedSignal()`
com a tag dada.

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


Instance:RemoveTag

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


Instance:ResetPropertyToDefault

Redefine uma propriedade para seu valor padrão.


Este método define o atributo com o nome dado para o valor dado. Se
o valor dado for `nil`, o atributo será removido, já 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 nomeação:

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

Ao tentar definir um atributo para um tipo não suportado, um erro será
gerado.

##### Veja Também

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


Instance:SetAttribute

O nome do atributo que está sendo definido.


value

O valor a ser atribuído ao 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 do `Class.Instance` com o nome dado. Se o
filho não existir, irá suspender a thread atual até que exista. Se o
parâmetro `timeOut` for especificado, esse 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
mecanismo 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
possui `Class.Workspace.StreamingEnabled` ativado, os `Class.BasePart|BaseParts`
que estão longe do personagem do jogador podem não ser transmitidos para o
cliente, potencialmente causando que scripts que tentam indexar objetos que
não existem ainda no cliente quebrem.

##### Observações

- Este método não suspende se um filho com o nome dado existir no momento
  da chamada.
- `Class.Instance:FindFirstChild()` é uma alternativa mais eficiente para
  `Class.Instance:WaitForChild()|WaitForChild()` para objetos que são
  assumidos como existentes.
- Se uma chamada para este método exceder 5 segundos sem retornar, e nenhum
  parâmetro `timeOut` tiver sido especificado, um aviso será impresso na
  saída de que a thread pode suspender indefinidamente.


Instance:WaitForChild

childName

timeOut

Retorna o filho da `Class.Instance` com o nome dado. Se o
filho não existir, irá gerar a thread atual até que exista.


Instance

Esta propriedade determina se a instância deve ser incluída quando o
experiência é publicada ou salva, ou quando `Class.Instance:Clone()|Clone()`
és chamado em um dos ancestrais da instância. Chamando
`Class.Instance:Clone()|Clone()` diretamente em uma instância retornará `nil`
se essa instância **não** for `Class.Instance.Archivable|Archivable`.

Copiar um objeto no Studio usando as opções **Duplicar** ou **Copiar**/**Colar**
ignorarão sua própria propriedade `Class.Instance.Archivable|Archivable`
e definirão `Class.Instance.Archivable|Archivable` como `true` para a
cópia.

```
local part = Instance.new("Part")
print(part:Clone())  --> Part
part.Archivable = false
print(part:Clone())  --> nil
```


Instance.Archivable

Determina se um `Class.Instance` e seus descendentes podem ser clonados usando
`Class.Instance:Clone()`, e podem ser salvos/publicados.


Instance.archivable

O conjunto de capacidades permitidas para serem usadas em scripts dentro desta
instância. Para que as capacidades tenham efeito, a propriedade `Class.Instance.Sandboxed`
deve estar habilitada.

Esta propriedade é usada por um recurso experimental. Veja
[capabilidades de script](/scripting/capabilities) para mais
detalhes.


Instance.Capabilities

O conjunto de capacidades permitidas para serem usadas em scripts dentro deste
container.


Um identificador não exclusivo da `Class.Instance`. Nomes são usados para manter
a hierarquia de objetos organizada, permitindo que scripts acessem
objetos específicos. O nome de uma instância não pode exceder 100 caracteres em
tamanho.

O nome de um objeto é frequentemente usado para acessar o objeto através da
hierarquia do modelo de dados usando os seguintes métodos:

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

local baseplate = Workspace.Baseplate
local baseplate = Workspace["Baseplate"]
local baseplate = Workspace:FindFirstChild("BasePlate")
```
Para que um objeto seja acessível usando o operador ponto (`.`), seu
nome deve começar com um sublinhado ou letra, e o restante do nome só pode
contêiner letras, números ou sublinhados (nenhum outro caractere
especial). Se o nome de um objeto não seguir essa sintaxe, ele não será
acessível usando o operador ponto e Luau não interpretará seu nome
como um identificador.

Se mais de um objeto com o mesmo nome for irmão, qualquer tentativa de
indexar um objeto por esse nome retornará apenas um dos objetos, semelhante
a `Class.Instance:FindFirstChild()`, mas não sempre o objeto desejado.
Se um objeto específico precisa ser acessado através do código, é recomendado
dar um nome exclusivo ou garantir que nenhum de seus irmãos compartilhe o
mesmo nome.

Veja também `Class.Instance:GetFullName()` para obter um nome completo incluindo
a hierarquia do objeto.


Instance.Name

Um identificador não exclusivo da `Class.Instance`.


A propriedade `Parent` determina o pai hierárquico da
`Class.Instance`. A seguinte terminologia é comumente usada ao falar
sobre como essa propriedade é configurada:

- Um objeto é um **filho** de outro objeto quando seu `Parent` é definido como
  aquele objeto.

- Os **descendentes** de um `Class.Instance` são os filhos daquele
  objeto, além dos descendentes dos filhos também.

- Os **ancestrais** de um `Class.Instance` são todos os objetos dos quais a
  instância é descendente.

É a partir da propriedade `Parent` que muitos outros membros da API recebem seus
nomes, como `Class.Instance:GetChildren()|GetChildren()` e
`Class.Instance:FindFirstChild()|FindFirstChild()`. Esta propriedade também
é usada para gerenciar se um objeto existe na experiência ou precisa ser
removido. Enquanto o pai de um objeto estiver no `Class.DataModel`, for
armazenado em uma variável ou referenciado pela propriedade de outro objeto, o
objeto permanece na experiência; caso contrário, o objeto será removido automaticamente.

Chamando `Class.Instance:Destroy()|Destroy()` definirá o `Parent` de um
`Class.Instance` e todos os seus descendentes para `nil`, e também **bloqueará**
a propriedade `Parent`. Um erro é gerado ao definir o `Parent` de um
objeto destruído.

Objetos recém-criados usando `Datatype.Instance.new()` não terão um
pai, e geralmente não estarão visíveis ou funcionarão até que um seja definido.

##### Replicação de Objeto

Um objeto criado pelo servidor não será replicado para os clientes até que seja
parentado a algum objeto que seja replicado. Ao criar um objeto e
configurar muitas propriedades, é recomendável definir a propriedade `Parent`
**por último**. Isso garante que o objeto se replique uma vez, em vez de replicar
muitas alterações de propriedades.

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

-- Defina o pai da nova instância por último (recomendado)
local part = Instance.new("Part")
part.Position = Vector3.new(0, 10, 0)
part.Parent = Workspace
```
No entanto, se você estiver parentando partes a um `Class.Model` cujo pai ainda não foi
definido, aceitar o parentamento de cada parte a esse modelo é aceitável, uma vez que o modelo
não teria sido replicado.


Instance.Parent

Determina o pai hierárquico da `Class.Instance`.


Esta propriedade costumava proteger objetos no serviço `Class.CoreGui` de
serem alterados por usuários de maneira não autorizada. Ela foi obsoleta
 e não faz nada.


Instance.RobloxLocked

Uma propriedade obsoleta que costumava proteger objetos de `Class.CoreGui`.


`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/AssetPatchSettings.yaml

AssetPatchSettings

Resumo

Propriedades

Métodos

Eventos

Propriedades

Métodos

Eventos

Nesta página