Um `Class.Actor` é um contêiner para código que pode ser dividido de forma segura em seu próprio
thread usando `Library.task.desynchronize()`. Também deve conter as
instâncias usadas por seus scripts.

Para saber mais sobre como usar múltiplos Actors para otimizar o desempenho de scripts, veja
[Parallel Luau](/scripting/multithreading).

#### Notas

- Cada `Actor` é executado em sua própria VM Luau. `Class.ModuleScript|ModuleScripts`
  exigidos por um `Actor` **não** são compartilhados ou armazenados em cache entre `Actors` ou com
  a thread principal. Cada VM executa sua própria cópia do módulo, então
  o estado a nível de módulo é isolado por `Actor`. Projete de acordo se seus
  módulos mantiverem estado que você pretende compartilhar.
- `script:GetActor()` retorna `nil` quando chamado de um `Class.ModuleScript`
  a menos que o `ModuleScript` seja um descendente do `Actor`. `ModuleScripts`
  armazenados em outros lugares (por exemplo, `Class.ReplicatedStorage`) e exigidos por um
  `Actor` não são considerados descendentes do `Actor`.


Este método é usado para vincular um callback Luau a uma mensagem com o
tópico especificado. Quando uma mensagem é enviada (usando
`Class.Actor:SendMessage()|SendMessage()`) para o tópico especificado, o
callback fornecido será chamado em um contexto de execução _serial_.

Vários callbacks Luau podem ser vinculados a um único actor e até mesmo a um
único tópico de mensagem.

Observação: Apenas os scripts que são descendentes de um Actor podem se vincular a suas
mensagens.

```lua
local actor = script:GetActor()

-- Imprimir uma mensagem quando uma mensagem de saudação é enviada para o Actor
-- a qual este script é um descendente.
local connection = actor:BindToMessage("Greeting", function(message)
  print("Recebida Mensagem de Saudação:", message)
end)
```

Actor:BindToMessage

topic

O tópico usado para identificar o tipo de mensagem.

function

Este objeto de conexão pode ser usado para desconectar o callback Luau
de receber mensagens.

Vincula um callback Luau a uma mensagem com o tópico especificado.

Este método é usado para vincular um callback Luau a uma mensagem com o
tópico especificado. Quando uma mensagem é enviada (usando
`Class.Actor:SendMessage()|SendMessage()`) para o tópico especificado, o
callback fornecido será chamado em um contexto de execução _paralela_.

Vários callbacks Luau podem ser vinculados a um único actor e até mesmo a um
único tópico de mensagem.

Observação: Apenas os scripts que são descendentes de um Actor podem se vincular a suas
mensagens.

```lua
local actor = script:GetActor()

-- Imprimir uma mensagem quando uma mensagem de saudação é enviada para o Actor
-- a qual este script é um descendente.
local connection = actor:BindToMessageParallel("Greeting", function(message)
  print("Recebida Mensagem de Saudação:", message)
end)
```

Actor:BindToMessageParallel

Envia uma mensagem para um Actor. As mensagens são enviadas de forma assíncrona, então o
remetente não irá bloquear ou render quando chamar o
`Class.Actor:SendMessage()|SendMessage()` método.

Como um único Actor pode receber diferentes tipos de mensagens, um parâmetro `topic`
é usado para distinguir entre vários tipos de mensagens.

Veja `Class.Actor:BindToMessage()|BindToMessage()` para detalhes sobre receber
uma mensagem enviada usando `Class.Actor:SendMessage()|SendMessage()`.

Note que os argumentos da mensagem são **passados por cópia** através das
fronteiras da VM Luau, não por referência. Enviar tabelas grandes envolve uma cópia completa a
cada chamada. Funções são vinculadas a uma VM específica e não podem ser passadas em
mensagens.

```lua
-- Assuma que `actor` é uma variável local referindo-se a uma instância de Actor
actor:SendMessage("Greeting", "Hello World")
```


Actor:SendMessage

O tópico usado para identificar a mensagem que está sendo enviada.

message

O conteúdo da mensagem a ser enviada ao Actor.

Actor

Um `Class.Actor` é um contêiner para código que pode ser dividido com segurança em sua própria
thread.

O seguinte exemplo inclui uma função básica que aceita uma tabela de objetos
e os coloca dentro de um novo Modelo, retornando esse Modelo.

Modelos são objetos contêineres, significando que eles agrupam objetos juntos. Eles são
melhor utilizados para manter coleções de `Class.BasePart|BaseParts` e possuem um número
de funções que aumentam sua funcionalidade.

