# socket io

***

**1. Real-Time Chat Application**

```javascript
// Server
const io = require("socket.io")(3000);
io.on("connection", (socket) => {
  socket.on("message", (msg) => {
    io.emit("message", msg);
  });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("message", (msg) => {
  console.log(msg);
});
```

**2. File Sharing Server**

```javascript
// Server
const io = require("socket.io")(3000);
const fs = require("fs");
io.on("connection", (socket) => {
  socket.on("file", (file) => {
    fs.writeFileSync(`./uploads/${file.name}`, file.data);
  });
});

// Client
const socket = io.connect("localhost:3000");
const file = new File([""], "test.txt");
socket.emit("file", file);
```

**3. Online Whiteboard**

```javascript
// Server
const io = require("socket.io")(3000);
let drawings = [];
io.on("connection", (socket) => {
  socket.emit("drawings", drawings);
  socket.on("drawing", (drawing) => {
    drawings.push(drawing);
    io.emit("drawings", drawings);
  });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("drawings", (drawings) => {
  // Draw the drawings on the canvas
});
socket.on("drawing", (drawing) => {
  // Draw the new drawing on the canvas
});
```

**4. Multiplayer Game**

```javascript
// Server
const io = require("socket.io")(3000);
let players = [];
io.on("connection", (socket) => {
  socket.emit("players", players);
  players.push(socket);
  socket.on("move", (move) => {
    socket.broadcast.emit("move", move);
  });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("players", (players) => {
  // Display the players on the screen
});
socket.on("move", (move) => {
  // Update the player's position on the screen
});
```

**5. Real-Time Location Tracking**

```javascript
// Server
const io = require("socket.io")(3000);
io.on("connection", (socket) => {
  socket.on("location", (location) => {
    io.emit("location", location);
  });
});

// Client
const socket = io.connect("localhost:3000");
navigator.geolocation.watchPosition((pos) => {
  socket.emit("location", {
    lat: pos.coords.latitude,
    lng: pos.coords.longitude,
  });
});
```

**6. Live Data Monitoring**

```javascript
// Server
const io = require("socket.io")(3000);
const data = [];
setInterval(() => {
  data.push(Math.random());
  io.emit("data", data);
}, 1000);

// Client
const socket = io.connect("localhost:3000");
socket.on("data", (data) => {
  // Display the data on a chart or graph
});
```

**7. Auction Bidding**

```javascript
// Server
const io = require("socket.io")(3000);
let bids = [];
io.on("connection", (socket) => {
  socket.emit("bids", bids);
  socket.on("bid", (bid) => {
    if (bid > bids[bids.length - 1]) {
      bids.push(bid);
      io.emit("bids", bids);
    }
  });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("bids", (bids) => {
  // Display the current bids on the screen
});
```

**8. Social Media Activity Feed**

```javascript
// Server
const io = require("socket.io")(3000);
let feeds = [];
io.on("connection", (socket) => {
  socket.emit("feeds", feeds);
  socket.on("newfeed", (feed) => {
    feeds.unshift(feed);
    io.emit("feeds", feeds);
  });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("feeds", (feeds) => {
  // Display the latest feeds on the screen
});
```

**9. Remote Control**

```javascript
// Server
const io = require("socket.io")(3000);
const gpio = require("onoff").Gpio;
const led = new Gpio(17, "out");
io.on("connection", (socket) => {
  socket.on("toggle", () => {
    led.writeSync(led.readSync() ? 0 : 1);
  });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("connect", () => {
  socket.emit("toggle");
});
```

**10. Home Automation**

```javascript
// Server
const io = require("socket.io")(3000);
const iot = require("node-red");
iot.init({
  host: "localhost",
  port: 1880,
});
io.on("connection", (socket) => {
  socket.on("control", (state) => {
    const payload = { state: state };
    iot.publish("light/control", payload);
  });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("connect", () => {
  socket.emit("control", "on");
});
```

**11. Real-Time Newsfeed**

