Introducción a Node.js, parte 11: Crear un chat con socket.io

Realizar un chat con Html y Javascript parece una tarea sencilla mirándolo desde lejos, sin embargo, no lo es. Un chat tiene cierta complejidad. Pensemos en cómo hacer uno, éste debería estar dividido en dos partes, por un lado tendremos la acción de enviar un mensaje al servidor, para que otros usuarios lo lean. Esto no debería ocasionarnos problemas, porque para lograrlo simplemente podemos utilizar una tecnología como Ajax, para enviar un mensaje al servidor. Sin embargo, la otra parte de un chat sí que no es tan simple: el recibir los mensajes.

Una petición ajax primero se comunica con el servidor, y luego espera una respuesta de éste. Pero a la hora de recibir los mensajes, debemos hacer lo inverso, el servidor debe enviarle un mensaje al cliente. Esto, no es fácil de conseguir en una aplicación Javascript y un lenguaje de servidor como PHP. También podemos simularlo, podemos enviar en un intervalos de tiempo, una petición al servidor, preguntando si hay nuevos mensajes, y así completar la segunda parte de nuestro chat.

Sin embargo Node.js trae consigo algo llamado socket.io, que nos permitirá no sólo enviar datos del cliente al servidor, sino también del servidor al cliente. Esto es lo que se conoce como Ajax Bidireccional o aplicación en tiempo real, y de alguna manera viene a darle una nueva cara al futuro de la web. No más, apretar F5 para recargar ver actualizada la página. Pero tampoco intervalos de tiempo que nos muestren las actualizaciones. De ahora en adelante, el servidor podrá comunicarse con el navegador en tiempo real, en forma casi instantánea. Pero lo más llamativo es que todo esto que hablamos Node lo hace demasiado fácil

En esta publicación veremos cómo hacer un chat básico, en donde varios usuarios podrán enviar mensajes, y estos llegarán al resto de forma inmediata. El proceso será muy simple, un cliente envía un mensaje al servidor, el servidor procesará este mensaje y lo enviará al resto de los clientes, como si se tratará de un tubo, como si el servidor fuese un puente que conecte a los clientes.

En primer lugar vamos a crear un nuevo proyecto, yo lo haré con Express, pero vale aclarar que socket.io trabaja en forma independiente a cualquier framework, así que si querés hacerlo de otro modo que no sea con Express, adelante.

Vamos a repetir el proceso que hicimos en Introducción a Node.js, parte 7: Instalar Express, creamos una nueva carpeta dentro de nodejs, a la cual yo llamaré “mi_primer_chat”. Luego entramos en ésta:

cd C:\Program Files\nodejs\mi_primer_chat

E instalamos Express:

express

¡¡¡ALTO AHÍ!!! Aun no instales las dependencias. Antes vamos a editar nuestro archivo package.json, vamos a buscar la línea con nuestras dependencias:

"dependencies": {
  "express": "3.4.7",
  "jade": "*"
}

Y vamos a agregar una nueva dependencia, que será justamente socket.io. Así que reemplazamos esto último por:

"dependencies": {
  "express": "3.4.7",
  "jade": "*",
  "socket.io":"*"
}

Guardamos ese archivo y ahora ya podemos volver a la consola e instalar las dependencias, dentro de nuestro proyecto:

npm install

Una vez que el proceso finalice ya podemos comenzar por crear las primeras líneas de nuestro proyecto.

En primer lugar vamos a hacer algunos cambios y vamos a crear un par de archivos. Primero vamos a public -> javascripts y aquí guardamos alguna librería de Jquery, yo usaré la 1.10.2

https://code.jquery.com/jquery-1.10.2.min.js

Esto no es obligatorio, pero así como Express nos facilitará el trabajo en el servidor, Jquery hará lo propio en el navegador.

También vamos a crear un archivo al que yo llamaré: chat_cliente.js. Este archivo será el encargado de todas las acciones en el navegador. Por el momento vamos a dejar este archivo en blanco.

También voy a crear una vista yendo a la carpeta views, a este archivo le pondré de nombre chat.jade, y por el momento lo editaré con el siguiente código:

extends layout
block content
  h1 Chat
  div#mensajes
  script(type="text/javascript", src="/javascripts/chat_cliente.js")

Con este archivo comenzaremos haciendo una prueba de la funcionalidad de socket.io, así que dentro de ese div vacío, mostraremos los mensajes que envíe el servidor. Y también importamos el Javascript que editaremos a continuación.

Ahora sólo nos falta agregar la librería de Jquery, y otro archivo Javascript que explicaré a continuación. Así que abrimos el archivo layout.jade y lo modificamos con el siguiente código:

doctype
html
  head
    title Chat con Node.js
    link(rel='stylesheet', href='/stylesheets/style.css')
    script(type="text/javascript", src="/javascripts/jquery-1.10.2.min.js")
    script(type="text/javascript", src="/socket.io/socket.io.js")
  body
    block content

Aquí agregamos la librería de Jquery, nada nuevo. Pero también incluimos la librería de socket.io, que será la que nos permitirá escuchar los mensajes que el servidor envía al cliente. Ese archivo socket.io.js, no hay que descargarlo ni nada, ya que la aplicación se encargará de eso por nosotros.

Ahora vamos a ir dentro de la carpeta routes y vamos a crear un nuevo archivo al que yo llamaré chat_servidor.js. Vamos a dejarlo vacío.

Importante: Estos archivos, chat_cliente.js y chat_servidor.js, serán los encargados de comunicar el navegador con el servidor. chat_cliente.js enviará información a chat_servidor.js, y a su vez el primero tendrá funcionalidades de escucha a lo que el segundo envíe. Será una comunicación bidireccional.

Y finalmente vamos a abrir nuestro archivo app.js y vamos a editar algunas líneas.

En primer lugar vamos a incluir el módulo de chat_servidor.js:

var chat = require('./routes/chat_servidor');

También vamos a agregar una nueva acción para mostrar chat.jade:

app.get('/chat', function(res, res){
   res.render('chat');
});

Además para iniciar socket.io necesitamos un objeto del servidor al recibir una nueva petición. Así que vamos a modificar:

http.createServer(app).listen(app.get('port'), function(){
   console.log('Express server listening on port ' + app.get('port'));
});

Por:

var server = http.createServer(app).listen(app.get('port'), function(){
   console.log('Express server listening on port ' + app.get('port'));
});

Y abajo agregamos la siguiente línea:

chat.iniciar(server);

Esto último va a dar error, porque claro el módulo chat_servidor, no tiene una función iniciar(), pero será la que creemos a continuación:

Así que vamos a routes -> chat_servidor.js y vamos a editarlo con las siguientes líneas:

var io;
exports.iniciar = function(http){
   io = require('socket.io').listen(http);
   io.sockets.on('connection', function(socket){
      //Este evento se disparará cada vez que un nuevo usuario se conecte.
   });
}

Con esto ya es suficiente para tener creado nuestro objeto socket.io, el cual nos permitirá escuchar y enviar mensajes al cliente.

Este objeto io, tendrá un evento ‘connection’, el cual se ejecutará cada vez que un usuario se conecte, y asignará un objeto socket, una comunicación para ese cliente.

Vamos a probarlo modificando el código de esta forma:

var io;
exports.iniciar = function(http){
   io = require('socket.io').listen(http);
   io.sockets.on('connection', function(socket){
      socket.emit('mensaje', {text: 'Bienvenido.'});
      socket.broadcast.emit('mensaje', {text: 'Un nuevo usuario se ha conectado.'});
      socket.on('disconnect', function(){
         socket.broadcast.emit('mensaje', {text: 'Un usuario se ha desconectado.'});
      });
   });
}

Bien, aquí una vez que el evento ‘connection’ se dispare sucederán dos cosas:

El evento emit() permite enviar un mensaje al usuario que acaba de conectarse.

socket.emit('mensaje', {text: 'Bienvenido.'});

Pero si lo que en cambio queremos es enviar un mensaje a los demás usuarios debemos usar broadcast.emit():

socket.broadcast.emit('mensaje', {text: 'Un nuevo usuario se ha conectado.'});

