首页 文章

如何在node.js中发出HTTP POST请求?

提问于
浏览
777

如何在node.js中使用数据创建出站HTTP POST请求?

18 回答

  • 15

    简单且无依赖性 . 使用Promise以便等待结果 . 它返回响应主体,不检查响应状态代码 .

    const https = require('https');
    
    function httpsPost({body, ...options}) {
        return new Promise((resolve,reject) => {
            const req = https.request({
                method: 'POST',
                ...options,
            }, res => {
                const chunks = [];
                res.on('data', data => chunks.push(data))
                res.on('end', () => {
                    let body = Buffer.concat(chunks);
                    switch(res.headers['content-type']) {
                        case 'application/json':
                            body = JSON.parse(body);
                            break;
                    }
                    resolve(body)
                })
            })
            req.on('error',reject);
            if(body) {
                req.write(body);
            }
            req.end();
        })
    }
    

    用法:

    const res = await httpsPost({
        hostname: 'sentry.io',
        path: `/api/0/organizations/org/releases/${changesetId}/deploys/`,
        headers: {
            'Authorization': `Bearer ${process.env.SENTRY_AUTH_TOKEN}`,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({
            environment: isLive ? 'production' : 'demo',
        })
    })
    
  • 11

    我喜欢superagent的简单性(https://github.com/visionmedia/superagent) . 节点和浏览器上的api相同 .

    2018编辑:最近,我已经开始使用node-fetch(https://www.npmjs.com/package/node-fetch),它的api与浏览器中的 fetch 匹配 .

  • 975

    您还可以使用Requestify,这是我为nodeJS编写的非常酷且简单的HTTP客户端,它支持缓存 .

    只需执行以下操作:

    var requestify = require('requestify');
    
        requestify.post('http://example.com', {
            hello: 'world'
        })
        .then(function(response) {
            // Get the response body (JSON parsed or jQuery object for XMLs)
            response.getBody();
        });
    
  • 18

    To Post Rest/JSON Request
    我们可以简单地使用请求包并保存我们必须在Json变量中发送的值 .

    首先在 npm install request --save 的控制台中安装require包

    var request = require('request');
    
        var options={
                    'key':'28',
                    'key1':'value',
                    'key2':'value'
                    }
    
        request({
                 url:"http://dev.api.ean.com/ean-services/rs/hotel/v3/ping?                      
                     minorRev="+options.key+
                     "&cid="+options.key1+
                     "&apiKey="+options.key2,
                 method:"POST",
                 json:true},function(error,response,body){
                         console.log(body)
                   }
        );
    
  • 5

    您可以使用请求库 . https://www.npmjs.com/package/request

    var request = require('request');
    

    要发布JSON数据:

    var myJSONObject = { ... };
    request({
        url: "http://josiahchoi.com/myjson",
        method: "POST",
        json: true,   // <--Very important!!!
        body: myJSONObject
    }, function (error, response, body){
        console.log(response);
    });
    

    要发布xml数据:

    var myXMLText = '<xml>...........</xml>'
    request({
        url: "http://josiahchoi.com/myjson",
        method: "POST",
        headers: {
            "content-type": "application/xml",  // <--Very important!!!
        },
        body: myXMLText
    }, function (error, response, body){
        console.log(response);
    });
    
  • 39

    这是我对 POSTGET 的解决方案 .

    About the Post method:

    如果正文是JSON对象,那么使用 JSON.stringify 对其进行反序列化很重要,并可能相应地设置 Content-Lenght 标头:

    var bodyString=JSON.stringify(body)
          var _headers = {
            'Content-Length': Buffer.byteLength(bodyString)
          };
    

    在将其写入请求之前:

    request.write( bodyString );
    

    About both Get and Post methods:

    timeout 可以作为 socket 断开连接发生,因此您必须注册其处理程序,如:

    request.on('socket', function (socket) {
            socket.setTimeout( self.timeout );
            socket.on('timeout', function() {
                request.abort();
                if(timeout) return timeout( new Error('request timed out') );
            });
        });
    

    request 处理程序是

    request.on('timeout', function () {
              // Timeout happend. Server received request, but not handled it
              // (i.e. doesn't send any response or it took to long).
              // You don't know what happend.
              // It will emit 'error' message as well (with ECONNRESET code).
              req.abort();
              if(timeout) return timeout( new Error('request timed out') );
            });
    

    我强烈建议注册两个处理程序 .

    响应主体是分块的,因此您必须在 data 处理程序中连接块:

    var body = '';
          response.on('data', function(d) {
              body += d;
          });
    

    end body 将包含整个响应正文:

    response.on('end', function() {
            try {
                var jsonResponse=JSON.parse(body);
                if(success) return success( jsonResponse );
            } catch(ex) { // bad json
              if(error) return error(ex.toString());
            }
          });
    

    try ... catch the JSON.parse`包装是安全的,因为你不能确定它实际上是格式良好的json,并且在你做请求时无法确定它 .

    Module: SimpleAPI

    /**
     * Simple POST and GET
     * @author Loreto Parisi (loretoparisi at gmail dot com)
    */
    (function() {
    
      var SimpleAPI;
    
      SimpleAPI = (function() {
    
        var qs = require('querystring');
    
        /**
         * API Object model
         * @author Loreto Parisi (loretoparisi at gmail dot com)
         */
        function SimpleAPI(host,port,timeout,ssl,debug,json) {
    
          this.host=host;
          this.port=port;
          this.timeout=timeout;
          /** true to use ssl - defaults to true */
          this.ssl=ssl || true;
          /** true to console log */
          this.debug=debug;
          /** true to parse response as json - defaults to true */
          this.json= (typeof(json)!='undefined')?json:true;
          this.requestUrl='';
          if(ssl) { // use ssl
              this.http = require('https');
          } else { // go unsafe, debug only please
              this.http = require('http');
          }
        }
    
        /**
         * HTTP GET
         * @author Loreto Parisi (loretoparisi at gmail dot com)
         */
        SimpleAPI.prototype.Get = function(path, headers, params, success, error, timeout) {
    
          var self=this;
          if(params) {
            var queryString=qs.stringify(params);
            if( queryString ) {
              path+="?"+queryString;
            }
          }
          var options = {
            headers : headers,
            hostname: this.host,
            path: path,
            method: 'GET'
          };
          if(this.port && this.port!='80') { // port only if ! 80
            options['port']=this.port;
          }
          if(self.debug) {
            console.log( "SimpleAPI.Get", headers, params, options );
          }
          var request=this.http.get(options, function(response) {
    
              if(self.debug) { // debug
                console.log( JSON.stringify(response.headers) );
              }
    
              // Continuously update stream with data
              var body = '';
              response.on('data', function(d) {
                  body += d;
              });
              response.on('end', function() {
                try {
                  if(self.json) {
                    var jsonResponse=JSON.parse(body);
                    if(success) return success( jsonResponse );
                  }
                  else {
                    if(success) return success( body );
                  }
                } catch(ex) { // bad json
                  if(error) return error( ex.toString() );
                }
              });
            });
            request.on('socket', function (socket) {
                socket.setTimeout( self.timeout );
                socket.on('timeout', function() {
                    request.abort();
                    if(timeout) return timeout( new Error('request timed out') );
                });
            });
            request.on('error', function (e) {
              // General error, i.e.
              //  - ECONNRESET - server closed the socket unexpectedly
              //  - ECONNREFUSED - server did not listen
              //  - HPE_INVALID_VERSION
              //  - HPE_INVALID_STATUS
              //  - ... (other HPE_* codes) - server returned garbage
              console.log(e);
              if(error) return error(e);
            });
            request.on('timeout', function () {
              // Timeout happend. Server received request, but not handled it
              // (i.e. doesn't send any response or it took to long).
              // You don't know what happend.
              // It will emit 'error' message as well (with ECONNRESET code).
              req.abort();
              if(timeout) return timeout( new Error('request timed out') );
            });
    
            self.requestUrl = (this.ssl?'https':'http') + '://' + request._headers['host'] + request.path;
            if(self.debug) {
              console.log("SimpleAPI.Post",self.requestUrl);
            }
            request.end();
        } //RequestGet
    
        /**
         * HTTP POST
         * @author Loreto Parisi (loretoparisi at gmail dot com)
         */
        SimpleAPI.prototype.Post = function(path, headers, params, body, success, error, timeout) {
          var self=this;
    
          if(params) {
            var queryString=qs.stringify(params);
            if( queryString ) {
              path+="?"+queryString;
            }
          }
          var bodyString=JSON.stringify(body)
          var _headers = {
            'Content-Length': Buffer.byteLength(bodyString)
          };
          for (var attrname in headers) { _headers[attrname] = headers[attrname]; }
    
          var options = {
            headers : _headers,
            hostname: this.host,
            path: path,
            method: 'POST',
            qs : qs.stringify(params)
          };
          if(this.port && this.port!='80') { // port only if ! 80
            options['port']=this.port;
          }
          if(self.debug) {
            console.log( "SimpleAPI.Post\n%s\n%s", JSON.stringify(_headers,null,2), JSON.stringify(options,null,2) );
          }
          if(self.debug) {
            console.log("SimpleAPI.Post body\n%s", JSON.stringify(body,null,2) );
          }
          var request=this.http.request(options, function(response) {
    
              if(self.debug) { // debug
                console.log( JSON.stringify(response.headers) );
              }
    
              // Continuously update stream with data
              var body = '';
              response.on('data', function(d) {
                  body += d;
              });
              response.on('end', function() {
                try {
                    console.log("END", body);
                    var jsonResponse=JSON.parse(body);
                    if(success) return success( jsonResponse );
                } catch(ex) { // bad json
                  if(error) return error(ex.toString());
                }
              });
    
            });
    
            request.on('socket', function (socket) {
                socket.setTimeout( self.timeout );
                socket.on('timeout', function() {
                    request.abort();
                    if(timeout) return timeout( new Error('request timed out') );
                });
            });
            request.on('error', function (e) {
              // General error, i.e.
              //  - ECONNRESET - server closed the socket unexpectedly
              //  - ECONNREFUSED - server did not listen
              //  - HPE_INVALID_VERSION
              //  - HPE_INVALID_STATUS
              //  - ... (other HPE_* codes) - server returned garbage
              console.log(e);
              if(error) return error(e);
            });
            request.on('timeout', function () {
              // Timeout happend. Server received request, but not handled it
              // (i.e. doesn't send any response or it took to long).
              // You don't know what happend.
              // It will emit 'error' message as well (with ECONNRESET code).
              req.abort();
              if(timeout) return timeout( new Error('request timed out') );
            });
    
            self.requestUrl = (this.ssl?'https':'http') + '://' + request._headers['host'] + request.path;
            if(self.debug) {
              console.log("SimpleAPI.Post",self.requestUrl);
            }
    
            request.write( bodyString );
            request.end();
    
        } //RequestPost
    
        return SimpleAPI;
    
      })();
    
      module.exports = SimpleAPI
    
    }).call(this);
    

    Usage:

    // Parameters
    // domain: example.com
    // ssl:true, port:80
    // timeout: 30 secs
    // debug: true
    // json response:true
    var api = new SimpleAPI('posttestserver.com', 80, 1000 * 10, true, true, true); 
    
    var headers = {
        'Content-Type' : 'application/json',
        'Accept' : 'application/json' 
    };
    var params = {
      "dir" : "post-test"
    };
    var method = 'post.php';
    
    api.Post(method, headers, params, body
        , function(response) { // success
           console.log( response );
        }
        , function(error) { // error
          console.log( error.toString() );
        }
        , function(error) { // timeout
           console.log( new Error('timeout error') );
        });
    
  • 3

    发布使用其他配置选项和自定义标头的axios.post请求的另一个axios示例 .

    var postData = {
      email: "test@test.com",
      password: "password"
    };
    
    let axiosConfig = {
      headers: {
          'Content-Type': 'application/json;charset=UTF-8',
          "Access-Control-Allow-Origin": "*",
      }
    };
    
    axios.post('http://<host>:<port>/<path>', postData, axiosConfig)
    .then((res) => {
      console.log("RESPONSE RECEIVED: ", res);
    })
    .catch((err) => {
      console.log("AXIOS ERROR: ", err);
    })
    
  • 11

    通过使用request依赖 .

    简单解决方案

    import request from 'request'
     var data = {
            "host":"127.1.1.1",
            "port":9008
        }
    
    request.post( baseUrl + '/peers/connect',
            {
                json: data,  // your payload data placed here
                headers: {
                    'X-Api-Key': 'dajzmj6gfuzmbfnhamsbuxivc', // if authentication needed
                    'Content-Type': 'application/json' 
                }
            }, function (error, response, body) {
                if (error) {
                    callback(error, null)
                } else {
                    callback(error, response.body)
                }
            });
    
  • 5

    在创建一个低级实用程序来处理帖子并获得我的项目请求之后经过很多努力之后,我决定在这里发布我的努力 . 就接受的答案而言,这里有一个用于发送http和https POST请求以发送JSON数据的片段 .

    const http = require("http")
    const https = require("https")
    
    // Request handler function
    let postJSON = (options, postData, callback) => {
    
        // Serializing JSON
        post_data = JSON.stringify(postData)
    
        let port = options.port == 443 ? https : http
    
        // Callback function for the request
        let req = port.request(options, (res) => {
            let output = ''
            res.setEncoding('utf8')
    
            // Listener to receive data
            res.on('data', (chunk) => {
                output += chunk
            });
    
            // Listener for intializing callback after receiving complete response
            res.on('end', () => {
                let obj = JSON.parse(output)
                callback(res.statusCode, obj)
            });
        });
    
       // Handle any errors occurred while making request
        req.on('error', (err) => {
            //res.send('error: ' + err.message)
        });
    
        // Request is made here, with data as string or buffer
        req.write(post_data)
        // Ending the request
        req.end()
    };
    
    let callPost = () => {
    
        let data = {
            'name': 'Jon',
            'message': 'hello, world'
        }
    
        let options = {
            host: 'domain.name',       // Your domain name
            port: 443,                 // 443 for https and 80 for http
            path: '/path/to/resource', // Path for the request
            method: 'POST',            
            headers: {
                'Content-Type': 'application/json',
                'Content-Length': Buffer.byteLength(data)
            }
        }
    
        postJSON(options, data, (statusCode, result) => {
            // Handle response
            // Process the received data
        });
    
    }
    
  • 6
    var https = require('https');
    
    
    /**
     * HOW TO Make an HTTP Call - POST
     */
    // do a POST request
    // create the JSON object
    jsonObject = JSON.stringify({
        "message" : "The web of things is approaching, let do some tests to be ready!",
        "name" : "Test message posted with node.js",
        "caption" : "Some tests with node.js",
        "link" : "http://www.youscada.com",
        "description" : "this is a description",
        "picture" : "http://youscada.com/wp-content/uploads/2012/05/logo2.png",
        "actions" : [ {
            "name" : "youSCADA",
            "link" : "http://www.youscada.com"
        } ]
    });
    
    // prepare the header
    var postheaders = {
        'Content-Type' : 'application/json',
        'Content-Length' : Buffer.byteLength(jsonObject, 'utf8')
    };
    
    // the post options
    var optionspost = {
        host : 'graph.facebook.com',
        port : 443,
        path : '/youscada/feed?access_token=your_api_key',
        method : 'POST',
        headers : postheaders
    };
    
    console.info('Options prepared:');
    console.info(optionspost);
    console.info('Do the POST call');
    
    // do the POST call
    var reqPost = https.request(optionspost, function(res) {
        console.log("statusCode: ", res.statusCode);
        // uncomment it for header details
    //  console.log("headers: ", res.headers);
    
        res.on('data', function(d) {
            console.info('POST result:\n');
            process.stdout.write(d);
            console.info('\n\nPOST completed');
        });
    });
    
    // write the json data
    reqPost.write(jsonObject);
    reqPost.end();
    reqPost.on('error', function(e) {
        console.error(e);
    });
    
  • 115

    我找到了一个视频,解释了如何实现这个目标:https://www.youtube.com/watch?v=nuw48-u3Yrg

    它使用默认的“http”模块以及“querystring”和“stringbuilder”模块 . 应用程序从网页中获取两个数字(使用两个文本框),并在提交时返回这两个数字的总和(以及保留文本框中的值) . 这是我在其他地方找到的最好的例子 .

    var http = require("http");
    var qs = require("querystring");
    var StringBuilder = require("stringbuilder");
    
    var port = 9000;
    
    function getCalcHtml(req, resp, data) {
        var sb = new StringBuilder({ newline: "\r\n" });
        sb.appendLine("<html>");
        sb.appendLine(" <body>");
        sb.appendLine("     <form method='post'>");
        sb.appendLine("         <table>");
        sb.appendLine("             <tr>");
        sb.appendLine("                 <td>Enter First No: </td>");
    
        if (data && data.txtFirstNo) {
            sb.appendLine("                 <td><input type='text' id='txtFirstNo' name='txtFirstNo' value='{0}'/></td>", data.txtFirstNo);
        }
        else {
            sb.appendLine("                 <td><input type='text' id='txtFirstNo' name='txtFirstNo' /></td>");
        }
    
        sb.appendLine("             </tr>");
        sb.appendLine("             <tr>");
        sb.appendLine("                 <td>Enter Second No: </td>");
    
        if (data && data.txtSecondNo) {
            sb.appendLine("                 <td><input type='text' id='txtSecondNo' name='txtSecondNo' value='{0}'/></td>", data.txtSecondNo);
        }
        else {
            sb.appendLine("                 <td><input type='text' id='txtSecondNo' name='txtSecondNo' /></td>");
        }
    
        sb.appendLine("             </tr>");
        sb.appendLine("             <tr>");
        sb.appendLine("                 <td><input type='submit' value='Calculate' /></td>");
        sb.appendLine("             </tr>");
    
        if (data && data.txtFirstNo && data.txtSecondNo) {
            var sum = parseInt(data.txtFirstNo) + parseInt(data.txtSecondNo);
            sb.appendLine("             <tr>");
            sb.appendLine("                 <td>Sum: {0}</td>", sum);
            sb.appendLine("             </tr>");
        }
    
        sb.appendLine("         </table>");
        sb.appendLine("     </form>")
        sb.appendLine(" </body>");
        sb.appendLine("</html>");
        sb.build(function (err, result) {
            resp.write(result);
            resp.end();
        });
    }
    
    function getCalcForm(req, resp, data) {
        resp.writeHead(200, { "Content-Type": "text/html" });
        getCalcHtml(req, resp, data);
    }
    
    function getHome(req, resp) {
        resp.writeHead(200, { "Content-Type": "text/html" });
        resp.write("<html><html><head><title>Home</title></head><body>Want to some calculation? Click <a href='/calc'>here</a></body></html>");
        resp.end();
    }
    
    function get404(req, resp) {
        resp.writeHead(404, "Resource Not Found", { "Content-Type": "text/html" });
        resp.write("<html><html><head><title>404</title></head><body>404: Resource not found. Go to <a href='/'>Home</a></body></html>");
        resp.end();
    }
    
    function get405(req, resp) {
        resp.writeHead(405, "Method not supported", { "Content-Type": "text/html" });
        resp.write("<html><html><head><title>405</title></head><body>405: Method not supported</body></html>");
        resp.end();
    }
    
    http.createServer(function (req, resp) {
        switch (req.method) {
            case "GET":
                if (req.url === "/") {
                    getHome(req, resp);
                }
                else if (req.url === "/calc") {
                    getCalcForm(req, resp);
                }
                else {
                    get404(req, resp);
                }
                break;
            case "POST":
                if (req.url === "/calc") {
                    var reqBody = '';
                    req.on('data', function (data) {
                        reqBody += data;
                        if (reqBody.length > 1e7) { //10MB
                            resp.writeHead(413, 'Request Entity Too Large', { 'Content-Type': 'text/html' });
                            resp.end('<!doctype html><html><head><title>413</title></head><body>413: Request Entity Too Large</body></html>');
                        }
                    });
                    req.on('end', function () {
                        var formData = qs.parse(reqBody);
                        getCalcForm(req, resp, formData);
                    });
                }
                else {
                    get404(req, resp);
                }
                break;
            default:
                get405(req, resp);
                break;
        }
    }).listen(port);
    
  • 737
    let request = require('request');
    let jsonObj = {};
    request({
        url: "https://myapii.com/sendJsonData",
        method: "POST",
        json: true,
        body: jsonObj
        }, function (error, resp, body){
           console.log(resp);
    });
    

    或者你可以另一个图书馆:

    let axios = require("axios");
    let jsonObj = {};
    
    const myJsonAPI = axios.create({
       baseURL: 'https://myapii.com',
       timeout: 120*1000
    });
    
    let response = await myJsonAPI.post("sendJsonData",jsonobj).catch(e=>{
        res.json(e);
    });
    console.log(response);
    
  • 0

    我使用RestlerNeedle进行制作 . 它们比原生的httprequest强大得多 . 可以通过基本认证,特殊 Headers 输入或甚至上传/下载文件来请求 .

    至于post / get操作,它们比使用httprequest的原始ajax调用更简单 .

    needle.post('https://my.app.com/endpoint', {foo:'bar'}, 
        function(err, resp, body){
            console.log(body);
    });
    
  • 8

    这是我用来发出请求的最简单方法:使用'request'模块 .

    用于安装“请求”模块的命令:

    $ npm install request
    

    示例代码:

    var request = require('request')
    
    var options = {
      method: 'post',
      body: postData, // Javascript object
      json: true, // Use,If you are sending JSON data
      url: url,
      headers: {
        // Specify headers, If any
      }
    }
    
    request(options, function (err, res, body) {
      if (err) {
        console.log('Error :', err)
        return
      }
      console.log(' Body :', body)
    
    });
    

    您还可以使用Node.js的内置“http”模块发出请求 .

  • 3

    以下是使用node.js向Google Compiler API发出POST请求的示例:

    // We need this to build our post string
    var querystring = require('querystring');
    var http = require('http');
    var fs = require('fs');
    
    function PostCode(codestring) {
      // Build the post string from an object
      var post_data = querystring.stringify({
          'compilation_level' : 'ADVANCED_OPTIMIZATIONS',
          'output_format': 'json',
          'output_info': 'compiled_code',
            'warning_level' : 'QUIET',
            'js_code' : codestring
      });
    
      // An object of options to indicate where to post to
      var post_options = {
          host: 'closure-compiler.appspot.com',
          port: '80',
          path: '/compile',
          method: 'POST',
          headers: {
              'Content-Type': 'application/x-www-form-urlencoded',
              'Content-Length': Buffer.byteLength(post_data)
          }
      };
    
      // Set up the request
      var post_req = http.request(post_options, function(res) {
          res.setEncoding('utf8');
          res.on('data', function (chunk) {
              console.log('Response: ' + chunk);
          });
      });
    
      // post the data
      post_req.write(post_data);
      post_req.end();
    
    }
    
    // This is an async file read
    fs.readFile('LinkedList.js', 'utf-8', function (err, data) {
      if (err) {
        // If this were just a small part of the application, you would
        // want to handle this differently, maybe throwing an exception
        // for the caller to handle. Since the file is absolutely essential
        // to the program's functionality, we're going to exit with a fatal
        // error instead.
        console.log("FATAL An error occurred trying to read in the file: " + err);
        process.exit(-2);
      }
      // Make sure there's data before we post it
      if(data) {
        PostCode(data);
      }
      else {
        console.log("No data to post");
        process.exit(-1);
      }
    });
    

    我已更新代码以显示如何从文件发布数据,而不是硬编码字符串 . 它使用async fs.readFile 命令来实现此目的,在成功读取后发布实际代码 . 如果's an error, it is thrown, and if there'没有数据,则进程以负值退出以指示失败 .

  • 0

    对于那些晚年来到这里的人 . 现在有各种不同的库可以用最少的编码来实现这一点 . 除非你绝对需要控制低级HTTP的东西,否则我更喜欢优雅的轻量级库来处理HTTP请求 .

    一个这样的图书馆是Unirest

    要安装它,请使用 npm .
    $ npm install unirest

    并且在每个人都习惯的 Hello, World! 示例上 .

    var unirest = require('unirest');
    
    unirest.post('http://example.com/helloworld')
    .header('Accept', 'application/json')
    .send({ "Hello": "World!" })
    .end(function (response) {
      console.log(response.body);
    });
    

    Extra:
    很多人也建议使用request [ 2 ]

    值得注意的是,幕后 Unirest 使用 request 库 .

    Unirest提供直接访问请求对象的方法 .

    Example:

    var Request = unirest.get('http://mockbin.com/request');
    
  • 2

    如果使用request库,这会变得更容易 .

    var request = require('request');
    
    request.post(
        'http://www.yoursite.com/formpage',
        { json: { key: 'value' } },
        function (error, response, body) {
            if (!error && response.statusCode == 200) {
                console.log(body)
            }
        }
    );
    

    除了提供一个很好的语法,它使json请求变得容易,处理oauth签名(对于twitter等),可以做多部分表单(例如用于上传文件)和流式传输 .

    要安装请求,请使用命令 npm install request

  • 13

    如果您正在寻找基于承诺的HTTP请求,axios可以很好地完成其工作 .

    const axios = require('axios');
    
      axios.post('/user', {
        firstName: 'Fred',
        lastName: 'Flintstone'
      })
      .then(function (response) {
        console.log(response);
      })
      .catch(function (error) {
        console.log(error);
      });
    

相关问题