BackpackItem es una clase abstracta para los elementos de la mochila, como HopperBins y
Tools.


BackpackItem

El icono de textura que se muestra para una herramienta en la mochila del jugador.

Esta propiedad debe ser configurada con el ID de contenido de una imagen subida al
sitio web de Roblox. Solo se soportan URIs de activos para esta propiedad.

Si esta propiedad se deja en blanco, la GUI `Class.Backpack` mostrará el
nombre de la herramienta en su lugar.


BackpackItem.TextureContent

El icono de textura que se muestra para una herramienta en la mochila del jugador.
Solo soporta URIs de activos.


El icono de textura que se muestra para una herramienta en la mochila del jugador.

Esta propiedad debe ser configurada con el ID de contenido de una imagen subida al
sitio web de Roblox.

Si esta propiedad se deja en blanco, la GUI `Class.Backpack` mostrará el
nombre de la herramienta en su lugar.


BackpackItem.TextureId

El icono de textura que se muestra para una herramienta en la mochila del jugador.


El siguiente ejemplo incluye una función básica que toma una tabla de objetos
y los parenta en un nuevo Modelo, devolviendo ese Modelo.

Los modelos son objetos contenedores, lo que significa que agrupan objetos juntos. Son
mejor utilizados para contener colecciones de `Class.BasePart|BaseParts` y tienen un número
de funciones que amplían su funcionalidad.

Los modelos están destinados a representar agrupaciones **geométricas**. Si tu agrupación no tiene
una interpretación geométrica, por ejemplo, una colección de
`Class.Script|Scripts`, utiliza un `Class.Folder` en su lugar.

Los modelos cuyas partes constitutivas están unidas con articulaciones (para que puedan
moverse o ser destruidas a través de simulación física) suelen tener un
`Class.Model.PrimaryPart|PrimaryPart` establecido, ya que especifica qué parte dentro
del modelo seguirá como pivote y caja delimitadora a medida que se mueve el modelo. Los
modelos estáticos que permanecen en un lugar no se benefician de tener una parte primaria configurada.

Los modelos tienen una amplia gama de aplicaciones, incluidos los personajes de jugador de Roblox.
También tienen una serie de comportamientos únicos que son importantes tener en
cuenta:

- Cuando un `Class.Humanoid` y un `Class.Part` llamado **Head** están parentados bajo
  un modelo, aparecerá una GUI de nombre/salud sobre el modelo; consulta
  [Visualización de Nombre/Salud del Personaje](/characters/name-health-display)
  para más detalles.
- Si la posición de una parte en el eje **Y** alcanza el
  `Class.Workspace.FallenPartsDestroyHeight`, y era el último objeto
  dentro de un `Class.Model`, el modelo también será destruido.
- Cuando se utiliza en un lugar con `Class.Workspace.StreamingEnabled` configurado en verdadero,
  el valor de `Class.Model.ModelStreamingMode|ModelStreamingMode` controla
  varios comportamientos sobre cómo se replica
  y/o se elimina el modelo y sus descendientes de los clientes. Además, el valor de
  `Class.Model.LevelOfDetail|LevelOfDetail` impacta el renderizado del modelo.

Como con todos los tipos de `Class.Instance`, el hecho de que un padre `Class.Model` sea
replicado a un cliente no garantiza que todos sus hijos se
replicarán. Esto es particularmente importante si estas instancias están siendo
accedidas por código que se ejecuta en el cliente, como en un `Class.LocalScript`.
Usar `Class.Model.ModelStreamingMode|ModelStreamingMode` con valores como
`Enum.ModelStreamingMode|Atomic` puede asegurar que el modelo completo y todos sus
descendientes están presentes si el modelo padre existe en el cliente, o puedes
usar `Class.Instance:WaitForChild()|WaitForChild()` cuando la atomicidad no es
deseada.

Establece este modelo como persistente para el jugador especificado. Los modelos
persistentes permanecen presentes para el jugador independientemente de las configuraciones o
condiciones de streaming.

`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar configurado en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la adición.

Model:AddPersistentPlayer

playerInstance

El `Class.Player` para hacer este modelo persistente.

Establece este modelo como persistente para el jugador especificado.
`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar configurado en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la adición.

En este ejemplo, las articulaciones en cada modelo de personaje de jugador añadido serán rotas
3 segundos después de aparecer. Romper estas articulaciones hará que el Humanoide
muera.

Este ejemplo de código demuestra la creación manual de juntas en dos partes que son
hermanas del script (PartA y PartB). Crea una junta en dos partes tocantes
con tipos de superficie compatibles (Studs e Inlet).

Rompe conexiones entre `BaseParts`, incluidas conexiones de superficie con
cualquier parte adyacente, `Class.WeldConstraint|WeldConstraints`, y todas
`Class.Weld|Welds` y otras `Class.JointInstance|JointInstances`.

Cuando se utiliza BreakJoints en un modelo de personaje de jugador, el
`Class.Humanoid` del personaje morirá ya que depende de la articulación del cuello.

Ten en cuenta que aunque las uniones producidas por conexiones de superficie con
partes adyacentes pueden técnicamente recrearse usando `Class.Model:MakeJoints()`, esto
solo recreará uniones producidas por superficies. Los desarrolladores no deben confiar
en esto, ya que las partes que siguen a las uniones rotas ya no pueden estar en
contacto entre sí.

Model:BreakJoints

Rompe conexiones entre `BaseParts`, incluidas conexiones de superficie con
cualquier parte adyacente, `Class.WeldConstraint|WeldConstraints` y todas
`Class.Weld|Welds` y otras `Class.JointInstance|JointInstances`.

Model:breakJoints

Esta función devuelve una descripción de un volumen que contiene todos
`Class.BasePart` hijos dentro de un `Class.Model`. La orientación del volumen
se basa en la orientación de la `Class.Model.PrimaryPart|PrimaryPart`, y coincide
con la caja de selección renderizada en Studio cuando se selecciona el modelo.
Reflejando el comportamiento de `Class.Terrain:FillBlock()`, devuelve un
`Datatype.CFrame` que representa el centro de esa caja delimitadora
y un `Datatype.Vector3` que representa su tamaño. El tamaño puede ser inexacto
 en tiempo de ejecución si las restricciones físicas están actuando sobre las partes dentro del
`Class.Model`.

La orientación de la caja delimitadora coincide con la orientación del
`Class.PVInstance.GetPivot|Pivot`, ya sea el pivote de la
`Class.Model.PrimaryPart|PrimaryPart` (si está presente) o el
`Class.Model.WorldPivot|WorldPivot` del modelo.

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

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