Modelos são destinados a representar grupos **geométricos**. Se seu agrupamento não tem
interpretação geométrica, por exemplo, uma coleção de
`Class.Script|Scripts`, use um `Class.Folder` ao invés disso.

Modelos cujas partes constituintes estão unidas por juntas (para que possam
se mover ou serem destruídas via simulação física) geralmente têm um
`Class.Model.PrimaryPart|PrimaryPart` definido, pois isso especifica qual parte dentro
do modelo o pivô e a caixa delimitadora "seguirão" conforme o modelo se move. Modelos
estáticos que permanecem em um lugar não se beneficiam de ter uma parte primária definida.

Modelos têm uma ampla gama de aplicações, incluindo personagens de jogadores Roblox.
Eles também têm um número de comportamentos únicos que são importantes de ter em
mente:

- Quando um `Class.Humanoid` e uma `Class.Part` chamada **Head** estão parentados a
  um modelo, uma GUI de nome/saúde aparecerá sobre o modelo; veja
  [Exibição de Nome/Saúde do Personagem](/characters/name-health-display)
  para detalhes.
- Se a posição de uma parte no eixo **Y** atinge o
  `Class.Workspace.FallenPartsDestroyHeight`, e era o último objeto
  dentro de um `Class.Model`, o modelo será destruído também.
- Quando usado em um lugar com `Class.Workspace.StreamingEnabled` definido como verdadeiro,
  o valor de `Class.Model.ModelStreamingMode|ModelStreamingMode` controla
  vários comportamentos em como o modelo e quaisquer descendentes são replicados
  e/ou removidos dos clientes. Além disso, o valor de
  `Class.Model.LevelOfDetail|LevelOfDetail` impacta a renderização do modelo.

Assim como todos os tipos de `Class.Instance`, o fato de um pai `Class.Model` ser
replicado para um cliente não garante que todos os seus filhos sejam
replicados. Isso é particularmente importante se essas instâncias estão sendo
acessadas por código em execução no cliente, como em um `Class.LocalScript`.
Usar `Class.Model.ModelStreamingMode|ModelStreamingMode` com valores como
`Enum.ModelStreamingMode|Atomic` pode garantir que o modelo inteiro e todos os
seus descendentes estejam presentes se o modelo pai existir no cliente, ou você
pode usar `Class.Instance:WaitForChild()|WaitForChild()` quando a atomicidade não é
desejada.

Define este modelo para ser persistente para o jogador especificado. Modelos
persistentes permanecem presentes para o jogador, independentemente das configurações ou
condições de streaming.

`Class.Model.ModelStreamingMode|ModelStreamingMode` deve ser definida como
`Enum.ModelStreamingMode|PersistentPerPlayer` para que o comportamento seja alterado
como resultado da adição.

Model:AddPersistentPlayer

playerInstance

O `Class.Player` para o qual tornar este modelo persistente.

Define este modelo para ser persistente para o jogador especificado.
`Class.Model.ModelStreamingMode|ModelStreamingMode` deve ser definido como
`Enum.ModelStreamingMode|PersistentPerPlayer` para que o comportamento seja alterado
como resultado da adição.

Neste exemplo, as juntas em cada Modelo de personagem do Jogador adicionado serão quebradas
3 segundos após o surgimento. Quebrar essas juntas fará com que o Humanoide
morra.


Este exemplo de código demonstra a criação manual de juntas em duas partes que são
irmãs do script (ParteA e ParteB). Ele cria uma junta em duas partes que estão em contato
com tipos de superfície compatíveis (Studs e Inlet).

Quebra as conexões entre `BaseParts`, incluindo conexões de superfície com
quaisquer partes adjacentes, `Class.WeldConstraint|WeldConstraints`, e todas
as `Class.Weld|Welds` e outras `Class.JointInstance|JointInstances`.

Quando BreakJoints é usado em um modelo de personagem de jogador, o
`Class.Humanoid` do personagem morrerá, pois depende da junta do pescoço.

Note que embora as juntas produzidas por conexões de superfície com partes adjacentes
possam tecnicamente ser recriadas usando `Class.Model:MakeJoints()`, isso
apenas recriará as juntas produzidas por superfícies. Os desenvolvedores não devem confiar
nisso, pois após as juntas serem quebradas as partes podem não estar mais em
contato umas com as outras.

Model:BreakJoints

Quebra as conexões entre `BaseParts`, incluindo conexões de superfície com
quaisquer partes adjacentes, `Class.WeldConstraint|WeldConstraints` e todas
as `Class.Weld|Welds` e outras `Class.JointInstance|JointInstances`.

Model:breakJoints

