Un tipo especial de `Class.StatsItem` que mide el promedio en tiempo de ejecución de un
valor entero interno. Hasta ahora, este StatsItem no se utiliza.


RunningAverageItemInt

Mide el promedio en tiempo de ejecución de un **valor entero**.


Un StatsItem es un elemento de medición interno que es creado por el motor para
evaluar muchos de los componentes del backend de Roblox. No se puede crear utilizando
`Datatype.Instance.new()`, pero su valor puede ser leído por los complementos. Se pueden
encontrar almacenados dentro del servicio `Class.Stats`.


StatsItem:GetValue

Devuelve el valor del StatsItem como una cadena formateada.


StatsItem:GetValueString

StatsItem

StatsItem.DisplayName

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

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


Demuestra la detección de cambios en la ascendencia de una instancia al conectarse al evento `Class.Instance.AncestryChanged`.
El Padre 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 la propiedad `Class.Instance.Parent` del objeto o uno de
sus ancestros es cambiada.

Este evento incluye dos parámetros: `child` se refiere al `Class.Instance`
cuyo `Class.Instance.Parent` fue realmente cambiado, mientras que `parent` se refiere
al nuevo `Class.Instance.Parent` de esta instancia.

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


Instance.AncestryChanged

child

La `Class.Instance` cuyo `Class.Instance.Parent` ha sido cambiado.


parent

El nuevo `Class.Instance.Parent` del `Class.Instance` cuyo
`Class.Instance.Parent` fue cambiado.


Se activa cuando la propiedad `Class.Instance.Parent` del 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 activarse cada vez que uno de los atributos de la pieza cambia:

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

local part = Workspace.Part

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

part.AttributeChanged:Connect(attributeChanged)
```

Véase 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 el `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 este `Class.Instance`.

Note que, al usar esta función en un cliente para detectar objetos creados por
el servidor, es necesario usar `Class.Instance:WaitForChild()` al
indexar los descendientes de estos objetos. Esto se debe a que el objeto y sus
descendientes no están garantizados a replicarse del 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)
```

Note que esta función solo funciona para los hijos inmediatos del
`Class.Instance`. Para una función que capture todos los descendientes, use
`Class.Instance.DescendantAdded`.

Véase también `Class.Instance.ChildRemoved`.


Instance.ChildAdded

El `Class.Instance` que ha sido agregado.


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


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 este `Class.Instance`.

Eliminado se refiere a cuando el padre de un objeto cambia de este
`Class.Instance` a algo diferente a este `Class.Instance`. Note que 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`.

Esta función solo funciona para los hijos inmediatos del `Class.Instance`.
Para una función que capture todos los descendientes, use
`Class.Instance.DescendantRemoving`.

Véase también `Class.Instance.ChildAdded`.


Instance.ChildRemoved

El `Class.Instance` que ha sido eliminado.


Se activa después de que un hijo es eliminado de este `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 un descendiente es agregado al `Class.Instance`.

Dado que se activa para cada descendiente, parentando un objeto al
`Class.Instance` activará el evento para este objeto y todos sus
descendientes individualmente.

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

Véase también `Class.Instance.DescendantRemoving`.


Instance.DescendantAdded

descendant

Se activa después de que un descendiente es agregado al `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 `Class.Instance`
cambie de tal manera 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 llamar a ese método en un
descendiente del padre causará que este evento se active.