Además asignaremos al socket un segundo evento, que es ‘disconnect’, el cual se disparará cuando el usuario se desconecte. En este caso avisamos a los demás usuarios que el usuario se ha desconectado:

socket.on('disconnect', function(){
   socket.broadcast.emit('mensaje', {text: 'Un usuario se ha desconectado.'});
});

Ahora sólo nos resta editar el javascript del cliente, y así asignar un evento que escuchará los mensajes que envíe el servidor. Así que vamos a public -> javascripts -> chat_cliente.js y lo editamos con el siguiente código:

var socket = io.connect('https://localhost:3000');
//Mensaje de bienvenida.
socket.on('mensaje', function(data){
   $("#mensajes").append('<p> ' + data.text + ' </p>');
});

En primer lugar creamos un objeto io, pero del lado del cliente:

var socket = io.connect('https://localhost:3000');

Y ahora sí, asignamos un evento, que debe coincidir con el del servidor. En este caso, el evento ‘mensaje’:

socket.on('mensaje', function(data){
   $("#mensajes").append('<p> ' + data.text + ' </p>');
});

De este modo cada vez que el servidor envíe un mensaje al cliente, se va a disparar una acción, que en nuestro caso va a mostrar el mensaje dentro del div con el id “mensajes”.

Podemos probar esto abriendo dos navegadores

Primero el cliente 1 se conecta y le muestra el mensaje de bienvenida.

Luego el cliente 2 se conecta, y también le aparece el mismo mensaje, pero también al cliente 1 le avisa que un nuevo usuario se ha conectado.

Finalmente el cliente 2 se desconecta, y al cliente 1 le avisa que un usuario se ha desconectado.

El proceso es muy simple, tanto el el cliente como el servidor pueden enviar mensajes al otro:

socket.emit('evento', data);

Y también ambos escucharán eventos:

socket.on('evento', function(data){
        //Acción del evento.
});

Para que el evento funcione correctamente, su nombre debe coincidir con la otra parte. Así del cliente al servidor, como del servidor al cliente.

 

Creando nuestro chat

Ahora que ya conocemos cómo trabajar con socket.io, podemos continuar haciendo un chat.

Primero vamos a modificar nuestra vista, así que vamos a views -> chat.jade y editamos nuevamente este archivo con el siguiente código:

extends layout
block content
  h1 Chat
  div#caja1
    form#form_nick(action="javascript:void(0);")
      input#nick(type="text", size="50")
      input(type="submit", value="Ingresar nick")
    div#mensajes
    form#form_mensaje(action="javascript:void(0);")
      input#mensaje(type="text", size="50")
      input(type="submit", value="Enviar mensaje")
  div#caja2
    h2 Conectados
    ul#usuarios
  script(type="text/javascript", src="/javascripts/chat_cliente.js")

En primer lugar vamos dividir nuestra vista en dos columnas. En la primera tendremos el formulario para ingresar el nick del visitante, el cual quedará invisible una vez que se registre al usuario. Luego en ésta, se harán visibles un contenedor con los mensajes del chat y el formulario para ingresar los mensajes en el chat.

En la segunda columna veremos la lista de los usuarios conectados.

Ahora vamos darle estilo con css, así que abrimos en archivo style.css, en public -> stylesheets -> style.css y agregamos debajo de todo el siguiente código:

#caja1 {
   float: left;
   width: 500px;
   height: 400px;
   border: solid 1px #000;
   margin-right: 15px;
}
#mensajes, #form_mensaje {
   display: none; 
}
#mensajes {
   width: 100%;
   height: 90%;
   margin-bottom: 5px;
   border-bottom: solid 1px #000;
   overflow-y: scroll;
}
#mensajes p {
   margin-left: 5px;
}
#caja2 {
   float: left;
   width: 200px;
   height: 400px;
   border: solid 1px #000;
   text-align: center;
   overflow-y: scroll;
}
#usuarios {
   margin: 0px;
   padding: 0px;
}

Continuamos yendo a ir a routes -> chat_servidor.js y a public -> javascripts -> chat_cliente.js y vamos a borrar el código de ambos, para comenzar de nuevo.

Servidor

En primer lugar vamos a editar el código de chat_servidor.js de la siguiente forma:

var nicks = new Array();
var io;
exports.iniciar = function(http){
   io = require('socket.io').listen(http);
   io.sockets.on('connection', function(socket){
      usuarios(socket);
      nick(socket);
      mensaje(socket);
      usuario_desconectado(socket); 
   });
}
function usuarios(socket){
   socket.emit('usuarios', {nicks: nicks});
   socket.broadcast.emit('usuarios', {nicks: nicks});
}
function nick(socket){
   socket.on('nick', function(data){
     var nick = data.nick;
     if(nicks.indexOf(nick) == -1){
        nicks.push(nick);
        socket.nick = nick;
        socket.emit('nick', {correcto: true, nick: nick});
        socket.broadcast.emit('nuevo_usuario', {nick: nick});
        usuarios(socket);
     }else{
        socket.emit('nick', {correcto: false, nick: nick});
     }
   })
}
function mensaje(socket){
   socket.on('mensaje', function(data){
      if(socket.nick){
         var mensaje = data.mensaje;
         var nick = socket.nick;
         socket.broadcast.emit('mensaje', {mensaje: mensaje, nick: nick});
      }
   });
}
function usuario_desconectado(socket){
   socket.on('disconnect', function(){
      if(socket.nick){
         nicks.splice(nicks.indexOf(socket.nick), 1);
         socket.broadcast.emit('disconnect', {nick: socket.nick});
         usuarios(socket);
      }
   });
}

Este será el código del servidor que nos permitirá escuchar eventos y enviar mensajes al cliente. Vamos a analizar el código:

Primero creamos dos variables para guardar todos los nicks de los usuarios del chat:

var nicks = new Array();

También creamos una variable para luego guardar el objeto io, como hicimos antes:

var io;

Y finalmente creamos la función principal del módulo donde se iniciará el objeto io, y le asignaremos el evento ‘connection’, el cual como dijimos antes, se disparará cuando un nuevo usuario ingrese al chat. Aquí llamaremos a cuatro funciones, las cuales se encargarán de toda la funcionalidad de nuestro chat:

io = require('socket.io').listen(http);
io.sockets.on('connection', function(socket){
   usuarios(socket);
   nick(socket);
   mensaje(socket);
   usuario_desconectado(socket); 
});

Lista de usuarios

La función usuarios() nos devolverá la lista de los usuarios conectados en ese momento, con sus nicks. Mediante los métodos .emit() y .broadcast.emit(), enviará esta información tanto al usuario, como al resto:

function usuarios(socket){
   socket.emit('usuarios', {nicks: nicks});
   socket.broadcast.emit('usuarios', {nicks: nicks});
}

Registrar nick

El usuario antes de entrar a la sala de chat deberá registrar un nick que cumpla una condición: no le pertenezca a otro usuario conectado:

function nick(socket){
   socket.on('nick', function(data){
     var nick = data.nick;
     if(nicks.indexOf(nick) == -1){
        nicks.push(nick);
        socket.nick = nick;
        socket.emit('nick', {correcto: true, nick: nick});
        socket.broadcast.emit('nuevo_usuario', {nick: nick});
        usuarios(socket);
     }else{
        socket.emit('nick', {correcto: false, nick: nick});
     }
   })
}

En primer lugar asignamos un evento llamado ‘nick’, que estará escuchando el envío desde el cliente (código que veremos más abajo) Va a recuperar un objeto enviado por el usuario, que tendrá una propiedad .nick, donde se guardará el nombre que eligió el usuario.

var nick = data.nick;

Luego, mediante el método .indexOf(), vamos a buscar ese nick en la lista almacenada. Este método, por si no lo conocés, recibirá como parámetro un valor, lo buscará en el array, y de encontrarlo nos devolverá la posición donde se encuentra, pero si no existe, nos devolverá -1. Por tanto si nos devuelve ese valor, -1, significa que ese nick puede usarse.

De estar permitido el nick, se va a guardar en la lista de nicks, y se le asignará al socket del visitante una propiedad .nick, con el valor del mismo:

nicks.push(nick);
socket.nick = nick;

También se enviará un mensaje al usuario un objeto para indicarle que el nick es correcto, y también el valor del mismo:

socket.emit('nick', {correcto: true, nick: nick});

Y también se enviará un mensaje al resto de los usuarios conectados, con el nick del nuevo usuario acaba de registrar su nick:

socket.broadcast.emit('nuevo_usuario', {nick: nick});

Finalmente volveremos a cargar la lista actualizada con los usuarios conectados:

usuarios(socket);

Mensajes nuevos

Mediante un evento al que llamamos ‘mensaje’, el servidor estará esperando la llegada de un nuevo mensaje:

function mensaje(socket){
   socket.on('mensaje', function(data){
      if(socket.nick){
         var mensaje = data.mensaje;
         var nick = socket.nick;
         socket.broadcast.emit('mensaje', {mensaje: mensaje, nick: nick});
      }
   });
}

Guardaremos el mensaje y el nick del usuario que lo ha mandando, y lo enviaremos  al resto de los usuarios:

var mensaje = data.mensaje;
var nick = socket.nick;
socket.broadcast.emit('mensaje', {mensaje: mensaje, nick: nick});

Usuario desconectado

También tendremos el evento que usamos antes, ‘disconnect’, el cual nos permitirá disparar una acción cada vez que un usuario se desconecta:

function usuario_desconectado(socket){
   socket.on('disconnect', function(){
      if(socket.nick){
         nicks.splice(nicks.indexOf(socket.nick), 1);
         socket.broadcast.emit('disconnect', {nick: socket.nick});
         usuarios(socket);
      }
   });
}

Eliminamos el nick de la lista:

nicks.splice(nicks.indexOf(socket.nick), 1);

Enviamos el mensaje a los usuarios con el nick:

socket.broadcast.emit('disconnect', {nick: socket.nick});

Y nuevamente actualizamos la lista de usuarios.

usuarios(socket);

 

Cliente

Ahora vamos a editar el código del cliente, el cual será el encargado de enviar peticiones al servidor, y también tendrá eventos que van a escuchar todo el tiempo los datos enviados desde el servidor al navegador. Así que vamos a nuestro archivo chat_cliente.js.

var socket = io.connect('https://localhost:3000');
//Recibe los usuarios conectados.
socket.on('usuarios', function(data){
   var nicks = data.nicks;
   $("#usuarios").html('');
   for(var i = 0; i < nicks.length; i++){
      $("#usuarios").append('<li>' + nicks[i] + '</li>');
   }
});
//Envía el nick para registrarse en el chat.
$("#form_nick [type='submit']").click(function(){
   var nick = $("#nick").val();
   socket.emit('nick', {nick: nick});
});
//Recibe una respuesta de si existe o no el nick.
socket.on('nick', function(data){
   if(data.correcto){
      $("#mensajes").append('<p style="color: #00f"> Bienvenido/a '+data.nick+' </p>').scrollTop($("#mensajes").height());
      $("#form_nick").hide();
      $("#mensajes,#form_mensaje").show();
   }else{
      alert('Ya existe un usuario con el nombre ' + data.nick);
   }
});
//Escucha cada vez que un nuevo usuario se conecte al chat.
socket.on('nuevo_usuario', function(data){
   $("#mensajes").append('<p style="color: #00f"> '+data.nick+' se ha conectado </p>').scrollTop($("#mensajes").height());
})
//Envía un mensaje al servidor.
$("#form_mensaje [type='submit']").click(function(){
   var mensaje = $("#mensaje").val();
   socket.emit('mensaje', {mensaje: mensaje});
   $("#mensajes").append('<p style="font-weight: bold;"> vos: '+mensaje+' </p>').scrollTop($("#mensajes").height());
   $("#mensaje").val('');
});
//Espera los mensajes nuevos del servidor.
socket.on('mensaje', function(data){
   $("#mensajes").append('<p> '+data.nick+': '+data.mensaje+' </p>').scrollTop($("#mensajes").height());
});
//Evento que se dispara cada vez un usuario se desconecta.
socket.on('disconnect', function(data){
   $("#mensajes").append('<p style="color: #f00"> '+data.nick+' se ha desconectado </p>').scrollTop($("#mensajes").height());
});

Como vimos antes, creamos un objeto socket.io:

var socket = io.connect('https://localhost:3000');

Ahora ya podemos crear las comunicaciones con el servidor.

Lista de usuarios

El evento ‘usuarios’ estará esperando del servidor la lista actualizada con los nicks de los usuarios actuales. Cada vez que la lista sea actualizada, se disparará una acción que guardará los nicks de los usuarios en la lista:

socket.on('usuarios', function(data){
   var nicks = data.nicks;
   $("#usuarios").html('');
   for(var i = 0; i < nicks.length; i++){
      $("#usuarios").append('<li>' + nicks[i] + '</li>');
   }
});

Registrar nick

Primero el usuario deberá enviar el nick al servidor:

$("#form_nick [type='submit']").click(function(){
   var nick = $("#nick").val();
   socket.emit('nick', {nick: nick});
});

Y el javascript del cliente estará esperando la respuesta del servidor, mediante el evento que le asignamos, ‘nick’. Éste nos devolverá la respuesta de si se ha podido registrar el usuario o el nick le pertenece a otro usuario:

socket.on('nick', function(data){
   if(data.correcto){
      $("#mensajes").append('<p style="color: #00f"> Bienvenido/a '+data.nick+' </p>').scrollTop($("#mensajes").height());
      $("#form_nick").hide();
      $("#mensajes,#form_mensaje").show();
   }else{
      alert('Ya existe un usuario con el nombre ' + data.nick);
   }
});

Si el nick fue registrado nos mostrará la bienvenida en la lista de los mensajes, y además ocultará el formulario de los nick y mostrará la lista de los mensajes y el formulario para enviar nuevos mensajes:

 $("#mensajes").append('<p style="color: #00f"> Bienvenido/a '+data.nick+' </p>').scrollTop($("#mensajes").height());
 $("#form_nick").hide();
 $("#mensajes,#form_mensaje").show();

Finalmente para que los otros usuarios conectados en el chat puedan ver el nick del nuevo usuario, llamamos al evento ‘nuevo_usuario’:

socket.on('nuevo_usuario', function(data){
   $("#mensajes").append('<p style="color: #00f"> '+data.nick+' se ha conectado </p>').scrollTop($("#mensajes").height());
})

Mensajes nuevos

Aquí estarán las dos funcionalidades principales del chat, el enviar mensajes:

$("#form_mensaje [type='submit']").click(function(){
   var mensaje = $("#mensaje").val();
   socket.emit('mensaje', {mensaje: mensaje});
   $("#mensajes").append('<p style="font-weight: bold;"> vos: '+mensaje+' </p>').scrollTop($("#mensajes").height());
   $("#mensaje").val('');
});

Y recibirlos:

socket.on('mensaje', function(data){
   $("#mensajes").append('<p> '+data.nick+': '+data.mensaje+' </p>').scrollTop($("#mensajes").height());
});

Pero lo bueno de esto, es que en el segundo caso los mensajes que se recuperen de otros usuarios, se harán en tiempo real, en forma instantánea. Mediante el evento que nombramos ‘mensaje’ desde el servidor, y también lo leemos de la misma forma desde el cliente.

Usuario desconectado

Y finalmente nuestro evento ‘disconnect’, el cual ejecutará una función cada vez que se desconecte un usuario.

socket.on('disconnect', function(data){
   $("#mensajes").append('<p style="color: #f00"> '+data.nick+' se ha desconectado </p>').scrollTop($("#mensajes").height());
});

 

Conclusión

He aquí la ventaja y el alcance que tiene trabajar con eventos. La forma tan simple con la que se pueden solucionar problemas que llevarían muchas horas de trabajo y dolores de cabeza.

En esta publicación hemos podido ver un claro ejemplo de cómo el navegador y el servidor, pueden trabajar en conjunto como si se tratara de uno solo. Por empezar el que ambos manejen un mismo lenguaje: javascript, y aquí también los roles se repartieron, ya no es cliente pide, servidor responde, aquí ambos se comunicaron como si fuese por un mismo canal donde ambos envían, donde ambos escuchan los envíos del otro.