Esta função retorna uma descrição de um volume que contém todos os
`Class.BasePart` filhos dentro de um `Class.Model`. A orientação do volume
baseia-se na orientação do `Class.Model.PrimaryPart|PrimaryPart`,
e corresponde à caixa de seleção renderizada no Studio quando o modelo é
selecionado. Espelhando o comportamento de `Class.Terrain:FillBlock()`, retorna um
`Datatype.CFrame` representando o centro daquela caixa delimitadora
e um `Datatype.Vector3` representando seu tamanho. O tamanho pode ser impreciso
em tempo de execução se restrições de física estiverem agindo sobre as partes dentro do
`Class.Model`.

A orientação da caixa delimitadora corresponde à orientação do
`Class.PVInstance.GetPivot|Pivot` - seja o pivô do
`Class.Model.PrimaryPart|PrimaryPart` (se presente) ou o
`Class.Model.WorldPivot|WorldPivot` do modelo.

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

local model = Workspace.Model
local part = Workspace.Part
local orientation, size = model:GetBoundingBox()

-- Redimensiona e posiciona a parte igual à caixa delimitadora do modelo
part.Size = size
part.CFrame = orientation
```

Model:GetBoundingBox

Um `Datatype.CFrame` representando a orientação do volume
seguido por um `Datatype.Vector3` representando o tamanho do volume.

Retorna uma descrição de um volume que contém todas as partes de um Modelo.

O exemplo de código abaixo demonstra como Model.GetExtentsSize pode ser usado para obter
o tamanho da caixa delimitadora que contém as partes.

Retorna o tamanho da menor caixa delimitadora que contém todos os
`Class.BasePart|BaseParts` no `Class.Model`. A orientação corresponde
a orientação do `Class.PVInstance.GetPivot|Pivot` - seja o
pivô do `Class.Model.PrimaryPart|PrimaryPart` (se presente) ou o
`Class.Model.WorldPivot|WorldPivot` do modelo.

Observe que esta função apenas retorna o tamanho da menor caixa delimitadora, e
o desenvolvedor deve empregar seu próprio método para obter a posição da
caixa delimitadora.

Model:GetExtentsSize

O tamanho de extensão `Datatype.Vector3` do `Class.Model`.

Retorna o tamanho da menor caixa delimitadora que contém todos os
`Class.BasePart|BaseParts` no `Class.Model`, alinhada com o
`Class.Model.PrimaryPart` se estiver definido.

Este valor historicamente retornava o CFrame de uma posição central no
modelo.

Model:GetModelCFrame

Este código criaria um modelo, colocaria algumas partes nele, posicionaria aleatoriamente,
e então imprimiria seu tamanho:

A função GetModelSize retorna o tamanho `Datatype.Vector3` do
`Class.Model`.

Model:GetModelSize

Quando este método é chamado de um `Class.Script`, ele retorna todos os
objetos `Class.Player` para os quais este modelo é persistente. Quando chamado de
um `Class.LocalScript`, este método apenas verifica se este modelo é persistente
para o `Class.Players.LocalPlayer|LocalPlayer`.

Model:GetPersistentPlayers

Uma tabela com todos os objetos `Class.Player` para os quais este objeto modelo é
persistente.

Retorna todos os objetos `Class.Player` para os quais este objeto modelo é
persistente. O comportamento varia dependendo se este método é chamado
em um `Class.Script` ou em um `Class.LocalScript`.

O seguinte código demonstra como GetPrimaryPartCFrame e
SetPrimaryPartCFrame podem ser usados para rotacionar um modelo.

Um modelo simples é criado no Workspace e um loop é iniciado que irá
rotacionar o modelo em 10 graus ao redor do eixo Y a cada 0,2 segundos.

Esta função foi substituída por `Class.PVInstance:GetPivot()` que
atua como uma substituição e não altera o comportamento do seu código. Use
`Class.PVInstance:GetPivot()` para novos trabalhos e migre suas chamadas atuais
`Class.Model:GetPrimaryPartCFrame()` quando for conveniente.

Retorna o `Datatype.CFrame` da `Class.Model.PrimaryPart` do modelo.

Esta função é equivalente ao seguinte:

    Model.PrimaryPart.CFrame

Observe que esta função gerará um erro se não existir parte primária para o
`Class.Model`. Se esse comportamento não for desejado, os desenvolvedores podem fazer o
seguinte, o que será igual a `nil` se não houver parte primária.

    local cFrame = Model.PrimaryPart e Model.PrimaryPart.CFrame

Model:GetPrimaryPartCFrame

Retorna o `Datatype.CFrame` da `Class.Model.PrimaryPart` do modelo.
Esta função gerará um erro se não existir parte primária para o
`Class.Model`.

Este exemplo de código demonstra como substituir em uma substituição para todas as cópias
de um modelo de árvore usando `Class.Model:PivotTo()` e `Class.Model:ScaleTo()`. O
pivot e a escala dos modelos são usados como referência, garantindo que os
 tamanhos e locais relativos dos modelos de substituição correspondam aos dos
originais.


Modelos contêm um fator de escala canônica persistente, que começa em 1
para modelos recém criados e muda à medida que o modelo é escalado ao chamar
`Class.Model:ScaleTo()`. Esta função retorna o fator de escala canônico atual
do modelo.

O fator de escala atual não impacta _diretamente_ o tamanho das Instâncias
sob o modelo. É usado para fins de autoria de conteúdo e scripting
para lembrar como o modelo foi escalado em relação ao seu tamanho original.

Dentro de uma determinada sessão, o modelo irá armazenar as informações precisas do tamanho
das Instâncias descendentes após a primeira chamada de `Class.Model:ScaleTo()`. Isso significa que
chamar `Class.Model:ScaleTo()|ScaleTo(x)` seguido por
`Class.Model:ScaleTo()|ScaleTo(1)` te devolverá _exatamente_ a
configuração original do modelo sem deriva de ponto flutuante. Evitar
deriva de ponto flutuante é a motivação para ter uma função Scale**To**
e não uma função Scale**By**.

O fator de escala impacta o comportamento do motor de uma forma: O fator de escala
de um modelo será aplicado aos deslocamentos de juntas de
`Class.Animation|Animations` reproduzidas em um `Class.AnimationController`
debaixo daquele modelo, para que rigs animados reproduzam corretamente
animações mesmo quando escaladas.

Model:GetScale

O fator de escala canônico atual do modelo.

Retorna a escala canônica do modelo, que padrão é 1 para modelos recém
criados e mudará à medida que é escalado via
`Class.Model:ScaleTo()`.

Este exemplo de código demonstra como juntas podem ser feitas usando a
função Model:MakeJoints.

Um modelo é instanciado, com duas partes uma em cima da outra. A parte de cima é
ancorada e a parte de baixo não. Normalmente, quando pai do Workspace
a parte de baixo cairia no Baseplate.

No entanto, como a propriedade TopSurface da parte de baixo é configurada para
Enum.SurfaceType.Weld, isso significa que quando Model:MakeJoints é executado uma
conexão é feita entre elas.

Portanto, a parte de baixo não cai até que as juntas no modelo sejam
quebradas. Isso geralmente é feito usando Model:BreakJoints, mas neste exemplo a
conexão é quebrada usando uma explosão.

Este exemplo de código demonstra a criação de juntas em duas partes que são
irmãs do script (ParteA e ParteB). Ele usa MakeJoints em duas partes tocando
com tipos de superfície compatíveis (Studs e Inlet).

A junção baseada em SurfaceType está obsoleta. Não use MakeJoints para novos
projetos. Use `Class.WeldConstraint|WeldConstraints` e
`Class.HingeConstraint|HingeConstraints` em vez disso.

Percorre todas as `Class.BasePart|Parts` no `Class.Model` e cria
juntas entre as partes especificadas e quaisquer superfícies planas de contato,
basedo-se nas superfícies das partes.

- Superfícies suaves não criarão juntas
- Superfícies adesivas criarão uma junta `Class.Glue`
- Weld criará uma junta `Class.Weld` com qualquer superfície, exceto
  Unjoinable
- Studs, Inlet ou Universal criarão cada uma uma junta `Class.Snap` com
  qualquer uma das outras duas superfícies (por exemplo, Studs com Inlet e
  Universal)
- Superfícies de Hinge e Motor criam instâncias de joint `Class.Rotate` e
  `Class.RotateV`

Esta função não funciona se a Parte não for um descendente do
`Class.Workspace`. Portanto, você deve primeiro garantir que o Modelo esteja parentado
no Workspace antes de usar MakeJoints.

Model:MakeJoints

Percorre todas as `Class.BasePart|BaseParts` no `Class.Model`. Se algum
lado de uma parte tiver um SurfaceType que pode fazer uma junta, será criada uma junta
com quaisquer partes adjacentes.

Model:makeJoints

Model:move

location

Este exemplo demonstra como `Class.Model:MoveTo()` evita colisões.

Um simples modelo em duas partes `Class.Model` é criado, e sua `Class.Model.PrimaryPart`
és definida. Uma grande parte de obstrução é colocada ao lado.

Após 5 segundos, `Class.Model:MoveTo()` é usado para direcionar o modelo a se mover
para dentro da parte de obstrução. No entanto, como MoveTo não moverá um modelo dentro
de uma obstrução, o `Class.Model` é movido para cima no eixo Y e colocado acima
da obstrução.


Move o `Class.Model.PrimaryPart|PrimaryPart` para a posição dada. Se
a parte primária não foi especificada, a parte raiz do modelo será
usada, mas a parte raiz não é determinística e é recomendável que
você sempre defina uma parte primária ao usar `Class.Model:MoveTo()|MoveTo()`.

Se houver quaisquer obstruções onde o modelo deve ser movido, como
`Class.Terrain` ou outras `Class.BasePart|BaseParts`, o modelo será
movido verticalmente para cima até que não haja nada no caminho. Se esse
comportamento não for desejado, `Class.PVInstance:PivotTo()` deve ser usado
em vez disso.

Observe que a rotação não é preservada ao mover um modelo com
`Class.Model:MoveTo()|MoveTo()`. É recomendável usar seja
`Class.Model:TranslateBy()|TranslateBy()` ou `Class.PVInstance:PivotTo()`
se a rotação atual do modelo precisar ser preservada.

Model:MoveTo

position

O `Datatype.Vector3` para onde o `Class.Model` é movido.

Move o `Class.Model.PrimaryPart|PrimaryPart` para a posição dada. Se
a parte primária não foi especificada, a parte raiz do modelo será
usada.

Model:moveTo

Faz com que este modelo não seja mais persistente para o jogador especificado. Isso não
garante que o modelo será imediatamente removido para o jogador; após
chamar este método, o modelo será tratado como
`Enum.ModelStreamingMode|Atomic` para aquele jogador e permanecerá presente
enquanto estiver dentro do raio de streaming alvo.

`Class.Model.ModelStreamingMode|ModelStreamingMode` deve ser definido como
`Enum.ModelStreamingMode|PersistentPerPlayer` para que o comportamento seja
alterado como resultado da remoção.

Model:RemovePersistentPlayer

O `Class.Player` para o qual tornar este modelo não persistente.

Faz com que este modelo não seja mais persistente para o jogador especificado.
`Class.Model.ModelStreamingMode|ModelStreamingMode` deve ser definido como
`Enum.ModelStreamingMode|PersistentPerPlayer` para que o comportamento seja
alterado como resultado da remoção.

Redefine a rotação das partes do modelo para a rotação de identidade definida anteriormente,
que é feita através do método `Class.Model:SetIdentityOrientation()`.

Model:ResetOrientationToIdentity

Modelos contêm um fator de escala canônico persistente, que começa em 1
para modelos recém criados. Esta função escala o modelo, em torno da localização do pivô,
relativo a como pareceria com um fator de escala de 1. Para
realizar isso, faz duas coisas:

- Define o fator de escala atual do modelo para o valor especificado
- Redimensiona e reposiciona todas as Instâncias descendentes de acordo

A escalonamento das localizações é feito em torno da localização do pivô.

Todas as propriedades "geométricas" de Instâncias descendentes serão escalonadas. Isso
obviamente inclui os tamanhos das partes, mas aqui estão alguns outros exemplos de
propriedades que são escalonadas:

- O comprimento de juntas como `Class.WeldConstraint|WeldConstraints`, e
  `Class.RopeConstraint`
- Velocidades e forças físicas como `Class.HingeConstraint`
- Propriedades visuais como tamanhos de emissores de partículas
- Outras propriedades de comprimento como `Class.Sound.RollOffMinDistance`

Model:ScaleTo

newScaleFactor

Define o fator de escala do modelo, ajustando o tamanho e a localização de
todas as Instâncias filhas de modo que tenham esse fator de escala em relação às
suas tamanho e localizações iniciais quando o fator de escala era 1.

Define a rotação de identidade do modelo dado, permitindo que você redefina a
rotação do modelo inteiro mais tarde, através do uso do método
`ResetOrientationToIdentity`.

Model:SetIdentityOrientation

Esta função foi substituída por `Class.PVInstance:PivotTo()` que
atua como uma substituição mais eficiente e não altera o comportamento do seu
código. Use `Class.PVInstance:PivotTo()` para novos trabalhos e migre suas
chamadas existentes `Class.Model:SetPrimaryPartCFrame()` quando for conveniente.

Define o `Class.BasePart.CFrame` da `Class.Model.PrimaryPart` do modelo.
Todas as outras partes do modelo também serão movidas e manterão suas
orientações e offsets em relação ao `Class.Model.PrimaryPart`.

Observe que esta função gerará um erro se não existir uma `Class.Model.PrimaryPart`
para o modelo. Isso pode causar problemas se, por exemplo, a parte primária
nunca foi definida ou foi destruída.

Model:SetPrimaryPartCFrame

cframe

Define o `Class.BasePart.CFrame` da `Class.Model.PrimaryPart` do modelo.
Todas as outras partes do modelo também serão movidas e manterão suas
orientações e offsets em relação ao `Class.Model.PrimaryPart`.

Este exemplo demonstra como `Class.Model:TranslateBy()` ignora colisões
 e respeita a orientação do modelo.

Um simples modelo de duas partes `Class.Model` é criado, rotacionado em 45 graus no eixo Y,
e a sua `Class.Model.PrimaryPart` é definida. Uma grande parte de obstrução é colocada
 ao lado.

Após 5 segundos, `Class.Model:TranslateBy()` é usado para direcionar o modelo a
 mover-se para dentro da parte de obstrução. O modelo se moverá para dentro da
 obstrução e manterá sua orientação atual.


Desloca um `Class.Model` pelo dado deslocamento `Datatype.Vector3`, preservando
a orientação do modelo. Se outro `Class.BasePart` ou `Class.Terrain`
já existir na nova posição, então o `Class.Model` irá sobrepor
esse objeto.

A tradução é aplicada no espaço mundial em vez de no espaço do objeto,
significando que mesmo se as partes do modelo estiverem orientadas de forma diferente,
ele ainda se moverá ao longo do eixo padrão.

Model:TranslateBy

delta

O `Datatype.Vector3` para traduzir o `Class.Model`.

Desloca um `Class.Model` pelo dado deslocamento `Datatype.Vector3`, preservando
a orientação do modelo. Se outro `Class.BasePart` ou `Class.Terrain`
já existir na nova posição, então o `Class.Model` irá sobrepor
esse objeto.

Model

Define o nível de detalhe no modelo para experiências com a
[streaming](/workspace/streaming) ativado. Malhas composites ou
imposter não suportam física, detecção de colisão ou
raycasting.

Quando definido como `Enum.ModelLevelOfDetail|StreamingMesh`, uma malha
"imposter" de resolução mais baixa (malha colorida e grosseira que envolve todas as partes filhas do
modelo) é renderizada fora do raio de streaming. Não suporta
texturas.

Quando definido como `Enum.ModelLevelOfDetail|SLIM`, um modelo **SLIM**
(Modelo Interativo Leve e Escalável) renderiza uma composição de todas as partes filhas em
resoluções progressivamente mais baixas a distâncias com base no raio de
streaming. Isso melhora muito a qualidade visual em relação a
`Enum.ModelLevelOfDetail|StreamingMesh`.

Quando definido como `Enum.ModelLevelOfDetail|Disabled` ou
`Enum.ModelLevelOfDetail|Automatic`, malhas de resolução mais baixa não serão
displayadas.


Model.LevelOfDetail

Define o nível de detalhe no modelo para experiências com streaming de instâncias
ativado.

Controla como `Class.Model|Models` são transmitidos para dentro e para fora quando o
[streaming](/workspace/streaming) de instâncias está ativado. O comportamento
depende do enum selecionado. Não tem efeito quando o streaming não está ativado.

Esta propriedade só deve ser alterada no Studio através da janela de
[Propriedades](/studio/properties) quando o streaming está
ativado, ou em `Class.Script|Scripts`, mas nunca em
`Class.LocalScript|LocalScripts` (fazer isso pode resultar em comportamento indefinido).

Model.ModelStreamingMode

Controla o comportamento de streaming do modelo em `Class.Model|Models` quando
o streaming de instâncias está ativado.

Este exemplo de código cria e lança um modelo de dado, e então informa se ele
caiu com o lado azul voltado para cima. Se `Class.Model.PrimaryPart` não for definido,
o pivô / caixa delimitadora do dado giraria, já que as partes dentro dele
são simuladas fisicamente durante a jogada.

Aponta para a parte primária do `Class.Model`. A parte primária é a
`Class.BasePart` que atua como a referência física para o pivô do
modelo. Ou seja, quando as partes dentro do modelo são movidas devido a simulação
física ou outros meios, o pivô se moverá em sincronia com a parte primária.

Observe que `Class.Model|Models` não têm `PrimaryPart` definido por padrão.
Se você estiver criando um modelo que precisa ser afetado pela física,
você deve definir manualmente esta propriedade no Studio ou dentro de um script. Se a
parte primária **não** for definida, o pivô permanecerá na mesma localização no
espaço mundial, mesmo que partes dentro do modelo sejam movidas.

Além disso, observe que ao definir esta propriedade, deve ser uma
`Class.BasePart` que seja um descendente do modelo. Se você tentar definir
`Class.Model.PrimaryPart` para um `Class.BasePart` que **não** seja um
descendente do modelo, ele será definido para essa parte, mas será redefinido para `nil`
durante o próximo passo de simulação &mdash; esse é um comportamento legado para suportar
scripts que assumem que podem temporariamente definir a parte primária para um
`Class.BasePart` que não é um descendente do modelo.

A regra geral para modelos é que:

- Modelos cujas partes estão unidas por juntas físicas como
  `Class.WeldConstraint|WeldConstraints` ou `Class.Motor6D|Motor6Ds`
  devem ter uma parte primária atribuída. Por exemplo, modelos de
  personagens Roblox têm sua `Class.Model.PrimaryPart` definida como a
  **HumanoidRootPart** por padrão.
- Modelos estáticos (geralmente `Class.BasePart.Anchored|Anchored`) que ficam em
  um lugar a menos que um script os mova explicitamente não requerem uma
  `Class.Model.PrimaryPart` e tendem a não se beneficiar de ter uma.

Model.PrimaryPart

A parte primária do `Class.Model`, ou `nil` se não for explicitamente definida.

Definir esta propriedade na janela de Propriedades escalará o modelo como
se `Class.Model:ScaleTo()` tivesse sido chamado nele, escalando todas as Instâncias descendentes
no modelo, como materiais, imagens e a geometria 3D das
partes, de modo que o modelo tenha o fator de escala especificado em relação ao seu
tamanho original.

Esta propriedade está disponível apenas no Studio e gerará um erro se
for usada em um `Class.Script` ou `Class.LocalScript`. `Class.Model:ScaleTo()` e
`Class.Model:GetScale()` devem ser usados a partir de scripts.

Model.Scale

Propriedade exclusiva para editor usada para escalar o modelo em torno de seu pivô. Definir
esta propriedade moverá a escala como se `Class.Model:ScaleTo()` tivesse
sido chamado nela.

Este exemplo de código mostra uma função personalizada para redefinir o ponto de pivot de um modelo
de volta ao centro da caixa delimitadora daquele modelo.

Esta propriedade determina onde o pivô de um `Class.Model` que não
tem um `Class.Model.PrimaryPart` definido está localizado. Se o
`Class.Model` **tem** um `Class.Model.PrimaryPart|PrimaryPart`, o
pivô do `Class.Model` é igual ao pivô daquela parte primária
em vez disso, e esta propriedade `Class.Model.WorldPivot|WorldPivot` é ignorada.

Para um `Class.Model` criado recentemente, seu pivô será tratado como o centro
da caixa delimitadora de seus conteúdos até a **primeira vez** que sua
propriedade `Class.Model.WorldPivot` for definida. Uma vez que o pivô do mundo é
definido pela primeira vez, é impossível restaurar esse comportamento inicial.

Comumente, mover o modelo com as ferramentas do Studio, ou com funções de
movimento de modelo como `Class.PVInstance:PivotTo()` e
`Class.Model:MoveTo()`, definirá o pivô do mundo e, portanto, encerrará esse novo
comportamento do modelo.

O propósito desse comportamento é permitir que o código Luau obtenha um pivô
sensato simplesmente criando um novo modelo e parentando objetos a ele, evitando a
necessidade de definir explicitamente `Class.Model.WorldPivot` toda vez que você cria um
modelo no código.

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

local model = Instance.new("Model")
Workspace.BluePart.Parent = model
Workspace.RedPart.Parent = model
model.Parent = Workspace

print(model:GetPivot())  -- Atualmente igual ao centro da caixa delimitadora contendo "BluePart" e "RedPart"

model:PivotTo(CFrame.new(0, 10, 0))  -- Isso funciona sem precisar definir explicitamente "model.WorldPivot"
```

