Socket.IO – API de serveur | Socket.IO – Monter un serveur MineCraft

Exposé par require ('socket.io').

nouveau serveur (httpServer[, options])

• httpServer (http.Server) le serveur à lier.
• options (Objet)

Fonctionne avec et sans Nouveau:

const io = exiger('socket.io') ();

const Serveur = exiger('socket.io')
const io = Nouveau Serveur();

Options disponibles:

Options disponibles pour le serveur Engine.IO sous-jacent:

Parmi ces options:

• le pingTimeout et pingInterval les paramètres auront un impact sur le délai avant qu'un client sache que le serveur n'est plus disponible. Par exemple, si la connexion TCP sous-jacente n’est pas correctement fermée en raison d’un problème de réseau, un client doit attendre jusqu’à pingTimeout + pingInterval ms avant d'obtenir un déconnecter un événement.

• L'ordre du les transports le tableau est important. Par défaut, une connexion d'interrogation longue est d'abord établie, puis mise à niveau vers WebSocket si possible. En utilisant ['websocket'] signifie qu'il n'y aura pas de solution de rechange si une connexion WebSocket ne peut pas être ouverte.

const serveur = exiger('http') .createServer ();

const io = exiger('socket.io') (serveur, 
        chemin: '/tester',
        serveClient: faux,
  
        pingInterval: 10000,
        pingTimeout: 5000,
        biscuit: faux
);

server.listen (3000)

nouveau serveur (port[, options])

• Port (Nombre) un port à écouter (un nouveau http.Server sera créé)
• options (Objet)

Voir ci-dessus pour la liste des disponibles options.

const io = exiger('socket.io') (3000
        chemin: '/tester',
        serveClient: faux,
  
        pingInterval: 10000,
        pingTimeout: 5000,
        biscuit: faux
);

nouveau serveur (options)

Voir ci-dessus pour la liste des disponibles options.

const io = exiger('socket.io') (
        chemin: '/tester',
        serveClient: faux,
);


const serveur = exiger('http') .createServer ();

io.attach (serveur, 
        pingInterval: 10000,
        pingTimeout: 5000,
        biscuit: faux
);

server.listen (3000)


io.attach (3000
        pingInterval: 10000,
        pingTimeout: 5000,
        biscuit: faux
);

serveur.sockets

Un alias pour la valeur par défaut (/) espace de noms.

io.sockets.emit ('salut', 'toutes les personnes')

io.of ('/').émettre('salut', 'toutes les personnes')

server.serveClient ([value])

• valeur (Booléen)
• Résultats Serveur | Booléen