-- Redimensiona y posiciona la parte igual a la caja delimitadora del modelo
part.Size = size
part.CFrame = orientation
```

Model:GetBoundingBox

Un `Datatype.CFrame` que representa la orientación del volumen
seguido de un `Datatype.Vector3` que representa el tamaño del volumen.

Devuelve una descripción de un volumen que contiene todas las partes de un Modelo.

El siguiente ejemplo de código demuestra cómo Model.GetExtentsSize se puede usar para obtener
el tamaño de la caja delimitadora que contiene las piezas.

Devuelve el tamaño de la caja delimitadora más pequeña que contiene todas las
`Class.BasePart|BaseParts` en el `Class.Model`. La orientación coincide
con la orientación de la `Class.PVInstance.GetPivot|Pivot`, ya sea el
pivote de la `Class.Model.PrimaryPart|PrimaryPart` (si está presente) o el
`Class.Model.WorldPivot|WorldPivot` del modelo.

Ten en cuenta que esta función solo devuelve el tamaño de la caja delimitadora más pequeña,
y el desarrollador debe emplear su propio método para obtener la posición de la
caja delimitadora.

Model:GetExtentsSize

El tamaño de extensión del `Datatype.Vector3` del `Class.Model`.

Devuelve el tamaño de la caja delimitadora más pequeña que contiene todas las
`Class.BasePart|BaseParts` en el `Class.Model`, alineada con el
`Class.Model.PrimaryPart` si está establecida.

Este valor, históricamente, devolvía el CFrame de una posición central en el
modelo.

Model:GetModelCFrame

Este código crearía un modelo, pondría algunas piezas en él, las posicionaría aleatoriamente,
y luego imprimiría su tamaño:

La función GetModelSize devuelve el tamaño `Datatype.Vector3` del
`Class.Model`.

Model:GetModelSize

Cuando este método se llama desde un `Class.Script`, devuelve todos los
objetos `Class.Player` para los que este modelo es persistente. Cuando se llama desde
un `Class.LocalScript`, este método solo comprueba si este modelo es persistente
para el `Class.Players.LocalPlayer|LocalPlayer`.

Model:GetPersistentPlayers

Una tabla con todos los objetos `Class.Player` para los que este modelo es
persistente.

Devuelve todos los objetos `Class.Player` para los que este modelo es
persistente. El comportamiento varía según si este método se llama
desde un `Class.Script` o un `Class.LocalScript`.

El siguiente código demuestra cómo GetPrimaryPartCFrame y
SetPrimaryPartCFrame pueden usarse para rotar un modelo.

Se crea un modelo simple en el Workspace y se inicia un bucle que
rotará el modelo 10 grados alrededor del eje Y cada 0.2 segundos.

Esta función ha sido reemplazada por `Class.PVInstance:GetPivot()` que
actúa como un reemplazo y no cambia el comportamiento de tu código. Usa
`Class.PVInstance:GetPivot()` para nuevos trabajos y migra tus existentes
llamadas a `Class.Model:GetPrimaryPartCFrame()` cuando sea conveniente.

Devuelve el `Datatype.CFrame` de la `Class.Model.PrimaryPart` del modelo.

Esta función es equivalente a lo siguiente.

    Model.PrimaryPart.CFrame

Ten en cuenta que esta función lanzará un error si no existe parte primaria para el
`Class.Model`. Si este comportamiento no es deseado, los desarrolladores pueden hacer lo siguiente,
lo cual será igual a `nil` si no hay parte primaria.

    local cFrame = Model.PrimaryPart y Model.PrimaryPart.CFrame

Model:GetPrimaryPartCFrame

Devuelve el `Datatype.CFrame` de la `Class.Model.PrimaryPart` del modelo.
Esta función lanzará un error si no existe parte primaria para el
`Class.Model`.

Este ejemplo de código demuestra cómo sustituir en un reemplazo para todas las copias
de un modelo de árbol usando `Class.Model:PivotTo()` y `Class.Model:ScaleTo()`. El
pivot y la escala de los modelos se utilizan como referencia, asegurando que los
sizes y ubicaciones relativas de los modelos de reemplazo coincidan con los de los
originales.


Los modelos contienen un factor de escala canónica persistente, que empieza en 1
para los modelos recién creados y cambia a medida que se escala el modelo al llamar
`Class.Model:ScaleTo()`. Esta función devuelve el factor de escala canónica actual del modelo.

El factor de escala actual no impacta _directamente_ el tamaño de las instancias
bajo el modelo. Se utiliza para la creación de contenido y propósitos de scripting
para recordar cómo se ha escalado el modelo en relación a su tamaño original.

Dentro de una sesión dada, el modelo almacenará en caché la información del tamaño original
preciso de las instancias descendientes después de la primera llamada a
`Class.Model:ScaleTo()`. Eso significa que llamar a
`Class.Model:ScaleTo()|ScaleTo(x)` seguido de
`Class.Model:ScaleTo()|ScaleTo(1)` te devolverá _exactamente_
el configuración original del modelo sin deriva de punto flotante. Evitar
la deriva de punto flotante es la motivación para tener una función Scale**To**
 en lugar de una función Scale**By**.

El factor de escala impacta el comportamiento del motor de una manera: El factor de escala
del modelo se aplicará a los desplazamientos de las uniones de
`Class.Animation|Animations` reproducidas en un `Class.AnimationController`
bajo ese modelo, para que los rigs animados reproduzcan correctamente
las animaciones incluso cuando se escalen.

Model:GetScale

El factor de escala canónica actual del modelo.

Devuelve la escala canónica del modelo, que por defecto es 1 para los modelos
recién creados y cambiará a medida que se escale mediante
`Class.Model:ScaleTo()`.

Este ejemplo de código demuestra cómo se pueden hacer juntas usando la
función Model:MakeJoints.

Se instancia un modelo, con dos partes una encima de la otra. La parte superior está
anclada y la parte inferior no. Normalmente, cuando está parentada al Workspace
la parte inferior caería al Baseplate.

Sin embargo, como la propiedad TopSurface de la parte inferior está configurada en
Enum.SurfaceType.Weld, esto significa que cuando se ejecuta Model:MakeJoints se
hace una conexión entre ellas.

Por lo tanto, la parte inferior no cae hasta que se rompen las juntas en el modelo.
Esto suele hacerse usando Model:BreakJoints, pero en este ejemplo la
conexión se rompe usando una explosión.

Este ejemplo de código demuestra la creación de juntas en dos partes que son
hermanas del script (PartA y PartB). Utiliza MakeJoints en dos partes que tocan
con tipos de superficie compatibles (Studs y Inlet).

La unión basada en SurfaceType está en desuso. No uses MakeJoints para nuevos
proyectos. Usa `Class.WeldConstraint|WeldConstraints` y
`Class.HingeConstraint|HingeConstraints` en su lugar.

Revisa todos los `Class.BasePart|Parts` en el `Class.Model` y crea
uniones entre las Partes especificadas y cualquier superficie plana en contacto,
 dependiendo de las superficies de las partes.

- Las superficies suaves no crearán uniones
- Las superficies de pegamento crearán una unión `Class.Glue`
- La soldadura creará una unión `Class.Weld` con cualquier superficie, excepto
  Unjoinable
- Studs, Inlet o Universal crearán cada uno una unión `Class.Snap` con
  cualquiera de las otras dos superficies (por ejemplo, Studs con Inlet y
  Universal)
- Superficies de bisagra y motor crean instancias de unión `Class.Rotate` y
  `Class.RotateV`

Esta función no funciona si la Parte no es un descendiente de
`Class.Workspace`. Por lo tanto, debes asegurarte primero de que el Modelo esté parentado
a Workspace antes de usar MakeJoints.

Model:MakeJoints

Revisa todos los `Class.BasePart|BaseParts` en el `Class.Model`. Si algún
lado de parte tiene un SurfaceType que puede crear una unión, creará una unión
con cualquier parte adyacente.

Model:makeJoints

Model:move

location

Este ejemplo demuestra cómo `Class.Model:MoveTo()` evita colisiones.

Se crea un simple `Class.Model` de dos partes, y su `Class.Model.PrimaryPart`
es configurado. Una gran parte de obstrucción se coloca al lado.

Después de 5 segundos, se usa `Class.Model:MoveTo()` para dirigir el modelo a
moverse dentro de la parte de obstrucción. Sin embargo, como MoveTo no moverá un modelo dentro
de una obstrucción, el `Class.Model` se mueve hacia arriba en el eje Y y se coloca encima
de la obstrucción.


Mueve la `Class.Model.PrimaryPart|PrimaryPart` a la posición dada. Si
no se ha especificado una parte primaria, se usará la parte raíz del modelo,
pero la parte raíz no es determinista y se recomienda que
siempre configures una parte primaria al usar `Class.Model:MoveTo()|MoveTo()`.

Si hay obstrucciones donde se debe mover el modelo, como
`Class.Terrain` u otros `Class.BasePart|BaseParts`, el modelo se moverá
verticalmente hacia arriba hasta que no haya nada en el camino. Si este
comportamiento no es deseado, se debe utilizar `Class.PVInstance:PivotTo()`
en su lugar.

Ten en cuenta que la rotación no se preserva al mover un modelo con
`Class.Model:MoveTo()|MoveTo()`. Se recomienda usar ya sea
`Class.Model:TranslateBy()|TranslateBy()` o `Class.PVInstance:PivotTo()`
si se necesita preservar la rotación actual del modelo.

Model:MoveTo

position

El `Datatype.Vector3` al que se mueve el `Class.Model`.

Mueve la `Class.Model.PrimaryPart|PrimaryPart` a la posición dada. Si
no se ha especificado una parte primaria, se usará la parte raíz del modelo.

Model:moveTo

Hace que este modelo ya no sea persistente para el jugador especificado. Esto no
garantiza que el modelo se eliminará inmediatamente para el jugador; después
de llamar a este método, el modelo se tratará como
`Enum.ModelStreamingMode|Atomic` para ese jugador y permanecerá presente
siempre que esté dentro del radio de streaming objetivo.

`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar configurado en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la eliminación.