Model.WorldPivot

Determina onde o pivô de um `Class.Model` que não tem um
`Class.Model.PrimaryPart` definido está localizado.

Modelos são objetos contêineres, o que significa que eles agrupam objetos juntos. Eles são
melhor utilizados para manter coleções de `Class.BasePart|BaseParts` e possuem um número
de funções que aumentam sua funcionalidade.

Uma `Class.PVInstance` é uma classe abstrata que não pode ser criada. É a
base para todos os objetos que têm uma localização física no mundo.


Este exemplo de código é um script de teletransporte simples que move seu personagem
10&nbsp;studs para frente na direção que você está mirando ao pressionar
a tecla <kbd>F</kbd>. Ele faz isso obtendo o pivot atual com
`Class.PVInstance:GetPivot()` e chamando `PVInstance|PivotTo` para mover o
personagem para frente.

Esta função obtém o pivô de uma `Class.PVInstance`. Isso é frequentemente utilizado
com `Class.PVInstance:PivotTo()` para mover um modelo.

`Class.Model|Models` e `Class.BasePart|BaseParts` são ambos
`Class.PVInstance|PVInstances` ("Instâncias de Velocidade de Posição") e assim ambos
possuem esta função.


PVInstance:GetPivot

Obtém o pivô de uma `Class.PVInstance`.


