WebSockets & Realtime Systems Programming · Aula

Transmitindo mensagens aos clientes

Aprenda a enviar mensagens do servidor para todos os clientes conectados ou apenas para clientes específicos.

Aula 3 de 412 etapas

Transmitindo mensagens aos clientes é uma aula grátis de WebSockets & Realtime Systems Programming no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de WebSockets & Realtime Systems Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de WebSockets & Realtime Systems Programming inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

What is Broadcasting?

Realtime applications often need to send updates to many users at once. Imagine a live sports score or a chat room.

Broadcasting is when your server sends a single message that is delivered to all currently connected clients.

Why Broadcast Messages?

Broadcasting is a fundamental pattern for many interactive applications:

Live Updates: Stock prices, news alerts, sensor data.
Chat Rooms: New messages visible to all participants.
Notifications: System-wide alerts to all active users.
Multiplayer Games: Player movements, game state changes for all players.

Server's Client List

To broadcast, your WebSocket server needs to know who's connected. The ws library (our Node.js WebSocket server library) automatically keeps track of all active connections.

When a client connects, its WebSocket object is added to an internal list. When it disconnects, it's removed.

Accessing Connected Clients

The ws library exposes the wss.clients property. This is a JavaScript Set containing all currently connected WebSocket client objects.

We can iterate over this Set to send messages to each individual client.

Implementing Full Broadcast

Here's how to modify your server to broadcast any message it receives to all connected clients:

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', ws => {
  console.log('Client connected');

  ws.on('message', message => {
    // Convert Buffer to string for display/processing
    const msg = message.toString();
    console.log(`Received: ${msg}`);
    
    // Broadcast the received message to all connected clients
    wss.clients.forEach(client => {
      if (client !== ws && client.readyState === WebSocket.OPEN) {
        client.send(`Broadcast: ${msg}`);
      }
    });
    
    // Also send back to the sender as confirmation
    if (ws.readyState === WebSocket.OPEN) {
      ws.send(`You sent: ${msg}`);
    }
  });

  ws.on('close', () => {
    console.log('Client disconnected');
  });

  ws.send('Welcome to the broadcast server!');
});

console.log('WebSocket server started on port 8080');

Broadcast Code Walkthrough

Let's break down the broadcast logic:

wss.clients.forEach(client => { ... }): This loop goes through every client in the connected set.
if (client !== ws && client.readyState === WebSocket.OPEN): We check if the client is not the sender (to avoid echoing back to them twice) and if their connection is still open.
client.send(`Broadcast: ${msg}`);: This is the magic! It sends the message to that specific client.

Testing the Broadcast

To test this, start your Node.js server. Then, open multiple browser tabs or client applications, all connecting to ws://localhost:8080.

When you send a message from one client, you should see it appear on all other connected clients!

Targeted Messaging

Broadcasting is powerful, but what if you need to send a message to just one or a few specific clients, not everyone?

This is called targeted messaging. Examples include private chat messages, direct user notifications, or status updates for specific admin users.

Identifying Specific Clients

The ws library doesn't inherently give clients unique IDs you can use for targeting. You'll need to implement this yourself:

When a client connects, assign it a unique ID (e.g., a UUID).
Store this ID along with the ws object in a Map or object on your server.
When a client sends a message that requires a targeted response, it can include its ID.

Simple Targeted Example

For a basic example, let's make a server that *only* sends a message back to the client that sent it (a direct echo). This demonstrates sending to a single ws object.

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8081 }); // Use a different port

wss.on('connection', ws => {
  console.log('Client connected for targeted example');

  ws.on('message', message => {
    const msg = message.toString();
    console.log(`Received: ${msg}`);
    
    // Send the message back ONLY to the client that sent it
    if (ws.readyState === WebSocket.OPEN) {
      ws.send(`You said: ${msg}`);
    }
  });

  ws.on('close', () => {
    console.log('Client disconnected from targeted example');
  });

  ws.send('Welcome! I will only talk directly to you.');
});

console.log('Targeted WebSocket server started on port 8081');

Broadcasting Check

You're building a live chat application. When a user sends a message, you want *all* other users in the same chat room to see that message.

Responda na aula interativa

Recap & Next Steps

Fantastic work! You've mastered how to send messages from your Node.js WebSocket server:

Broadcasting: Sending a message to all connected clients by looping through wss.clients.
Targeted Messaging: Sending to a specific client using its individual ws object.

These techniques are crucial for building dynamic and interactive realtime applications. Next, we'll dive into how clients connect and interact with these server-side messages!

Grátis para começar

Aprenda WebSockets & Realtime Systems Programming com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 12
Aulas: 47

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Transmitindo mensagens aos clientes” é grátis?

Sim — o texto completo de “Transmitindo mensagens aos clientes” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de WebSockets & Realtime Systems Programming, atualize para CoddyKit PRO. O curso de WebSockets & Realtime Systems Programming inclui 4 aulas no total.

O que vou aprender em “Transmitindo mensagens aos clientes”?

Aprenda a enviar mensagens do servidor para todos os clientes conectados ou apenas para clientes específicos. Você pratica WebSockets & Realtime Systems Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar WebSockets & Realtime Systems Programming?

Nenhuma experiência prévia é necessária. WebSockets & Realtime Systems Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Transmitindo mensagens aos clientes”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de WebSockets & Realtime Systems Programming?

Sim. Cada aula de WebSockets & Realtime Systems Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Configurando um projeto Node.js
Implementando a lógica no lado do servidor
Transmitindo mensagens aos clientes
Gerenciando salas e canais

← Voltar para WebSockets & Realtime Systems Programming