Sending and Receiving

// Raw string
ws.send("Hello!");

// JSON (most common pattern)
ws.send(JSON.stringify({ type: "chat", text: "Hello", ts: Date.now() }));

// Template literal
ws.send(`ping:${Date.now()}`);

// Send a typed array
const arr = new Uint8Array([0x01, 0x02, 0x03, 0xff]);
ws.send(arr.buffer);          // send the underlying ArrayBuffer
ws.send(arr);                 // ws (Node) also accepts TypedArray directly

// Structured binary with DataView
const buf = new ArrayBuffer(8);
const view = new DataView(buf);
view.setUint32(0, 42, false);       // big-endian
view.setFloat32(4, 3.14, false);
ws.send(buf);

// Node.js server
ws.send(Buffer.from("hello"));
ws.send(Buffer.from([0x01, 0x02, 0x03]));
ws.send(Buffer.alloc(16));           // zero-filled
ws.send(Buffer.from(someString, "utf8"));

const blob = new Blob([JSON.stringify(obj)], { type: "application/json" });
ws.send(blob);

// ws library: 3rd argument is a callback called after the data is flushed
ws.send(data, { binary: false, compress: true }, (err) => {
  if (err) console.error("failed to send:", err);
  else console.log("sent and flushed");
});

// Browser
ws.addEventListener("message", ({ data }) => {
  if (typeof data === "string") {
    const msg = JSON.parse(data);   // if JSON
    console.log(msg.type, msg.payload);
  }
});

// Node (ws library) — data is Buffer by default
ws.on("message", (data, isBinary) => {
  if (!isBinary) {
    const text = data.toString("utf8");
    const msg = JSON.parse(text);
  }
});

// Browser — prefer arraybuffer for direct byte access
ws.binaryType = "arraybuffer";
ws.addEventListener("message", ({ data }) => {
  if (data instanceof ArrayBuffer) {
    const view = new DataView(data);
    const id = view.getUint32(0, false);
    const value = view.getFloat32(4, false);
  }
});

// Node — data arrives as Buffer
ws.on("message", (data, isBinary) => {
  if (isBinary) {
    const id = data.readUInt32BE(0);
    const value = data.readFloatBE(4);
  }
});

ws.on("message", (data) => {
  const text = data.toString();
  if (text.startsWith("ping:")) return ws.send("pong:" + text.slice(5));
  if (text.startsWith("msg:"))  return handleChat(text.slice(4));
});

// Both sides agree on { type, payload } shape
ws.on("message", (raw) => {
  const { type, payload } = JSON.parse(raw.toString());
  switch (type) {
    case "join":   handleJoin(payload); break;
    case "chat":   handleChat(payload); break;
    case "leave":  handleLeave(payload); break;
    default: console.warn("unknown type:", type);
  }
});

ws.on("message", (data, isBinary) => {
  if (!isBinary) return;
  const op = data[0];          // first byte is opcode
  switch (op) {
    case 0x01: handleMove(data.slice(1)); break;
    case 0x02: handleShot(data.slice(1)); break;
  }
});

// Streaming a large file over WebSocket (Node ws)
import { createReadStream } from "fs";

const stream = createReadStream("large-file.bin");
stream.on("data", (chunk) => {
  if (ws.readyState === WebSocket.OPEN) ws.send(chunk);
});

// Check bufferedAmount before sending (browser)
function drainSend(ws, messages) {
  for (const msg of messages) {
    if (ws.bufferedAmount > 65536) {
      // defer remaining messages
      setTimeout(() => drainSend(ws, messages.slice(messages.indexOf(msg))), 50);
      return;
    }
    ws.send(msg);
  }
}

// Node ws — pause/resume the stream
ws.pause();              // stop firing message events
// ... do slow async work ...
ws.resume();             // resume

function send(ws, type, payload) {
  if (ws.readyState !== WebSocket.OPEN) return;
  try {
    ws.send(JSON.stringify({ type, payload, ts: Date.now() }));
  } catch (err) {
    console.error("send error:", err);
  }
}

send(ws, "chat", { text: "Hello", room: "general" });

// Echo everything back to sender
wss.on("connection", (ws) => {
  ws.on("message", (data, isBinary) => {
    ws.send(data, { binary: isBinary });   // echo in same format
  });
});