Transforma a `Class.PVInstance` junto com todos os seus descendentes
`Class.PVInstance|PVInstances` de modo que o pivô agora esteja localizado na
`Datatype.CFrame` especificada. Esta é a função principal que deve ser
usada para mover `Class.Model|Models` via script.

`Class.BasePart|BaseParts` são movidos dessa forma ao ter seu
`Datatype.CFrame` transformado pelo deslocamento necessário.
`Class.Model|Models` são movidos dessa forma ao ter seu
`Class.Model.WorldPivot` transformado pelo deslocamento necessário.

Note que, por questões de eficiência, eventos `Class.Object.Changed` não são
disparados para `Class.BasePart.Position|Position` e
`Class.BasePart.Orientation|Orientation` de `Class.BasePart|BaseParts`
movidos desta forma; eles são disparados apenas para `Datatype.CFrame`.

Ao chamar `Class.PVInstance:PivotTo()|PivotTo` em `Class.Model|Models`,
os deslocamentos das partes e modelos descendentes são armazenados em cache, de
modo que chamadas subsequentes a `Class.PVInstance:PivotTo()|PivotTo` no mesmo modelo
dnão acumulam deriva de ponto flutuante entre as partes que compõem o
modelo.

`Class.Model|Models` e `Class.BasePart|BaseParts` são ambos
`Class.PVInstance|PVInstances` ("Instâncias de Velocidade de Posição") e assim ambos
possuem esta função.


