¿Cómo se realiza una solicitud HTTP POST en node.js?


946

¿Cómo puedo hacer una solicitud HTTP POST saliente, con datos, en node.js?


16
Como se sugiere en la respuesta de Jed Watson , recomiendo encarecidamente usar request a menos que esté escribiendo una API de bajo nivel.
namuol

44
Simplemente podría usar node-fetchque es una implementación del fetchmétodo nativo de JavaScript para realizar solicitudes HTTP.
Fez Vrasta

Esta publicación cubre los escenarios de uso básico para usar la solicitud. blog.modulus.io/node.js-tutorial-how-to-use-request-module
Shaswat Rungta

Respuestas:


855

Aquí hay un ejemplo del uso de node.js para realizar una solicitud POST a la API del compilador de Google:

// 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);
  }
});

He actualizado el código para mostrar cómo publicar datos desde un archivo, en lugar de la cadena codificada. Utiliza el fs.readFilecomando asíncrono para lograr esto, publicando el código real después de una lectura exitosa. Si hay un error, se arroja, y si no hay datos, el proceso sale con un valor negativo para indicar un error.


44
¿Se calcula correctamente el encabezado de longitud de contenido? Se supone que son bytes, ¿verdad?
Eric

77
Tenga en cuenta que querystring.stringify() no admite objetos anidados , por lo que es posible que desee utilizarlos qs.stringify().
johndodo

51
Content-Lengthson bytes y no necesariamente la longitud de la cadena (UTF-16, etc.). Usar Buffer.byteLength(data)siempre será correcto.
greenimpala

44
para enviar datos estándar, el objeto querystring.stringifydebe ser su propio objeto de datos, no la basura que se muestra en esta respuesta (¿qué puede ser útil para objetos basados ​​en archivos?). Estuve atrapado en eso durante siglos ... stackoverflow.com/questions/9768192/… proporcionó mi solución completa
RozzA

77
Gotcha: si está utilizando un sitio encriptado SSL, necesitará la biblioteca "https". No puede simplemente cambiar el puerto a 443.
Dave Collins

1137

Esto se vuelve mucho más fácil si usa la biblioteca de solicitudes .

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);
        }
    }
);

Además de proporcionar una buena sintaxis, facilita las solicitudes json, maneja la firma automática (para twitter, etc.), puede hacer formularios de varias partes (por ejemplo, para cargar archivos) y transmitir.

Para instalar la solicitud, use el comando npm install request


153
{form: {key: 'value'}} debe reemplazarse por {json: {key: 'value'}} (ya que la pregunta no es específica de los formularios). También hay que entender que 'formulario' y 'json' son palabras clave de la biblioteca de solicitud y no son parte de los datos personalizados (por más trivial que pueda parecer este último comentario, me tomó algo de tiempo descifrarlo ...)
blacelle

77
Sigo volviendo a esta pregunta y respuesta. Realmente debería ser "la" respuesta a la pregunta.
Spencer Kormos

66
Te mereces una insignia de oro puramente por esta respuesta. Es mucho más útil que el aceptado ... ¿y ya existía en 2012? Wow
Zoltán Schmidt

3
es posible que deba agregar dependencia ejecutando este comando 'npm install --save request'
Shady Sherif

18
Esta biblioteca ha quedado en desuso.
Evorlor

138

Puede usar la biblioteca de solicitudes. https://www.npmjs.com/package/request

var request = require('request');

Para publicar datos JSON:

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

Para publicar datos 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);
});

Después de revisar en su documentación. establece lo siguiente: json: establece el cuerpo pero a la representación JSON del valor y agrega Content-type: application / json header. Además, analiza el cuerpo de respuesta como JSON. Eso significa que cuando json = true, establecerá encabezado y json y cuerpo. De lo contrario, no se establece el encabezado y se analiza como texto. (Al igual que el ejemplo XML anterior). Eso hace que la API de solicitud sea práctica y simplista, pero bastante difícil de entender por primera vez.
Josiah Choi

Está técnicamente en sus documentos, pero ninguno de los ejemplos lo muestra, solo datos de formulario. Es una aguja en el pajar, y como tal, es una gran omisión, ya que esta es la segunda forma más frecuente en que uso ajax en JS, y ciertamente una de las más comunes en la web.
Kyle Baker,

Usar request.post es IMO algo más agradable que especificar POST como método. Estos son algunos ejemplos de GitHub para usar request.post
drorw

12
Esta biblioteca ha quedado en desuso.
Evorlor

44

Yo uso Restler y Needle para fines de producción. Ambos son mucho más poderosos que la httprequest nativa. Es posible solicitar con autenticación básica, entrada de encabezado especial o incluso cargar / descargar archivos.

En cuanto a la operación post / get, también son mucho más simples de usar que las llamadas ajax sin procesar que usan httprequest.

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

Intenté request, node-form-data y superagent antes de aguja. La aguja fue la única que funcionó correctamente para mí cuando intentaba cargar un archivo de formulario de varias partes.
Paul Young

35

