How to transfer nodejs data to the front end-Front-end Q&A-php.cn

How to transfer nodejs data to the front end

WBOY

Release： 2023-05-14 12:31:37

Original

1525 people have browsed it

With the popularity of Node.js, more and more developers are beginning to use this technology to create web applications. As a back-end technology, Node.js can transmit data to the front-end page in various ways. Here are some techniques for transferring Node.js data to the front-end:

RESTful API

RESTful API is one of the most popular web service architectures currently. Node.js can use frameworks such as Express.js or Hapi to develop RESTful APIs. RESTful API is based on HTTP protocol, which can send data to the client through GET, POST, PUT or DELETE methods. The front end requests these APIs through AJAX, and then the server returns data in JSON (JavaScript Object Notation) format for use by the front end.

The following is a simple example:

First, we need to create a server-side code using the Express.js framework:

const express = require('express');
const app = express();

app.get('/api/users', (req, res) => {
  const users = [
    { name: 'Alice', age: 25 },
    { name: 'Bob', age: 30 },
    { name: 'Chris', age: 35 },
  ];
  res.json(users);
});

app.listen(3000, () => {
  console.log('Server started on port 3000');
});

Copy after login

Here we use the Express.js framework Create a RESTful API. When the client requests /api/users, the server will return a JSON data containing user information.

Using jQuery for AJAX calls:

$.ajax({
  url: '/api/users',
  type: 'GET',
  success: function(data) {
    console.log(data);
  },
  error: function(xhr, textStatus, error) {
    console.log(xhr.statusText);
  }
});

Copy after login

WebSockets

WebSocket is a real-time communication protocol that allows for communication between a browser and a server Two-way communication. Node.js can use the socket.io library to implement WebSocket functionality. Using WebSockets, the server can push real-time data to the client, which is more efficient than short polling and long polling (polling) methods.

The following is a simple example:

First, we need to create the server code, using the socket.io library:

const app = require('http').createServer(handler);
const io = require('socket.io')(app);
const fs = require('fs');

app.listen(3000, () => {
  console.log('Server started on port 3000');
});

function handler(req, res) {
  fs.readFile(__dirname + '/index.html', function(err, data) {
    if (err) {
      res.writeHead(500);
      return res.end('Error loading index.html');
    }
    res.writeHead(200);
    res.end(data);
  });
}

io.on('connection', function(socket) {
  setInterval(() => {
    const number = Math.floor(Math.random() * 10);
    socket.emit('number', number);
  }, 1000);
});

Copy after login

Here we use the socket.io library to create a WebSocket server. When the client connects to the server, the server will start a timer with an interval of 1 second and send a random number to the client.

Client code (index.html):

<!doctype html>
<html>
  <head>
    <title>WebSockets Example</title>
  </head>
  <body>
    <div id="container"></div>
    <script src="https://cdn.socket.io/socket.io-1.4.5.js"></script>
    <script>
      var socket = io.connect('http://localhost:3000');
      socket.on('number', (data) => {
        document.getElementById('container').innerHTML = 'Random number: ' + data;
      });
    </script>
  </body>
</html>

Copy after login

Here we use the socket.io library to establish a WebSocket connection with the server and register the 'number' event listener. When the server passes a number, the client will display the number.

Server-Sent Events

Server-Sent Events (SSE) is a technology that pushes a stream of events to the client. SSE allows the server to send data to the client in real time without the client making a request to the server. Node.js can use the EventSource library to support server push event streaming.

The following is a simple example:

Server code:

const http = require('http');

http.createServer((req, res) => {
  res.writeHead(200, {
    'Content-Type': 'text/event-stream',
    'Cache-Control': 'no-cache',
    'Connection': 'keep-alive',
  });

  setInterval(() => {
    const data = { time: new Date().toTimeString() };
    res.write(`event: time
`);
    res.write(`data: ${JSON.stringify(data)}

`);
  }, 1000);
}).listen(3000);

console.log('Server started on port 3000');

Copy after login

Here we use the HTTP module of Node.js to create an SSE server. When the client connects to the server, the server will send an event stream and send a message containing the current time every 1 second.

Client code:

<!doctype html>
<html>
  <head>
    <title>Server-Sent Events Example</title>
  </head>
  <body>
    <div id="container"></div>
    <script>
      const eventSource = new EventSource('http://localhost:3000');
      eventSource.addEventListener('time', (event) => {
        const data = JSON.parse(event.data);
        document.getElementById('container').innerHTML = data.time;
      });
    </script>
  </body>
</html>

Copy after login

Here we use JavaScript's EventSource object to listen to the event stream pushed by the server. When there is a 'time' event in the event stream, the client will display the current time.

Conclusion

By using the above technology, we can easily transfer data in Node.js to the front-end page. RESTful APIs, WebSockets, and Server-Sent Events are great ways to achieve this goal.

The above is the detailed content of How to transfer nodejs data to the front end. For more information, please follow other related articles on the PHP Chinese website!