Model:RemovePersistentPlayer

El `Class.Player` para hacer que este modelo ya no sea persistente.

Hace que este modelo ya no sea persistente para el jugador especificado.
`Class.Model.ModelStreamingMode|ModelStreamingMode` debe estar establecido en
`Enum.ModelStreamingMode|PersistentPerPlayer` para que el comportamiento cambie
como resultado de la eliminación.

Restablece la rotación de las partes del modelo a la rotación de identidad
anteriormente establecida, que se hace a través del método
`Class.Model:SetIdentityOrientation()`.

Model:ResetOrientationToIdentity

Los modelos contienen un factor de escala canónica persistente, que empieza en 1
para los modelos recién creados. Esta función escala el modelo, alrededor de la ubicación del pivote,
en relación a cómo se vería con un factor de escala de 1. Para
lograr esto, hace dos cosas:

- Establece el factor de escala actual del modelo al valor especificado
- Redimensiona y reposiciona todas las instancias descendientes en consecuencia

La escala de las ubicaciones se realiza alrededor de la ubicación del pivote.

Todas las propiedades "geométricas" de las instancias descendientes serán escaladas. Eso
obviamente incluye los tamaños de las partes, pero aquí hay algunos otros ejemplos de
propiedades que se escalan:

- La longitud de las uniones como `Class.WeldConstraint|WeldConstraints`, y
  `Class.RopeConstraint`
- Velocidades y fuerzas físicas como `Class.HingeConstraint`
- Propiedades visuales como tamaños de emisores de partículas
- Otras propiedades de longitud como `Class.Sound.RollOffMinDistance`

Model:ScaleTo

newScaleFactor

Establece el factor de escala del modelo, ajustando el tamaño y la ubicación de
 todas las instancias descendientes para que tengan ese factor de escala en relación a
sus tamaños y ubicaciones iniciales cuando el factor de escala era 1.

Establece la rotación de identidad del modelo dado, permitiéndote restablecer la
rotación de todo el modelo más tarde, a través del uso del método
`ResetOrientationToIdentity`.

Model:SetIdentityOrientation

Esta función ha sido reemplazada por `Class.PVInstance:PivotTo()` que
actúa como un reemplazo más eficiente y no cambia el comportamiento de tu
código. Usa `Class.PVInstance:PivotTo()` para nuevos trabajos y migra tus
existentes llamadas a `Class.Model:SetPrimaryPartCFrame()` cuando sea conveniente.

Establece el `Class.BasePart.CFrame` de la `Class.Model.PrimaryPart` del modelo.
Todas las demás partes en el modelo también se moverán y mantendrán su
orientación y desplazamiento respectivos respecto a la `Class.Model.PrimaryPart`.