Si valeur est vrai le serveur connecté (voir Serveur # attaché) servira les fichiers du client. Par défaut à vrai. Cette méthode n'a aucun effet après attacher est appelé. Si aucun argument n'est fourni, cette méthode retourne la valeur actuelle.

const io = exiger('socket.io') (http,  servirClient: faux );


const io = exiger('socket.io') ();
io.serveClient (faux)
io.attach (http);

server.path ([value])

• valeur (Chaîne)
• Résultats Serveur | Chaîne

Définit le chemin valeur sous lequel moteur.io et les fichiers statiques seront servis. Par défaut à /socket.io. Si aucun argument n'est fourni, cette méthode retourne la valeur actuelle.

const io = exiger('socket.io') ();
io.path ('/ myownpath')


const socket = io (
        chemin: '/ myownpath'
);

server.adapter ([value])

• valeur (Adaptateur)
• Résultats Serveur | Adaptateur

Définit l'adaptateur valeur. Par défaut, une instance de Adaptateur qui est livré avec socket.io qui est basé sur la mémoire. Voir socket.io-adaptateur. Si aucun argument n'est fourni, cette méthode retourne la valeur actuelle.

const io = exiger('socket.io') (3000)
const redis = exiger('socket.io-redis')
io.adapter (redis ( hôte: 'localhost', Port: 6379 ));

server.origins ([value])

• valeur (String | String[])
• Résultats Serveur | Chaîne

Définit les origines autorisées valeur. Par défaut, toutes les origines sont autorisées. Si aucun argument n'est fourni, cette méthode retourne la valeur actuelle.

io.origines ([[[["https://foo.example.com:443"])

server.origins (fn)

• fn (Une fonction)
• Résultats Serveur

Fournit une fonction prenant deux arguments origine: String et rappel (erreur, succès), où Succès est une valeur booléenne indiquant si l'origine est autorisée ou non. Si Succès est réglé sur faux, Erreur doit être fourni sous forme de valeur de chaîne qui sera ajoutée à la réponse du serveur, par ex. “Origine non autorisée”.

Inconvénients potentiels:

• dans certaines situations, lorsqu'il est impossible de déterminer origine il peut avoir valeur de *
• Comme cette fonction sera exécutée pour chaque requête, il est conseillé de la faire fonctionner le plus rapidement possible.
• Si socket.io est utilisé avec Express, les en-têtes CORS ne seront affectés que pour socket.io demandes. Pour Express, vous pouvez utiliser cors.

io.origines ((origine, rappel) => 
  si (origine! == 'https://foo.example.com') 
    revenir rappeler('origine non autorisée', faux)
        
        rappeler(nul, vrai)
);

server.attach (httpServer[, options])

• httpServer (http.Server) le serveur auquel s'attacher
• options (Objet)

Attache le Serveur à une instance de engine.io sur httpServer avec le fourni options (éventuellement).

server.attach (port[, options])

• Port (Nombre) le port pour écouter
• options (Objet)

Attache le Serveur à une instance de engine.io sur un nouveau http.Server avec le options (éventuellement).

server.listen (httpServer[, options])

Synonyme de server.attach (httpServer[, options]).

server.listen (port[, options])

Synonyme de server.attach (port[, options]).

server.bind (moteur)

• moteur (engine.Server)
• Résultats Serveur

Utilisation avancée uniquement. Lie le serveur à un moteur spécifique.io Serveur (ou API compatible) instance.

server.onconnection (socket)

• prise (engine.Socket)
• Résultats Serveur

Utilisation avancée uniquement. Crée un nouveau socket.io client depuis le engine.io entrant (ou une API compatible) Prise.

serveur.of (nsp)

• nsp (String | RegExp | Fonction)
• Résultats Espace de noms

Initialise et récupère le donné Espace de noms par son identifiant de chemin nsp. Si l'espace de nom a déjà été initialisé, il le renvoie immédiatement.

const adminNamespace = io.of ('/ admin')

Une expression régulière ou une fonction peut également être fournie, afin de créer un espace de nom de manière dynamique:

const dynamicNsp = io.of (/ ^  / dynamic-  d + $ /).sur('relier', (socket) => 
  const newNamespace = socket.nsp; 

  
        newNamespace.emit ('Bonjour')
);


const socket = io ('/ dynamic-101')


dynamicNsp.emit ('Bonjour')


dynamicNsp.use ((prise, prochaine) => );

Avec une fonction:

io.of ((nom, requête, suivant) => 
        suivant(nul, checkToken (query.token));
).sur('relier', (socket) => );

server.close ([callback])

Ferme le serveur socket.io. le rappeler l'argument est facultatif et sera appelé lorsque toutes les connexions seront fermées.

const Serveur = exiger('socket.io')
const PORT = 3030;
const serveur = exiger('http').Serveur();

const io = serveur (PORT);

io.close (); 

server.listen (PORT); 

io = serveur (serveur);

server.engine.generateId

Ecrase la méthode par défaut pour générer votre identifiant de socket personnalisé.

La fonction est appelée avec un objet de requête de noeud (http.IncomingMessage) comme premier paramètre.

io.engine.generateId = (req) => 
  revenir "custom: id:" + custom_id ++; 

Représente un pool de sockets connectés sous une étendue donnée identifiée par un chemin (par exemple: /bavarder).

Un client se connecte toujours à / (l’espace de noms principal), puis connectez-vous potentiellement à d’autres espaces de noms (tout en utilisant la même connexion sous-jacente).

Pour savoir comment et pourquoi, consultez: Pièces et espaces de noms.

namespace.name

La propriété d'identifiant d'espace de nom.

namespace.connected

Le hash de Prise objets connectés à cet espace de noms, indexés par identifiant.

namespace.adapter

le Adaptateur utilisé pour l'espace de noms. Utile lorsque vous utilisez le Adaptateur basé sur Redis, car il expose des méthodes pour gérer les sockets et les salles de votre cluster.

Remarque: l'adaptateur de l'espace de noms principal est accessible avec io.of ('/'). adaptateur.

namespace.to (room)

• pièce (Chaîne)
• Résultats Espace de noms pour chaîner

Définit un modificateur pour une émission d'événement ultérieure que l'événement sera uniquement diffusé aux clients qui ont rejoint le donné pièce.

Pour émettre dans plusieurs pièces, vous pouvez appeler à plusieurs fois.

const io = exiger('socket.io') ();
const adminNamespace = io.of ('/ admin')

adminNamespace.to ('niveau 1').émettre('un évènement' certains: 'Les données' );

namespace.in (room)

Synonyme de namespace.to (salle).

namespace.emit (eventName[, …args])

Émet un événement à tous les clients connectés. Les deux suivants sont équivalents:

const io = exiger('socket.io') ();
io.emit ('un événement envoyé à tous les clients connectés') 

const chat = io.of ('/bavarder')
chat.emit ('un événement envoyé à tous les clients connectés dans l'espace de noms de discussion')

Remarque: les accusés de réception ne sont pas pris en charge lors de l'émission à partir d'un espace de noms.

namespace.clients (rappel)

Obtient une liste d'ID de clients connectés à cet espace de noms (sur tous les nœuds, le cas échéant).

const io = exiger('socket.io') ();
io.of ('/bavarder') .clients ((erreur, clients) => 
  si (Erreur) jeter Erreur;
  console.log (clients); 
);

Un exemple pour obtenir tous les clients dans la chambre de l’espace de noms:

io.of ('/bavarder').dans('général') .clients ((erreur, clients) => 
  si (Erreur) jeter Erreur;
  console.log (clients); 
);

Comme pour la diffusion, tous les clients de l’espace de nom par défaut sont tous les clients:

io.clients ((erreur, clients) => 
  si (Erreur) jeter Erreur;
  console.log (clients); 
);

namespace.use (fn)

Enregistre un middleware, une fonction qui est exécutée pour chaque entrée Prise, et reçoit comme paramètres le socket et une fonction permettant de différer éventuellement l’exécution au prochain middleware enregistré.

Les erreurs transmises aux rappels de middleware sont envoyées comme spéciales Erreur paquets aux clients.

io.use ((prise, prochaine) => 
  si (socket.request.headers.cookie) revenir suivant();
        suivant(Nouveau Erreur('Erreur d'authentification'));
);

Evénement: 'connect'

• prise (Prise) connexion socket avec le client

Tiré sur une connexion du client.

io.on ('relier', (socket) => 
  
);

io.of ('/ admin').sur('relier', (socket) => 
  
);

Evénement: ‘connexion’

Synonyme d’événement: «connect».

Drapeau: «volatile»

Définit un modificateur pour une émission d'événement ultérieure selon laquelle les données d'événement peuvent être perdues si les clients ne sont pas prêts à recevoir des messages (en raison de la lenteur du réseau ou d'autres problèmes, ou du fait qu'ils sont connectés au cours d'une longue interrogation et qu'ils se trouvent au milieu d'une requête. cycle de réponse).

io.volatile.emit ('un évènement' certains: 'Les données' ); 

Drapeau: «binaire»

Spécifie s'il existe des données binaires dans les données émises. Augmente les performances lorsque spécifié. Peut être vrai ou faux.

io.binary (faux).émettre('un évènement' certains: 'Les données' );

Drapeau: «local»

Définit un modificateur pour une émission d'événement ultérieure selon laquelle les données d'événement seront uniquement diffuser au nœud actuel (lorsque l’adaptateur Redis est utilisé).

io.local.emit ('un évènement' certains: 'Les données' );

UNE Prise est la classe fondamentale pour interagir avec les clients du navigateur. UNE Prise appartient à un certain Espace de noms (par défaut /) et utilise un sous-jacent Client communiquer.

Il convient de noter le Prise ne se rapporte pas directement au TCP / IP sous-jacent réel prise et ce n'est que le nom de la classe.

Dans chaque Espace de noms, vous pouvez également définir des canaux arbitraires (appelés pièce) que le Prise peut rejoindre et partir. Cela fournit un moyen pratique de diffuser à un groupe de Prises (voir Socket # to au dessous de).

le Prise La classe hérite de EventEmitter. le Prise la classe annule la émettre méthode, et ne modifie aucune autre EventEmitter méthode. Toutes les méthodes documentées ici qui apparaissent également comme EventEmitter méthodes (en dehors de émettre) sont mis en œuvre par EventEmitteret documentation pour EventEmitter s'applique.

socket.id

Un identifiant unique pour la session, qui provient du sous-jacent Client.

socket.rooms

Un hachage de chaînes identifiant les salles dans lesquelles se trouve ce client, indexé par nom de salle.

io.on ('lien', (socket) => 
        socket.join ('chambre 237', () => 
    laisser chambres = Objet.keys (socket.rooms);
    console.log (chambres); 
        );
);

socket.client

Une référence au sous-jacent Client objet.

socket.conn

Une référence au sous-jacent Client connexion de transport (engine.io Prise objet). Cela permet d'accéder à la couche de transport d'E / S, qui reste (principalement) abstraite du socket TCP / IP réel.

socket.request

Un proxy getter qui renvoie la référence à la demande qui est à l'origine du moteur.io sous-jacent Client. Utile pour accéder aux en-têtes de requête tels que Biscuit ou Agent utilisateur.

prise de main

Les détails de la poignée de main:

        en-têtes:
        temps: ,
        adresse: ,
        xdomain:,
        sécurisé:
        Publié: ,
        URL:,
        question: 

Usage:

io.use ((prise, prochaine) => 
  laisser poignée de main = socket.handshake;
  
);

io.on ('lien', (socket) => 
  laisser poignée de main = socket.handshake;
  
);

socket.use (fn)

Enregistre un middleware, une fonction qui est exécutée pour chaque entrée Paquet et reçoit en paramètre le paquet et une fonction permettant de différer éventuellement l'exécution au middleware enregistré suivant.

Les erreurs passées aux rappels de middleware sont envoyées comme spéciales Erreur paquets aux clients.

io.on ('lien', (socket) => 
        socket.use ((paquet, ensuite) => 
    si (packet.doge === vrai) revenir suivant();
                suivant(Nouveau Erreur('Pas une erreur de chien'));
        );
);

socket.send ([…args][, ack])

• args
• ack (Une fonction)
• Résultats Prise

Envoie un message un événement. Voir socket.emit (eventName[, …args][, ack]).

socket.emit (eventName[, …args][, ack])

(annule EventEmitter.emit)

• Nom de l'événement (Chaîne)
• args
• ack (Une fonction)
• Résultats Prise

Emet un événement sur le socket identifié par le nom de la chaîne. Tout autre paramètre peut être inclus. Toutes les infrastructures de données sérialisables sont prises en charge, y compris Tampon.

socket.emit ('Bonjour', 'monde')
socket.emit ('avec-binaire', 1, '2' 3: '4', 5: Nouveau Tampon(6));

le ack L’argument est facultatif et sera appelé avec la réponse du client.

io.on ('lien', (socket) => 
        socket.emit ('un évènement' certains: 'Les données' );

        socket.emit ('furet', 'tobi', (data) => 
    console.log (données); 
        );

  
  
  
  

);

socket.on (eventName, rappel)

(hérité de EventEmitter)

• Nom de l'événement (Chaîne)
• rappeler (Une fonction)
• Résultats Prise

Enregistrez un nouveau gestionnaire pour l'événement donné.

socket.on ('nouvelles', (data) => 
  console.log (données);
);

socket.on ('nouvelles', (arg1, arg2, arg3) => 
  
);

socket.on ('nouvelles', (data, callback) => 
        rappeler(0)
);

socket.once (eventName, listener)

socket.removeListener (eventName, listener)

socket.removeAllListeners ([eventName])

socket.eventNames ()

Hérité de EventEmitter (avec d'autres méthodes non mentionnées ici). Voir la documentation de Node.js pour la événements module.

socket.join (room[, callback])

• pièce (Chaîne)
• rappeler (Une fonction)
• Résultats Prise pour chaîner

Ajoute le client au pièceet déclenche éventuellement un rappel avec se tromper signature (le cas échéant).

io.on ('lien', (socket) => 
        socket.join ('chambre 237', () => 
    laisser chambres = Objet.keys (socket.rooms);
    console.log (chambres); 
                io.to ('chambre 237').émettre("un nouvel utilisateur a rejoint la salle") 
        );
);

Les mécanismes de jonction des salles sont gérés par le Adaptateur qui a été configuré (voir Adaptateur # serveur ci-dessus), par défaut sur socket.io-adaptateur.

Pour votre commodité, chaque socket rejoint automatiquement une pièce identifiée par son identifiant (voir Socket # id). Cela facilite la diffusion de messages vers d'autres sockets:

io.on ('lien', (socket) => 
        socket.on ('dire à quelqu'un', (id, msg) => 
    
                socket.to (id) .emit ('mon message', msg);
        );
);

socket.join (chambres[, callback])

• pièces (Tableau)
• rappeler (Une fonction)
• Résultats Prise pour chaîner

Ajoute le client à la liste des salles et déclenche éventuellement un rappel avec se tromper signature (le cas échéant).

socket.leave (room[, callback])

• pièce (Chaîne)
• rappeler (Une fonction)
• Résultats Prise pour chaîner

Supprime le client de pièceet déclenche éventuellement un rappel avec se tromper signature (le cas échéant).

Les chambres sont laissées automatiquement lors de la déconnexion.

socket.to (salle)

• pièce (Chaîne)
• Résultats Prise pour chaîner

Définit un modificateur pour une émission d'événement ultérieure que l'événement sera uniquement diffusé aux clients qui ont rejoint le donné pièce (la prise elle-même étant exclue).

Pour émettre dans plusieurs pièces, vous pouvez appeler à plusieurs fois.

io.on ('lien', (socket) => 

  
        socket.to ('autres').émettre('un évènement' certains: 'Les données' );

  
        socket.to ('room1').à('room2').émettre('Bonjour')

  
        socket.to (). emit ('Hey')

  
  
);

Remarque: les accusés de réception ne sont pas pris en charge lors de la diffusion.

socket.in (salle)

Synonyme de socket.to (salle).

socket.compress (valeur)

• valeur (Booléen) si le paquet suivant sera compressé
• Résultats Prise pour chaîner

Définit un modificateur pour une émission d'événement ultérieure selon laquelle les données d'événement seront uniquement comprimé si la valeur est vrai. Par défaut à vrai lorsque vous n'appelez pas la méthode.

io.on ('lien', (socket) => 
        socket.compress (faux).émettre('non compressé', "c'est rugueux")
);

socket.disconnect (close)

• Fermer (Booléen) s'il faut fermer la connexion sous-jacente
• Résultats Prise

Déconnecte ce client. Si la valeur de fermeture est vrai, ferme la connexion sous-jacente. Sinon, il ne fait que déconnecter l'espace de noms.

io.on ('lien', (socket) => 
        setTimeout (() => socket.disconnect (vrai), 5000)
);

Drapeau: ‘broadcast’

Définit un modificateur pour une émission d'événement ultérieure selon laquelle les données d'événement seront uniquement diffuser à tous les sockets, mais l'expéditeur.

io.on ('lien', (socket) => 
        socket.broadcast.emit ('un évènement' certains: 'Les données' ); 
);

Drapeau: «volatile»

Définit un modificateur pour une émission d'événement ultérieure selon laquelle les données d'événement peuvent être perdues si le client n'est pas prêt à recevoir des messages (en raison de la lenteur du réseau ou d'autres problèmes, ou parce qu'ils sont connectés au cours d'une longue interrogation et qu'ils sont au milieu d'une demande. cycle de réponse).

io.on ('lien', (socket) => 
        socket.volatile.emit ('un évènement' certains: 'Les données' ); 
);

Drapeau: «binaire»

Spécifie s'il existe des données binaires dans les données émises. Augmente les performances lorsque spécifié. Peut être vrai ou faux.

var io = exiger('socket.io') ();
io.on ('lien', une fonction(prise)
        socket.binary (faux).émettre('un évènement' certains: 'Les données' ); 
);

Evénement: "déconnecter"

• raison (Chaîne) la raison de la déconnexion (côté client ou côté serveur)

Tiré lors de la déconnexion.

io.on ('lien', (socket) => 
        socket.on ('déconnecter', (raison) => 
    
        );
);

Raisons possibles:

Evénement: ‘erreur’

• Erreur (Objet) objet d'erreur

Déclenché lorsqu'une erreur survient.

io.on ('lien', (socket) => 
        socket.on ('Erreur', (erreur) => 
    
        );
);

Evénement: "déconnexion"

• raison (Chaîne) la raison de la déconnexion (côté client ou côté serveur)

Se déclenche lorsque le client va être déconnecté (mais n’a pas quitté son pièces encore).

io.on ('lien', (socket) => 
        socket.on ('déconnecter', (raison) => 
    laisser chambres = Objet.keys (socket.rooms);
    
        );
);

Ce sont des événements réservés (avec relier, nouveauListener et removeListener) qui ne peuvent pas être utilisés comme noms d’événements.

le Client La classe représente une connexion de transport entrant (engine.io). UNE Client peut être associé à de nombreux multiplexés Prises qui appartiennent à différents Espace de nomss.

client.conn

Une référence au sous-jacent moteur.io Prise lien.

client.request

Un proxy getter qui renvoie la référence à la demande qui est à l'origine de la connexion engine.io. Utile pour accéder aux en-têtes de requête tels que Biscuit ou Agent utilisateur.