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_websocketpeer.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

532 lines
28 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_WebSocketPeer:
WebSocketPeer
=============
**Eredita:** :ref:`PacketPeer<class_PacketPeer>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
Una connessione WebSocket.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
This class represents WebSocket connection, and can be used as a WebSocket client (`RFC 6455 <https://datatracker.ietf.org/doc/html/rfc6455>`__-compliant) or as a remote peer of a WebSocket server.
You can send WebSocket binary frames using :ref:`PacketPeer.put_packet()<class_PacketPeer_method_put_packet>`, and WebSocket text frames using :ref:`send()<class_WebSocketPeer_method_send>` (prefer text frames when interacting with text-based API). You can check the frame type of the last packet via :ref:`was_string_packet()<class_WebSocketPeer_method_was_string_packet>`.
To start a WebSocket client, first call :ref:`connect_to_url()<class_WebSocketPeer_method_connect_to_url>`, then regularly call :ref:`poll()<class_WebSocketPeer_method_poll>` (e.g. during :ref:`Node<class_Node>` process). You can query the socket state via :ref:`get_ready_state()<class_WebSocketPeer_method_get_ready_state>`, get the number of pending packets using :ref:`PacketPeer.get_available_packet_count()<class_PacketPeer_method_get_available_packet_count>`, and retrieve them via :ref:`PacketPeer.get_packet()<class_PacketPeer_method_get_packet>`.
.. tabs::
.. code-tab:: gdscript
extends Node
var socket = WebSocketPeer.new()
func _ready():
socket.connect_to_url("wss://example.com")
func _process(delta):
socket.poll()
var state = socket.get_ready_state()
if state == WebSocketPeer.STATE_OPEN:
while socket.get_available_packet_count():
print("Packet: ", socket.get_packet())
elif state == WebSocketPeer.STATE_CLOSING:
# Keep polling to achieve proper close.
pass
elif state == WebSocketPeer.STATE_CLOSED:
var code = socket.get_close_code()
var reason = socket.get_close_reason()
print("WebSocket closed with code: %d, reason %s. Clean: %s" % [code, reason, code != -1])
set_process(false) # Stop processing.
To use the peer as part of a WebSocket server refer to :ref:`accept_stream()<class_WebSocketPeer_method_accept_stream>` and the online tutorial.
.. rst-class:: classref-reftable-group
Proprietà
------------------
.. table::
:widths: auto
+---------------------------------------------------+--------------------------------------------------------------------------------+-------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`handshake_headers<class_WebSocketPeer_property_handshake_headers>` | ``PackedStringArray()`` |
+---------------------------------------------------+--------------------------------------------------------------------------------+-------------------------+
| :ref:`float<class_float>` | :ref:`heartbeat_interval<class_WebSocketPeer_property_heartbeat_interval>` | ``0.0`` |
+---------------------------------------------------+--------------------------------------------------------------------------------+-------------------------+
| :ref:`int<class_int>` | :ref:`inbound_buffer_size<class_WebSocketPeer_property_inbound_buffer_size>` | ``65535`` |
+---------------------------------------------------+--------------------------------------------------------------------------------+-------------------------+
| :ref:`int<class_int>` | :ref:`max_queued_packets<class_WebSocketPeer_property_max_queued_packets>` | ``4096`` |
+---------------------------------------------------+--------------------------------------------------------------------------------+-------------------------+
| :ref:`int<class_int>` | :ref:`outbound_buffer_size<class_WebSocketPeer_property_outbound_buffer_size>` | ``65535`` |
+---------------------------------------------------+--------------------------------------------------------------------------------+-------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`supported_protocols<class_WebSocketPeer_property_supported_protocols>` | ``PackedStringArray()`` |
+---------------------------------------------------+--------------------------------------------------------------------------------+-------------------------+
.. rst-class:: classref-reftable-group
Metodi
------------
.. table::
:widths: auto
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`accept_stream<class_WebSocketPeer_method_accept_stream>`\ (\ stream\: :ref:`StreamPeer<class_StreamPeer>`\ ) |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`close<class_WebSocketPeer_method_close>`\ (\ code\: :ref:`int<class_int>` = 1000, reason\: :ref:`String<class_String>` = ""\ ) |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`connect_to_url<class_WebSocketPeer_method_connect_to_url>`\ (\ url\: :ref:`String<class_String>`, tls_client_options\: :ref:`TLSOptions<class_TLSOptions>` = null\ ) |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_close_code<class_WebSocketPeer_method_get_close_code>`\ (\ ) |const| |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_close_reason<class_WebSocketPeer_method_get_close_reason>`\ (\ ) |const| |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_connected_host<class_WebSocketPeer_method_get_connected_host>`\ (\ ) |const| |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_connected_port<class_WebSocketPeer_method_get_connected_port>`\ (\ ) |const| |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_current_outbound_buffered_amount<class_WebSocketPeer_method_get_current_outbound_buffered_amount>`\ (\ ) |const| |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`State<enum_WebSocketPeer_State>` | :ref:`get_ready_state<class_WebSocketPeer_method_get_ready_state>`\ (\ ) |const| |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_requested_url<class_WebSocketPeer_method_get_requested_url>`\ (\ ) |const| |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_selected_protocol<class_WebSocketPeer_method_get_selected_protocol>`\ (\ ) |const| |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`poll<class_WebSocketPeer_method_poll>`\ (\ ) |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`send<class_WebSocketPeer_method_send>`\ (\ message\: :ref:`PackedByteArray<class_PackedByteArray>`, write_mode\: :ref:`WriteMode<enum_WebSocketPeer_WriteMode>` = 1\ ) |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`send_text<class_WebSocketPeer_method_send_text>`\ (\ message\: :ref:`String<class_String>`\ ) |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_no_delay<class_WebSocketPeer_method_set_no_delay>`\ (\ enabled\: :ref:`bool<class_bool>`\ ) |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`was_string_packet<class_WebSocketPeer_method_was_string_packet>`\ (\ ) |const| |
+----------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumerazioni
------------------------
.. _enum_WebSocketPeer_WriteMode:
.. rst-class:: classref-enumeration
enum **WriteMode**: :ref:`🔗<enum_WebSocketPeer_WriteMode>`
.. _class_WebSocketPeer_constant_WRITE_MODE_TEXT:
.. rst-class:: classref-enumeration-constant
:ref:`WriteMode<enum_WebSocketPeer_WriteMode>` **WRITE_MODE_TEXT** = ``0``
Specifica che i messaggi di WebSocket devono essere trasferiti sotto forma di testo (è consentito solo UTF-8 valido).
.. _class_WebSocketPeer_constant_WRITE_MODE_BINARY:
.. rst-class:: classref-enumeration-constant
:ref:`WriteMode<enum_WebSocketPeer_WriteMode>` **WRITE_MODE_BINARY** = ``1``
Specifica che i messaggi di WebSocket devono essere trasferiti sotto forma binaria (è consentita qualsiasi combinazione di byte).
.. rst-class:: classref-item-separator
----
.. _enum_WebSocketPeer_State:
.. rst-class:: classref-enumeration
enum **State**: :ref:`🔗<enum_WebSocketPeer_State>`
.. _class_WebSocketPeer_constant_STATE_CONNECTING:
.. rst-class:: classref-enumeration-constant
:ref:`State<enum_WebSocketPeer_State>` **STATE_CONNECTING** = ``0``
Il socket è stato creato. La connessione non è ancora aperta.
.. _class_WebSocketPeer_constant_STATE_OPEN:
.. rst-class:: classref-enumeration-constant
:ref:`State<enum_WebSocketPeer_State>` **STATE_OPEN** = ``1``
La connessione è aperta e pronta a comunicare.
.. _class_WebSocketPeer_constant_STATE_CLOSING:
.. rst-class:: classref-enumeration-constant
:ref:`State<enum_WebSocketPeer_State>` **STATE_CLOSING** = ``2``
La connessione è in fase di chiusura. Ciò significa che una richiesta di chiusura è stata inviata al peer remoto ma la conferma non è stata ricevuta.
.. _class_WebSocketPeer_constant_STATE_CLOSED:
.. rst-class:: classref-enumeration-constant
:ref:`State<enum_WebSocketPeer_State>` **STATE_CLOSED** = ``3``
La connessione è chiusa o non può essere aperta.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni delle proprietà
------------------------------------------------------
.. _class_WebSocketPeer_property_handshake_headers:
.. rst-class:: classref-property
:ref:`PackedStringArray<class_PackedStringArray>` **handshake_headers** = ``PackedStringArray()`` :ref:`🔗<class_WebSocketPeer_property_handshake_headers>`
.. rst-class:: classref-property-setget
- |void| **set_handshake_headers**\ (\ value\: :ref:`PackedStringArray<class_PackedStringArray>`\ )
- :ref:`PackedStringArray<class_PackedStringArray>` **get_handshake_headers**\ (\ )
Le intestazioni HTTP aggiuntive da inviare durante l'handshake WebSocket.
\ **Nota:** Non supportato nelle esportazioni per Web a causa delle restrizioni dei browser.
**Note:** The returned array is *copied* and any changes to it will not update the original property value. See :ref:`PackedStringArray<class_PackedStringArray>` for more details.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_property_heartbeat_interval:
.. rst-class:: classref-property
:ref:`float<class_float>` **heartbeat_interval** = ``0.0`` :ref:`🔗<class_WebSocketPeer_property_heartbeat_interval>`
.. rst-class:: classref-property-setget
- |void| **set_heartbeat_interval**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_heartbeat_interval**\ (\ )
L'intervallo (in secondi) in cui il peer invierà automaticamente frame di controllo "ping" WebSocket. Se impostato su ``0``, non verrà inviato alcun frame di controllo "ping".
\ **Nota:** Non ha alcun effetto nelle esportazioni Web a causa delle restrizioni dei browser.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_property_inbound_buffer_size:
.. rst-class:: classref-property
:ref:`int<class_int>` **inbound_buffer_size** = ``65535`` :ref:`🔗<class_WebSocketPeer_property_inbound_buffer_size>`
.. rst-class:: classref-property-setget
- |void| **set_inbound_buffer_size**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_inbound_buffer_size**\ (\ )
La dimensione del buffer di input in byte (più o menu la quantità massima di memoria che verrà allocata per i pacchetti in entrata).
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_property_max_queued_packets:
.. rst-class:: classref-property
:ref:`int<class_int>` **max_queued_packets** = ``4096`` :ref:`🔗<class_WebSocketPeer_property_max_queued_packets>`
.. rst-class:: classref-property-setget
- |void| **set_max_queued_packets**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_max_queued_packets**\ (\ )
La quantità massima di pacchetti che saranno ammessi nelle code di attesa (sia in entrata sia in uscita).
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_property_outbound_buffer_size:
.. rst-class:: classref-property
:ref:`int<class_int>` **outbound_buffer_size** = ``65535`` :ref:`🔗<class_WebSocketPeer_property_outbound_buffer_size>`
.. rst-class:: classref-property-setget
- |void| **set_outbound_buffer_size**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_outbound_buffer_size**\ (\ )
La dimensione del buffer di input in byte (più o meno la quantità massima di memoria che verrà allocata per i pacchetti in uscita).
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_property_supported_protocols:
.. rst-class:: classref-property
:ref:`PackedStringArray<class_PackedStringArray>` **supported_protocols** = ``PackedStringArray()`` :ref:`🔗<class_WebSocketPeer_property_supported_protocols>`
.. rst-class:: classref-property-setget
- |void| **set_supported_protocols**\ (\ value\: :ref:`PackedStringArray<class_PackedStringArray>`\ )
- :ref:`PackedStringArray<class_PackedStringArray>` **get_supported_protocols**\ (\ )
I sotto-protocolli di WebSocket consentiti durante l'handshake di WebSocket.
**Note:** The returned array is *copied* and any changes to it will not update the original property value. See :ref:`PackedStringArray<class_PackedStringArray>` for more details.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _class_WebSocketPeer_method_accept_stream:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **accept_stream**\ (\ stream\: :ref:`StreamPeer<class_StreamPeer>`\ ) :ref:`🔗<class_WebSocketPeer_method_accept_stream>`
Accetta una connessione di peer eseguendo l'handshake HTTP come server WebSocket. Il ``stream`` deve essere un flusso TCP valido recuperato tramite :ref:`TCPServer.take_connection()<class_TCPServer_method_take_connection>`, o un flusso TLS accettato tramite :ref:`StreamPeerTLS.accept_stream()<class_StreamPeerTLS_method_accept_stream>`.
\ **Nota:** Non supportato nelle esportazioni per Web a causa delle restrizioni dei browser.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_close:
.. rst-class:: classref-method
|void| **close**\ (\ code\: :ref:`int<class_int>` = 1000, reason\: :ref:`String<class_String>` = ""\ ) :ref:`🔗<class_WebSocketPeer_method_close>`
Closes this WebSocket connection.
\ ``code`` is the status code for the closure (see `RFC 6455 section 7.4 <https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1>`__ for a list of valid status codes). If ``code`` is negative, the connection will be closed immediately without notifying the remote peer.
\ ``reason`` is the human-readable reason for closing the connection. It can be any UTF-8 string that's smaller than 123 bytes.
\ **Note:** To achieve a clean closure, you will need to keep polling until :ref:`STATE_CLOSED<class_WebSocketPeer_constant_STATE_CLOSED>` is reached.
\ **Note:** The Web export might not support all status codes. Please refer to browser-specific documentation for more details.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_connect_to_url:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **connect_to_url**\ (\ url\: :ref:`String<class_String>`, tls_client_options\: :ref:`TLSOptions<class_TLSOptions>` = null\ ) :ref:`🔗<class_WebSocketPeer_method_connect_to_url>`
Si collega all'URL indicato. I certificati TLS saranno verificati contro il nome host durante la connessione utilizzando il protocollo ``wss://``. È possibile passare il parametro opzionale ``tls_client_options`` per personalizzare le autorità di certificazione attendibili, o disabilitare la verifica dei nomi comuni. Vedi :ref:`TLSOptions.client()<class_TLSOptions_method_client>` e :ref:`TLSOptions.client_unsafe()<class_TLSOptions_method_client_unsafe>`.
\ **Nota:** Questo metodo non è bloccante e restituirà :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` prima che la connessione venga stabilita, a patto che i parametri forniti siano validi e il peer non si trovi in uno stato non valido (ad esempio, già connesso). Chiama regolarmente :ref:`poll()<class_WebSocketPeer_method_poll>` (ad esempio, durante il processo di un :ref:`Node<class_Node>`) e controlla il risultato di :ref:`get_ready_state()<class_WebSocketPeer_method_get_ready_state>` per sapere se la connessione riesce o fallisce.
\ **Nota:** Per evitare avvisi o errori di contenuti misti in Web, potresti dover usare un ``url`` che inizia con ``wss://`` (sicuro) invece di ``ws://``. In questo modo, assicurati di utilizzare il nome di dominio completamente qualificato che corrisponde a quello definito nel certificato TLS del server. Non collegare direttamente tramite l'indirizzo IP per le connessioni ``wss://``, in quanto non corrisponde al certificato TLS.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_get_close_code:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_close_code**\ (\ ) |const| :ref:`🔗<class_WebSocketPeer_method_get_close_code>`
Restituisce il codice di stato del frame di WebSocket, o ``-1`` quando la connessione non è stata chiusa in maniera pulito. Chiama solo questo metodo quando :ref:`get_ready_state()<class_WebSocketPeer_method_get_ready_state>` restituisce :ref:`STATE_CLOSED<class_WebSocketPeer_constant_STATE_CLOSED>`.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_get_close_reason:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_close_reason**\ (\ ) |const| :ref:`🔗<class_WebSocketPeer_method_get_close_reason>`
Restituisce la stringa che rappresenta il motivo di stato di chiusura del frame WebSocket ricevuta. Chiama solo questo metodo quando :ref:`get_ready_state()<class_WebSocketPeer_method_get_ready_state>` restituisce :ref:`STATE_CLOSED<class_WebSocketPeer_constant_STATE_CLOSED>`.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_get_connected_host:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_connected_host**\ (\ ) |const| :ref:`🔗<class_WebSocketPeer_method_get_connected_host>`
Restituisce l'indirizzo IP del peer connesso.
\ **Nota:** Non disponibile nell'esportazione per Web.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_get_connected_port:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_connected_port**\ (\ ) |const| :ref:`🔗<class_WebSocketPeer_method_get_connected_port>`
Restituisce la porta remota del peer connesso.
\ **Nota:** Non disponibile nell'esportazione per Web.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_get_current_outbound_buffered_amount:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_current_outbound_buffered_amount**\ (\ ) |const| :ref:`🔗<class_WebSocketPeer_method_get_current_outbound_buffered_amount>`
Restituisce la quantità attuale dei dati nel buffer di websocket in uscita. **Nota:** Le esportazioni Web utilizzano WebSocket.bufferedAmount, mentre altre piattaforme utilizzano un buffer interno.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_get_ready_state:
.. rst-class:: classref-method
:ref:`State<enum_WebSocketPeer_State>` **get_ready_state**\ (\ ) |const| :ref:`🔗<class_WebSocketPeer_method_get_ready_state>`
Restituisce lo stato di disponibilità della connessione.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_get_requested_url:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_requested_url**\ (\ ) |const| :ref:`🔗<class_WebSocketPeer_method_get_requested_url>`
Restituisce l'URL richiesto da questo peer. L'URL deriva dal ``url`` passato a :ref:`connect_to_url()<class_WebSocketPeer_method_connect_to_url>` o dalle intestazioni HTTP quando agisce come server (ossia quando si utilizza :ref:`accept_stream()<class_WebSocketPeer_method_accept_stream>`).
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_get_selected_protocol:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_selected_protocol**\ (\ ) |const| :ref:`🔗<class_WebSocketPeer_method_get_selected_protocol>`
Restituisce il sotto-protocollo WebSocket selezionato per questa connessione o una stringa vuota se il sotto-protocollo non è stato ancora selezionato.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_poll:
.. rst-class:: classref-method
|void| **poll**\ (\ ) :ref:`🔗<class_WebSocketPeer_method_poll>`
Aggiorna lo stato di connessione e riceve i pacchetti in arrivo. Chiama questa funzione regolarmente per mantenerla in uno stato pulito.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_send:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **send**\ (\ message\: :ref:`PackedByteArray<class_PackedByteArray>`, write_mode\: :ref:`WriteMode<enum_WebSocketPeer_WriteMode>` = 1\ ) :ref:`🔗<class_WebSocketPeer_method_send>`
Invia il messaggio ``message`` utilizzando la modalità di scrittura desiderata (``write_mode``). Quando si invia una :ref:`String<class_String>`, preferisci usare :ref:`send_text()<class_WebSocketPeer_method_send_text>`.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_send_text:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **send_text**\ (\ message\: :ref:`String<class_String>`\ ) :ref:`🔗<class_WebSocketPeer_method_send_text>`
Invia il messaggio ``message`` utilizzando la modalità di testo WebSocket. Preferisci questo metodo piuttosto che :ref:`PacketPeer.put_packet()<class_PacketPeer_method_put_packet>` quando interagisci con API basata su testo di terze parti (ad esempio quando si utilizzano messaggi formattati in :ref:`JSON<class_JSON>`).
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_set_no_delay:
.. rst-class:: classref-method
|void| **set_no_delay**\ (\ enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_WebSocketPeer_method_set_no_delay>`
Disattiva l'algoritmo di Nagle sul socket TCP sottostante (predefinito). Vedi :ref:`StreamPeerTCP.set_no_delay()<class_StreamPeerTCP_method_set_no_delay>` per ulteriori informazioni.
\ **Nota:** Non disponibile nell'esportazione per Web.
.. rst-class:: classref-item-separator
----
.. _class_WebSocketPeer_method_was_string_packet:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **was_string_packet**\ (\ ) |const| :ref:`🔗<class_WebSocketPeer_method_was_string_packet>`
Restituisce ``true`` se l'ultimo pacchetto ricevuto è stato inviato come un payload di testo. Vedi :ref:`WriteMode<enum_WebSocketPeer_WriteMode>`.
.. |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