Ten en cuenta que esta función lanzará un error si no existe `Class.Model.PrimaryPart`
para el modelo. Esto puede causar problemas si, por ejemplo, la parte primaria
nunca se estableció o ha sido destruida.

Model:SetPrimaryPartCFrame

cframe

El `Datatype.CFrame` que se debe establecer.

Establece el `Class.BasePart.CFrame` de la `Class.Model.PrimaryPart` del modelo.
Todas las demás partes en el modelo también se moverán y mantendrán su
orientación y desplazamiento respectivos respecto a la `Class.Model.PrimaryPart`.

Este ejemplo demuestra cómo `Class.Model:TranslateBy()` ignora las colisiones
y respeta la orientación del modelo.

Se crea un `Class.Model` simple de dos partes, rotado 45 grados en el eje Y,
y se establece su `Class.Model.PrimaryPart`. Se coloca una gran parte de obstrucción
al lado.

Después de 5 segundos, se utiliza `Class.Model:TranslateBy()` para dirigir el modelo a
moverse dentro de la parte de obstrucción. El modelo se moverá dentro de la
obstrucción y mantendrá su orientación actual.


Desplaza un `Class.Model` por el desplazamiento `Datatype.Vector3` dado, preservando
la orientación del modelo. Si ya existe otro `Class.BasePart` o `Class.Terrain`
en la nueva posición, entonces el `Class.Model` se superpondrá
con dicho objeto.

La traducción se aplica en el espacio mundial en lugar del espacio del objeto,
lo que significa que incluso si las partes del modelo están orientadas de manera diferente, aún
se moverá a lo largo del eje estándar.

Model:TranslateBy

delta

El `Datatype.Vector3` por el cual se traduce el `Class.Model`.

Desplaza un `Class.Model` por el desplazamiento `Datatype.Vector3` dado, preservando
la orientación del modelo. Si ya existe otro `Class.BasePart` o `Class.Terrain`
en la nueva posición, entonces el `Class.Model` se superpondrá
con dicho objeto.

Model

Establece el nivel de detalle en el modelo para experiencias con
[streaming](/workspace/streaming) habilitado. Los modelos compuestos o
imposter no admiten física, detección de colisiones ni
raycasting.

Cuando se establece en `Enum.ModelLevelOfDetail|StreamingMesh`, un modelo
"imposter" de menor resolución (malla coloreada y gruesa que envuelve todos los
componentes secundarios del modelo) se renderiza fuera del radio de streaming. No admite
texturas.

Cuando se establece en `Enum.ModelLevelOfDetail|SLIM`, un modelo **SLIM** (Modelo
Interactivo Ligero Escalable) renderiza un compuesto de todos los componentes
secundarios a resoluciones progresivamente más bajas a distancias basadas en el
radio de streaming. Esto mejora enormemente la calidad visual en comparación con
`Enum.ModelLevelOfDetail|StreamingMesh`.

Cuando se establece en `Enum.ModelLevelOfDetail|Disabled` o
`Enum.ModelLevelOfDetail|Automatic`, las mallas de menor resolución no se
displayarán.


Model.LevelOfDetail

Establece el nivel de detalle en el modelo para experiencias con
streaming de instancias habilitado.

Controla cómo se transmiten hacia adentro y hacia afuera los `Class.Model|Models` cuando
se habilita el [streaming](/workspace/streaming) de instancias. El comportamiento
depende del enum seleccionado. No tiene efecto cuando el streaming no está habilitado.

Esta propiedad solo debe modificarse en Studio a través de la
ventana de [Propiedades](/studio/properties) cuando el streaming está
habilitado, o en `Class.Script|Scripts`, pero nunca en
`Class.LocalScript|LocalScripts` (hacerlo puede resultar en un comportamiento indefinido).

Model.ModelStreamingMode

Controla el comportamiento de streaming del modelo en `Class.Model|Models` cuando
se habilita el streaming de instancias.

Este ejemplo de código crea y lanza un modelo de dado, luego indica si
aterrizó con el lado azul hacia arriba. Si `Class.Model.PrimaryPart` no se establece,
el pivote / caja delimitadora del dado rotaría, ya que las partes dentro de él
son simuladas físicamente durante el lanzamiento.

Apunta a la parte primaria del `Class.Model`. La parte primaria es la
`Class.BasePart` que actúa como la referencia física para el pivote del
modelo. Es decir, cuando las partes dentro del modelo se mueven debido a la
simulación física u otros medios, el pivote se moverá sincronizado con la parte
primaria.

Ten en cuenta que los `Class.Model|Models` no tienen `PrimaryPart` configurado por defecto.
Si estás creando un modelo que necesita ser afectado por la física, debes
configurar manualmente esta propiedad en Studio o dentro de un script. Si la
parte primaria **no** está configurada, el pivote permanecerá en la misma ubicación en
el espacio mundial, incluso si las partes dentro del modelo son movidas.

También ten en cuenta que al establecer esta propiedad, debe ser un
`Class.BasePart` que sea descendiente del modelo. Si intentas establecer
`Class.Model.PrimaryPart` en un `Class.BasePart` que **no** es un
descendiente del modelo, se configurará en esa parte pero se restablecerá a `nil`
 durante el siguiente paso de simulación &mdash; este es un comportamiento heredado para
soportar scripts que suponen que pueden configurar temporalmente la parte primaria en un
`Class.BasePart` que no es un descendiente del modelo.

La regla general para los modelos es que:

- Los modelos cuyas partes están unidas a través de uniones físicas como
  `Class.WeldConstraint|WeldConstraints` o `Class.Motor6D|Motor6Ds`
  deben tener una parte primaria asignada. Por ejemplo, los modelos de
  personajes de Roblox tienen su `Class.Model.PrimaryPart` configurado en el
  **HumanoidRootPart** por defecto.
- Los modelos estáticos (generalmente `Class.BasePart.Anchored|Anchored`) que permanecen en
  un lugar a menos que un script los mueva explícitamente no requieren un
  `Class.Model.PrimaryPart` y tienden a no beneficiarse de tener uno configurado.

Model.PrimaryPart

La parte primaria del `Class.Model`, o `nil` si no está configurada explícitamente.

Configurar esta propiedad en la ventana de Propiedades escalará el modelo como
si se hubiera llamado a `Class.Model:ScaleTo()` en él, escalando todas las instancias
hijas en el modelo, como materiales, imágenes y la geometría 3D de las
partes, para que el modelo tenga el factor de escala especificado en relación a su
 tamaño original.

