Returns Creates a new Socket for the given namespace. Only auth ({ auth: {key: "value"} }) is read from the options object. Other keys will be ignored and should be passed when instancing a new Manager(nsp, options).
Event: ‘error’
Fired upon a connection error.
socket . io . on ( "error" , ( error ) => { // ... }); Event: ‘reconnect’
attempt
Fired upon a successful reconnection.
socket . io . on ( "reconnect" , ( attempt ) => { // ... }); Event: ‘reconnect_attempt’
attempt
Fired upon an attempt to reconnect.
socket . io . on ( "reconnect_attempt" , ( attempt ) => { // ... }); Event: ‘reconnect_error’
Fired upon a reconnection attempt error.
socket . io . on ( "reconnect_error" , ( error ) => { // ... }); Event: ‘reconnect_failed’ Fired when couldn’t reconnect within reconnectionAttempts.
socket . io . on ( "reconnect_failed" , () => { // ... }); Event: ‘ping’ Fired when a ping packet is received from the server.
socket . io . on ( "ping" , () => { // ... }); Socket
A Socket is the fundamental class for interacting with the server. A Socket belongs to a certain Namespace (by default /) and uses an underlying Manager to communicate.
A Socket is basically an EventEmitter which sends events to — and receive events from — the server over the network.
socket . emit ( "hello" , { a : "b" , c : [] }); socket . on ( "hey" , (... args ) => { // ... }); More information can be found here .
socket.id
A unique identifier for the socket session. Set after the connect event is triggered, and updated after the reconnect event.
const socket = io ( "http://localhost" ); console . log ( socket . id ); // undefined socket . on ( "connect" , () => { console . log ( socket . id ); // "G5p5..." }); socket.connected
Whether or not the socket is connected to the server.
const socket = io ( "http://localhost" ); socket . on ( "connect" , () => { console . log ( socket . connected ); // true }); socket.disconnected
Whether or not the socket is disconnected from the server.
const socket = io ( "http://localhost" ); socket . on ( "connect" , () => { console . log ( socket . disconnected ); // false }); socket.io
A reference to the underlying Manager .
socket . on ( "connect" , () => { const engine = socket . io . engine ; console . log ( engine . transport . name ); // in most cases, prints "polling" engine . once ( "upgrade" , () => { // called when the transport is upgraded (i.e. from HTTP long-polling to WebSocket) console . log ( engine . transport . name ); // in most cases, prints "websocket" }); engine . on ( "packet" , ({ type , data }) => { // called for each packet received }); engine . on ( "packetCreate" , ({ type , data }) => { // called for each packet sent }); engine . on ( "drain" , () => { // called when the write buffer is drained }); engine . on ( "close" , ( reason ) => { // called when the underlying connection is closed }); }); socket.connect() Added in v1.0.0
Manually connects the socket.
const socket = io ({ autoConnect : false }); // ... socket . connect (); It can also be used to manually reconnect:
socket . on ( "disconnect" , () => { socket . connect (); }); socket.open() Added in v1.0.0
Synonym of socket.connect() .
socket.send([…args][, ack])
Sends a message event. See socket.emit(eventName[, …args][, ack]) .
socket.emit(eventName[, …args][, ack])
eventName args <any[]>ack Returns true
Emits an event to the socket identified by the string name. Any other parameters can be included. All serializable datastructures are supported, including Buffer.
socket . emit ( "hello" , "world" ); socket . emit ( "with-binary" , 1 , "2" , { 3 : "4" , 5 : Buffer . from ([ 6 , 7 , 8 ]) }); The ack argument is optional and will be called with the server answer.
Client
socket . emit ( "hello" , "world" , ( response ) => { console . log ( response ); // "got it" }); Server
io . on ( "connection" , ( socket ) => { socket . on ( "hello" , ( arg , callback ) => { console . log ( arg ); // "world" callback ( "got it" ); }); }); socket.on(eventName, callback) Inherited from the EventEmitter class .
eventName listener Returns
Register a new handler for the given event.
socket . on ( "news" , ( data ) => { console . log ( data ); }); // with multiple arguments socket . on ( "news" , ( arg1 , arg2 , arg3 , arg4 ) => { // ... }); // with callback socket . on ( "news" , ( cb ) => { cb ( 0 ); }); socket.once(eventName, callback) Inherited from the EventEmitter class .
eventName listener Returns
Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.
socket . once ( "my-event" , () => { // ... }); socket.off([eventName][, listener]) Inherited from the EventEmitter class .
eventName listener Returns
Removes the specified listener from the listener array for the event named eventName.
const myListener = () => { // ... } socket . on ( "my-event" , myListener ); // then later socket . off ( "my-event" , myListener ); The listener argument can also be omitted:
// remove all listeners for that event socket . off ( "my-event" ); // remove all listeners for all events socket . off (); socket.listeners(eventName) Inherited from the EventEmitter class .
Returns the array of listeners for the event named eventName.
socket . on ( "my-event" , () => { // ... }); console . log ( socket . listeners ( "my-event" )); // prints [ [Function] ] socket.onAny(callback) Added in v3.0.0
Register a new catch-all listener.
socket . onAny (( event , ... args ) => { console . log ( `got ${event}` ); }); socket.prependAny(callback) Added in v3.0.0
Register a new catch-all listener. The listener is added to the beginning of the listeners array.
socket . prependAny (( event , ... args ) => { console . log ( `got ${event}` ); }); socket.offAny([listener]) Added in v3.0.0
Removes the previously registered listener. If no listener is provided, all catch-all listeners are removed.
const myListener = () => { /* ... */ }; socket . onAny ( myListener ); // then, later socket . offAny ( myListener ); socket . offAny (); socket.listenersAny() Added in v3.0.0
Returns the list of registered catch-all listeners.
const listeners = socket . listenersAny (); socket.onAnyOutgoing(callback) Added in v4.5.0
Register a new catch-all listener for outgoing packets.
socket . onAnyOutgoing (( event , ... args ) => { console . log ( `got ${event}` ); }); socket.prependAnyOutgoing(callback) Added in v4.5.0
Register a new catch-all listener for outgoing packets. The listener is added to the beginning of the listeners array.
socket . prependAnyOutgoing (( event , ... args ) => { console . log ( `got ${event}` ); }); socket.offAnyOutgoing([listener]) Added in v4.5.0
Removes the previously registered listener. If no listener is provided, all catch-all listeners are removed.
const myListener = () => { /* ... */ }; socket . onAnyOutgoing ( myListener ); // remove a single listener socket . offAnyOutgoing ( myListener ); // remove all listeners socket . offAnyOutgoing (); socket.listenersAnyOutgoing() Added in v4.5.0
Returns the list of registered catch-all listeners for outgoing packets.
const listeners = socket . listenersAnyOutgoing (); socket.compress(value)
Sets a modifier for a subsequent event emission that the event data will only be compressed if the value is true. Defaults to true when you don’t call the method.
socket . compress ( false ). emit ( "an event" , { some : "data" }); socket.timeout(value) Added in v4.4.0
Sets a modifier for a subsequent event emission that the callback will be called with an error when the given number of milliseconds have elapsed without an acknowledgement from the server:
socket . timeout ( 5000 ). emit ( "my-event" , ( err ) => { if ( err ) { // the server did not acknowledge the event in the given delay } }); socket.disconnect() Added in v1.0.0
Manually disconnects the socket. In that case, the socket will not try to reconnect.
Associated disconnection reason:
client-side: "io client disconnect" server-side: "client namespace disconnect"
If this is the last active Socket instance of the Manager, the low-level connection will be closed.
socket.close() Added in v1.0.0
Synonym of socket.disconnect() .
Flag: ‘volatile’ Added in v3.0.0
Sets a modifier for the subsequent event emission indicating that the packet may be dropped if:
the socket is not connected the low-level transport is not writable (for example, when a POST request is already running in HTTP long-polling mode)
socket . volatile . emit ( /* ... */ ); // the server may or may not receive it Event: ‘connect’ Fired upon connection to the Namespace (including a successful reconnection).
socket . on ( "connect" , () => { // ... });
Please note that you shouldn’t register event handlers in the connect handler itself, as a new handler will be registered every time the Socket reconnects:
// BAD socket . on ( "connect" , () => { socket . on ( "data" , () => { /* ... */ }); }); // GOOD socket . on ( "connect" , () => { /* ... */ }); socket . on ( "data" , () => { /* ... */ }); Event: ‘disconnect’
reason details <DisconnectDetails>
Fired upon disconnection. The list of possible disconnection reasons:
Reason Description io server disconnectThe server has forcefully disconnected the socket with socket.disconnect() io client disconnectThe socket was manually disconnected using socket.disconnect() ping timeoutThe server did not send a PING within the pingInterval + pingTimeout range transport closeThe connection was closed (example: the user has lost connection, or the network was changed from WiFi to 4G) transport errorThe connection has encountered an error (example: the server was killed during a HTTP long-polling cycle)
In the first two cases (explicit disconnection), the client will not try to reconnect and you need to manually call socket.connect().
In all other cases, the client will wait for a small random delay and then try to reconnect:
socket . on ( "disconnect" , ( reason ) => { if ( reason === "io server disconnect" ) { // the disconnection was initiated by the server, you need to reconnect manually socket . connect (); } // else the socket will automatically try to reconnect }); Event: ‘connect_error’
connect_error
Fired when a namespace middleware error occurs.
socket . on ( "connect_error" , ( error ) => { // ... }); 
我的书签
添加书签
移除书签