PVInstance:PivotTo

targetCFrame

O `Datatype.CFrame` que o pivô da `Class.PVInstance` deve igualar
depois de movê-lo.


Transforma a `Class.PVInstance` junto com todos os seus descendentes
`Class.PVInstance|PVInstances` de modo que o pivô agora esteja localizado na
`Datatype.CFrame` especificada.


PVInstance

PVInstance.Origin

PVInstance.Pivot Offset

Classe abstrata para todos os objetos que têm uma localização física no mundo.


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

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

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

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


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

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

Instance.AncestryChanged

child

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

parent

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

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

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

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

local part = Workspace.Part

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

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

Instance.AttributeChanged

attribute

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

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

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

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

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

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

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

Instance.ChildAdded

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

Instance.childAdded

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

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

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

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

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

Instance.ChildRemoved

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

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

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

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

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

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

Instance.DescendantAdded

descendant

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

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

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

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

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

#### Aviso

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

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

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

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

Instance.DescendantRemoving

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

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

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


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


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

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

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

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

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

Instance.Destroying

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

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

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

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

local function stylePropertyChanged()
	print("Propriedades de estilo alteradas")
end

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

Instance.StyledPropertiesChanged

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

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

#### Avisos

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

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

Instance:AddTag

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

Instance:children

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

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