Esta propiedad solo está disponible en Studio y lanzará un error si se utiliza
en un `Class.Script` o `Class.LocalScript`. Se recomienda usar
`Class.Model:ScaleTo()` y `Class.Model:GetScale()` desde scripts.

Model.Scale

Propiedad solo para editores utilizada para escalar el modelo alrededor de su pivote. Configurar
esta propiedad moverá la escala como si se hubiera llamado a `Class.Model:ScaleTo()` en ella.

Este ejemplo de código muestra una función personalizada para restablecer el pivot de un modelo
de vuelta al centro de la caja delimitadora de ese modelo.

Esta propiedad determina dónde está ubicado el pivote de un `Class.Model` que **no** tiene un
`Class.Model.PrimaryPart` establecido. Si el `Class.Model` **tiene** un
`Class.Model.PrimaryPart|PrimaryPart`, el pivote del `Class.Model` es igual al pivote de esa parte
primaria en su lugar, y esta propiedad `Class.Model.WorldPivot|WorldPivot` se ignora.

Para un `Class.Model` recién creado, su pivote se tratará como el centro
de la caja delimitadora de su contenido hasta la **primer vez** que se
e establezca su propiedad `Class.Model.WorldPivot`. Una vez que el pivote del mundo se establece por\ primera vez, es imposible restaurar este comportamiento inicial.

Comúnmente, mover el modelo con las herramientas de Studio, o con funciones
de movimiento de modelos como `Class.PVInstance:PivotTo()` y
`Class.Model:MoveTo()`, establecerá el pivote del mundo y así finalizará este nuevo
comportamiento del modelo.

El propósito de este comportamiento es permitir que el código de Luau obtenga un pivote
sensible simplemente creando un nuevo modelo y parentando objetos en él, evitando la
necesidad de establecer explícitamente `Class.Model.WorldPivot` cada vez que creas un
modelo en el 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())  -- Actualmente igual al centro de la caja delimitadora que contiene "BluePart" y "RedPart"

model:PivotTo(CFrame.new(0, 10, 0))  -- Esto funciona sin necesidad de establecer explícitamente "model.WorldPivot"
```

Model.WorldPivot

Determina dónde está ubicado el pivote de un `Class.Model` que **no** tiene un
`Class.Model.PrimaryPart` establecido.

Los modelos son objetos contenedores, lo que significa que agrupan objetos juntos. Son
mejor utilizados para contener colecciones de `Class.BasePart|BaseParts` y tienen un número
de funciones que amplían su funcionalidad.

Una `Class.PVInstance` es una clase abstracta que no se puede crear. Es la
base para todos los objetos que tienen una ubicación física en el mundo.


Este ejemplo de código es un script simple de teleportación que mueve tu personaje
10&nbsp;studs hacia adelante en la dirección en la que actualmente estás mirando cuando presionas
la <kbd>F</kbd> tecla. Lo hace obteniendo el pivot actual con
`Class.PVInstance:GetPivot()` y llamando a `PVInstance|PivotTo` para mover el
personaje hacia adelante.

Esta función obtiene el pivote de una `Class.PVInstance`. Esto se utiliza a menudo
con `Class.PVInstance:PivotTo()` para mover un modelo.

`Class.Model|Models` y `Class.BasePart|BaseParts` son ambos
`Class.PVInstance|PVInstances` ("Instancias de Velocidad de Posición") y así ambos
tienen esta función.


PVInstance:GetPivot

Obtiene el pivote de una `Class.PVInstance`.


Transforma la `Class.PVInstance` junto con todas sus descendientes
`Class.PVInstance|PVInstances` de tal manera que el pivote ahora se ubica en el
`Datatype.CFrame` especificado. Esta es la función principal que se debe
usar para mover `Class.Model|Models` mediante scripting.

`Class.BasePart|BaseParts` se mueven de esta manera al transformar su
`Datatype.CFrame` por el desplazamiento necesario.
`Class.Model|Models` se mueven de esta forma al transformar su
`Class.Model.WorldPivot` por el desplazamiento necesario.

Nota que, por razones de eficiencia, los eventos `Class.Object.Changed` no
se desencadenan para `Class.BasePart.Position|Position` y
`Class.BasePart.Orientation|Orientation` de `Class.BasePart|BaseParts`
movidos de esta manera; solo se desencadenan para `Datatype.CFrame`.

Al llamar a `Class.PVInstance:PivotTo()|PivotTo` en `Class.Model|Models`,
los desplazamientos de las partes y modelos descendientes se almacenan en caché, de tal manera que
las llamadas posteriores a `Class.PVInstance:PivotTo()|PivotTo` en el mismo modelo
o no acumulan deriva de punto flotante entre las partes que conforman el
modelo.

`Class.Model|Models` y `Class.BasePart|BaseParts` son ambos
`Class.PVInstance|PVInstances` ("Instancias de Velocidad de Posición") y así ambos
tienen esta función.


PVInstance:PivotTo

targetCFrame

El `Datatype.CFrame` que el pivote de `Class.PVInstance` debe igualar
despues de moverlo.


Transforma la `Class.PVInstance` junto con todas sus descendientes
`Class.PVInstance|PVInstances` de tal manera que el pivote ahora se ubica en el
`Datatype.CFrame` especificado.


PVInstance

PVInstance.Origin

PVInstance.Pivot Offset

Clase abstracta para todos los objetos que tienen una ubicación física en el mundo.


`Instance` es la clase base para todas las clases de la jerarquía de clases de Roblox
que pueden ser parte del árbol de `Class.DataModel`.

No es posible crear directamente objetos `Instance` en la raíz, pero el constructor especial
`Datatype.Instance.new()` crea objetos a través de código, tomando el
nombre de la clase como parámetro y devolviendo el objeto creado.

Demuestra cómo detectar cambios en la ascendencia de una instancia al conectarse al
`Class.Instance.AncestryChanged` evento.

El Parent de ChangingPart se establece en diferentes valores con el tiempo. El padre de
la parte es el ancestro de la parte, por lo que el evento `Class.Instance.AncestryChanged`
se activará cada vez que cambie.


Se activa cuando esta instancia es reparentada o cuando cualquiera de sus
ancestros es reparentado.

Puedes usar este evento para rastrear la eliminación de una instancia en el
Studio, como la eliminación manual en el Explorador o a través de un
plugin. Si necesitas detectar cuándo una instancia es destruida usando
`Class.Instance:Destroy()`, usa en su lugar el evento
`Class.Instance.Destroying`.

Instance.AncestryChanged

child

La instancia cuya propiedad `Class.Instance.Parent|Parent` ha cambiado,
que puede ser esta instancia o un ancestro más distante, **no**
es necesariamente la instancia a la que el controlador está conectado.

parent

Se activa cuando la propiedad `Class.Instance.Parent` de este objeto o uno de
sus ancestros es cambiada.

Este evento se activa cada vez que se cambia cualquier atributo en la instancia,
incluyendo cuando un atributo se establece en `nil`. El nombre del
atributo cambiado se pasa a la función conectada.

Por ejemplo, el siguiente fragmento de código conecta la función
`attributeChanged()` para que se active cada vez que cambia uno de los
atributos de la parte:

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

local part = Workspace.Part

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

part.AttributeChanged:Connect(attributeChanged)
```
Consulta también `Class.Instance:GetAttributeChangedSignal()` que devuelve un
evento que se activa cuando un atributo específico cambia.