Simple y sin dependencia. Utiliza una promesa para que pueda esperar el resultado. Devuelve el cuerpo de respuesta y no verifica el código de estado de respuesta.

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();
    })
}

Uso:

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',
    })
})

¿Para qué se utiliza writeel método req,write()?
Ari

@Ari That escribe el cuerpo de la solicitud ... nodejs.org/api/…
mpen

21

También puede usar Requestify , un cliente HTTP realmente genial y simple que escribí para nodeJS + que admite el almacenamiento en caché.

Solo haz lo siguiente:

    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();
    });

1
No me funciona, vea el problema aquí: github.com/ranm8/requestify/issues/2
Erel Segal-Halevi

20

Actualización 2020:

Realmente he estado disfrutando de phin : el cliente HTTP Node.js ultraligero

Se puede usar de dos maneras diferentes. Uno con Promesas (Async / Await) y el otro con estilos tradicionales de devolución de llamada.

Instalar a través de: npm i phin

Directamente desde su README con await:

const p = require('phin')

await p({
    url: 'https://ethanent.me',
    method: 'POST',
    data: {
        hey: 'hi'
    }
})


Estilo sin compromiso (devolución de llamada):

const p = require('phin').unpromisified

p('https://ethanent.me', (err, res) => {
    if (!err) console.log(res.body)
})

A partir de 2015 , ahora hay una gran variedad de bibliotecas diferentes que pueden lograr esto con una codificación mínima. Prefiero las bibliotecas elegantes y livianas para las solicitudes HTTP a menos que necesite absolutamente el control de las cosas HTTP de bajo nivel.

Una de esas bibliotecas es Unirest

Para instalarlo, use npm.
$ npm install unirest

Y sobre el Hello, World!ejemplo al que todos están acostumbrados.

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:
Mucha gente también sugiere el uso de la solicitud [2]

Vale la pena señalar que detrás de escena Unirestutiliza la requestbiblioteca.

Unirest proporciona métodos para acceder al objeto de solicitud directamente.

Ejemplo:

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

1
Otro que encontré que se ve bastante bien es github.com/request/request, que parece un poco más popular que unirest al menos al momento de escribir esto
Lochlan

Puedo dar fe de solicitar. Es una muy buena biblioteca. Creo que esa solicitud proporciona más funcionalidad de bajo nivel, por lo que es apropiado usarla para aplicaciones específicas. Cuando no necesariamente me importan las cosas de bajo nivel, encuentro que Unirest es adecuado.
Levi Roberts

¿Por qué se consideraría que el malestar es ligero cuando depende de la solicitud? La solicitud en sí tiene 22 dependencias, no veo cómo esto es liviano
raphadko

@raphadko Estoy seguro de que a lo largo de los años se ha producido una hinchazón característica. Asegúrese de verificar la marca de tiempo de cuando publiqué mi respuesta;)
Levi Roberts

17
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);
});

¿Hay alguna manera de ver el cuerpo de la publicación de la solicitud en la solicitud o en la respuesta?
jacoballenwood

17

Hay docenas de bibliotecas de código abierto disponibles que puede usar para hacer una solicitud HTTP POST en Node.

1. Axios (recomendado)

const axios = require('axios');

const data = {
    name: 'John Doe',
    job: 'Content Writer'
};

axios.post('https://reqres.in/api/users', data)
    .then((res) => {
        console.log(`Status: ${res.status}`);
        console.log('Body: ', res.data);
    }).catch((err) => {
        console.error(err);
    });

2. Aguja

const needle = require('needle');

const data = {
    name: 'John Doe',
    job: 'Content Writer'
};

needle('post', 'https://reqres.in/api/users', data, {json: true})
    .then((res) => {
        console.log(`Status: ${res.statusCode}`);
        console.log('Body: ', res.body);
    }).catch((err) => {
        console.error(err);
    });

3. Solicitud

const request = require('request');

const options = {
    url: 'https://reqres.in/api/users',
    json: true,
    body: {
        name: 'John Doe',
        job: 'Content Writer'
    }
};

request.post(options, (err, res, body) => {
    if (err) {
        return console.log(err);
    }
    console.log(`Status: ${res.statusCode}`);
    console.log(body);
});

4. Módulo HTTPS nativo

const https = require('https');

const data = JSON.stringify({
    name: 'John Doe',
    job: 'Content Writer'
});

const options = {
    hostname: 'reqres.in',
    path: '/api/users',
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'Content-Length': data.length
    }
};


const req = https.request(options, (res) => {
    let data = '';

    console.log('Status Code:', res.statusCode);

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

    res.on('end', () => {
        console.log('Body: ', JSON.parse(data));
    });

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

req.write(data);
req.end();

Para más detalles, consulte este artículo .


14

Esta es la forma más simple que uso para hacer una solicitud: usando el módulo 'solicitud'.

Comando para instalar el módulo 'solicitud':

$ npm install request

Código de ejemplo:

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)

});

También puede usar el módulo incorporado 'http' de Node.js para realizar una solicitud.


1
Esta biblioteca ha quedado en desuso.
Yuri Tkachenko

12

