node.js realtime framework server
npm install @enounca/socket.io
!NPM version
!Downloads

The following example attaches socket.io to a plain Node.JS
HTTP server listening on port 3000.
``js`
var server = require('http').createServer();
var io = require('socket.io')(server);
io.on('connection', function(socket){
socket.on('event', function(data){});
socket.on('disconnect', function(){});
});
server.listen(3000);
`js`
var io = require('socket.io')();
io.on('connection', function(socket){});
io.listen(3000);
Starting with 3.0, express applications have become request handler
functions that you pass to http or http Server instances. You needServer
to pass the to socket.io, and not the express application
function.
`js`
var app = require('express')();
var server = require('http').createServer(app);
var io = require('socket.io')(server);
io.on('connection', function(){ / … / });
server.listen(3000);
Like Express.JS, Koa works by exposing an application as a request
handler function, but only by calling the callback method.
`js`
var app = require('koa')();
var server = require('http').createServer(app.callback());
var io = require('socket.io')(server);
io.on('connection', function(){ / … / });
server.listen(3000);
Exposed by require('socket.io').
Creates a new Server. Works with and without new:
`js`
var io = require('socket.io')();
// or
var Server = require('socket.io');
var io = new Server();
Optionally, the first or second argument (see below) of the Server
constructor can be an options object.
The following options are supported:
- serveClient sets the value for Server#serveClient()path
- sets the value for Server#path()
The same options passed to socket.io are always passed to
the engine.io Server that gets created. See engine.io
options
as reference.
Creates a new Server and attaches it to the given srv. Optionallyopts
can be passed.
Binds socket.io to a new http.Server that listens on port.
If v is true the attached server (see Server#attach) will servetrue
the client files. Defaults to .
This method has no effect after attach is called.
`jsserveClient
// pass a server and the option
var io = require('socket.io')(http, { serveClient: false });
// or pass no server and then you can call the method
var io = require('socket.io')();
io.serveClient(false);
io.attach(http);
`
If no arguments are supplied this method returns the current value.
Sets the path v under which engine.io and the static files will be/socket.io
served. Defaults to .
If no arguments are supplied this method returns the current value.
Sets the adapter v. Defaults to an instance of the Adapter that
ships with socket.io which is memory based. See
socket.io-adapter.
If no arguments are supplied this method returns the current value.
Sets the allowed origins v. Defaults to any origins being allowed.
If no arguments are supplied this method returns the current value.
Sets the allowed origins as dynamic function. Function takes two arguments origin:String and callback(error, success), where success is a boolean value indicating whether origin is allowed or not.
__Potential drawbacks__:
in some situations, when it is not possible to determine origin it may have value of socket.io
* As this function will be executed for every request, it is advised to make this function work as fast as possible
* If is used together with Express, the CORS headers will be affected only for socket.io requests. For Express can use cors
The default (/) namespace.
Attaches the Server to an engine.io instance on srv with theopts
supplied (optionally).
Attaches the Server to an engine.io instance that is bound to portopts
with the given (optionally).
Synonym of Server#attach.
Advanced use only. Binds the server to a specific engine.io Server
(or compatible API) instance.
Advanced use only. Creates a new socket.io client from the incomingsocket
engine.io (or compatible API) .
Initializes and retrieves the given Namespace by its pathnamensp
identifier .
If the namespace was already initialized it returns it right away.
Emits an event to all connected clients. The following two are
equivalent:
`js`
var io = require('socket.io')();
io.sockets.emit('an event sent to all connected clients');
io.emit('an event sent to all connected clients');
For other available methods, see Namespace below.
Closes socket server
`js
var Server = require('socket.io');
var PORT = 3030;
var server = require('http').Server();
var io = Server(PORT);
io.close(); // Close current server
server.listen(PORT); // PORT is free to use
io = Server(server);
`
See Namespace#use below.
Represents a pool of sockets connected under a given scope identified
by a pathname (eg: /chat).
By default the client always connects to /.
#### Events
- connection / connect. Fired upon a connection.
Parameters:
- Socket the incoming socket.
The namespace identifier property.
Hash of Socket objects that are connected to this namespace indexedid
by .
Gets a list of client IDs connected to this namespace (across all nodes if applicable).
An example to get all clients in a namespace:
`js`
var io = require('socket.io')();
io.of('/chat').clients(function(error, clients){
if (error) throw error;
console.log(clients); // => [PZDoMHjiu8PYfRiKAAAF, Anw2LatarvGVVXEIAAAD]
});
An example to get all clients in namespace's room:
`js`
var io = require('socket.io')();
io.of('/chat').in('general').clients(function(error, clients){
if (error) throw error;
console.log(clients); // => [Anw2LatarvGVVXEIAAAD]
});
As with broadcasting, the default is all clients from the default namespace ('/'):
`js`
var io = require('socket.io')();
io.clients(function(error, clients){
if (error) throw error;
console.log(clients); // => [6em3d4TJP8Et9EMNAAAA, G5p55dHhGgUnLUctAAAB]
});
Registers a middleware, which is a function that gets executed for
every incoming Socket and receives as parameter the socket and a
function to optionally defer execution to the next registered
middleware.
`js`
var io = require('socket.io')();
io.use(function(socket, next){
if (socket.request.headers.cookie) return next();
next(new Error('Authentication error'));
});
Errors passed to middleware callbacks are sent as special error
packets to clients.
A Socket is the fundamental class for interacting with browserSocket
clients. A belongs to a certain Namespace (by default /)Client
and uses an underlying to communicate.
A list of strings identifying the rooms this socket is in.
A reference to the underlying Client object.
A reference to the underlying Client transport connection (engine.ioSocket
object).
A getter proxy that returns the reference to the request thatClient
originated the underlying engine.io . Useful for accessingCookie
request headers such as or User-Agent.
A unique identifier for the socket session, that comes from the
underlying Client.
Emits an event to the socket identified by the string name. Any
other parameters can be included.
All datastructures are supported, including Buffer. JavaScript
functions can't be serialized/deserialized.
`js`
var io = require('socket.io')();
io.on('connection', function(socket){
socket.emit('an event', { some: 'data' });
});
Adds the socket to the room, and fires optionally a callback fnerr
with signature (if any).
The socket is automatically a member of a room identified with its
session id (see Socket#id).
The mechanics of joining rooms are handled by the AdapterServer#adapter
that has been configured (see above), defaulting to
socket.io-adapter.
Removes the socket from room, and fires optionally a callback fnerr
with signature (if any).
Rooms are left automatically upon disconnection.
The mechanics of leaving rooms are handled by the AdapterServer#adapter
that has been configured (see above), defaulting to
socket.io-adapter.
Sets a modifier for a subsequent event emission that the event will
only be _broadcasted_ to sockets that have joined the given room.
To emit to multiple rooms, you can call to several times.
`js`
var io = require('socket.io')();
io.on('connection', function(socket){
socket.to('others').emit('an event', { some: 'data' });
});
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.
`js`
var io = require('socket.io')();
io.on('connection', function(socket){
socket.compress(false).emit('an event', { some: 'data' });
});
The Client class represents an incoming transport (engine.io)Client
connection. A can be associated with many multiplexed SocketNamespace
that belong to different s.
A reference to the underlying engine.io Socket connection.
A getter proxy that returns the reference to the request thatCookie
originated the engine.io connection. Useful for accessing
request headers such as or User-Agent.
Socket.IO is powered by debug.
In order to see all the debug output, run your app with the environment variable
DEBUG including the desired scope.
To see the output from all of Socket.IO's debugging scopes you can use:
```
DEBUG=socket.io* node myapp
MIT