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);

js
var app = require('express')();
var server = require('http').createServer(app);
var io = require('socket.io')(server);
io.on('connection', function(){ /* … */ });
server.listen(3000);

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();
```

Creates a new `Server` and attaches it to the given `srv`. Optionally
`opts` 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 serve
the client files. Defaults to `true`.

This method has no effect after `attach` is called.

```js
// pass a server and the `serveClient` 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
served. Defaults to `/socket.io`.

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](https://github.com/socketio/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.

The default (`/`) namespace.

Attaches the `Server` to an engine.io instance on `srv` with the
supplied `opts` (optionally).

Attaches the `Server` to an engine.io instance that is bound to `port`
with the given `opts` (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 incoming
engine.io (or compatible API) `socket`.

Initializes and retrieves the given `Namespace` by its pathname
identifier `nsp`.

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 `/`.

The namespace identifier property.

Hash of `Socket` objects that are connected to this namespace indexed
by `id`.

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 browser
clients. A `Socket` belongs to a certain `Namespace` (by default `/`)
and uses an underlying `Client` to communicate.

A hash of strings identifying the rooms this socket is in, indexed by
room name.

A reference to the underlying `Client` object.

A reference to the underlying `Client` transport connection (engine.io
`Socket` object).

A getter proxy that returns the reference to the `request` that
originated the underlying engine.io `Client`. Useful for accessing
request headers such as `Cookie` 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 `fn`
with `err` 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 `Adapter`
that has been configured (see `Server#adapter` above), defaulting to
[socket.io-adapter](https://github.com/socketio/socket.io-adapter).

Removes the socket from `room`, and fires optionally a callback `fn`
with `err` signature (if any).

**Rooms are left automatically upon disconnection**.

The mechanics of leaving rooms are handled by the `Adapter`
that has been configured (see `Server#adapter` above), defaulting to
[socket.io-adapter](https://github.com/socketio/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' });
});
```

Same as `Socket#to`

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)
connection. A `Client` can be associated with many multiplexed `Socket`
that belong to different `Namespace`s.

A reference to the underlying `engine.io` `Socket` connection.

A getter proxy that returns the reference to the `request` that
originated the engine.io connection. Useful for accessing
request headers such as `Cookie` or `User-Agent`.

DEBUG=socket.io* node myapp