Finalmente creo yo que aquí está el futuro de la web: las aplicaciones en tiempo real. Porque esto no sólo puede servir para un chat. Noticias de un diario en tiempo real, partidos de fútbol, juegos, etc.

Descargar ejemplo

Anterior: Introducción a Node.js, parte 10: Archivos públicos con express

Siguiente: Introducción a Node.js, parte 12: Conexión con MongoDB

Redes sociables

    15 Replies to “Introducción a Node.js, parte 11: Crear un chat con socket.io”

    1. Hola Ferchu,

      ¿Y si en lugar de un chat se quisiera montar un sistema de publicación tipo twiter, muro de facebook, o más simple que eso, donde el cliente solo se conectara y recibiera notificaciones?

      No me queda claro como sería la lógica para estos casos. Supongo que el cliente se conecta como en el chat y el servidor realiza consultas continuamente a una base de datos o a un servicio web y le notifica a los clientes conectados si hay nueva información.

      Un saludo

      1. Exactamente, osea, en realidad la publicación iba más por el lado de cómo funciona socket.io. Pero obviamente cómo está hecho acá no se están guardando en ningún lado los mensajes, y si el servidor se reinicia, se pierde todo.

        Saludos!

    2. Muy buena lección, pero tengo el problema de cuando quiero trabajar en red, el chat no funciona, (solo funciona en modo local) que es lo que estoy haciendo mal T_T

    3. Hola, buenos tutoriales, enhorabuena.
      Tengo un problema al seguir los tutoriales de Node. Me he instalado Node.js, express y las dependencias, pero para poder arrancar express tengo que hacerlo a través del archivo www que se encuentra en la carpeta bin. Al parecer es una característica de una actualización de express. El problema es que no puedo usar la variable server, que aquí se encuentra ya creada de antemano en el archivo www.
      Gracias, un saludo.

      1. Y si en lugar de crear una variable con el nombre server, le ponés otro nombre?

        Por ejemplo:

        var server2 = http.createServer(app).listen(app.get(‘port’), function(){
        console.log(‘Express server listening on port ‘ + app.get(‘port’));
        });

        chat.iniciar(server2);

      1. Alex, la verdad es que las cosas que he hecho con Node, las subí a servidores administrados por mí, por tanto, no tengo idea.

        Qué errores te salen?

        1. Hola, Buenas noches Fernando, te comento que todavía no tengo los conceptos de deploy claros, aunque he ya he subido aplicaciones a Heroku en Django, siguiendo las guías y me han funcionado, las sugerencias de Heroku es que aumente Dynos, solo uno es gratis, aunque guiándome por stackoverflow algunos dicen que es por el uso de sockets, me toca investigar, de todas maneras agradezco que respondas los mensajes que te dejan, hasta la próxima!!

    4. Hola Fernando, espero me puedas ayudar con esto, estoy haciendo un chat tipo facebook y pues en si ya tengo el chat(envio y recibo mensajes en tiempo real), estoy usando socket.io para esto, pero lo que pasa es que al hacerlo tipo facebook necesito hacer como una bandeja de entrada, osea que todos los mensajes que envíes los puedas ver después, como una bandeja de entrada. Espero me puedas dar un tip para esto o pasar un enlace para hacer esto en especifico. De antemano gracias 😀
      (P.D.: Me encantan tus cursos de node, de todos los que he encontrado de node en español los tuyos son de los mejores)

      1. Bueno, pero para eso ya deberías trabajar con base de datos, e ir guardando en una tabla (si usás sql) o en documentos (si usás nosql)

        Sinceramente no puedo ayudarte mucho con ello, debería saber las reglas de negocio que vos hiciste o que te dio tu cliente.

        Saludos!

        1. Hola, de antemano gracias por responder, mi aplicación no es tanto para un cliente, es más para desarrollo propio, estoy haciendo una aplicacion de cursos en linea en la cual los profesores mediante el chat podran comunicarse con sus alumnos, solo quería saber si no había como alguna opción o algo así que ofreciera específicamente node o socket io para hacer lo que ya te explique y no tener que guardarlo en una base de datos, por cierto, estoy trabajando con MongoDB.
          Nuevamente gracias por responder. Igual saludos!!! 😀

    Comments are closed.