Dado que este evento se activa **antes** de la eliminación del descendiente, el padre del
descendiente no cambiará en el momento en que se active 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 activa 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
```

Véase también `Class.Instance.DescendantAdded|DescendantAdded`.


Instance.DescendantRemoving

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


Se activa inmediatamente antes de que un descendiente del `Class.Instance` sea eliminado.


Esta muestra demuestra cómo, al usar el comportamiento de señales inmediatas, una Instancia que se está destruyendo permanece en su lugar hasta que la función conectada cede.

Esta muestra demuestra cómo, al usar el comportamiento de señales diferidas,
una Instancia es destruida antes de que se dispare la señal.

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

Si la propiedad `Class.Workspace.SignalBehavior` está configurada en
`Enum.SignalBehavior.Immediate`, este evento se activa inmediatamente antes de que el
`Class.Instance` o uno de sus antepasados sea destruido con
`Class.Instance:Destroy()`.

Si la propiedad `Class.Workspace.SignalBehavior` está configurada en
`Enum.SignalBehavior.Deferred`, este evento se activará en el próximo punto de reanudación,
lo que será después de que el `Class.Instance` o uno de sus antepasados sea
destruido con `Class.Instance:Destroy()`.

Con el comportamiento `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 un `Class.Instance` en Studio, como eliminar manualmente
a través del [Explorer](/studio/explorer) o a través de un plugin,
el `Class.Instance` no se destruye. 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 sea
destruida a través de `Class.Instance:Destroy()`.


Este evento se activa cada vez que se cambia una 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("Propiedades de estilo cambiadas")
end

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


Instance.StyledPropertiesChanged

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


Instance.childAdded

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

##### Advertencias

- Las etiquetas de una instancia que fueron agregadas del lado del cliente se
  perderán si el servidor luego agrega o elimina una etiqueta en esa instancia porque el servidor
  replica todas las etiquetas juntas y sobrescribe etiquetas anteriores.

- Al etiquetar una instancia, es común que algunos recursos se utilicen para
darle a la etiqueta su funcionalidad, por ejemplo, conexiones de eventos o tablas.
  Para prevenir pérdidas de memoria, es una buena idea limpiar estos recursos (desconectar,
  establecer en `nil`, etc.) cuando ya no se necesiten para una etiqueta. Hagas 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

Esta función destruye todos los hijos y descendientes de una instancia.

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

-- Agrega algunas chispas
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

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

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

part:ClearAllChildren()