Me gusta la simplicidad de superagent ( https://github.com/visionmedia/superagent ). La misma API tanto en el nodo como en el navegador.

;(async function() {
  var response = await superagent.post('http://127.0.0.1:8125/', {age: 2})
  console.log(response)
})

También hay node-fetch ( https://www.npmjs.com/package/node-fetch ), que tiene una API que coincide fetchcon los navegadores; sin embargo, esto requiere codificación de cadena de consulta manual, no maneja automáticamente los tipos de contenido, o así que cualquiera de los otros trabajos superagentes lo hace.


1
Y en contraste con la aguja, el unirest y el co, se entrega a ser liviano (superagente: 16k, unirest: 1M, aguja: 530K)
Lars

9

Si está buscando solicitudes HTTP basadas en promesas, axios hace su trabajo muy bien.

  const axios = require('axios');

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

O

await axios.post('/user', {firstName: 'Fred',lastName: 'Flintstone'})

6

Para publicar solicitud de Rest / JSON
Simplemente podemos usar el paquete de solicitud y guardar los valores que tenemos que enviar en la variable Json.

Primero instale el paquete requerido en su consola mediante la solicitud de instalación npm --save

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)
               }
    );

2
Nunca construya su propia cadena de consulta. Estás descuidando codificar adecuadamente tus valores. Node.js tiene una biblioteca para este mismo propósito: nodejs.org/api/querystring.html
Brad

Esta biblioteca ha quedado en desuso.
Yuri Tkachenko

4

Encontré un video que explica cómo lograr esto: https://www.youtube.com/watch?v=nuw48-u3Yrg

Utiliza el módulo predeterminado "http" junto con los módulos "querystring" y "stringbuilder". La aplicación toma dos números (usando dos cuadros de texto) de una página web y al enviarlos, devuelve la suma de esos dos (junto con la persistencia de los valores en los cuadros de texto). Este es el mejor ejemplo que pude encontrar en cualquier otro lugar.

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);

4

Esta es mi solución para POSTy GET.

Sobre el Postmétodo:

Si el cuerpo es un objeto JSON, es importante deserializarlo JSON.stringifyy posiblemente configurar el Content-Lenghtencabezado en consecuencia:

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

antes de escribirlo a la solicitud:

request.write( bodyString );

Sobre ambos Gety Postmétodos:

El timeoutpuede ocurrir como socketdesconexión, por lo que debe registrar su manejador como:

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

mientras el requestmanejador es

       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') );
        });

Le sugiero que registre ambos manejadores.

El cuerpo de respuesta está fragmentado, por lo que debe concatenar fragmentos en el datacontrolador:

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

En la enddel bodycontendrá todo el cuerpo de la respuesta:

      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());
        }
      });

Es seguro envolver con un try... catch theJSON.parse` ya que no puede estar seguro de que en realidad es un json bien formateado y no hay forma de estar seguro al momento de hacer la solicitud.

Módulo: 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);

Uso:

// 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') );
    });

4

Después de luchar mucho mientras creaba una utilidad de bajo nivel para manejar la publicación y recibir solicitudes para mi proyecto, decidí publicar mi esfuerzo aquí. Mucho en la línea de respuesta aceptada, aquí hay un fragmento para hacer solicitudes POST http y https para enviar datos 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
    });

}

2
¿Nunca usas los post_datos serializados? ¿la escritura como objeto js se convierte en búfer por defecto?
ThatBrianDude

3
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);
});

O podrías usar esta biblioteca:

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);

requestLa biblioteca ha quedado en desuso.
Yuri Tkachenko

3

Axios es un cliente HTTP basado en promesas para el navegador y Node.js. Axios facilita el envío de solicitudes HTTP asíncronas a puntos finales REST y realiza operaciones CRUD. Se puede usar en JavaScript simple o con una biblioteca como Vue o React.

const axios = require('axios');

        var dataToPost = {
          email: "your email",
          password: "your password"
        };

        let axiosConfiguration = {
          headers: {
              'Content-Type': 'application/json;charset=UTF-8',
              "Access-Control-Allow-Origin": "*",
          }
        };

        axios.post('endpoint or url', dataToPost, axiosConfiguration)
        .then((res) => {
          console.log("Response: ", res);
        })
        .catch((err) => {
          console.log("error: ", err);
        })

2

Publicar otro ejemplo de axios de una solicitud axios.post que utiliza opciones de configuración adicionales y encabezados personalizados.

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);
})


0

Mediante el uso de solicitud de dependencia.

Solución simple :

 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)
            }
        });

3
de donde requestviene
CodyBugstein

Esta biblioteca ha quedado en desuso.
Yuri Tkachenko

0

Request-PromiseProporciona una respuesta basada en promesas. Los códigos de respuesta http que no sean 2xx harán que la promesa sea rechazada. Esto se puede sobrescribir configurando options.simple = false

var options = {
  method: 'POST',
  uri: 'http://api.posttestserver.com/post',
  body: {
  some: 'payload'
 },
  json: true // Automatically stringifies the body to JSON
};

rp(options)
.then(function (parsedBody) {
    // POST succeeded...
})
.catch(function (err) {
    // POST failed...
});
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.