Instance.AttributeChanged

attribute

El nombre del atributo que ha sido cambiado.

Se activa cada vez que se cambia un atributo en la `Class.Instance`.

Este fragmento imprime los nombres de los objetos a medida que se añaden al Espacio de Trabajo:

Se activa después de que un objeto es parentado a esta `Class.Instance`.

Nota, al usar este método en un cliente para detectar objetos creados por el
servidor, es necesario usar `Class.Instance:WaitForChild()` al
indexar los descendientes de este objeto. Esto se debe a que el objeto y sus
descendientes no se garantiza que se repliquen desde el servidor al cliente
simultáneamente. Por ejemplo:

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

Workspace.ChildAdded:Connect(function(child)
	-- Usa WaitForChild() ya que los descendientes pueden no haberse replicado aún
	local head = child:WaitForChild("Head")
end)
```
Nota, este evento solo opera para hijos inmediatos de la
`Class.Instance`. Para un evento que capture todos los descendientes, usa
`Class.Instance.DescendantAdded`.

Consulta también `Class.Instance.ChildRemoved`.

Instance.ChildAdded

La `Class.Instance` que ha sido añadida.

Se activa después de que un objeto es parentado a esta `Class.Instance`.

Instance.childAdded

Este fragmento imprime los nombres de los objetos a medida que se eliminan del
Espacio de trabajo:

Se activa después de que un hijo es eliminado de esta `Class.Instance`.

Eliminado se refiere a cuando el padre de un objeto se cambia de esta
`Class.Instance` a algo diferente de esta `Class.Instance`. Nota, este
evento también se activará cuando un hijo sea destruido (usando
`Class.Instance:Destroy()`) ya que la función de destrucción establece el
padre de un objeto a `nil`.

Este evento solo opera para hijos inmediatos de la `Class.Instance`.
Para un evento que capture todos los descendientes, usa
`Class.Instance.DescendantRemoving`.

Consulta también `Class.Instance.ChildAdded`.

Instance.ChildRemoved

La `Class.Instance` que ha sido eliminada.

Se activa después de que un hijo es eliminado de esta `Class.Instance`.

Este siguiente ejemplo imprimirá el nombre de cualquier objeto que se agregue al
Espacio de trabajo:

Este evento se activa después de que se añade un descendiente a la `Class.Instance`.

Al activarse para cada descendiente, parentar un objeto a la
`Class.Instance` activará el evento para este objeto y todos sus
descendientes individualmente.

Si solo te preocupas por los **hijos directos** de la
`Class.Instance`, usa `Class.Instance.ChildAdded` en su lugar.

Consulta también `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

Se activa después de que se añade un descendiente a la `Class.Instance`.

El siguiente ejemplo imprime el nombre de cualquier descendiente mientras se está eliminando
del Workspace:

Este evento se activa **inmediatamente antes** de que el padre de la `Class.Instance`
cambie de forma que una instancia **descendiente** ya no será un
descendiente. `Class.Instance:Destroy()|Destroy()` cambia el
`Class.Instance.Parent|Parent` de una instancia a `nil`, por lo que al llamar a
ese método en un descendiente del padre, este evento se activará.

Dado que este evento se activa **antes** de la eliminación del descendiente,
el padre del descendiente no cambiará en el momento de la activación de
este evento. Si el descendiente también es un **hijo directo** del
padre, este evento se activará antes de `Class.Instance.ChildRemoved`.

Si un descendiente tiene hijos, este evento se activará primero con el
descendiente, seguido por sus descendientes.

#### Advertencia

Este evento se activa con el objeto descendiente que se está eliminando.
Intentar establecer el `Class.Instance.Parent|Parent` del descendiente en
algo más fallará. A continuación se muestra un ejemplo que demuestra esto:

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

