socket.io
उपयोगकर्ताओं को socket.io के साथ संभालना

परिचय

उपयोगकर्ताओं को संभालने के लिए उदाहरण सर्वर साइड कोड

सबसे पहले यह ध्यान रखना महत्वपूर्ण है कि जब एक नया सॉकेट बनाया जाता है, तो उसे एक विशिष्ट आईडी दी जाती है जिसे socket.id द्वारा पुनः प्राप्त किया socket.id । इस id फिर एक के भीतर रखा जा सकता है user वस्तु है और हम इस तरह के एक उपयोगकर्ता नाम जो इस उदाहरण में इस्तेमाल किया गया है पुनः प्राप्त करने के रूप में एक पहचानकर्ता असाइन कर सकते हैं user वस्तुओं।

/**
 * Created by Liam Read on 27/04/2017.
 */

var express = require('express');
var app = express();
var http = require('http').Server(app);
var io = require('socket.io')(http);


function User(socketId) {

    this.id = socketId;
    this.status = "online";
    this.username = "bob";

    this.getId = function () {
        return this.id;
    };

    this.getName = function () {
        return this.username;
    };

    this.getStatus = function () {
        return this.status;
    };

    this.setStatus = function (newStatus) {
        this.status = newStatus;
    }
}

var userMap = new Map();

/**
 * Once a connection has been opened this will be called.
 */
io.on('connection', function (socket) {

    var user;

    /**
     * When a user has entered there username and password we create a new entry within the userMap.
     */
    socket.on('registerUser', function (data) {

        userMap.set(data.name, new User(socket.id));

        //Lets make the user object available to all other methods to make our code DRY.
        user = userMap.get(data.name);
    });

    socket.on('loginUser', function (data) {
        if (userMap.has(data.name)) {
            //user has been found

            user = userMap.get(data.name);
        } else {
            //Let the client know that no account was found when attempting to sign in.
            socket.emit('noAccountFound', {
                msg: "No account was found"
            });
        }
    });

    socket.on('disconnect', function () {
        //Let's set this users status to offline.
        user.setStatus("offline");
    });

    /**
     * Dummy server event that represents a client looking to send a message to another user.
     */
    socket.on('sendAnotherUserAMessage', function (data) {

        //Make note here that by checking to see if the user exists within the map we can be sure that when
        // retrieving the value after && that we won't have any unexpected errors.
        if (userMap.has(data.name) && userMap.get(data.name).getStatus() !== "offline") {
            var OtherUser = userMap.get(data.name);
        } else {
            //We use a return here so further code isn't executed, you could replace this with some for of
            //error handling or a different event back to the user.
            return;
        }

        //Lets send our message to the user.
        io.to(OtherUser.getId()).emit('recMessage', {
            msg: "Nice code!"
        })
});


});

यह किसी भी तरह से संभव के करीब का एक पूर्ण उदाहरण नहीं है, लेकिन users को संभालने के लिए एक दृष्टिकोण की बुनियादी समझ देनी चाहिए।

उपयोगकर्ता आईडी द्वारा संदेशों का उत्सर्जन करने का सरल तरीका

सर्वर पर:

var express = require('express');
var socketio = require('socket.io');

var app = express();
var server = http.createServer(app);
var io = socketio(server);

io.on('connect', function (socket) {
  socket.on('userConnected', socket.join);
  socket.on('userDisconnected', socket.leave);
});

function message (userId, event, data) {
  io.sockets.to(userId).emit(event, data);
}

ग्राहक पर:

var socket = io('http://localhost:9000');  // Server endpoint

socket.on('connect', connectUser);

socket.on('message', function (data) {
  console.log(data);
});

function connectUser () {  // Called whenever a user signs in
  var userId = ...  // Retrieve userId
  if (!userId) return;
  socket.emit('userConnected', userId);
}

function disconnectUser () {  // Called whenever a user signs out
  var userId = ...  // Retrieve userId
  if (!userId) return;
  socket.emit('userDisconnected', userId);
}

यह विधि विशिष्ट उपयोगकर्ताओं को सर्वर पर सभी सॉकेट के संदर्भ के बिना अद्वितीय आईडी द्वारा संदेश भेजने की अनुमति देती है।

मोडलिंग एक्सेस करने वाले उपयोगकर्ताओं को संभालना

यह उदाहरण दिखाता है कि आप 1-1 आधार पर उपयोगकर्ताओं से बातचीत कैसे कर सकते हैं।

//client side
function modals(socket) {

    this.sendModalOpen = (modalIdentifier) => {

        socket.emit('openedModal', {
            modal: modalIdentifier
        });
    };

    this.closeModal = () => {
        socket.emit('closedModal', {
            modal: modalIdentifier
        });
    };

}


socket.on('recModalInfo', (data) => {
    for (let x = 0; x < data.info.length; x++) {
        console.log(data.info[x][0] + " has open " + data.info[x][1]);
    }
});

//server side
let modal = new Map();

io.on('connection', (socket) => {

    //Here we are sending any new connections a list of all current modals being viewed with Identifiers.
    //You could send all of the items inside the map() using map.entries

    let currentInfo = [];

    modal.forEach((value, key) => {
        currentInfo.push([key, value]);
    });

    socket.emit('recModalInfo', {
        info: currentInfo
    });

    socket.on('openedModal', (data) => {
        modal.set(socket.id, data.modalIdentifier);
    });

    socket.on('closedModal', (data) => {
        modal.delete(socket.id);
    });

});

यहां सभी आधुनिक इंटरैक्शन को संभालने से, सभी नए जुड़े उपयोगकर्ताओं के पास सभी जानकारी होगी जिनके बारे में वर्तमान में देखा जा रहा है, हमें अपने सिस्टम के भीतर वर्तमान उपयोगकर्ताओं के आधार पर निर्णय लेने की अनुमति देता है।