你也可以使用Requestify，这是我为nodeJS +编写的一个非常酷且非常简单的HTTP客户端，它支持缓存。

只需对GET方法请求执行以下操作:

var requestify = require('requestify');

requestify.get('http://example.com/api/resource')
  .then(function(response) {
      // Get the response body (JSON parsed or jQuery object for XMLs)
      response.getBody();
  }
);

你也可以使用Requestify，这是我为nodeJS +编写的一个非常酷且非常简单的HTTP客户端，它支持缓存。

只需对GET方法请求执行以下操作:

var requestify = require('requestify');

requestify.get('http://example.com/api/resource')
  .then(function(response) {
      // Get the response body (JSON parsed or jQuery object for XMLs)
      response.getBody();
  }
);

如果你需要向一个IP和一个域发送GET请求(其他答案没有提到你可以指定一个端口变量)，你可以使用这个函数:

function getCode(host, port, path, queryString) {
    console.log("(" + host + ":" + port + path + ")" + "Running httpHelper.getCode()")

    // Construct url and query string
    const requestUrl = url.parse(url.format({
        protocol: 'http',
        hostname: host,
        pathname: path,
        port: port,
        query: queryString
    }));

    console.log("(" + host + path + ")" + "Sending GET request")
    // Send request
    console.log(url.format(requestUrl))
    http.get(url.format(requestUrl), (resp) => {
        let data = '';

        // A chunk of data has been received.
        resp.on('data', (chunk) => {
            console.log("GET chunk: " + chunk);
            data += chunk;
        });

        // The whole response has been received. Print out the result.
        resp.on('end', () => {
            console.log("GET end of response: " + data);
        });

    }).on("error", (err) => {
        console.log("GET Error: " + err);
    });
}

不要错过文件顶部的require模块:

http = require("http");
url = require('url')

另外请记住，您可以使用https模块在安全的网络上进行通信。所以这两条线会改变:

https = require("https");
...
https.get(url.format(requestUrl), (resp) => { ......

这个版本是基于bryanmac函数最初提出的，它使用承诺，更好的错误处理，并在ES6中重写。

let http = require("http"),
    https = require("https");

/**
* getJSON:  REST get request returning JSON object(s)
* @param options: http options object
*/
exports.getJSON = function (options) {
    console.log('rest::getJSON');
    let reqHandler = +options.port === 443 ? https : http;

    return new Promise((resolve, reject) => {
        let req = reqHandler.request(options, (res) => {
            let output = '';
            console.log('rest::', options.host + ':' + res.statusCode);
            res.setEncoding('utf8');

            res.on('data', function (chunk) {
                output += chunk;
            });

            res.on('end', () => {
                try {
                    let obj = JSON.parse(output);
                    // console.log('rest::', obj);
                    resolve({
                        statusCode: res.statusCode,
                        data: obj
                    });
                }
                catch (err) {
                    console.error('rest::end', err);
                    reject(err);
                }
            });
        });

        req.on('error', (err) => {
            console.error('rest::request', err);
            reject(err);
        });

        req.end();
    });
};

因此，您不必传入回调函数，而是getJSON()返回一个承诺。在下面的例子中，该函数在ExpressJS路由处理程序中使用

router.get('/:id', (req, res, next) => {
    rest.getJSON({
        host: host,
        path: `/posts/${req.params.id}`,
        method: 'GET'
    }).then(({ statusCode, data }) => {
        res.json(data);
    }, (error) => {
        next(error);
    });
});

当出现错误时，它将错误委托给服务器错误处理中间件。

下面是我的一个示例中的一些代码片段。它是异步的，返回一个JSON对象。它可以执行任何形式的GET请求。

请注意，有更多的最佳方法(只是一个例子)-例如，而不是将你放入数组中的块连接起来，等等…希望它能让你从正确的方向开始:

const http = require('http');
const https = require('https');

/**
 * getJSON:  RESTful GET request returning JSON object(s)
 * @param options: http options object
 * @param callback: callback to pass the results JSON object(s) back
 */

module.exports.getJSON = (options, onResult) => {
  console.log('rest::getJSON');
  const port = options.port == 443 ? https : http;

  let output = '';

  const req = port.request(options, (res) => {
    console.log(`${options.host} : ${res.statusCode}`);
    res.setEncoding('utf8');

    res.on('data', (chunk) => {
      output += chunk;
    });

    res.on('end', () => {
      let obj = JSON.parse(output);

      onResult(res.statusCode, obj);
    });
  });

  req.on('error', (err) => {
    // res.send('error: ' + err.message);
  });

  req.end();
};

它是通过创建一个选项对象来调用的，比如:

const options = {
  host: 'somesite.com',
  port: 443,
  path: '/some/path',
  method: 'GET',
  headers: {
    'Content-Type': 'application/json'
  }
};

并提供一个回调函数。

例如，在一个服务中，我需要上面的REST模块，然后这样做:

rest.getJSON(options, (statusCode, result) => {
  // I could work with the resulting HTML/JSON here. I could also just return it
  console.log(`onResult: (${statusCode})\n\n${JSON.stringify(result)}`);

  res.statusCode = statusCode;

  res.send(result);
});

更新

如果你正在寻找异步/等待(线性，无回调)，承诺，编译时支持和智能感知，我们创建了一个轻量级的HTTP和REST客户端，符合要求:

微软typed-rest-client

对于任何想要在NodeJS中发送HTTP请求的库的人来说，axios也是一个不错的选择。它支持Promises:)

Install (npm)

示例GET请求:

const axios = require('axios');

axios.get('https://google.com')
  .then(function (response) {
    // handle success
    console.log(response);
  })
  .catch(function (error) {
    // handle error
    console.log(error);
  })

Github页面

更新10/02/2022

Node.js在实验模式下集成了v17.5.0中的fetch。现在，您可以像在客户端一样使用fetch发送请求。目前，这是一个实验性的功能，所以要小心。