Workspace.DescendantRemoving:Connect(function(descendant)
	-- ¡No manipules el padre del descendiente en esta función!
	-- Este evento se activa PORQUE el padre fue manipulado, y el cambio aún no ha ocurrido
	-- Por lo tanto, es problemático cambiar el padre de esta manera:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```
Consulta también `Class.Instance.DescendantAdded|DescendantAdded`.

Instance.DescendantRemoving

La `Class.Instance` que se está eliminando.

Se activa inmediatamente antes de que se elimine un descendiente de la `Class.Instance`.

Este ejemplo demuestra cómo, al usar el comportamiento de señal Inmediata, una
Instancia que está siendo destruida permanece en su lugar hasta que la función conectada se detiene.


Este ejemplo demuestra cómo, al usar el comportamiento de señal diferida, una Instancia
se destruye antes de que se dispare la señal.


La `Class.Instance` nunca se eliminará de la memoria mientras una función conectada
la esté utilizando. Sin embargo, si la función se bloquea en algún momento,
la `Class.Instance` y sus descendientes serán parentados a `nil`.

Si la propiedad `Class.Workspace.SignalBehavior` está establecida en
`Enum.SignalBehavior.Immediate`, este evento se activa inmediatamente antes del
`Class.Instance` o de uno de sus ancestros es destruido con
`Class.Instance:Destroy()`.

Si la propiedad `Class.Workspace.SignalBehavior` está establecida en
`Enum.SignalBehavior.Deferred`, este evento se activa en el siguiente
punto de reanudación, que estará después de que el `Class.Instance` o uno de
sus ancestros sean destruidos con `Class.Instance:Destroy()`.

Con el comportamiento de `Enum.SignalBehavior.Deferred|Deferred`, conectar un
script a su propio evento `Class.Instance.Destroying` es problemático, ya que el
script será destruido antes de que se pueda llamar al callback (lo que significa
que no se ejecutará).

Al eliminar una `Class.Instance` en Studio, como eliminar manualmente
a través del [Explorador](/studio/explorer) o a través de un
plugin, la `Class.Instance` no es destruida. En su lugar, el padre se establece
en `nil` lo que puedes rastrear con `Class.Instance.AncestryChanged`.

Instance.Destroying

Se activa inmediatamente antes (o se difiere hasta después) de que la instancia se
destruya a través de `Class.Instance:Destroy()`. 

Este evento se activa cada vez que se cambia cualquier propiedad de estilo en la instancia,
incluyendo cuando una propiedad se establece en `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("Las propiedades de estilo han cambiado")
end

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

Instance.StyledPropertiesChanged

Se activa cada vez que se cambia cualquier propiedad de estilo en la instancia,
incluyendo cuando una propiedad se establece en `nil`.

Este método aplica una etiqueta a la instancia, sin efecto si la etiqueta ya
ha sido aplicada. Agregar una etiqueta con éxito generará una señal creada por
`Class.CollectionService:GetInstanceAddedSignal()` con la etiqueta dada.

#### Advertencias

- Las etiquetas de una instancia que fueron añadidas del lado del cliente se eliminarán si el
  servidor más tarde añade o elimina una etiqueta en esa instancia porque el servidor
  replica todas las etiquetas juntas y sobrescribe las etiquetas anteriores.

- Al etiquetar una instancia, es común que se utilicen algunos recursos para
darle a la etiqueta su funcionalidad, por ejemplo conexiones de eventos o tablas.
  Para prevenir fugas de memoria, es una buena idea limpiar estos recursos
  (desconectar, establecer en `nil`, etc.) cuando ya no sean necesarios para una etiqueta. Haz esto al
  llamar a `Class.Instance:RemoveTag()`, al
  llamar a `Class.Instance:Destroy()`, o en una función conectada a una señal
  devuelta por `Class.CollectionService:GetInstanceRemovedSignal()`.

Instance:AddTag

La función de los hijos devuelve un array de los hijos del objeto.

Instance:children

Devuelve un array de los hijos del objeto.

Este método destruye todos los hijos y descendientes de una instancia.

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

-- Agregar algunos destellos
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
```
Si no deseas destruir **todos** los hijos y descendientes, usa ya sea
`Class.Instance:GetChildren()` o `Class.Instance:GetDescendants()` para
recorrer esos hijos/descendientes y seleccionar qué destruir. Por
ejemplo, el siguiente extracto de código destruirá todos
`Class.BasePart|BaseParts` descendientes de un `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 destruye todos los hijos de una instancia.

Demuestra cómo clonar un modelo usando `Class.Instance:Clone()`.

`Clone()` crea una copia de una instancia y de todos sus descendientes,
ignorando todas las instancias que no son
`Class.Instance.Archivable|Archivable`. La copia de la instancia raíz es
devuelta por este método y su `Class.Instance.Parent|Parent` se establece en
`nil`. Ten en cuenta que si la instancia misma tiene
`Class.Instance.Archivable|Archivable` establecida en `false`, este método devolverá
`nil`.

Si una propiedad de referencia como `Class.ObjectValue.Value` se establece en una
instancia clonada, el valor de la propiedad de la copia depende del
valor original:

- Si una propiedad de referencia se refiere a una instancia que también fue clonada,
  la copia se referirá a la copia.
- Si una propiedad de referencia se refiere a una instancia que no fue clonada,
  se mantiene el mismo valor en la copia.

Instance:Clone

Crea una copia de una instancia y de todos sus descendientes, ignorando instancias
que no son `Class.Instance.Archivable|Archivable`.

Instance:clone

Demuestra cómo destruir una Parte utilizando la función `Class.Instance:Destroy()`.

Esta función es la manera correcta de eliminar objetos que ya no son
necesarios.


Establece la propiedad `Class.Instance.Parent` en `nil`, bloquea la
propiedad `Class.Instance.Parent`, desconecta todas las conexiones, y llama a
`Destroy()` en todos los hijos. Este método es la manera correcta de eliminar
objetos que ya no son necesarios.

Eliminar objetos innecesarios es importante, ya que objetos y
conexiones innecesarias en un lugar consumen memoria lo que puede llevar
con el tiempo a problemas serios de rendimiento.

Como mejor práctica después de llamar a `Destroy()` en un objeto, establece cualquier
variable que haga referencia al objeto (o sus descendientes) en `nil`. Esto
previene que tu código acceda a cualquier cosa relacionada con el objeto.

```lua
local part = Instance.new("Part")
part.Name = "Hola, mundo"
part:Destroy()
-- No hagas esto:
print(part.Name)  --> "Hola, mundo"
-- Haz esto para prevenir que la línea anterior funcione:
part = nil
```
Una vez que un `Class.Instance` ha sido destruido por este método, no puede ser
reutilizado porque la propiedad `Class.Instance.Parent` está bloqueada. Para
**eliminar temporalmente** un objeto en lugar de destruirlo, establece
`Class.Instance.Parent|Parent` en `nil`. Por ejemplo:

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

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```
Para destruir un objeto después de un tiempo determinado, usa
`Class.Debris:AddItem()`.

Instance:Destroy

Establece la propiedad `Class.Instance.Parent` en `nil`, bloquea la
propiedad `Class.Instance.Parent`, desconecta todas las conexiones, y llama a
`Destroy()` en todos los hijos.

Instance:destroy

Devuelve el primer ancestro del `Class.Instance` cuyo
`Class.Instance.Name` es igual al nombre dado.

Este método trabaja hacia arriba, lo que significa que comienza en el `Class.Instance.Parent`
inmediato de la instancia y trabaja hacia el `Class.DataModel`. Si no se
encuentra un ancestro coincidente, devuelve `nil`.

El siguiente fragmento de código encontraría el primer ancestro del objeto
llamado `Car`.

```
local car = object:FindFirstAncestor("Car")
```
Para variantes de este método que encuentran ancestros de una clase específica,
consulta `Class.Instance:FindFirstAncestorOfClass()` y
`Class.Instance:FindFirstAncestorWhichIsA()`.

Instance:FindFirstAncestor

name

Devuelve el primer ancestro del `Class.Instance` cuyo
`Class.Instance.Name` es igual al nombre dado.

Devuelve el primer ancestro del `Class.Instance` cuyo
`Class.Object.ClassName` es igual al className dado.

Este método trabaja hacia arriba, lo que significa que comienza en el `Class.Instance.Parent`
inmediato de la instancia y trabaja hacia el `Class.DataModel`. Si no se
encuentra un ancestro coincidente, devuelve `nil`.

Un uso común de este método es encontrar el `Class.Model` al que
pertenece un `Class.BasePart`. Por ejemplo:

```
local model = part:FindFirstAncestorOfClass("Model")
```
Este método es una variante de `Class.Instance:FindFirstAncestor()` que
verifica la propiedad `Class.Object.ClassName` en lugar de `Class.Instance.Name`. También
existe `Class.Instance:FindFirstAncestorWhichIsA()`, que usa el método `Class.Object:IsA()` en su lugar para respetar la
herencia de clases.

Instance:FindFirstAncestorOfClass

className

Devuelve el primer ancestro del `Class.Instance` cuyo
`Class.Object.ClassName` es igual al className dado.

Devuelve el primer ancestro del `Class.Instance` para quien
`Class.Object:IsA()` devuelve verdadero para el className dado.

Este método trabaja hacia arriba, lo que significa que comienza en el `Class.Instance.Parent`
inmediato de la instancia y trabaja hacia el `Class.DataModel`. Si no se
encuentra un ancestro coincidente, devuelve `nil`.

A diferencia de `Class.Instance:FindFirstAncestorOfClass()`, este método utiliza
`Class.Object:IsA()` que respeta la herencia de clases. Por ejemplo:

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```
Por lo tanto, el siguiente fragmento de código devolverá el primer
ancestro `Class.BasePart`, independientemente de si es un `Class.WedgePart`,
`Class.MeshPart` o `Class.Part`.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```
Consulta también `Class.Instance:FindFirstAncestor()`.

Instance:FindFirstAncestorWhichIsA

Devuelve el primer ancestro del `Class.Instance` para quien
`Class.Object:IsA()` devuelve verdadero para el className dado.

A continuación, buscaría en Workspace un objeto llamado "Brick". Si se encuentra, cambiará el nombre del objeto a "Foo".

Devuelve el primer hijo del `Class.Instance` con el nombre dado, o
`nil` si no existe tal hijo. Si el argumento opcional `recursive` es
`true`, este método busca todos los descendientes en lugar de solo los
hijos inmediatos del `Class.Instance`.

#### Verificando la Existencia de un Objeto

`FindFirstChild()` es necesario si necesitas verificar que un objeto existe
antes de continuar. Intentar indexar un hijo por nombre usando el operador
punto generará un error si el hijo no existe.

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

-- La siguiente línea da error si la parte no existe en el espacio de trabajo
Workspace.Part.Transparency = 0.5
```
Un enfoque mejor es usar `FindFirstChild()` para primero comprobar si `Part`,
luego usar una instrucción `if` para ejecutar código que lo necesite.

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

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

#### Encontrar un Hijo cuyo Nombre Coincida con una Propiedad

A veces el `Class.Instance.Name|Name` de un objeto es el mismo que el de una
propiedad de `Class.Instance.Parent|Parent`. Al usar el operador punto, las
propiedades tienen prioridad sobre los hijos si comparten un nombre.

En el siguiente ejemplo, se añade una `Class.Folder` llamada `Color` a un
`Class.Part`, que también tiene la propiedad `Class.Part.Color`. Ten en cuenta que
`part.Color` se refiere al valor de la propiedad `Datatype.Color3`, no a la instancia hija
`Class.Folder`. Un beneficio de usar
`Class.Instance:FindFirstChild()|FindFirstChild()` es que la
introducción de nuevas propiedades no pone en riesgo tu código.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- La propiedad
local c2 = part:FindFirstChild("Color")  -- La carpeta hija
```

#### Notas de Rendimiento

`Class.Instance:FindFirstChild()|FindFirstChild()` toma aproximadamente un 20% más de
tiempo que usar el operador punto y casi 8 veces más que simplemente guardar un
referencia a un objeto. Por lo tanto, debes evitar llamarlo en
código dependiente del rendimiento, como en bucles ajustados o funciones conectadas
a `Class.RunService.Heartbeat` y `Class.RunService.PreRender`. En su lugar,
almacena el resultado en una variable, o considera usar
`Class.Instance.ChildAdded|ChildAdded` o
`Class.Instance:WaitForChild()|WaitForChild()` para detectar cuándo un hijo de un
dado nombre se convierte disponible.

Instance:FindFirstChild

recursive

Si la búsqueda debe ser realizada de forma recursiva.

Devuelve el primer hijo del `Class.Instance` encontrado con el nombre dado.

Instance:findFirstChild

Devuelve el primer hijo del `Class.Instance` cuyo
`Class.Object.ClassName|ClassName` es igual al `className` dado.
A diferencia de `Class.Instance:FindFirstChildWhichIsA()`, este método solo devuelve
objetos cuya clase coincide con `className`, ignorando la herencia de clases. Si no se
encuentra un hijo coincidente, este método devuelve `nil`.

Instance:FindFirstChildOfClass

Devuelve el primer hijo del `Class.Instance` cuyo
`Class.Object.ClassName|ClassName` es igual al nombre de clase dado.

Devuelve el primer hijo del `Class.Instance` para quien
`Class.Object:IsA()` devuelve verdadero para el className dado.

Si no se encuentra un hijo coincidente, este método devuelve `nil`. Si el argumento
opcional recursivo es verdadero, este método busca todos los descendientes en lugar
de solo los hijos inmediatos del `Class.Instance`.

A diferencia de `Class.Instance:FindFirstChildOfClass()`, este método utiliza
`Class.Object:IsA()` que respeta la herencia de clases. Por ejemplo:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```
Por lo tanto, el siguiente fragmento de código devolverá el primer
hijo `Class.BasePart`, independientemente de si es un `Class.WedgePart`,
`Class.MeshPart` o `Class.Part`.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```
Los desarrolladores que busquen un hijo por nombre, deben usar
`Class.Instance:FindFirstChild()` en su lugar.

Instance:FindFirstChildWhichIsA

Devuelve el primer hijo del `Class.Instance` para quien
`Class.Object:IsA()` devuelve verdadero para el className dado.

Instance

`Instance` es la clase base para todas las clases de la jerarquía de clases de Roblox
que pueden ser parte del árbol de `Class.DataModel`.

/reference/engine/classes/BackpackItem.yaml