```javascript
// Server
const io = require("socket.io")(3000);
const axios = require("axios");
const url = "https://newsapi.org/v2/top-headlines?country=us&apiKey=<API_KEY>";
setInterval(() => {
  axios.get(url).then((res) => {
    io.emit("news", res.data.articles);
  });
}, 60000);

// Client
const socket = io.connect("localhost:3000");
socket.on("news", (articles) => {
  // Display the latest news headlines on the screen
});
```

**12. Real-Time Twitter Stream**

```javascript
// Server
const io = require("socket.io")(3000);
const TwitterStream = require("twitter-stream-api");
const client = new TwitterStream({
  consumer_key: "<CONSUMER_KEY>",
  consumer_secret: "<CONSUMER_SECRET>",
  access_token: "<ACCESS_TOKEN>",
  access_token_secret: "<ACCESS_TOKEN_SECRET>",
});
client.stream("statuses/filter", { track: "#javascript" });
client.on("data", (tweet) => {
  io.emit("tweet", tweet);
});

// Client
const socket = io.connect("localhost:3000");
socket.on("tweet", (tweet) => {
  // Display the latest tweets on the screen
});
```

**13. Real-Time Stock Market Data**

```javascript
// Server
const io = require("socket.io")(3000);
const WebSocket = require("ws");
const ws = new WebSocket("wss://stream.binance.com:9443/ws/btcusdt@trade");
ws.on("message", (data) => {
  const parsedData = JSON.parse(data);
  io.emit("stock", parsedData);
});

// Client
const socket = io.connect("localhost:3000");
socket.on("stock", (data) => {
  // Display the latest stock market data on the screen
});
```

**14. Real-Time Currency Exchange Rates**

```javascript
// Server
const io = require("socket.io")(3000);
const axios = require("axios");
const url = "https://api.exchangeratesapi.io/latest";
setInterval(() => {
  axios.get(url).then((res) => {
    io.emit("currency", res.data.rates);
  });
}, 60000);

// Client
const socket = io.connect("localhost:3000");
socket.on("currency", (rates) => {
  // Display the latest currency exchange rates on the screen
});
```

**15. Real-Time Weather Updates**

```javascript
// Server
const io = require("socket.io")(3000);
const axios = require("axios");
const url = "https://api.openweathermap.org/data/2.5/weather?q=London&appid=<API_KEY>";
setInterval(() => {
  axios.get(url).then((res) => {
    io.emit("weather", res.data);
  });
}, 60000);

// Client
const socket = io.connect("localhost:3000");
socket.on("weather", (data) => {
  // Display the latest weather data on the screen
});
```

**16. Real-Time IoT Device Monitoring**

```javascript
// Server
const io = require("socket.io")(3000);
const mqtt = require("mqtt");
const client = mqtt.connect("mqtt://localhost:1883");
client.subscribe("iot/+/temperature");
client.on("message", (topic, message) => {
  const [device, data] = topic.split("/");
  io.emit(`${device}/temperature`, { data: Number(message) });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("iot/device1/temperature", (data) => {
  // Display the latest temperature data from device1 on the screen
});
```

**17. Real-Time Ride-Hailing**

```javascript
// Server
const io = require("socket.io")(3000);
let drivers = [];
let riders = [];
io.on("connection", (socket) => {
  const type = socket.handshake.query.type;
  if (type === "driver") drivers.push(socket);
  else if (type === "rider") riders.push(socket);
  socket.on("request", (data) => {
    riders.forEach((rider) => rider.emit("request", data));
  });
  socket.on("accept", (data) => {
    riders.forEach((rider) => rider.emit("accept", data));
    drivers.splice(
      drivers.findIndex((driver) => driver === socket),
      1
    );
  });
});

// Client (Driver)
const socket = io.connect("localhost:3000", {
  query: { type: "driver" },
});
socket.on("request", (data) => {
  // Display the ride request on the screen
});
socket.on("accept", (data) => {
  // Display the accepted ride on the screen
});

// Client (Rider)
const socket = io.connect("localhost:3000", {
  query: { type: "rider" },
});
socket.on("request", (data) => {
  // Display the ride request on the screen
});
```

**18. Real-Time Order Processing**

