**MessagingService** permite que servidores da mesma experiência se comuniquem
eu entre si em tempo real (menos de 1 segundo) usando tópicos. Tópicos são
strings definidas pelo desenvolvedor (1–80 caracteres) que os servidores usam para enviar e
receber mensagens.

A entrega é feita com o melhor esforço e não é garantida. Certifique-se de arquitetar sua
experiência de modo que falhas na entrega não sejam críticas.

[Cross-Server Messaging](/cloud-services/cross-server-messaging)
explora como se comunicar entre servidores com mais detalhes.

Se você quiser publicar mensagens ad-hoc para servidores de jogo ao vivo, pode usar as
[Open Cloud APIs](/cloud/guides/usage-messaging).

#### Limitações

Observe que esses limites estão sujeitos a mudanças.

<table>
	<thead>
		<tr>
			<th>Limite</th>
			<th>Máximo</th>
		</tr>
	</thead>
	<tbody>
		<tr>
			<td>
				<b>Tamanho da mensagem</b>
			</td>
			<td>
				1kB
			</td>
		</tr>
		<tr>
			<td>
				<b>Mensagens enviadas por servidor de jogo</b>
			</td>
			<td>
				 600 + 240 * (número de jogadores neste servidor de jogo) por minuto
			</td>
		</tr>
		<tr>
			<td>
				<b>Mensagens recebidas por tópico</b>
			</td>
			<td>
				(40 + 80 * número de servidores) por minuto
			</td>
		</tr>
		<tr>
			<td>
				<b>Mensagens recebidas para todo o jogo</b>
			</td>
			<td>
				 (400 + 200 * número de servidores) por minuto
			</td>
		</tr>
    <tr>
			<td>
				<b>Inscrições permitidas por servidor de jogo</b>
			</td>
			<td>
				 20 + 8 * (número de jogadores neste servidor de jogo)
			</td>
		</tr>
    <tr>
			<td>
				<b>Requisições de inscrição por servidor de jogo</b>
			</td>
			<td>
				 240 requisições por minuto
			</td>
		</tr>
	</tbody>
</table>


Esta função envia a mensagem fornecida a todos os inscritos no tópico,
acionando os callbacks registrados a serem invocados.

Yield até que a mensagem seja recebida pelo backend.


MessagingService:PublishAsync

topic

message

Os dados a serem incluídos na mensagem.


Invoca o callback fornecido sempre que uma mensagem é enviada para o tópico.


Este exemplo demonstra como usar `Class.MessagingService:SubscribeAsync()`
para escutar um tópico para bate-papo entre servidores dentro de um universo de jogo.

Quando um jogador entra, o exemplo se inscreve no tópico
_player-<player.UserId>_. Quando uma mensagem é enviada com esse tópico, a
callback conectada é executada e imprime _Recebeu a mensagem para <player.Name>_.
Ele também desconecta a conexão quando a
`Class.Player.AncestryChanged|ancestry do jogador muda`.

Para que isso funcione como esperado, deve ser colocado em um `Script` do servidor.

Esta função registra um callback para começar a ouvir o tópico dado.
O callback é acionado quando um tópico recebe uma mensagem. Ele pode ser chamado
várias vezes para o mesmo tópico.

#### Callback

O callback é invocado com um único argumento, uma tabela com as seguintes
entradas:

<table>
	<thead>
		<tr>
			<th>Campo</th>
			<th>Resumo</th>
		</tr>
	</thead>
	<tbody>
		<tr>
			<td>
				<b>Dados</b>
			</td>
			<td>
				Payload fornecido pelo desenvolvedor
			</td>
		</tr>
		<tr>
			<td>
				<b>Enviado</b>
			</td>
			<td>
				Tempo Unix em segundos em que a mensagem foi enviada
			</td>
		</tr>
	</tbody>
</table>

Ele faz yield até que a inscrição seja devidamente registrada e retorna um
objeto de conexão.

Para cancelar a inscrição, chame `Datatype.RBXScriptConnection|Disconnect()` no
objeto retornado. Uma vez chamado, o callback nunca deve ser acionado.
Encerrar o script que contém as conexões também causa a desinscrição da conexão subjacente.

Veja também `Class.MessagingService:PublishAsync()` que envia a mensagem fornecida para todos os inscritos no tópico, acionando seus callbacks registrados a serem invocados.


MessagingService:SubscribeAsync

callback

Função a ser invocada sempre que uma mensagem for recebida.


Conexão que pode ser usada para cancelar a inscrição do tópico.


MessagingService

Permite que servidores da mesma experiência se comuniquem entre si.


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

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

Instance:children

Instance:clone

Instance:destroy

Instance:findFirstChild

Instance:getChildren

Instance:isDescendantOf

Instance:remove

Instance

Esta propriedade determina se a instância deve ser incluída quando a
experiência é publicada ou salva, ou quando `Class.Instance:Clone()|Clone()`
és chamado em um dos ancestrais da instância. Chamar
`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**
ignora sua própria propriedade `Class.Instance.Archivable|Archivable`
e define `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.

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

Esta propriedade é utilizada por um recurso experimental. Consulte
[capacidades 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 único do `Class.Instance`. Nomes são usados para manter
a hierarquia de objetos organizada, além de permitir que scripts acessem
objetos específicos. O nome de uma instância não pode exceder 100 caracteres.

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 tornar um objeto acessível usando o operador de ponto (`.`), seu
nome deve começar com um sublinhado ou letra, e o restante do nome só
pode conter letras, números ou sublinhados (nenhum outro caractere
especial). Se o nome de um objeto não seguir esta sintaxe, ele não estará
acessível usando o operador de ponto e o 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 nem sempre o objeto desejado.
Se um objeto específico precisar ser acessado via código, é recomendável
dar a ele um nome único ou garantir que nenhum de seus irmãos compartilhe o
mesmo nome.

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

Instance.Name

Um identificador não único do `Class.Instance`.

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

- Um objeto é um **filho** de, ou é **parentado a**, outro objeto quando
  seu `Parent` é definido para esse objeto.

- Os **descendentes** de um `Class.Instance` são os filhos desse
  objeto, mais os 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 obtêm 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`, estiver
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.

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

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

##### Replicação de Objetos

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 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 estiver parentando partes a um `Class.Model` cujo pai ainda não foi
configurado, parentar cada parte a esse modelo é aceitável, pois o modelo
não teria sido replicado.

Instance.Parent

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

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

/reference/engine/classes/MessagingService.yaml

MessagingService

Resumo

Propriedades

Métodos

Eventos

Propriedades

Métodos

Eventos

Nesta página