print("Hijos:", #part:GetChildren())  --> Hijos: 0
```

Si no deseas destruir **todos** los hijos y descendientes, utiliza
`Class.Instance:GetChildren()` o `Class.Instance:GetDescendants()` para
distribuir esos hijos/descendientes y seleccionar lo que deseas destruir. Por
ejemplo, el siguiente fragmento de código destruirá todos
`Class.BasePart|BaseParts` descendiendo 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

Esta función 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 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` establecido en `false`, esta función 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 del 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,
  el mismo valor se mantiene en la copia.


Instance:Clone

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


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

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

Establece la propiedad `Class.Instance.Parent` en `nil`, bloquea el
`Class.Instance.Parent` property, desconecta todas las conexiones, y llama
`Destroy()` en todos los hijos. Esta función es la forma correcta de desechar
objetos que ya no se necesitan.

Desechar objetos innecesarios es importante, ya que los objetos y
conexiones innecesarios en un lugar consumen memoria que puede llevar a serios problemas de
rendimiento a lo largo del tiempo.

Como buena 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 se puede
reutilizar 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 establecido, usa
`Class.Debris:AddItem()`.


Instance:Destroy

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


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

Esta función funciona hacia arriba, lo que significa que comienza en el padre inmediato
del objeto 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 esta función que encuentran ancestros de una clase específica,
por favor ve a `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.

Esta función funciona hacia arriba, lo que significa que comienza en el padre inmediato
del objeto y trabaja hacia el `Class.DataModel`. Si no se encuentra un
ancestro coincidente, devuelve `nil`.

Un uso común de esta función es encontrar el `Class.Model` al que
pertenece un `Class.BasePart`. Por ejemplo:

```
local model = part:FindFirstAncestorOfClass("Model")
```

Esta función es una variante de `Class.Instance:FindFirstAncestor()` que
verifica la propiedad `Class.Object.ClassName` en lugar de
`Class.Instance.Name`. `Class.Instance:FindFirstAncestorWhichIsA()` también
existe, utilizando 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.

Esta función trabaja hacia arriba, lo que significa que comienza en el padre inmediato
del objeto y trabaja hacia el `Class.DataModel`. Si no se encuentra un
ancestro coincidente, devuelve `nil`.

A diferencia de `Class.Instance:FindFirstAncestorOfClass()`, esta función usa
`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")
```

Ver 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`, esta función busca en todos los descendientes en lugar de solo en los
hijos inmediatos del `Class.Instance`.

##### Comprobando 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 de punto
lanza un error si el hijo no existe.

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

-- La siguiente línea da error si el part no existe en el workspace
Workspace.Part.Transparency = 0.5
```

Un mejor enfoque es usar `FindFirstChild()` para primero comprobar si hay un
`Part`, luego usar una declaración `if` para ejecutar el código que lo necesite.

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

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

##### Encontrando un Hijo cuyo Nombre Coincide con una Propiedad

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

En el siguiente ejemplo, un `Class.Folder` llamado `Color` se agrega a un
`Class.Part`, que también tiene la propiedad `Class.Part.Color`. Observa 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 impone un riesgo en 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
que usar el operador de punto y casi 8 veces más que simplemente almacenar
una 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 cambio,
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
given nombre se vuelve disponible.


Instance:FindFirstChild

recursive

Si la búsqueda debe realizarse de manera recursiva.


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


Devuelve el primer hijo del `Class.Instance` cuyo
`Class.Object.ClassName|ClassName` es igual al `className` dado.
A diferencia de `Class.Instance:FindFirstChildWhichIsA()`, esta función solo
devuelve objetos cuya clase coincide con `className`, ignorando la herencia
de clases. Si no se encuentra un hijo coincidente, esta función 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, esta función devuelve `nil`. Si el
argumento opcional recursivo es verdadero, esta función busca todos los
descendientes en lugar de solo los hijos inmediatos del
`Class.Instance`.

A diferencia de `Class.Instance:FindFirstChildOfClass()`, esta función 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 buscan un hijo por nombre, deberían 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.


Devuelve el primer descendiente encontrado con el dado `Class.Instance.Name`.

Este método está deshabilitado y no puede ser utilizado. Para encontrar el primer descendiente
de una instancia, considera usar el parámetro `recursive` en
`Class.Instance:FindFirstChild()` en su lugar.


Instance:FindFirstDescendant

Devuelve el primer descendiente encontrado con el dado `Class.Instance.Name`.


Si el `Class.Instance` es un `Class.Actor`, el `Class.Actor` mismo es
devuelto. De lo contrario, su ancestro más cercano `Class.Actor` es devuelto. Si no
hay ancestro que sea un `Class.Actor`, el resultado es `nil`.


Instance:GetActor

Devuelve el `Class.Actor` asociado con la Instancia, si existe.


Este método devuelve el valor que ha sido asignado al nombre de
atributo dado. Si no se ha asignado ningún atributo, se devuelve `nil`.

Por ejemplo, el siguiente fragmento de código establece y luego obtiene el valor del
atributo `InitialPosition` de la instancia:

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

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local initialPosition = instance:GetAttribute("InitialPosition")
print(initialPosition)
```

##### Ver También

- `Class.Instance:SetAttribute()` que establece el atributo con el nombre dado
  al valor dado.
- `Class.Instance:GetAttributes()` que devuelve un diccionario de pares clave-valor
  para cada uno de los atributos de la instancia.


Instance:GetAttribute

El nombre del atributo que se está recuperando.


El valor que ha sido asignado al nombre de atributo dado. Si no se ha
asignado ningún atributo, se devuelve `nil`.


Devuelve el valor que ha sido asignado al nombre de atributo dado.


Esta función devuelve un evento que se comporta exactamente como el
`Class.Object.Changed|Changed`, excepto que solo se dispara cuando cambia el
atributo específico dado; efectivamente es similar a
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` pero
para atributos.

Generalmente es una buena idea usar este método en lugar de conectar a
`Class.Object.Changed|Changed` con una función que verifica el nombre del atributo. Las
llamadas subsiguientes a este método en el mismo objeto con el mismo nombre de atributo devuelven el mismo evento.

El siguiente ejemplo de código devuelve una señal que dispara la función
`attributeChanged()` cuando cambia el atributo `InitialPosition` de la parte:

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

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local function attributeChanged()
	print("Atributo cambiado")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```

Ver también `Class.Instance.AttributeChanged` que se dispara siempre que cualquier
atributo se cambia en la instancia.


Instance:GetAttributeChangedSignal

El nombre del atributo especificado para el que se devuelve la señal de cambio.


Un evento que se dispara cuando cambia el atributo dado.


Devuelve un evento que se dispara cuando cambia el atributo dado.


Este método devuelve un diccionario de pares clave-valor para cada atributo
donde la clave es el nombre del atributo y el valor es un valor no `nil`.

Por ejemplo, el siguiente fragmento de código imprime los atributos de una instancia
y sus valores:

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

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)
part:SetAttribute("CanUse", true)