-- Adiciona alguns brilhos
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

  local sc = Instance.new("Sparkles")
  sc.Parent = sparkles
end

print("Children:", #part:GetChildren())  --> Children: 3

part:ClearAllChildren()

print("Children:", #part:GetChildren())  --> Children: 0
```
Se você não desejar destruir **todos** os filhos e descendentes, use
`Class.Instance:GetChildren()` ou `Class.Instance:GetDescendants()` para
desloopar esses filhos/descendentes e selecionar o que deve ser destruído. Por
exemplo, o seguinte exemplo de código destruirá todos os`Class.BasePart|BaseParts`
descendentes de um `Class.Model`:

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

local model = Workspace:FindFirstChild("TestModel")

for _, descendant in model:GetDescendants() do
	if descendant:IsA("BasePart") then
		descendant:Destroy()
	end
end
```

Instance:ClearAllChildren

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

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

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

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

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

Instance:Clone

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

Instance:clone

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

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


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

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

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

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

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

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

Instance:Destroy

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

Instance:destroy

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

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

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

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

Instance:FindFirstAncestor

name

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

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

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

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

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

Instance:FindFirstAncestorOfClass

className

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

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

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

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

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

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

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

Instance:FindFirstAncestorWhichIsA

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

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

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

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

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

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

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

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

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

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

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

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

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

#### Notas de Desempenho

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

Instance:FindFirstChild

recursive

Se a busca deve ser realizada recursivamente.

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

Instance

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