godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/it/class_fileaccess.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

1488 lines
106 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_FileAccess:
FileAccess
==========
**Eredita:** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
Fornisce metodi per le operazioni di lettura e scrittura dei file.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
Questa classe può essere utilizzata per memorizzare in modo permanente i dati nel file system del dispositivo utente e per leggerli. È utile per memorizzare i dati di salvataggio o i file di configurazione di gioco.
\ **Esempio:** Come scrivere e leggere da un file. Il file denominato ``"save_game.dat"`` sarà memorizzato nella cartella dei dati utente, come specificato nella documentazione :doc:`Percorsi dati <../tutorials/io/data_paths>`:
.. tabs::
.. code-tab:: gdscript
func save_to_file(content):
var file = FileAccess.open("user://save_game.dat", FileAccess.WRITE)
file.store_string(content)
func load_from_file():
var file = FileAccess.open("user://save_game.dat", FileAccess.READ)
var content = file.get_as_text()
return content
.. code-tab:: csharp
public void SaveToFile(string content)
{
using var file = FileAccess.Open("user://save_game.dat", FileAccess.ModeFlags.Write);
file.StoreString(content);
}
public string LoadFromFile()
{
using var file = FileAccess.Open("user://save_game.dat", FileAccess.ModeFlags.Read);
string content = file.GetAsText();
return content;
}
Un'istanza di **FileAccess** ha il proprio cursore del file, che rappresenta la posizione in byte nel file in cui sarà eseguita la prossima operazione di lettura/scrittura. Funzioni come :ref:`get_8()<class_FileAccess_method_get_8>`, :ref:`get_16()<class_FileAccess_method_get_16>`, :ref:`store_8()<class_FileAccess_method_store_8>` e :ref:`store_16()<class_FileAccess_method_store_16>` sposteranno il cursore in avanti del numero di byte letti/scritti. È possibile spostare il cursore in una posizione specifica tramite :ref:`seek()<class_FileAccess_method_seek>` o :ref:`seek_end()<class_FileAccess_method_seek_end>`, e recuperare la sua posizione tramite :ref:`get_position()<class_FileAccess_method_get_position>`.
Un'istanza di **FileAccess** chiuderà il suo file quando l'istanza viene liberata. Poiché eredita :ref:`RefCounted<class_RefCounted>`, ciò avviene automaticamente quando non è più in uso. È possibile chiamare il metodo :ref:`close()<class_FileAccess_method_close>` per chiuderlo prima. In C#, il riferimento deve essere eliminato manualmente, il che si può fare con l'istruzione ``using`` o chiamando direttamente il metodo ``Dispose``.
\ **Nota:** Per accedere alle risorse del progetto una volta esportate, si consiglia di utilizzare :ref:`ResourceLoader<class_ResourceLoader>` invece di **FileAccess**, poiché alcuni file vengono convertiti in formati specifici del motore e i loro file sorgente originali potrebbero non essere presenti nel pacchetto PCK esportato. Se si utilizza **FileAccess**, assicurarsi che il file sia incluso nell'esportazione modificandone la modalità di importazione in **Mantieni file (esportato così com'è)** nel pannello di importazione oppure, per i file in cui questa opzione non è disponibile, modificare il filtro di esportazione di non risorse nella finestra di dialogo Esporta per includere l'estensione dei file (ad esempio ``*.txt``).
\ **Nota:** I file si chiudono automaticamente solo se il processo esce "normalmente" (ad esempio cliccando sul pulsante di chiusura del gestore delle finestre o premendo :kbd:`Alt + F4`). Se l'esecuzione del progetto è interrotta premendo :kbd:`F8` mentre il progetto è in esecuzione, il file non si chiuderà perché il processo di gioco sarà terminato. È possibile aggirare questo problema chiamando :ref:`flush()<class_FileAccess_method_flush>` a intervalli regolari.
.. rst-class:: classref-introduction-group
Tutorial
----------------
- :doc:`Il File system <../tutorials/scripting/filesystem>`
- :doc:`Caricamento e salvataggio di file a tempo di esecuzione <../tutorials/io/runtime_file_loading_and_saving>`
- :doc:`API di serializzazione binaria <../tutorials/io/binary_serialization_api>`
- `Demo di voxel 3D <https://godotengine.org/asset-library/asset/2755>`__
.. rst-class:: classref-reftable-group
Proprietà
------------------
.. table::
:widths: auto
+-------------------------+---------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`big_endian<class_FileAccess_property_big_endian>` |
+-------------------------+---------------------------------------------------------+
.. rst-class:: classref-reftable-group
Metodi
------------
.. table::
:widths: auto
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`close<class_FileAccess_method_close>`\ (\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`FileAccess<class_FileAccess>` | :ref:`create_temp<class_FileAccess_method_create_temp>`\ (\ mode_flags\: :ref:`int<class_int>`, prefix\: :ref:`String<class_String>` = "", extension\: :ref:`String<class_String>` = "", keep\: :ref:`bool<class_bool>` = false\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`eof_reached<class_FileAccess_method_eof_reached>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`file_exists<class_FileAccess_method_file_exists>`\ (\ path\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`flush<class_FileAccess_method_flush>`\ (\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_8<class_FileAccess_method_get_8>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_16<class_FileAccess_method_get_16>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_32<class_FileAccess_method_get_32>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_64<class_FileAccess_method_get_64>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_access_time<class_FileAccess_method_get_access_time>`\ (\ file\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_as_text<class_FileAccess_method_get_as_text>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`get_buffer<class_FileAccess_method_get_buffer>`\ (\ length\: :ref:`int<class_int>`\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_csv_line<class_FileAccess_method_get_csv_line>`\ (\ delim\: :ref:`String<class_String>` = ","\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_double<class_FileAccess_method_get_double>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`get_error<class_FileAccess_method_get_error>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`get_extended_attribute<class_FileAccess_method_get_extended_attribute>`\ (\ file\: :ref:`String<class_String>`, attribute_name\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_extended_attribute_string<class_FileAccess_method_get_extended_attribute_string>`\ (\ file\: :ref:`String<class_String>`, attribute_name\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`get_extended_attributes_list<class_FileAccess_method_get_extended_attributes_list>`\ (\ file\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`get_file_as_bytes<class_FileAccess_method_get_file_as_bytes>`\ (\ path\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_file_as_string<class_FileAccess_method_get_file_as_string>`\ (\ path\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_float<class_FileAccess_method_get_float>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_half<class_FileAccess_method_get_half>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_hidden_attribute<class_FileAccess_method_get_hidden_attribute>`\ (\ file\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_length<class_FileAccess_method_get_length>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_line<class_FileAccess_method_get_line>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_md5<class_FileAccess_method_get_md5>`\ (\ path\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_modified_time<class_FileAccess_method_get_modified_time>`\ (\ file\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`get_open_error<class_FileAccess_method_get_open_error>`\ (\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_pascal_string<class_FileAccess_method_get_pascal_string>`\ (\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_path<class_FileAccess_method_get_path>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_path_absolute<class_FileAccess_method_get_path_absolute>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_position<class_FileAccess_method_get_position>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_read_only_attribute<class_FileAccess_method_get_read_only_attribute>`\ (\ file\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_real<class_FileAccess_method_get_real>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_sha256<class_FileAccess_method_get_sha256>`\ (\ path\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_size<class_FileAccess_method_get_size>`\ (\ file\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |bitfield|\[:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>`\] | :ref:`get_unix_permissions<class_FileAccess_method_get_unix_permissions>`\ (\ file\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`get_var<class_FileAccess_method_get_var>`\ (\ allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_open<class_FileAccess_method_is_open>`\ (\ ) |const| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`FileAccess<class_FileAccess>` | :ref:`open<class_FileAccess_method_open>`\ (\ path\: :ref:`String<class_String>`, flags\: :ref:`ModeFlags<enum_FileAccess_ModeFlags>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`FileAccess<class_FileAccess>` | :ref:`open_compressed<class_FileAccess_method_open_compressed>`\ (\ path\: :ref:`String<class_String>`, mode_flags\: :ref:`ModeFlags<enum_FileAccess_ModeFlags>`, compression_mode\: :ref:`CompressionMode<enum_FileAccess_CompressionMode>` = 0\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`FileAccess<class_FileAccess>` | :ref:`open_encrypted<class_FileAccess_method_open_encrypted>`\ (\ path\: :ref:`String<class_String>`, mode_flags\: :ref:`ModeFlags<enum_FileAccess_ModeFlags>`, key\: :ref:`PackedByteArray<class_PackedByteArray>`, iv\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray()\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`FileAccess<class_FileAccess>` | :ref:`open_encrypted_with_pass<class_FileAccess_method_open_encrypted_with_pass>`\ (\ path\: :ref:`String<class_String>`, mode_flags\: :ref:`ModeFlags<enum_FileAccess_ModeFlags>`, pass\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`remove_extended_attribute<class_FileAccess_method_remove_extended_attribute>`\ (\ file\: :ref:`String<class_String>`, attribute_name\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`resize<class_FileAccess_method_resize>`\ (\ length\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`seek<class_FileAccess_method_seek>`\ (\ position\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`seek_end<class_FileAccess_method_seek_end>`\ (\ position\: :ref:`int<class_int>` = 0\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`set_extended_attribute<class_FileAccess_method_set_extended_attribute>`\ (\ file\: :ref:`String<class_String>`, attribute_name\: :ref:`String<class_String>`, data\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`set_extended_attribute_string<class_FileAccess_method_set_extended_attribute_string>`\ (\ file\: :ref:`String<class_String>`, attribute_name\: :ref:`String<class_String>`, data\: :ref:`String<class_String>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`set_hidden_attribute<class_FileAccess_method_set_hidden_attribute>`\ (\ file\: :ref:`String<class_String>`, hidden\: :ref:`bool<class_bool>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`set_read_only_attribute<class_FileAccess_method_set_read_only_attribute>`\ (\ file\: :ref:`String<class_String>`, ro\: :ref:`bool<class_bool>`\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`set_unix_permissions<class_FileAccess_method_set_unix_permissions>`\ (\ file\: :ref:`String<class_String>`, permissions\: |bitfield|\[:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>`\]\ ) |static| |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_8<class_FileAccess_method_store_8>`\ (\ value\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_16<class_FileAccess_method_store_16>`\ (\ value\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_32<class_FileAccess_method_store_32>`\ (\ value\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_64<class_FileAccess_method_store_64>`\ (\ value\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_buffer<class_FileAccess_method_store_buffer>`\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_csv_line<class_FileAccess_method_store_csv_line>`\ (\ values\: :ref:`PackedStringArray<class_PackedStringArray>`, delim\: :ref:`String<class_String>` = ","\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_double<class_FileAccess_method_store_double>`\ (\ value\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_float<class_FileAccess_method_store_float>`\ (\ value\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_half<class_FileAccess_method_store_half>`\ (\ value\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_line<class_FileAccess_method_store_line>`\ (\ line\: :ref:`String<class_String>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_pascal_string<class_FileAccess_method_store_pascal_string>`\ (\ string\: :ref:`String<class_String>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_real<class_FileAccess_method_store_real>`\ (\ value\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_string<class_FileAccess_method_store_string>`\ (\ string\: :ref:`String<class_String>`\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`store_var<class_FileAccess_method_store_var>`\ (\ value\: :ref:`Variant<class_Variant>`, full_objects\: :ref:`bool<class_bool>` = false\ ) |
+-------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumerazioni
------------------------
.. _enum_FileAccess_ModeFlags:
.. rst-class:: classref-enumeration
enum **ModeFlags**: :ref:`🔗<enum_FileAccess_ModeFlags>`
.. _class_FileAccess_constant_READ:
.. rst-class:: classref-enumeration-constant
:ref:`ModeFlags<enum_FileAccess_ModeFlags>` **READ** = ``1``
Apre il file per operazioni di sola lettura. Il cursore viene posizionato all'inizio del file.
.. _class_FileAccess_constant_WRITE:
.. rst-class:: classref-enumeration-constant
:ref:`ModeFlags<enum_FileAccess_ModeFlags>` **WRITE** = ``2``
Opens the file for write operations. If the file exists, it is truncated to zero length and its contents are cleared. Otherwise, it is created.
\ **Note:** When creating a file it must be in an already existing directory. To recursively create directories for a file path, see :ref:`DirAccess.make_dir_recursive()<class_DirAccess_method_make_dir_recursive>`.
.. _class_FileAccess_constant_READ_WRITE:
.. rst-class:: classref-enumeration-constant
:ref:`ModeFlags<enum_FileAccess_ModeFlags>` **READ_WRITE** = ``3``
Apre il file per operazioni di lettura e scrittura. Non tronca il file. Il cursore è posizionato all'inizio del file.
.. _class_FileAccess_constant_WRITE_READ:
.. rst-class:: classref-enumeration-constant
:ref:`ModeFlags<enum_FileAccess_ModeFlags>` **WRITE_READ** = ``7``
Opens the file for read and write operations. If the file exists, it is truncated to zero length and its contents are cleared. Otherwise, it is created. The file cursor is positioned at the beginning of the file.
\ **Note:** When creating a file it must be in an already existing directory. To recursively create directories for a file path, see :ref:`DirAccess.make_dir_recursive()<class_DirAccess_method_make_dir_recursive>`.
.. rst-class:: classref-item-separator
----
.. _enum_FileAccess_CompressionMode:
.. rst-class:: classref-enumeration
enum **CompressionMode**: :ref:`🔗<enum_FileAccess_CompressionMode>`
.. _class_FileAccess_constant_COMPRESSION_FASTLZ:
.. rst-class:: classref-enumeration-constant
:ref:`CompressionMode<enum_FileAccess_CompressionMode>` **COMPRESSION_FASTLZ** = ``0``
Usa il metodo di compressione `FastLZ <https://fastlz.org/>`__.
.. _class_FileAccess_constant_COMPRESSION_DEFLATE:
.. rst-class:: classref-enumeration-constant
:ref:`CompressionMode<enum_FileAccess_CompressionMode>` **COMPRESSION_DEFLATE** = ``1``
Usa il metodo di compressione `DEFLATE <https://it.wikipedia.org/wiki/Deflate>`__.
.. _class_FileAccess_constant_COMPRESSION_ZSTD:
.. rst-class:: classref-enumeration-constant
:ref:`CompressionMode<enum_FileAccess_CompressionMode>` **COMPRESSION_ZSTD** = ``2``
Usa il metodo di compressione `]Zstandard <https://facebook.github.io/zstd/>`__.
.. _class_FileAccess_constant_COMPRESSION_GZIP:
.. rst-class:: classref-enumeration-constant
:ref:`CompressionMode<enum_FileAccess_CompressionMode>` **COMPRESSION_GZIP** = ``3``
Usa il metodo di compressione `gzip <https://www.gzip.org/>`__.
.. _class_FileAccess_constant_COMPRESSION_BROTLI:
.. rst-class:: classref-enumeration-constant
:ref:`CompressionMode<enum_FileAccess_CompressionMode>` **COMPRESSION_BROTLI** = ``4``
Utilizza il metodo di compressione `brotli <https://github.com/google/brotli>`__ (solo la decompressione è supportata).
.. rst-class:: classref-item-separator
----
.. _enum_FileAccess_UnixPermissionFlags:
.. rst-class:: classref-enumeration
flags **UnixPermissionFlags**: :ref:`🔗<enum_FileAccess_UnixPermissionFlags>`
.. _class_FileAccess_constant_UNIX_READ_OWNER:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_READ_OWNER** = ``256``
Bit di lettura per il proprietario.
.. _class_FileAccess_constant_UNIX_WRITE_OWNER:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_WRITE_OWNER** = ``128``
Bit di scrittura per il proprietario.
.. _class_FileAccess_constant_UNIX_EXECUTE_OWNER:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_EXECUTE_OWNER** = ``64``
Bit di esecuzione per il proprietario.
.. _class_FileAccess_constant_UNIX_READ_GROUP:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_READ_GROUP** = ``32``
Bit di lettura per il gruppo.
.. _class_FileAccess_constant_UNIX_WRITE_GROUP:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_WRITE_GROUP** = ``16``
Bit di scrittura per il gruppo.
.. _class_FileAccess_constant_UNIX_EXECUTE_GROUP:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_EXECUTE_GROUP** = ``8``
Bit di esecuzione per il gruppo.
.. _class_FileAccess_constant_UNIX_READ_OTHER:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_READ_OTHER** = ``4``
Bit di lettura per altri.
.. _class_FileAccess_constant_UNIX_WRITE_OTHER:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_WRITE_OTHER** = ``2``
Bit di scrittura per altri.
.. _class_FileAccess_constant_UNIX_EXECUTE_OTHER:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_EXECUTE_OTHER** = ``1``
Bit di esecuzione per altri.
.. _class_FileAccess_constant_UNIX_SET_USER_ID:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_SET_USER_ID** = ``2048``
Bit di impostazione dell'id utente all'esecuzione.
.. _class_FileAccess_constant_UNIX_SET_GROUP_ID:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_SET_GROUP_ID** = ``1024``
Bit di impostazione dell'id gruppo all'esecuzione.
.. _class_FileAccess_constant_UNIX_RESTRICTED_DELETE:
.. rst-class:: classref-enumeration-constant
:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>` **UNIX_RESTRICTED_DELETE** = ``512``
Bit di eliminazione riservata (permanente).
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni delle proprietà
------------------------------------------------------
.. _class_FileAccess_property_big_endian:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **big_endian** :ref:`🔗<class_FileAccess_property_big_endian>`
.. rst-class:: classref-property-setget
- |void| **set_big_endian**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_big_endian**\ (\ )
Se ``true``, il file viene letto con l'`ordine dei byte <https://it.wikipedia.org/wiki/Ordine_dei_byte>`__ big-endian. Se ``false``, il file viene letto con little-endian. In caso di dubbi, lascia questo su ``false`` poiché la maggior parte dei file viene scritta con l'ordine little-endian.
\ **Nota:** Questo è sempre reimpostato sull'ordine dei byte del sistema, che è little-endian su tutte le piattaforme supportate, ogni volta che si apre il file. Pertanto, bisogna impostare :ref:`big_endian<class_FileAccess_property_big_endian>` *dopo* aver aperto il file, non prima.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _class_FileAccess_method_close:
.. rst-class:: classref-method
|void| **close**\ (\ ) :ref:`🔗<class_FileAccess_method_close>`
Chiude il file attualmente aperto e impedisce ulteriori operazioni di lettura o scrittura. Usa :ref:`flush()<class_FileAccess_method_flush>` per rendere persistenti i dati sul disco senza chiudere il file.
\ **Nota:** **FileAccess** si chiuderà automaticamente quando viene liberato, il che accade quando esce dall'ambito o quando gli viene assegnato ``null``. In C# il riferimento deve essere eliminato manualmente, il che può essere fatto con l'istruzione ``using`` o chiamando direttamente il metodo ``Dispose``.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_create_temp:
.. rst-class:: classref-method
:ref:`FileAccess<class_FileAccess>` **create_temp**\ (\ mode_flags\: :ref:`int<class_int>`, prefix\: :ref:`String<class_String>` = "", extension\: :ref:`String<class_String>` = "", keep\: :ref:`bool<class_bool>` = false\ ) |static| :ref:`🔗<class_FileAccess_method_create_temp>`
Crea un file temporaneo. Questo file verrà liberato quando verrà liberato il **FileAccess** restituito.
Se ``prefix`` non è vuoto, verrà prefissato al nome del file, separato da ``-``.
Se ``extension`` non è vuoto, verrà suffissato al nome del file temporaneo.
Se ``keep`` è ``true``, il file non verrà eliminato quando verrà liberato il **FileAccess** restituito.
Restituisce ``null`` se l'apertura del file non è riuscita. È possibile usare :ref:`get_open_error()<class_FileAccess_method_get_open_error>` per controllare l'errore che si è verificato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_eof_reached:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **eof_reached**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_eof_reached>`
Restituisce ``true`` se il cursore del file ha già letto oltre la fine del file.
\ **Nota:** ``eof_reached() == false`` non può essere utilizzato per verificare se sono disponibili altri dati. Per effettuare un ciclo mentre sono disponibili altri dati, utilizza:
.. tabs::
.. code-tab:: gdscript
while file.get_position() < file.get_length():
# Leggi i dati
.. code-tab:: csharp
while (file.GetPosition() < file.GetLength())
{
// Leggi i dati
}
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_file_exists:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **file_exists**\ (\ path\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_file_exists>`
Restituisce ``true`` se il file esiste nel percorso specificato.
\ **Nota:** Molti tipi di risorse sono importati (ad esempio texture o file audio) e la loro risorsa sorgente non sarà inclusa nel gioco esportato, poiché solo la versione importata è utilizzata. Vedi :ref:`ResourceLoader.exists()<class_ResourceLoader_method_exists>` per un approccio alternativo che tenga conto della rimappatura delle risorse.
Per un equivalente relativo non statico, utilizza :ref:`DirAccess.file_exists()<class_DirAccess_method_file_exists>`.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_flush:
.. rst-class:: classref-method
|void| **flush**\ (\ ) :ref:`🔗<class_FileAccess_method_flush>`
Scrive il buffer del file sul disco. Lo svuotamento viene eseguito automaticamente quando il file viene chiuso. Ciò significa che non è necessario chiamare :ref:`flush()<class_FileAccess_method_flush>` manualmente prima di chiudere un file. Tuttavia, :ref:`flush()<class_FileAccess_method_flush>` può essere utilizzato per garantire che i dati siano al sicuro anche se il progetto si blocca invece di essere chiuso correttamente.
\ **Nota:** Chiama :ref:`flush()<class_FileAccess_method_flush>` solo quando è effettivamente necessario. Altrimenti, diminuirà le prestazioni a causa delle scritture costanti sul disco.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_8:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_8**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_8>`
Restituisce i prossimi 8 bit del file interpretati come un intero. Questo fa avanzare il cursore del file di 1 byte. Vedi :ref:`store_8()<class_FileAccess_method_store_8>` per i dettagli su quali valori si possono memorizzare e recuperare in questo modo.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_16:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_16**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_16>`
Restituisce i prossimi 16 bit del file interpretati come un intero. Questo fa avanzare il cursore del file di 2 byte. Vedi :ref:`store_16()<class_FileAccess_method_store_16>` per i dettagli su quali valori si possono memorizzare e recuperare in questo modo.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_32:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_32**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_32>`
Restituisce i prossimi 32 bit del file interpretati come un intero. Questo fa avanzare il cursore del file di 4 byte. Vedi :ref:`store_32()<class_FileAccess_method_store_32>` per i dettagli su quali valori si possono memorizzare e recuperare in questo modo.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_64:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_64**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_64>`
Restituisce i prossimi 64 bit del file interpretati come un intero. Questo fa avanzare il cursore del file di 8 byte. Vedi :ref:`store_64()<class_FileAccess_method_store_64>` per i dettagli su quali valori si possono memorizzare e recuperare in questo modo.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_access_time:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_access_time**\ (\ file\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_access_time>`
Restituisce l'ultima volta che il file al percorso ``file`` vi è stato accesso nel formato timestamp Unix, oppure ``0`` in caso di errore. Questo timestamp Unix può essere convertito in un altro formato attraverso il singleton :ref:`Time<class_Time>`.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_as_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_as_text**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_as_text>`
Returns the whole file as a :ref:`String<class_String>`. Text is interpreted as being UTF-8 encoded. This ignores the file cursor and does not affect it.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **get_buffer**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_FileAccess_method_get_buffer>`
Restituisce i prossimi ``length`` byte del file come :ref:`PackedByteArray<class_PackedByteArray>`. Questo fa avanzare il cursore del file di ``length`` byte.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_csv_line:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **get_csv_line**\ (\ delim\: :ref:`String<class_String>` = ","\ ) |const| :ref:`🔗<class_FileAccess_method_get_csv_line>`
Restituisce il valore successivo del file in formato CSV (Comma-Separated Values). È possibile passare un delimitatore diverso ``delim`` da usare diverso da quello predefinito ``","`` (la virgola). Questo delimitatore deve essere di un solo carattere e non può essere una virgoletta doppia.
Il testo è interpretato come codificato in UTF-8. I valori nel testo devono essere racchiusi tra virgolette doppie se includono il carattere delimitatore. Si possono evitare le virgolette doppie all'interno di un valore nel testo raddoppiando le loro occorrenze. Questo fa avanzare il cursore del file fino a dopo il carattere di nuova riga alla fine della riga.
Ad esempio, le seguenti righe CSV sono valide e saranno elaborate correttamente come due stringhe ciascuna:
.. code:: text
Alice,"Ciao, Bob!"
Bob,Alice! Che sorpresa!
Alice,"Pensavo che avresti risposto con ""Ciao, mondo""."
Nota come la seconda riga possa omettere le virgolette attorno, poiché non include il delimitatore. Tuttavia *potrebbe* benissimo usare le virgolette, ed è stata scritta senza solo per dimostrazione. La terza riga deve usare ``""`` per ogni virgoletta che deve essere interpretata come tale invece che come fine di un valore del testo.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_double:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_double**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_double>`
Restituisce i prossimi 64 bit del file interpretandoli come numero in virgola mobile. Questo fa avanzare il cursore del file di 8 byte.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_error:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **get_error**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_error>`
Restituisce l'ultimo errore che si è verificato durante l'esecuzione di un operazione. Gli errori possibili sono le costanti ``ERR_FILE_*`` di :ref:`Error<enum_@GlobalScope_Error>`.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_extended_attribute:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **get_extended_attribute**\ (\ file\: :ref:`String<class_String>`, attribute_name\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_extended_attribute>`
Reads the file extended attribute with name ``attribute_name`` as a byte array.
\ **Note:** This method is implemented on Linux, macOS, and Windows.
\ **Note:** Extended attributes support depends on the file system. Attributes will be lost when the file is moved between incompatible file systems.
\ **Note:** On Linux, only "user" namespace attributes are accessible, namespace prefix should not be included.
\ **Note:** On Windows, alternate data streams are used to store extended attributes.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_extended_attribute_string:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_extended_attribute_string**\ (\ file\: :ref:`String<class_String>`, attribute_name\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_extended_attribute_string>`
Reads the file extended attribute with name ``attribute_name`` as a UTF-8 encoded string.
\ **Note:** This method is implemented on Linux, macOS, and Windows.
\ **Note:** Extended attributes support depends on the file system. Attributes will be lost when the file is moved between incompatible file systems.
\ **Note:** On Linux, only "user" namespace attributes are accessible, namespace prefix should not be included.
\ **Note:** On Windows, alternate data streams are used to store extended attributes.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_extended_attributes_list:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **get_extended_attributes_list**\ (\ file\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_extended_attributes_list>`
Returns a list of file extended attributes.
\ **Note:** This method is implemented on Linux, macOS, and Windows.
\ **Note:** Extended attributes support depends on the file system. Attributes will be lost when the file is moved between incompatible file systems.
\ **Note:** On Linux, only "user" namespace attributes are accessible, namespace prefix should not be included.
\ **Note:** On Windows, alternate data streams are used to store extended attributes.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_file_as_bytes:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **get_file_as_bytes**\ (\ path\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_file_as_bytes>`
Restituisce l'intero contenuto del file al percorso ``path`` come un :ref:`PackedByteArray<class_PackedByteArray>` senza alcuna decodifica.
Restituisce un :ref:`PackedByteArray<class_PackedByteArray>` vuoto se si è verificato un errore durante l'apertura del file. È possibile usare :ref:`get_open_error()<class_FileAccess_method_get_open_error>` per controllare l'errore che si è verificato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_file_as_string:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_file_as_string**\ (\ path\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_file_as_string>`
Restituisce l'intero contenuto del file al percorso ``path`` come :ref:`String<class_String>`. Il testo è interpretato come codificato in UTF-8.
Restituisce una :ref:`String<class_String>` vuota se si è verificato un errore durante l'apertura del file. È possibile usare :ref:`get_open_error()<class_FileAccess_method_get_open_error>` per controllare l'errore che si è verificato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_float:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_float**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_float>`
Restituisce i prossimi 32 bit del file interpretandoli come numero in virgola mobile. Questo fa avanzare il cursore del file di 4 byte.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_half:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_half**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_half>`
Restituisce i prossimi 16 bit del file interpretandoli come numero in virgola mobile a mezza precisione. Questo fa avanzare il cursore del file di 2 byte.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_hidden_attribute:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_hidden_attribute**\ (\ file\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_hidden_attribute>`
Returns ``true`` if the **hidden** attribute is set on the file at the given path.
\ **Note:** This method is implemented on iOS, BSD, macOS, and Windows.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_length:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_length**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_length>`
Restituisce la dimensione del file in byte. Per una pipe, restituisce il numero di byte disponibili per la lettura dalla pipe.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_line:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_line**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_line>`
Restituisce la riga successiva del file come :ref:`String<class_String>`. La stringa restituita non include caratteri di nuova riga (``\n``) o di ritorno a capo (``\r``), ma include qualsiasi altro spazio vuoto iniziale o finale. Questo fa avanzare il cursore del file fino a dopo il carattere di nuova riga alla fine della riga.
Il testo è interpretato come codificato in UTF-8.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_md5:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_md5**\ (\ path\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_md5>`
Restituisce l'hash MD5 che rappresenta il file nel percorso specificato oppure una :ref:`String<class_String>` vuota in caso di errore.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_modified_time:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_modified_time**\ (\ file\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_modified_time>`
Restituisce l'ultima volta che il file al percorso ``file`` è stato modificato nel formato timestamp Unix, oppure ``0`` in caso di errore. Questo timestamp Unix può essere convertito in un altro formato attraverso il singleton :ref:`Time<class_Time>`.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_open_error:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **get_open_error**\ (\ ) |static| :ref:`🔗<class_FileAccess_method_get_open_error>`
Restituisce il risultato dell'ultima chiamata a :ref:`open()<class_FileAccess_method_open>` nel thread attuale.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_pascal_string:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_pascal_string**\ (\ ) :ref:`🔗<class_FileAccess_method_get_pascal_string>`
Restituisce una :ref:`String<class_String>` salvata in formato Pascal dal file, il che significa che la lunghezza della stringa è memorizzata esplicitamente all'inizio. Vedi :ref:`store_pascal_string()<class_FileAccess_method_store_pascal_string>`. Può includere caratteri di nuova riga. Il cursore del file avanza dopo la lettura dei byte.
Il testo è interpretato come codificato in UTF-8.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_path:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_path**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_path>`
Restituisce il percorso come :ref:`String<class_String>` per il file attualmente aperto.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_path_absolute:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_path_absolute**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_path_absolute>`
Restituisce il percorso assoluto come :ref:`String<class_String>` per il file attualmente aperto.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_position:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_position**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_position>`
Restituisce la posizione del cursore del file in byte dall'inizio del file. Questo è il cursore di lettura/scrittura del file impostato da :ref:`seek()<class_FileAccess_method_seek>` o :ref:`seek_end()<class_FileAccess_method_seek_end>` e avanzato dalle operazioni di lettura/scrittura.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_read_only_attribute:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_read_only_attribute**\ (\ file\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_read_only_attribute>`
Returns ``true`` if the **read only** attribute is set on the file at the given path.
\ **Note:** This method is implemented on iOS, BSD, macOS, and Windows.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_real:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_real**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_get_real>`
Restituisce i prossimi bit dal file come numero in virgola mobile. Questo fa avanzare il cursore del file di 4 o 8 byte, a seconda della precisione utilizzata dalla build di Godot che ha salvato il file.
Se il file è stato salvato da una build di Godot compilata con l'opzione ``precision=single`` (predefinito), il numero di bit letti per quel file sono 32. Altrimenti, se compilata con l'opzione ``precision=double``, il numero di bit letti è 64.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_sha256:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_sha256**\ (\ path\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_sha256>`
Restituisce una :ref:`String<class_String>` SHA-256 che rappresenta il file nel percorso specificato o una :ref:`String<class_String>` vuota in caso di errore.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_size:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_size**\ (\ file\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_size>`
Returns the size of the file at the given path, in bytes, or ``-1`` on error.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_unix_permissions:
.. rst-class:: classref-method
|bitfield|\[:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>`\] **get_unix_permissions**\ (\ file\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_get_unix_permissions>`
Returns the UNIX permissions of the file at the given path.
\ **Note:** This method is implemented on iOS, Linux/BSD, and macOS.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_get_var:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **get_var**\ (\ allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_FileAccess_method_get_var>`
Restituisce il prossimo valore :ref:`Variant<class_Variant>` dal file. Se ``allow_objects`` è ``true``, è permesso decodificare gli oggetti. Questo fa avanzare il cursore del file del numero di byte letti.
Internamente, questo metodo utilizza lo stesso meccanismo di codifica del metodo :ref:`@GlobalScope.var_to_bytes()<class_@GlobalScope_method_var_to_bytes>`, come descritto nella documentazione dell':doc:`API di serializzazione binaria <../tutorials/io/binary_serialization_api>`.
\ **Attenzione:** Un oggetto deserializzato può contenere codice che verrà eseguito. Non usare questa opzione se l'oggetto serializzato arriva da fonti sconosciute per evitare eventuali rischi di sicurezza come l'esecuzione di codice remoto.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_is_open:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_open**\ (\ ) |const| :ref:`🔗<class_FileAccess_method_is_open>`
Restituisce ``true`` se il file è attualmente aperto.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_open:
.. rst-class:: classref-method
:ref:`FileAccess<class_FileAccess>` **open**\ (\ path\: :ref:`String<class_String>`, flags\: :ref:`ModeFlags<enum_FileAccess_ModeFlags>`\ ) |static| :ref:`🔗<class_FileAccess_method_open>`
Crea un nuovo oggetto **FileAccess** e apre il file per la scrittura o la lettura, a seconda dei flag.
Restituisce ``null`` se non è stato possibile aprire il file. È possibile usare :ref:`get_open_error()<class_FileAccess_method_get_open_error>` per controllare l'errore che si è verificato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_open_compressed:
.. rst-class:: classref-method
:ref:`FileAccess<class_FileAccess>` **open_compressed**\ (\ path\: :ref:`String<class_String>`, mode_flags\: :ref:`ModeFlags<enum_FileAccess_ModeFlags>`, compression_mode\: :ref:`CompressionMode<enum_FileAccess_CompressionMode>` = 0\ ) |static| :ref:`🔗<class_FileAccess_method_open_compressed>`
Crea un nuovo oggetto **FileAccess** e apre un file compresso per la lettura o la scrittura.
\ **Nota:** :ref:`open_compressed()<class_FileAccess_method_open_compressed>` può leggere solo i file salvati da Godot, non i formati di compressione di terze parti. Consulta `GitHub Issue n. 28999 <https://github.com/godotengine/godot/issues/28999>`__ per una soluzione alternativa.
Restituisce ``null`` se non è stato possibile aprire il file. È possibile usare :ref:`get_open_error()<class_FileAccess_method_get_open_error>` per controllare l'errore che si è verificato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_open_encrypted:
.. rst-class:: classref-method
:ref:`FileAccess<class_FileAccess>` **open_encrypted**\ (\ path\: :ref:`String<class_String>`, mode_flags\: :ref:`ModeFlags<enum_FileAccess_ModeFlags>`, key\: :ref:`PackedByteArray<class_PackedByteArray>`, iv\: :ref:`PackedByteArray<class_PackedByteArray>` = PackedByteArray()\ ) |static| :ref:`🔗<class_FileAccess_method_open_encrypted>`
Crea un nuovo oggetto **FileAccess** e apre un file crittografato in modalità di scrittura o lettura. Bisogna passare una chiave binaria per crittografarlo o decrittografarlo.
\ **Nota:** La chiave fornita deve essere lunga 32 byte.
Restituisce ``null`` se non è stato possibile aprire il file. È possibile usare :ref:`get_open_error()<class_FileAccess_method_get_open_error>` per controllare l'errore che si è verificato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_open_encrypted_with_pass:
.. rst-class:: classref-method
:ref:`FileAccess<class_FileAccess>` **open_encrypted_with_pass**\ (\ path\: :ref:`String<class_String>`, mode_flags\: :ref:`ModeFlags<enum_FileAccess_ModeFlags>`, pass\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_open_encrypted_with_pass>`
Crea un nuovo oggetto **FileAccess** e apre un file crittografato in modalità di scrittura o lettura. Bisogna passare una password per crittografarlo o decrittografarlo.
Restituisce ``null`` se non è stato possibile aprire il file. È possibile usare :ref:`get_open_error()<class_FileAccess_method_get_open_error>` per controllare l'errore che si è verificato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_remove_extended_attribute:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **remove_extended_attribute**\ (\ file\: :ref:`String<class_String>`, attribute_name\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_remove_extended_attribute>`
Removes file extended attribute with name ``attribute_name``.
\ **Note:** This method is implemented on Linux, macOS, and Windows.
\ **Note:** Extended attributes support depends on the file system. Attributes will be lost when the file is moved between incompatible file systems.
\ **Note:** On Linux, only "user" namespace attributes are accessible, namespace prefix should not be included.
\ **Note:** On Windows, alternate data streams are used to store extended attributes.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_resize:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **resize**\ (\ length\: :ref:`int<class_int>`\ ) :ref:`🔗<class_FileAccess_method_resize>`
Ridimensiona il file a una lunghezza specificata. Il file deve essere aperto in una modalità che ne permetta la scrittura. Se il file è esteso, sono accodati caratteri NUL. Se il file è troncato, tutti i dati dal file finale alla lunghezza originale del file sono persi.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_seek:
.. rst-class:: classref-method
|void| **seek**\ (\ position\: :ref:`int<class_int>`\ ) :ref:`🔗<class_FileAccess_method_seek>`
Sets the file cursor to the specified position in bytes, from the beginning of the file. This changes the value returned by :ref:`get_position()<class_FileAccess_method_get_position>`.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_seek_end:
.. rst-class:: classref-method
|void| **seek_end**\ (\ position\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_FileAccess_method_seek_end>`
Sets the file cursor to the specified position in bytes, from the end of the file. This changes the value returned by :ref:`get_position()<class_FileAccess_method_get_position>`.
\ **Note:** This is an offset, so you should use negative numbers otherwise the file cursor will be at the end of the file.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_set_extended_attribute:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **set_extended_attribute**\ (\ file\: :ref:`String<class_String>`, attribute_name\: :ref:`String<class_String>`, data\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |static| :ref:`🔗<class_FileAccess_method_set_extended_attribute>`
Writes file extended attribute with name ``attribute_name`` as a byte array.
\ **Note:** This method is implemented on Linux, macOS, and Windows.
\ **Note:** Extended attributes support depends on the file system. Attributes will be lost when the file is moved between incompatible file systems.
\ **Note:** On Linux, only "user" namespace attributes are accessible, namespace prefix should not be included.
\ **Note:** On Windows, alternate data streams are used to store extended attributes.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_set_extended_attribute_string:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **set_extended_attribute_string**\ (\ file\: :ref:`String<class_String>`, attribute_name\: :ref:`String<class_String>`, data\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_FileAccess_method_set_extended_attribute_string>`
Writes file extended attribute with name ``attribute_name`` as a UTF-8 encoded string.
\ **Note:** This method is implemented on Linux, macOS, and Windows.
\ **Note:** Extended attributes support depends on the file system. Attributes will be lost when the file is moved between incompatible file systems.
\ **Note:** On Linux, only "user" namespace attributes are accessible, namespace prefix should not be included.
\ **Note:** On Windows, alternate data streams are used to store extended attributes.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_set_hidden_attribute:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **set_hidden_attribute**\ (\ file\: :ref:`String<class_String>`, hidden\: :ref:`bool<class_bool>`\ ) |static| :ref:`🔗<class_FileAccess_method_set_hidden_attribute>`
Imposta l'attributo **hidden** (nascosto) del file.
\ **Nota:** Questo metodo è implementato su iOS, BSD, macOS, e Windows.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_set_read_only_attribute:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **set_read_only_attribute**\ (\ file\: :ref:`String<class_String>`, ro\: :ref:`bool<class_bool>`\ ) |static| :ref:`🔗<class_FileAccess_method_set_read_only_attribute>`
Imposta l'attributo **read only** (sola lettura) del file.
\ **Nota:** Questo metodo è implementato su iOS, BSD, macOS, e Windows.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_set_unix_permissions:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **set_unix_permissions**\ (\ file\: :ref:`String<class_String>`, permissions\: |bitfield|\[:ref:`UnixPermissionFlags<enum_FileAccess_UnixPermissionFlags>`\]\ ) |static| :ref:`🔗<class_FileAccess_method_set_unix_permissions>`
Imposta i permessi UNIX del file.
\ **Nota:** Questo metodo è implementato su iOS, BSD, macOS, e Windows.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_8:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_8**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_FileAccess_method_store_8>`
Memorizza un intero come 8 bit nel file. Questo fa avanzare il cursore del file di 1 byte. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** ``value`` dovrebbe essere compreso nell'intervallo ``[0, 255]``. Qualsiasi altro valore andrà in overflow e verrà avvolto.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
Per memorizzare un intero con segno, usa :ref:`store_64()<class_FileAccess_method_store_64>` o convertirlo manualmente (vedi :ref:`store_16()<class_FileAccess_method_store_16>` per un esempio).
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_16:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_16**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_FileAccess_method_store_16>`
Memorizza un intero come 16 bit nel file. Questo fa avanzare il cursore del file di 2 byte. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** ``value`` dovrebbe essere compreso nell'intervallo ``[0, 2^16 - 1]``. Qualsiasi altro valore andrà in overflow e si avvolgerà.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
Per memorizzare un intero con segno, usa :ref:`store_64()<class_FileAccess_method_store_64>` o memorizza un intero con segno nell'intervallo ``[-2^15, 2^15 - 1]`` (ovvero mantenendo un bit per il segno) e calcolarne manualmente il segno durante la lettura. Ad esempio:
.. tabs::
.. code-tab:: gdscript
const MAX_15B = 1 << 15
const MAX_16B = 1 << 16
func unsigned16_to_signed(unsigned):
return (unsigned + MAX_15B) % MAX_16B - MAX_15B
func _ready():
var f = FileAccess.open("user://file.dat", FileAccess.WRITE_READ)
f.store_16(-42) # Questo si avvolge e memorizza 65494 (2^16 - 42).
f.store_16(121) # Nei limiti, memorizzerà 121.
f.seek(0) # Torna indietro per iniziare a leggere il valore memorizzato.
var read1 = f.get_16() # 65494
var read2 = f.get_16() # 121
var converted1 = unsigned16_to_signed(read1) # -42
var converted2 = unsigned16_to_signed(read2) # 121
.. code-tab:: csharp
public override void _Ready()
{
using var f = FileAccess.Open("user://file.dat", FileAccess.ModeFlags.WriteRead);
f.Store16(unchecked((ushort)-42)); // Questo si avvolge e memorizza 65494 (2^16 - 42).
f.Store16(121); // Nei limiti, memorizzerà 121.
f.Seek(0); // Torna indietro per iniziare a leggere il valore memorizzato.
ushort read1 = f.Get16(); // 65494
ushort read2 = f.Get16(); // 121
short converted1 = (short)read1; // -42
short converted2 = (short)read2; // 121
}
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_32:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_32**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_FileAccess_method_store_32>`
Memorizza un intero come 32 bit nel file. Questo fa avanzare il cursore del file di 4 byte. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** ``value`` dovrebbe essere compreso nell'intervallo ``[0, 2^32 - 1]``. Qualsiasi altro valore andrà in overflow e si avvolgerà.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
Per memorizzare un intero con segno, usa :ref:`store_64()<class_FileAccess_method_store_64>` o convertirlo manualmente (vedi :ref:`store_16()<class_FileAccess_method_store_16>` per un esempio).
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_64:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_64**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_FileAccess_method_store_64>`
Memorizza un intero come 64 bit nel file. Questo fa avanzare il cursore del file di 8 byte. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** ``value`` deve essere compreso nell'intervallo ``[-2^63, 2^63 - 1]`` (ovvero deve essere un valore :ref:`int<class_int>` valido).
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_buffer:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_buffer**\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_FileAccess_method_store_buffer>`
Memorizza l'array di byte fornito nel file. Questo fa avanzare il cursore del file del numero di byte memorizzati. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_csv_line:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_csv_line**\ (\ values\: :ref:`PackedStringArray<class_PackedStringArray>`, delim\: :ref:`String<class_String>` = ","\ ) :ref:`🔗<class_FileAccess_method_store_csv_line>`
Stores the given :ref:`PackedStringArray<class_PackedStringArray>` in the file as a line formatted in the CSV (Comma-Separated Values) format. You can pass a different delimiter ``delim`` to use other than the default ``","`` (comma). This delimiter must be one-character long.
Text will be encoded as UTF-8. Returns ``true`` if the operation is successful.
\ **Note:** If an error occurs, the resulting value of the file position indicator is indeterminate.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_double:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_double**\ (\ value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_FileAccess_method_store_double>`
Memorizza un numero in virgola mobile a 64 bit nel file. Questo fa avanzare il cursore del file di 8 byte. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_float:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_float**\ (\ value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_FileAccess_method_store_float>`
Memorizza un numero in virgola mobile a 32 bit nel file. Questo fa avanzare il cursore del file di 4 byte. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_half:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_half**\ (\ value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_FileAccess_method_store_half>`
Memorizza un numero in virgola mobile a 16 bit nel file. Questo fa avanzare il cursore del file di 2 byte. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_line:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_line**\ (\ line\: :ref:`String<class_String>`\ ) :ref:`🔗<class_FileAccess_method_store_line>`
Memorizza la riga ``line`` nel file, seguita da un carattere di nuova riga (``\n``), codificando il testo come UTF-8. Questo fa avanzare il cursore del file della lunghezza della riga, dopo il carattere di nuova riga. La quantità di byte scritti dipende dai byte codificati in UTF-8, che può essere diversa da :ref:`String.length()<class_String_method_length>` il quale conta il numero di codici UTF-32. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** se si verifica un errore, il valore risultante dell'indicatore di posizione del file è indeterminato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_pascal_string:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_pascal_string**\ (\ string\: :ref:`String<class_String>`\ ) :ref:`🔗<class_FileAccess_method_store_pascal_string>`
Memorizza la :ref:`String<class_String>` specificata come una riga nel file in formato Pascal (ovvero memorizza anche la lunghezza della stringa). Il testo sarà codificato come UTF-8. Questo fa avanzare il cursore del file del numero di byte scritti a seconda dei byte codificati in UTF-8, che può essere diverso da :ref:`String.length()<class_String_method_length>` il quale conta il numero di codici UTF-32. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_real:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_real**\ (\ value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_FileAccess_method_store_real>`
Memorizza un numero in virgola mobile. Questo fa avanzare il cursore del file di 4 o 8 byte, a seconda della precisione utilizzata dalla build attuale di Godot.
Se si utilizza una build di Godot compilata con l'opzione ``precision=single`` (predefinito), questo metodo salverà un float a 32 bit. Altrimenti, se compilata con l'opzione ``precision=double``, salverà un float a 64 bit. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_string:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_string**\ (\ string\: :ref:`String<class_String>`\ ) :ref:`🔗<class_FileAccess_method_store_string>`
Memorizza la stringa ``string`` nel file senza un carattere di ritorno a capo (``\n``), codificando il testo come UTF-8. Questo fa avanzare il cursore del file della lunghezza della stringa in byte codificati in UTF-8, che può essere diversa da :ref:`String.length()<class_String_method_length>` il quale conta il numero di codici UTF-32. Restituisce ``true`` se l'operazione ha successo.
\ **Nota:** Questo metodo è progettato per scrivere file di testo. La stringa è memorizzata come buffer codificato in UTF-8, senza la lunghezza della stringa o lo zero di terminazione. Ciò significa che non può essere recuperata facilmente. Se si desidera memorizzare una stringa recuperabile in un file binario, considera di usare :ref:`store_pascal_string()<class_FileAccess_method_store_pascal_string>`. Per recuperare stringhe da un file di testo, è possibile usare ``get_buffer(length).get_string_from_utf8()`` (se si conosce la lunghezza) o :ref:`get_as_text()<class_FileAccess_method_get_as_text>`.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
.. rst-class:: classref-item-separator
----
.. _class_FileAccess_method_store_var:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **store_var**\ (\ value\: :ref:`Variant<class_Variant>`, full_objects\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_FileAccess_method_store_var>`
Inserisce un qualunque Variant nel file. Se ``full_objects`` è ``true``, è consentito codificare le istanze di oggetti (e può potenzialmente includere codice). Questo fa avanzare il cursore del file del numero di byte memorizzati. Restituisce ``true`` se l'operazione ha successo.
Internamente, questo metodo utilizza lo stesso meccanismo di codifica del metodo :ref:`@GlobalScope.var_to_bytes()<class_@GlobalScope_method_var_to_bytes>`, come descritto nella documentazione dell':doc:`API di serializzazione binaria <../tutorials/io/binary_serialization_api>`.
\ **Nota:** Non tutte le proprietà sono incluse. Saranno serializzate solo le proprietà configurate con il flag :ref:`@GlobalScope.PROPERTY_USAGE_STORAGE<class_@GlobalScope_constant_PROPERTY_USAGE_STORAGE>`. È possibile aggiungere un nuovo flag di utilizzo a una proprietà sovrascrivendo il metodo :ref:`Object._get_property_list()<class_Object_private_method__get_property_list>` nella tua classe. Puoi anche controllare come è configurato l'utilizzo della proprietà chiamando :ref:`Object._get_property_list()<class_Object_private_method__get_property_list>`. Consulta :ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` per i possibili flag di utilizzo.
\ **Nota:** Se si verifica un errore, il valore risultante dell'indicatore di posizione nel file non può essere determinato.
.. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)`
.. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)`
.. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)`
.. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)`
.. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)`
.. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)`
.. |void| replace:: :abbr:`void (Nessun valore restituito.)`
Reference in New Issue View Git Blame Copy Permalink