for name, value in part:GetAttributes() do
	print(name .. " = " .. value)
end
```

Ver también `Class.Instance:GetAttribute()` que devuelve el valor que ha sido
asignado al nombre de atributo dado.


Instance:GetAttributes

Un diccionario de pares de cadena → variante para cada atributo donde la
cadena es el nombre del atributo y la variante es un valor no nulo.


Devuelve un diccionario de los atributos de la instancia.


A continuación se imprimiría el nombre de todos los objetos actualmente en Workspace cuando se ejecuta.

Devuelve un array (una tabla indexada numéricamente) que contiene todos los
hijos directos de la instancia, o cada `Class.Instance` cuyo
`Class.Instance.Parent|Parent` es igual al objeto. El array se puede
iterar usando un bucle for numérico o genérico:

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

-- Ejemplo de bucle for numérico
local children = Workspace:GetChildren()
for i = 1, #children do
	local child = children[i]
	print(child.Name .. " es el hijo número " .. i)
end
```

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

-- Ejemplo de bucle for genérico
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " es el hijo número " .. i)
end
```

Los hijos se ordenan según el orden en que su
propiedad `Class.Instance.Parent|Parent` se estableció en el objeto.

Ver también la función `Class.Instance:GetDescendants()|GetDescendants`.


Instance:GetChildren

Un array que contiene los hijos de la instancia.


Devuelve un array que contiene todos los hijos de la instancia.


Devuelve una cadena codificada del ID de depuración utilizado internamente por Roblox. Ten en cuenta
que:

- Este elemento está protegido. Intentar usarlo en un `Class.Script` o
  `Class.LocalScript` causará un error.
- Un ID de depuración es un ID utilizado en procesos de depuración. Permite que un depurador
  lea cada instrucción antes de que una aplicación la procese. Todos los objetos en
  Roblox actúan como procesos y cada uno ejecuta instrucciones (o 'código') que pueden
  ser depuradas si es necesario.
- Esto puede ser útil para complementos que necesitan distinguir objetos similares entre sí
  (como objetos que comparten el mismo nombre).


Instance:GetDebugId

scopeLength

Devuelve una cadena codificada del ID de depuración utilizado internamente por Roblox.


GetDescendants se usa a menudo para hacer algo con todos los descendientes que son un
tipo particular de objeto. El código en este ejemplo utiliza GetDescendants y
`Class.Instance:IsA()` para encontrar todas las partes en el espacio de trabajo y las
convierte en verdes.

Este método de objeto devuelve un array que contiene todos los descendientes
de ese objeto. A diferencia de `Class.Instance:GetChildren()`, que solo devuelve
los hijos inmediatos de un objeto, este método encuentra cada hijo del
objeto, cada hijo de esos hijos, y así sucesivamente.


Instance:GetDescendants

Un array que contiene los descendientes de la instancia.


Devuelve un array que contiene todos los descendientes de la instancia.


Este ejemplo de código demuestra el comportamiento de `Class.Instance:GetFullName()`.
Muestra cómo se comporta la función cuando se llama a un objeto que no está en la
jerarquía de `DataModel`, y también muestra cómo el valor de retorno no escapa
caracteres especiales.

Este ejemplo de código reimplementa la función `Class.Instance:GetFullName()` en
Lua.

Devuelve una cadena que describe la ascendencia de la instancia. La cadena es una
concatenación del `Class.Instance.Name|Name` del objeto y sus
ancestros, separados por puntos. El `Class.DataModel` (`game`) no
se considera. Por ejemplo, un `Class.Part` en el `Class.Workspace` puede
devolver `Class.Workspace.Part`.

Cuando se llama a un `Class.Instance` que no es un descendiente del
`Class.DataModel`, esta función considera todos los ancestros hasta e incluyendo el más alto
que no tiene un `Class.Instance.Parent|Parent`.

Esta función es útil para registros y depuración. No deberías intentar
analizar la cadena devuelta para ninguna operación útil; esta función no escapa
puntos (o cualquier otro símbolo) en los nombres de objetos. En otras palabras,
aunque su salida a menudo parece ser un identificador válido de Luau, no es
garantizado.


Instance:GetFullName

El nombre completo del `Class.Instance`.


Devuelve una cadena que describe la ascendencia de la instancia.


Este método devuelve el valor estilizado o explícitamente modificado de la
propiedad especificada, o el valor por defecto de la propiedad si no ha sido
estilizada/modificada. Esto difiere ligeramente de acceder al valor de la propiedad
directamente, como `[GuiObject].Rotation`, que devuelve el valor por defecto o
modificado de la propiedad.

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

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

local coreSheet = ReplicatedStorage:FindFirstChild("CoreSheet")
local rule = coreSheet:FindFirstChildWhichIsA("StyleRule")
rule.Selector = "TextButton"

-- Referencia a un botón
local button = HUDContainer:FindFirstChildWhichIsA("TextButton")

print(button:GetStyled("Rotation")) --> 0 (valor por defecto)
print(button.Rotation) --> 0 (valor por defecto)

-- Aplicar rotación a través de la propiedad de regla de estilo
rule:SetProperty("Rotation", 30)

print(button:GetStyled("Rotation")) --> 30 (valor estilizado basado en la regla)
print(button.Rotation) --> 0 (valor por defecto)

-- Modificar/override explícitamente la propiedad estilizada
button.Rotation = 45

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


Instance:GetStyled

El valor estilizado o explícitamente modificado de la propiedad especificada, o
el valor por defecto de la propiedad si no ha sido estilizada/modificada.


Devuelve el valor estilizado o explícitamente modificado de la propiedad especificada,
o el valor por defecto de la propiedad si no ha sido estilizada/modificada.


Este método devuelve un evento que se comporta exactamente como el
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged`,
específicamente que solo se dispara cuando cambia la propiedad de estilo dada. Es
generalmente una buena idea usar este método en lugar de una conexión a
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` con una
dos posibles cambios en las propiedades. Llamadas adicionales a este método en
el mismo objeto con el mismo nombre de propiedad devuelven el mismo evento.

Ten en cuenta que este evento no pasará ningún argumento a una función conectada,
por lo que el valor de la propiedad cambiada debe leerse directamente dentro de un
script.

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

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

local function stylePropertyChanged()
	print("¡Propiedad de estilo cambiada!")
end

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


Instance:GetStyledPropertyChangedSignal

property

Nombre de la propiedad de estilo para la cual escuchar cambios.


Evento que se dispara cuando cambia la propiedad de estilo dada.


Este método devuelve un array de las etiquetas aplicadas a la instancia dada, como
cadenas. Puedes agregar etiquetas ya sea en Studio en la
[Ventana de Propiedades](/studio/properties) o en tiempo de ejecución con
`Class.Instance:AddTag()|AddTag()`.

Este método es útil cuando quieres hacer algo con múltiples etiquetas en
una instancia a la vez. Sin embargo, es ineficiente usar este método para
comprobar la existencia de una sola etiqueta; en su lugar, usa
`Class.Instance:HasTag()|HasTag()` para comprobar una etiqueta específica.


Instance:GetTags

Obtiene un array de todas las etiquetas aplicadas a la instancia.


Este método devuelve `true` si la etiqueta proporcionada ha sido agregada a la
objeto. Puedes agregar etiquetas ya sea en Studio en la
[Ventana de Propiedades](/studio/properties) o en tiempo de ejecución con
`Class.Instance:AddTag()|AddTag()`.


Instance:HasTag

Verifica si la instancia tiene una etiqueta dada.


Demuestra cómo determinar si una instancia es el ancestro de otra usando `Class.Instance:IsAncestorOf()`
Workspace y SpawnLocation son ancestros del decal de SpawnLocation.
Workspace es un ancestro de SpawnLocation.
SpawnLocation y su decal son descendientes de Workspace, no ancestros.
Decal es un descendiente de SpawnLocation, no un ancestro.

Devuelve verdadero si un `Class.Instance` es ancestro del dado
descendiente.

Un `Class.Instance` se considera ancestro de un objeto si el
`Class.Instance.Parent` del objeto o el `Class.Instance.Parent` de uno de sus padres
está establecido en el `Class.Instance`.

Ver también `Class.Instance:IsDescendantOf()`.


Instance:IsAncestorOf

Verdadero si el `Class.Instance` es un ancestro del dado descendiente.


Devuelve verdadero si un `Class.Instance` es ancestro del dado
descendiente.


Devuelve `true` si un `Class.Instance` es descendiente del dado
ancestro.

Ten en cuenta que `IsDescendantOf()` no puede ser usado con un parámetro `nil` para
verificar si un objeto ha sido eliminado.

Ver también `Class.Instance:IsAncestorOf()`.


Instance:IsDescendantOf

ancestor

Verdadero si el `Class.Instance` es un descendiente del dado ancestro.


Devuelve `true` si un `Class.Instance` es descendiente del dado
ancestro.


Devuelve `true` si el valor almacenado en la propiedad especificada es igual al
predeterminado instanciado por código. Por ejemplo, si al mostrar el
`Class.TextLabel.TextSize|TextSize` propiedad de un `Class.TextLabel`
indica `8`, entonces llamar a `IsPropertyModified("TextSize")` en la etiqueta
devolverá `false` porque `8` es el valor predeterminado para
`Class.TextLabel.TextSize` cuando la etiqueta se crea mediante
`Instance.new("TextLabel")` en lugar de insertarse a través de las flujos de inserción de Studio.

Ten en cuenta que si este método devuelve `true`, el estilo **no** afectará la
propiedad porque modificar explícitamente una propiedad tiene precedencia sobre
estilizarla.


Instance:IsPropertyModified

Booleano que indica si la propiedad ha sido modificada.


Devuelve `true` si el valor almacenado en la propiedad especificada es igual al
por defecto instanciado por código.


El siguiente código demuestra cómo una parte puede ser agregada nuevamente al DataModel
después de haber sido eliminada:

Esta función establece el `Class.Instance.Parent` del objeto en `nil`, y hace
lo mismo para todos sus descendientes.

Si el objeto es referenciado antes de ser eliminado, es posible que se
recupere el objeto en un momento posterior.


Instance:Remove

Establece el `Parent` del objeto en `nil`, y hace lo mismo para todos sus
descendientes.


Este método elimina una etiqueta de una instancia. No lanzará un error si
el objeto no tiene la etiqueta. Eliminar una etiqueta con éxito disparará una
señal creada por `Class.CollectionService:GetInstanceRemovedSignal()`
con la etiqueta dada.

Ten en cuenta que al etiquetar una instancia, es común que se utilicen algunos recursos para
darle a la etiqueta su funcionalidad, como conexiones de eventos o tablas. Para
prevenir pérdidas de memoria, es una buena idea limpiar estos recursos
(desconectar, establecer en `nil`, etc.) cuando ya no se necesiten para una etiqueta.


Instance:RemoveTag

Restablece una propiedad a su valor predeterminado. Por ejemplo, llamar
`ResetPropertyToDefault("Rotation")` en un `Class.TextLabel` es equivalente
a establecer su `Class.TextLabel.Rotation|Rotation` en `0` (el valor predeterminado de la propiedad). Este método se puede usar para garantizar que el estilo sobreescriba
el valor predeterminado de esta propiedad.


Instance:ResetPropertyToDefault

Restablece una propiedad a su valor predeterminado.


Este método establece el atributo con el nombre dado al valor dado. Si
el valor dado es `nil`, el atributo se eliminará, ya que `nil` es
devuelto por defecto.

Por ejemplo, el siguiente fragmento de código establece el atributo
`InitialPosition` de la instancia en `Datatype.Vector3|Vector3.new(0, 10, 0)`:

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

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

##### Limitaciones

Requisitos y restricciones de nomenclatura:

- Los nombres deben usar solo caracteres alfanuméricos y guiones bajos.
- No están permitidos espacios ni símbolos únicos.
- Las cadenas deben tener 100 caracteres o menos.
- No se permiten nombres que comiencen con **RBX** a menos que el llamador sea un
  script central de Roblox (reservado para Roblox).

Al intentar establecer un atributo en un tipo no compatible, se lanzará un error.

##### Ver También

- `Class.Instance:GetAttribute()` que devuelve el valor que ha sido
  asignado al nombre de atributo dado.
- `Class.Instance:GetAttributes()` que devuelve un diccionario de pares clave-valor
  para cada uno de los atributos de la instancia.


Instance:SetAttribute

El nombre del atributo que se está estableciendo.


value

El valor para establecer el atributo especificado.


Establece el atributo con el nombre dado al valor dado.


El siguiente código espera a que se agregue una instancia llamada "Parte" a
Espacio de trabajo.

Devuelve el hijo del `Class.Instance` con el nombre dado. Si el
hijo no existe, bloqueará el hilo actual hasta que lo haga. Si
el parámetro `timeOut` está especificado, este método se agotará después del
número especificado de segundos y devolverá `nil`.

##### Uso Principal

`Class.Instance:WaitForChild()|WaitForChild()` es extremadamente importante al
trabajar en código ejecutado por el cliente en un `Class.LocalScript`. El motor de
Roblox no garantiza el tiempo o el orden en que los objetos se replican desde el servidor al cliente. Además, si una experiencia
 tiene `Class.Workspace.StreamingEnabled` establecido en verdadero,
`Class.BasePart|BaseParts` que están lejos del personaje del jugador
pueden no ser transmitidos al cliente, lo que podría causar que los scripts se rompan
al indexar objetos que aún no existen en el cliente.

##### Notas

- Esta función no se bloqueará si un hijo con el nombre dado existe cuando
  se realiza la llamada.
- `Class.Instance:FindFirstChild()` es una alternativa más eficiente para
  `Class.Instance:WaitForChild()|WaitForChild()` para objetos que se
  suponen que existen.
- Si una llamada a este método supera los 5 segundos sin devolver, y no
  se ha especificado ningún parámetro `timeOut`, se imprimirá una advertencia en la
  salida de que el hilo puede bloquearse indefinidamente.


Instance:WaitForChild

childName

timeOut

Un parámetro de tiempo de espera opcional.


Devuelve el hijo del `Class.Instance` con el nombre dado. Si el
hijo no existe, bloqueará el hilo actual hasta que lo haga.


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


Instance:children

Devuelve un array de los hijos del objeto.


Instance:clone

Instance:destroy

Instance:findFirstChild

Instance:getChildren

Instance:isDescendantOf

Instance:remove

Instance

Esta propiedad determina si la instancia debe ser incluida cuando la
experiencia es publicada o guardada, o cuando se llama a `Class.Instance:Clone()|Clone()`
en uno de los ancestros de la instancia. Llamar a
`Class.Instance:Clone()|Clone()` directamente en una instancia devolverá `nil`
si esa instancia **no** es `Class.Instance.Archivable|Archivable`.

Copiar un objeto en Studio usando las opciones de **Duplicar** o **Copiar**/**Pegar**
ignorará su propia propiedad `Class.Instance.Archivable|Archivable`
y establecerá `Class.Instance.Archivable|Archivable` en `true` para la
copia.

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


Instance.Archivable

Determina si un `Class.Instance` y sus descendientes pueden ser clonados usando
`Class.Instance:Clone()`, y pueden ser guardados/publicados.


El conjunto de capacidades permitidas para ser utilizadas en scripts dentro de esta
instancia. Para que las capacidades surtan efecto, la propiedad `Class.Instance.Sandboxed`
debe estar habilitada.

Esta propiedad es utilizada por una función experimental. Ver
[capacidades de los scripts](/scripting/capabilities) para más detalles.


Instance.Capabilities

El conjunto de capacidades permitidas para ser utilizadas en scripts dentro de este
contenedor.


Un identificador no único del `Class.Instance`. Los nombres se utilizan para mantener
organizada la jerarquía de objetos, además de permitir que los scripts accedan
a objetos específicos. El nombre de una instancia no puede exceder los 100 caracteres en
tamaño.

El nombre de un objeto se utiliza a menudo para acceder al objeto a través del modelo de datos
utilizando los siguientes métodos:

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

local baseplate = Workspace.Baseplate
local baseplate = Workspace["Baseplate"]
local baseplate = Workspace:FindFirstChild("BasePlate")
```

