How does nodejs accept the interface requested by the front end?

Node.js is an open source, cross-platform runtime environment written based on JavaScript. It can run JavaScript code on the backend, so it can achieve seamless connection between the front and back ends. Node.js provides a set of low-level APIs through the HTTP module to easily create HTTP servers and clients.

In development where the front-end and back-end are separated, the front-end may need to send a request to the back-end to obtain data. At this time, Node.js can serve as a back-end server and provide interfaces for front-end calls. This article will introduce how to use Node.js to accept the interface of front-end requests.

Step 1: Install Node.js and related modules

First you need to install the Node.js environment. Download the installation package from the official website. After installation, enter the following command in the terminal to check whether the installation is successful:

node -v

If the current Node.js version number is displayed, the installation is successful.

Then you need to install some related modules. Commonly used ones include Express, Body-parser, etc. You can use the npm command in the terminal to install, for example:

npm install express --save

The --save parameter is used here, which means that the module is installed into the dependencies of the project and the information is written to the package.json file.

Step 2: Create an interface

To create an interface, you can use the Express framework to simplify the operation. Create a new server.js file in the project root directory and enter the following code:

const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());

app.get('/api/data', (req, res) => {
  // 处理请求逻辑
  res.send('Hello, World!');
});

app.listen(3000, () => {
  console.log('server is running at http://localhost:3000');
});

This code creates an Express application and configures a route to handle GET requests sent by the front end. When the front end sends a GET request to the /api/data path, the server will call the logic in the callback function and return a response with the content "Hello, World!". JSON data can also be returned based on specific business logic.

Step 3: Test the interface

Send a GET request to the front end through the browser or Postman tool to test whether the interface is running normally. Enter the http://localhost:3000/api/data address in the browser, and the page will display the Hello, World! string. Enter the address of the GET request into the Postman tool and you should be able to see the response content.

Step 4: Process POST requests

You can also use the Express framework to process POST requests. Add the following code to the server.js file:

app.post('/api/data', (req, res) => {
  const data = req.body;
  // 处理请求逻辑
  res.send('接收到 POST 请求');
});

This code configures a route to handle POST requests. When the front end sends a POST request to the /api/data path, the server will call the logic in the callback function. . The data submitted in the POST request can be obtained through req.body, and the specific logic of the interface can be implemented in the callback function.

Step 5: Call the interface

The front end can use Ajax to send a request to call the backend interface. For example, you can use jQuery's $.ajax() method (you need to introduce the jQuery library). The following is sample code that calls a POST request:

$.ajax({
  url: '/api/data',
  type: 'post',
  data: {
    name: '张三',
    age: 18
  },
  success: function (data) {
    console.log(data);
  },
  error: function (err) {
    console.error(err);
  }
});

This code sends a POST request to http://localhost:3000/api/data via the $.ajax() method, passing a JSON object. When successful, the response content will be output to the console, and when failed, an error message will be output.

The above are the steps for using the interface of Node.js to accept front-end requests. This article describes how to install Node.js and related modules, create an interface using the Express framework, handle POST requests, and call the interface using Ajax. Through these operations, data interaction between the front and back ends can be easily realized.

The above is the detailed content of How does nodejs accept the interface requested by the front end?. For more information, please follow other related articles on the PHP Chinese website!