:github_url: hide .. _class_Resource: Resource ======== **Hereda:** :ref:`RefCounted` **<** :ref:`Object` **Heredado por:** :ref:`Animation`, :ref:`AnimationLibrary`, :ref:`AnimationNode`, :ref:`AnimationNodeStateMachinePlayback`, :ref:`AnimationNodeStateMachineTransition`, :ref:`AudioBusLayout`, :ref:`AudioEffect`, :ref:`AudioStream`, :ref:`BitMap`, :ref:`BoneMap`, :ref:`ButtonGroup`, :ref:`CameraAttributes`, :ref:`ColorPalette`, :ref:`Compositor`, :ref:`CompositorEffect`, :ref:`CryptoKey`, :ref:`Curve`, :ref:`Curve2D`, :ref:`Curve3D`, :ref:`EditorNode3DGizmoPlugin`, :ref:`EditorSettings`, :ref:`Environment`, :ref:`FoldableGroup`, :ref:`Font`, :ref:`GDExtension`, :ref:`GLTFAccessor`, :ref:`GLTFAnimation`, :ref:`GLTFBufferView`, :ref:`GLTFCamera`, :ref:`GLTFDocument`, :ref:`GLTFDocumentExtension`, :ref:`GLTFLight`, :ref:`GLTFMesh`, :ref:`GLTFNode`, :ref:`GLTFPhysicsBody`, :ref:`GLTFPhysicsShape`, :ref:`GLTFSkeleton`, :ref:`GLTFSkin`, :ref:`GLTFSpecGloss`, :ref:`GLTFState`, :ref:`GLTFTexture`, :ref:`GLTFTextureSampler`, :ref:`Gradient`, :ref:`Image`, :ref:`ImporterMesh`, :ref:`InputEvent`, :ref:`JointLimitation3D`, :ref:`JSON`, :ref:`LabelSettings`, :ref:`LightmapGIData`, :ref:`Material`, :ref:`Mesh`, :ref:`MeshLibrary`, :ref:`MissingResource`, :ref:`MultiMesh`, :ref:`NavigationMesh`, :ref:`NavigationMeshSourceGeometryData2D`, :ref:`NavigationMeshSourceGeometryData3D`, :ref:`NavigationPolygon`, :ref:`Noise`, :ref:`Occluder3D`, :ref:`OccluderPolygon2D`, :ref:`OggPacketSequence`, :ref:`OpenXRAction`, :ref:`OpenXRActionMap`, :ref:`OpenXRActionSet`, :ref:`OpenXRBindingModifier`, :ref:`OpenXRHapticBase`, :ref:`OpenXRInteractionProfile`, :ref:`OpenXRIPBinding`, :ref:`PackedDataContainer`, :ref:`PackedScene`, :ref:`PhysicsMaterial`, :ref:`PolygonPathFinder`, :ref:`RDShaderFile`, :ref:`RDShaderSPIRV`, :ref:`RichTextEffect`, :ref:`SceneReplicationConfig`, :ref:`Script`, :ref:`Shader`, :ref:`ShaderInclude`, :ref:`Shape2D`, :ref:`Shape3D`, :ref:`Shortcut`, :ref:`SkeletonModification2D`, :ref:`SkeletonModificationStack2D`, :ref:`SkeletonProfile`, :ref:`Skin`, :ref:`Sky`, :ref:`SpriteFrames`, :ref:`StyleBox`, :ref:`SyntaxHighlighter`, :ref:`Texture`, :ref:`Theme`, :ref:`TileMapPattern`, :ref:`TileSet`, :ref:`TileSetSource`, :ref:`Translation`, :ref:`VideoStream`, :ref:`VideoStreamPlayback`, :ref:`VisualShaderNode`, :ref:`VoxelGIData`, :ref:`World2D`, :ref:`World3D`, :ref:`X509Certificate` Clase base para objetos serializables. .. rst-class:: classref-introduction-group Descripción ---------------------- Resource es la clase base para todos los tipos de recursos específicos de Godot, sirviendo principalmente como contenedores de datos. Ya que heredan de :ref:`RefCounted`, los recursos son contados por referencia y liberados cuando ya no están en uso. También pueden anidarse dentro de otros recursos, y guardarse en el disco. :ref:`PackedScene`, uno de los :ref:`Object`\ s más comunes en un proyecto de Godot, también es un recurso, únicamente capaz de almacenar e instanciar los :ref:`Node`\ s que contiene tantas veces como se desee. En GDScript, los recursos pueden ser cargados desde el disco por su :ref:`resource_path` usando :ref:`@GDScript.load()` o :ref:`@GDScript.preload()`. El motor mantiene un caché global de todos los recursos cargados, referenciados por rutas (ver :ref:`ResourceLoader.has_cached()`). Un recurso será cacheado cuando se cargue por primera vez y se removerá del caché una vez que todas las referencias sean liberadas. Cuando un recurso está en caché, las cargas subsiguientes usando su ruta devolverán la referencia en caché. \ **Nota:** En C#, los recursos no se liberarán instantáneamente después de que ya no estén en uso. En cambio, la recolección de basura se ejecutará periódicamente y liberará los recursos que ya no estén en uso. Esto significa que los recursos no utilizados permanecerán en la memoria durante un tiempo antes de ser eliminados. .. rst-class:: classref-introduction-group Tutoriales -------------------- - :doc:`Recursos <../tutorials/scripting/resources>` - :doc:`When and how to avoid using nodes for everything <../tutorials/best_practices/node_alternatives>` .. rst-class:: classref-reftable-group Propiedades ---------------------- .. table:: :widths: auto +-----------------------------+-----------------------------------------------------------------------------------+-----------+ | :ref:`bool` | :ref:`resource_local_to_scene` | ``false`` | +-----------------------------+-----------------------------------------------------------------------------------+-----------+ | :ref:`String` | :ref:`resource_name` | ``""`` | +-----------------------------+-----------------------------------------------------------------------------------+-----------+ | :ref:`String` | :ref:`resource_path` | ``""`` | +-----------------------------+-----------------------------------------------------------------------------------+-----------+ | :ref:`String` | :ref:`resource_scene_unique_id` | | +-----------------------------+-----------------------------------------------------------------------------------+-----------+ .. rst-class:: classref-reftable-group Métodos -------------- .. table:: :widths: auto +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`RID` | :ref:`_get_rid`\ (\ ) |virtual| |const| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`_reset_state`\ (\ ) |virtual| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`_set_path_cache`\ (\ path\: :ref:`String`\ ) |virtual| |const| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`_setup_local_to_scene`\ (\ ) |virtual| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Resource` | :ref:`duplicate`\ (\ deep\: :ref:`bool` = false\ ) |const| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Resource` | :ref:`duplicate_deep`\ (\ deep_subresources_mode\: :ref:`DeepDuplicateMode` = 1\ ) |const| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`emit_changed`\ (\ ) | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`generate_scene_unique_id`\ (\ ) |static| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_id_for_path`\ (\ path\: :ref:`String`\ ) |const| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Node` | :ref:`get_local_scene`\ (\ ) |const| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`RID` | :ref:`get_rid`\ (\ ) |const| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_built_in`\ (\ ) |const| | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`reset_state`\ (\ ) | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_id_for_path`\ (\ path\: :ref:`String`, id\: :ref:`String`\ ) | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set_path_cache`\ (\ path\: :ref:`String`\ ) | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`setup_local_to_scene`\ (\ ) | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`take_over_path`\ (\ path\: :ref:`String`\ ) | +---------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Señales -------------- .. _class_Resource_signal_changed: .. rst-class:: classref-signal **changed**\ (\ ) :ref:`🔗` Emitida cuando el recurso cambia, normalmente cuando se modifica una de sus propiedades. Véase también :ref:`emit_changed()`. \ **Nota:** Esta señal no se emite automáticamente para las propiedades de los recursos personalizados. Si es necesario, se debe crear un setter para emitir la señal. .. rst-class:: classref-item-separator ---- .. _class_Resource_signal_setup_local_to_scene_requested: .. rst-class:: classref-signal **setup_local_to_scene_requested**\ (\ ) :ref:`🔗` **Obsoleto:** This signal is only emitted when the resource is created. Override :ref:`_setup_local_to_scene()` instead. Emitido por un recurso recién duplicado con :ref:`resource_local_to_scene` establecido a ``true``. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Enumeraciones -------------------------- .. _enum_Resource_DeepDuplicateMode: .. rst-class:: classref-enumeration enum **DeepDuplicateMode**: :ref:`🔗` .. _class_Resource_constant_DEEP_DUPLICATE_NONE: .. rst-class:: classref-enumeration-constant :ref:`DeepDuplicateMode` **DEEP_DUPLICATE_NONE** = ``0`` No se duplica ningún subrecurso. Esto es útil incluso en una duplicación profunda para tener todos los arrays y diccionarios duplicados pero siguiendo apuntando a los recursos originales. .. _class_Resource_constant_DEEP_DUPLICATE_INTERNAL: .. rst-class:: classref-enumeration-constant :ref:`DeepDuplicateMode` **DEEP_DUPLICATE_INTERNAL** = ``1`` Solo se duplicarán los subrecursos sin una ruta o con una ruta local de la escena. .. _class_Resource_constant_DEEP_DUPLICATE_ALL: .. rst-class:: classref-enumeration-constant :ref:`DeepDuplicateMode` **DEEP_DUPLICATE_ALL** = ``2`` Cada subrecurso encontrado será duplicado, incluso si tiene una ruta no local. En otras palabras, incluso los recursos potencialmente grandes almacenados por separado serán duplicados. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descripciones de Propiedades -------------------------------------------------------- .. _class_Resource_property_resource_local_to_scene: .. rst-class:: classref-property :ref:`bool` **resource_local_to_scene** = ``false`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_local_to_scene**\ (\ value\: :ref:`bool`\ ) - :ref:`bool` **is_local_to_scene**\ (\ ) Si es ``true``, el recurso es duplicado para cada instancia de todas las escenas que lo usen. En tiempo de ejecución, el recurso puede ser modificado en una escena sin afectar a otras instancias (véase :ref:`PackedScene.instantiate()`). \ **Nota:** Cambiar esta propiedad en tiempo de ejecución no tiene efecto en los recursos duplicados ya creados. .. rst-class:: classref-item-separator ---- .. _class_Resource_property_resource_name: .. rst-class:: classref-property :ref:`String` **resource_name** = ``""`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_name**\ (\ value\: :ref:`String`\ ) - :ref:`String` **get_name**\ (\ ) Un nombre opcional para este recurso. Cuando se define, su valor se muestra para representar el recurso en el panel Inspector. Para los scripts incorporados, el nombre se muestra como parte del nombre de la pestaña en el editor de scripts. \ **Nota:** Algunos formatos de recursos no soportan nombres de recursos. Aún puedes establecer el nombre en el editor o a través de código, pero se perderá cuando el recurso se recargue. Por ejemplo, solo los scripts incorporados pueden tener un nombre de recurso, mientras que los scripts almacenados en archivos separados no pueden. .. rst-class:: classref-item-separator ---- .. _class_Resource_property_resource_path: .. rst-class:: classref-property :ref:`String` **resource_path** = ``""`` :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_path**\ (\ value\: :ref:`String`\ ) - :ref:`String` **get_path**\ (\ ) La ruta única a este recurso. Si se ha guardado en disco, el valor será su ruta de archivo. Si el recurso está contenido exclusivamente dentro de una escena, el valor será la ruta de archivo de la :ref:`PackedScene`, seguida de un identificador único. \ **Nota:** Establecer esta propiedad manualmente puede fallar si un recurso con la misma ruta ya ha sido cargado previamente. Si es necesario, usa :ref:`take_over_path()`. .. rst-class:: classref-item-separator ---- .. _class_Resource_property_resource_scene_unique_id: .. rst-class:: classref-property :ref:`String` **resource_scene_unique_id** :ref:`🔗` .. rst-class:: classref-property-setget - |void| **set_scene_unique_id**\ (\ value\: :ref:`String`\ ) - :ref:`String` **get_scene_unique_id**\ (\ ) Un identificador único relativo a la escena de este recurso. Si se deja vacío, el ID se genera automáticamente cuando este recurso se guarda dentro de un :ref:`PackedScene`. Si el recurso no está dentro de una escena, esta propiedad está vacía por defecto. \ **Nota:** Cuando se guarda el :ref:`PackedScene`, si varios recursos de la misma escena utilizan el mismo ID, solo el primer recurso de la jerarquía de la escena conserva el ID original. A los demás recursos se les asignan nuevos ID desde :ref:`generate_scene_unique_id()`. \ **Nota:** El establecimiento de esta propiedad no emite la señal :ref:`changed`. \ **Advertencia:** Al establecerlo, el ID solo debe consistir en letras, números y guiones bajos. De lo contrario, fallará y por defecto se generará un ID aleatorio. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descripciones de Métodos ------------------------------------------------ .. _class_Resource_private_method__get_rid: .. rst-class:: classref-method :ref:`RID` **_get_rid**\ (\ ) |virtual| |const| :ref:`🔗` Sobrescribe este método para devolver un :ref:`RID` personalizado cuando se llama a :ref:`get_rid()`. .. rst-class:: classref-item-separator ---- .. _class_Resource_private_method__reset_state: .. rst-class:: classref-method |void| **_reset_state**\ (\ ) |virtual| :ref:`🔗` Para los recursos que almacenan el estado en propiedades no exportadas, como a través de :ref:`Object._validate_property()` o :ref:`Object._get_property_list()`, este método debe ser implementado para borrarlas. .. rst-class:: classref-item-separator ---- .. _class_Resource_private_method__set_path_cache: .. rst-class:: classref-method |void| **_set_path_cache**\ (\ path\: :ref:`String`\ ) |virtual| |const| :ref:`🔗` Sobrescribe este método para ejecutar lógica adicional después de que se llame a :ref:`set_path_cache()` en este objeto. .. rst-class:: classref-item-separator ---- .. _class_Resource_private_method__setup_local_to_scene: .. rst-class:: classref-method |void| **_setup_local_to_scene**\ (\ ) |virtual| :ref:`🔗` Sobrescribe este método para personalizar el recurso recién duplicado creado a partir de :ref:`PackedScene.instantiate()`, si el :ref:`resource_local_to_scene` del original está establecido en ``true``. \ **Ejemplo:** Establece un valor ``damage`` aleatorio para cada recurso local de una escena instanciada: :: extends Resource var damage = 0 func _setup_local_to_scene(): damage = randi_range(10, 40) .. rst-class:: classref-item-separator ---- .. _class_Resource_method_duplicate: .. rst-class:: classref-method :ref:`Resource` **duplicate**\ (\ deep\: :ref:`bool` = false\ ) |const| :ref:`🔗` Duplica este recurso, devolviendo un nuevo recurso con sus propiedades ``export``\ adas o :ref:`@GlobalScope.PROPERTY_USAGE_STORAGE` copiadas del original. Si ``deep`` es ``false``, se devuelve una copia **superficial**: las propiedades anidadas :ref:`Array`, :ref:`Dictionary` y **Resource** no se duplican y se comparten con el recurso original. Si ``deep`` es ``true``, se devuelve una copia **profunda**: todos los arrays, diccionarios y arrays empaquetados anidados también se duplican (recursivamente). Cualquier **Resource** encontrado dentro solo se duplicará si es local, como :ref:`DEEP_DUPLICATE_INTERNAL` utilizado con :ref:`duplicate_deep()`. Se aplican las siguientes excepciones: - Las propiedades de subrecursos con la bandera :ref:`@GlobalScope.PROPERTY_USAGE_ALWAYS_DUPLICATE` siempre se duplican (recursivamente o no, dependiendo de ``deep``). - Las propiedades de subrecursos con la bandera :ref:`@GlobalScope.PROPERTY_USAGE_NEVER_DUPLICATE` nunca se duplican. \ **Nota:** Para recursos personalizados, este método fallará si :ref:`Object._init()` ha sido definido con parámetros requeridos. \ **Nota:** Al duplicar con ``deep`` establecido en ``true``, cada recurso encontrado, incluido aquel sobre el que se llama a este método, se duplicará solo una vez y se referenciará tantas veces como sea necesario en el duplicado. Por ejemplo, si estás duplicando el recurso A que tiene el recurso B referenciado dos veces, obtendrás un nuevo recurso A' que referencia a un nuevo recurso B' dos veces. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_duplicate_deep: .. rst-class:: classref-method :ref:`Resource` **duplicate_deep**\ (\ deep_subresources_mode\: :ref:`DeepDuplicateMode` = 1\ ) |const| :ref:`🔗` Duplicates this resource, deeply, like :ref:`duplicate()` when passing ``true``, with extra control over how subresources are handled. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_emit_changed: .. rst-class:: classref-method |void| **emit_changed**\ (\ ) :ref:`🔗` Emite la señal :ref:`changed`. Este método se llama automáticamente para algunos recursos incorporados. \ **Nota:** Para los recursos personalizados, se recomienda llamar a este método siempre que se produzca un cambio significativo, como una propiedad modificada. Esto asegura que los :ref:`Object`\ s personalizados que dependen del recurso se actualicen correctamente. :: var daño: set(nuevo_valor): if daño != nuevo_valor: damage = nuevo_valor emit_changed() .. rst-class:: classref-item-separator ---- .. _class_Resource_method_generate_scene_unique_id: .. rst-class:: classref-method :ref:`String` **generate_scene_unique_id**\ (\ ) |static| :ref:`🔗` Genera un identificador único para un recurso que se contendrá dentro de una :ref:`PackedScene`, basado en la fecha, hora y un valor aleatorio actuales. La string devuelta se compone únicamente de letras (``a`` a ``y``) y números (``0`` a ``8``). Véase también :ref:`resource_scene_unique_id`. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_get_id_for_path: .. rst-class:: classref-method :ref:`String` **get_id_for_path**\ (\ path\: :ref:`String`\ ) |const| :ref:`🔗` Desde la caché interna para ID únicos de escena, devuelve el ID de este recurso para la escena en ``path``. Si no hay ninguna entrada, se devuelve una string vacía. Útil para mantener los ID únicos de escena iguales al implementar un formato de recurso personalizado compatible con VCS extendiendo :ref:`ResourceFormatLoader` y :ref:`ResourceFormatSaver`. \ **Nota:** Este método solo se implementa cuando se ejecuta en un contexto de editor. En tiempo de ejecución, devuelve una string vacía. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_get_local_scene: .. rst-class:: classref-method :ref:`Node` **get_local_scene**\ (\ ) |const| :ref:`🔗` Si :ref:`resource_local_to_scene` está establecido en ``true`` y el recurso se ha cargado desde una instanciación de :ref:`PackedScene`, devuelve el :ref:`Node` raíz de la escena donde se utiliza este recurso. De lo contrario, devuelve ``null``. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_get_rid: .. rst-class:: classref-method :ref:`RID` **get_rid**\ (\ ) |const| :ref:`🔗` Devuelve el :ref:`RID` de este recurso (o un :ref:`RID` vacío). Muchos recursos (como :ref:`Texture2D`, :ref:`Mesh`, etc.) son abstracciones de alto nivel de recursos almacenados en un servidor especializado (:ref:`DisplayServer`, :ref:`RenderingServer`, etc.), por lo que esta función devolverá el :ref:`RID` original. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_is_built_in: .. rst-class:: classref-method :ref:`bool` **is_built_in**\ (\ ) |const| :ref:`🔗` Devuelve ``true`` si el recurso está guardado en el disco como parte del archivo de otro recurso. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_reset_state: .. rst-class:: classref-method |void| **reset_state**\ (\ ) :ref:`🔗` Hace que el recurso borre sus propiedades no exportadas. Véase también :ref:`_reset_state()`. Útil al implementar un formato de recurso personalizado extendiendo :ref:`ResourceFormatLoader` y :ref:`ResourceFormatSaver`. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_set_id_for_path: .. rst-class:: classref-method |void| **set_id_for_path**\ (\ path\: :ref:`String`, id\: :ref:`String`\ ) :ref:`🔗` En la caché interna para ID únicos de escena, establece el ID de este recurso a ``id`` para la escena en ``path``. Si ``id`` está vacío, la entrada de caché para ``path`` se borra. Útil para mantener los ID únicos de escena iguales al implementar un formato de recurso personalizado amigable con VCS extendiendo :ref:`ResourceFormatLoader` y :ref:`ResourceFormatSaver`. \ **Nota:** Este método solo está implementado cuando se ejecuta en un contexto de editor. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_set_path_cache: .. rst-class:: classref-method |void| **set_path_cache**\ (\ path\: :ref:`String`\ ) :ref:`🔗` Establece la ruta del recurso a ``path`` sin involucrar la caché de recursos. Útil para manejar los valores de :ref:`CacheMode` al implementar un formato de recurso personalizado extendiendo :ref:`ResourceFormatLoader` y :ref:`ResourceFormatSaver`. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_setup_local_to_scene: .. rst-class:: classref-method |void| **setup_local_to_scene**\ (\ ) :ref:`🔗` **Obsoleto:** This method should only be called internally. Llama a :ref:`_setup_local_to_scene()`. Si :ref:`resource_local_to_scene` está establecido en ``true``, este método es llamado automáticamente desde :ref:`PackedScene.instantiate()` por el recurso recién duplicado dentro de la instancia de la escena. .. rst-class:: classref-item-separator ---- .. _class_Resource_method_take_over_path: .. rst-class:: classref-method |void| **take_over_path**\ (\ path\: :ref:`String`\ ) :ref:`🔗` Establece la :ref:`resource_path` a ``path``, potencialmente sobrescribiendo una entrada de caché existente para esta ruta. Los intentos posteriores de cargar un recurso sobrescrito por la ruta devolverán este recurso en su lugar. .. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)` .. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)` .. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)` .. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)` .. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)` .. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)` .. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)` .. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)` .. |void| replace:: :abbr:`void (Sin valor de retorno.)`