Para hacer que un objeto sea accesible usando el operador de punto (`.`), su
nombre debe empezar con un guion bajo o letra, y el resto del nombre solo puede
contener letras, números o guiones bajos (sin otros caracteres especiales). Si el nombre de un objeto
no sigue esta sintaxis, no será accesible usando el operador de punto y Luau no interpretará su nombre
como un identificador.

Si hay más de un objeto con el mismo nombre que son hermanos, cualquier intento de
indexar un objeto por ese nombre devolverá solo uno de los objetos, similar a
`Class.Instance:FindFirstChild()`, pero no siempre el objeto deseado.
Si se necesita acceder a un objeto específico a través del código, se recomienda
darle un nombre único o garantizar que ninguno de sus hermanos comparta el
mismo nombre.

Ver también `Class.Instance:GetFullName()` para obtener un nombre completo que incluya
la jerarquía del objeto.


Instance.Name

Un identificador no único del `Class.Instance`.


La propiedad `Parent` determina el padre jerárquico del
`Class.Instance`. La siguiente terminología se utiliza comúnmente al hablar
sobre cómo se establece esta propiedad:

- Un objeto es un **hijo** de, o está **padreado a**, otro objeto cuando
  su `Parent` se establece en ese objeto.

- Los **descendientes** de un `Class.Instance` son los hijos de ese
  objeto, más los descendientes de los hijos también.