```javascript
// Server
const io = require("socket.io")(3000);
let orders = [];
io.on("connection", (socket) => {
  socket.emit("orders", orders);
  socket.on("neworder", (order) => {
    orders.push(order);
    io.emit("orders", orders);
  });
  socket.on("updateorder", (order) => {
    const index = orders.findIndex((o) => o.id === order.id);
    orders[index] = order;
    io.emit("orders", orders);
  });
  socket.on("deleteorder", (order) => {
    const index = orders.findIndex((o) => o.id === order.id);
    orders.splice(index, 1);
    io.emit("orders", orders);
  });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("orders", (orders) => {
  // Display the latest orders on the screen
});
```

**19. Real-Time Customer Support Chat**

```javascript
// Server
const io = require("socket.io")(3000);
let agents = [];
let customers = [];
io.on("connection", (socket) => {
  const type = socket.handshake.query.type;
  if (type === "agent") agents.push(socket);
  else if (type === "customer") customers.push(socket);
  socket.on("message", (data) => {
    const { from, to, message } = data;
    if (from === "agent") io.to(to).emit("message", message);
    else if (from === "customer")
      io.to(agents[0].id).emit("message", message);
  });
});

// Client (Agent)
const socket = io.connect("localhost:3000", {
  query: { type: "agent" },
});
socket.on("message", (message) => {
  // Display the customer's message on the screen
});

// Client (Customer)
const socket = io.connect("localhost:3000", {
  query: { type: "customer" },
});
socket.on("message", (message) => {
  // Display the agent's response on the screen
});
```

**20. Real-Time Notifications**

```javascript
// Server
const io = require("socket.io")(3000);
let users = [];
io.on("connection", (socket) => {
  users.push(socket);
  socket.on("notification", (data) => {
    const { to, message } = data;
    io.to(to).emit("notification", message);
  });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("notification", (message) => {
  // Display the notification on the screen
});
```

**21. Real-Time Video Streaming**

```javascript
// Server
const io = require("socket.io")(3000);
const ffmpeg = require("fluent-ffmpeg");
const stream = ffmpeg("video.mp4").output("pipe:");
io.on("connection", (socket) => {
  stream.pipe(socket);
});

// Client
const socket = io.connect("localhost:3000");
const video = document.createElement("video");
video.src = socket;
document.body.appendChild(video);
video.play();
```

**22. Real-Time Audio Streaming**

```javascript
// Server
const io = require("socket.io")(3000);
const fs = require("fs");
const stream = fs.createReadStream("audio.mp3");
io.on("connection", (socket) => {
  socket.emit("audio", stream);
});

// Client
const socket = io.connect("localhost:3000");
socket.on("audio", (stream) => {
  const audio = new Audio();
  audio.srcObject = stream;
  audio.play();
});
```

**23. Real-Time Image Sharing**

```javascript
// Server
const io = require("socket.io")(3000);
const mime = require("mime");
io.on("connection", (socket) => {
  socket.on("image", (data) => {
    io.emit("image", {
      type: mime.getType(data.name),
      data: data.data,
    });
  });
});

// Client
const socket = io.connect("localhost:3000");
const image = new Image();
socket.on("image", (data) => {
  image.src = "data:" + data.type + ";base64," + data.data;
});
```

**24. Real-Time File Uploading**

```javascript
// Server
const io = require("socket.io")(3000);
io.on("connection", (socket) => {
  socket.on("upload", (stream) => {
    stream.pipe(fs.createWriteStream("file.txt"));
  });
});

// Client
const socket = io.connect("localhost:3000");
const file = new File(["Hello world!"], "file.txt");
socket.emit("upload", file.stream());
```

**25. Real-Time Database Synchronization**

```javascript
// Server
const io = require("socket.io")(3000);
const db = require("database");
io.on("connection", (socket) => {
  socket.emit("data", db.getAll());
  db.on("change", () => {
    io.emit("data", db.getAll());
  });
});

// Client
const socket = io.connect("localhost:3000");
socket.on("data", (data) => {
  // Display the database data on the screen
});
```