- Los **ancestros** de un `Class.Instance` son todos los objetos de los cuales el
  instancia es un descendiente.

Es a partir de la propiedad `Parent` que muchos otros miembros de la API obtienen su
nombre, como `Class.Instance:GetChildren()|GetChildren()` y
`Class.Instance:FindFirstChild()|FindFirstChild()`. Esta propiedad también
se utiliza para gestionar si un objeto existe en la experiencia o necesita ser
eliminado. Siempre que el padre de un objeto esté en el `Class.DataModel`, esté
almacenado en una variable, o esté referenciado por la propiedad de otro objeto, el
objeto permanece en la experiencia; de lo contrario, el objeto será eliminado automáticamente.

Llamar a `Class.Instance:Destroy()|Destroy()` establecerá el `Parent` de un
`Class.Instance` y todos sus descendientes a `nil`, y también **bloqueará**
el `Parent` property. Se genera un error al intentar establecer el `Parent` de un
objeto destruido.

Los objetos creados recién utilizando `Datatype.Instance.new()` no tendrán un
padre, y generalmente no serán visibles o funcionarán hasta que se establezca uno.

##### Replicación de Objetos

Un objeto creado por el servidor no se replicará a los clientes hasta que se le
asigne un padre a algún objeto que se replica. Al crear un objeto y establecer muchas propiedades,
es recomendable establecer la propiedad `Parent` **último**. Esto asegura que el objeto se replica una vez, en lugar de replicar muchos cambios de propiedad.

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

-- Establecer el padre de la nueva instancia último (recomendado)
local part = Instance.new("Part")
part.Position = Vector3.new(0, 10, 0)
part.Parent = Workspace
```

Sin embargo, si se están colocando partes en un `Class.Model` cuyo padre aún no ha sido
establecido, colocar cada parte dentro de ese modelo es aceptable ya que el modelo
no se habría replicado.


Instance.Parent

Determina el padre jerárquico del `Class.Instance`.


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


/reference/engine/classes/RunningAverageItemInt.yaml