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

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

preguntado el 27 de mayo de 11 a las 21:05

Como se sugiere en La respuesta de Jed Watson, Recomiendo encarecidamente usar solicita a menos que esté escribiendo una API de bajo nivel. -

Podrías usar node-fetch que es una implementación del nativo fetch Método JavaScript para realizar solicitudes HTTP. -

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

El módulo de solicitud recomendado en un comentario anterior es ahora mismo -

21 Respuestas

A continuación, se muestra 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);
  }
});

Actualicé el código para mostrar cómo publicar datos desde un archivo, en lugar de la cadena codificada. Utiliza el async fs.readFile comando para lograr esto, publicando el código real después de una lectura exitosa. Si hay un error, se lanza, y si no hay datos, el proceso sale con un valor negativo para indicar falla.

Respondido 28 Oct 15, 12:10

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

Tenga en cuenta que querystring.stringify() no admite objetos anidados, por lo que es posible que desee utilizar qs.stringify() en lugar de. - juandodo

Content-Length son bytes y no necesariamente la longitud de la cadena (UTF-16, etc.). Utilizando Buffer.byteLength(data) siempre será correcto. - impalaverde

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

Entendido: si está utilizando un sitio cifrado con SSL, necesitará la biblioteca "https". No puede simplemente cambiar el puerto a 443. - Dave Collins

request ahora está en desuso Es recomendado usas una alternativa

Sin ningún orden en particular y terriblemente incompleto:

Comparación de estadísticas Algunos ejemplos de código

Respuesta original:

Esto se vuelve mucho más fácil si usa el solicita biblioteca.

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 sintaxis agradable, facilita las solicitudes json, maneja la firma de oauth (para twitter, etc.), puede hacer formularios de varias partes (por ejemplo, para cargar archivos) y transmitir.

Para instalar el comando de uso de solicitud npm install request

Respondido el 17 de Septiembre de 20 a las 13:09

{formulario: {clave: 'valor'}} debe reemplazarse por {json: {clave: 'valor'}} (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 solicitudes y no parte de los datos personalizados (por trivial que pueda parecer este último comentario, me tomó un tiempo darme cuenta ...) - blacelle

Sigo volviendo a esta pregunta y respuesta. Realmente debería ser "la" respuesta a la pregunta. - spencer kormos

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

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

Esta biblioteca ha quedado obsoleta. - Evorlor

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

Respondido 25 ago 16, 06:08

Después de revisar en su documentación. establece lo siguiente: json: establece el cuerpo pero en la representación JSON del valor y agrega el encabezado Content-type: application / json. Además, analiza el cuerpo de la respuesta como JSON. Eso significa que cuando json = true, establecerá header y json y body. De lo contrario, no se establece ningún encabezado y se analiza como texto. (Como el ejemplo XML anterior). Eso hace que la API de solicitud sea práctica y simplista, pero bastante difícil de entender a la primera. - Josías 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 sin duda una de las más comunes en la web. - Kyle Baker

Usar request.post es, en mi opinión, algo más agradable que especificar POST como método. Aquí están algunas ejemplos de GitHub para usar request.post - Dormir

Esta biblioteca ha quedado obsoleta. - Evorlor

Simple y sin dependencia. Utiliza una promesa para que puedas esperar el resultado. Devuelve el cuerpo de la respuesta y no verifica el código de estado de la 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:

async function main() {
    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',
        })
    })
}

main().catch(err => {
    console.log(err)
})

Respondido 08 Oct 20, 07:10

Qué es write método en req,write() ¿se utiliza para? - Ari

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

Gracias, este es realmente adecuado para aws lambda, ya que ahora siempre requiere async await para trabajar. - Tuananhcwrs

@mpen, ¿alguna vez ejecutó este código? Parece que el ejemplo de solicitud tiene un orden de parámetros incorrecto. - Brocchini de Mozart

@MozartBrocchini Sí, te perdiste las llaves :-) Estoy usando desestructuración de objetos. - mpen

yo suelo restler y Aguja para fines de producción. Ambos son mucho más potentes que http: // www. Es posible solicitar con autenticación básica, entrada de encabezado especial o incluso cargar / descargar archivos.

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

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

respondido 11 mar '13, 22:03

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

Hay docenas de bibliotecas de código abierto disponibles que puede utilizar para realizar 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. Solicite

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 obtener más detalles, consulte este artículo.

Respondido el 20 de Septiembre de 19 a las 23:09

Update 2020:

Realmente he estado disfrutando Phin - El cliente HTTP ultraligero de Node.js

Se puede utilizar de dos formas diferentes. Uno con promesas (Async / Await) y el otro con estilos de devolución de llamada tradicionales.

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 no prometido (devolución de llamada):

const p = require('phin').unpromisified

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

A partir del 2015 ahora hay una amplia variedad de bibliotecas diferentes que pueden lograr esto con una codificación mínima. Prefiero bibliotecas elegantes y ligeras para solicitudes HTTP a menos que sea absolutamente necesario controlar las cosas HTTP de bajo nivel.

Una de esas bibliotecas es Malestar

Para instalarlo, use npm.
$ npm install unirest

Y en el Hello, World! ejemplo al que todo el mundo está acostumbrado.

var unirest = require('unirest');

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


Extras:
Mucha gente también sugiere el uso de solicita [2]

Vale la pena señalar que detrás de escena Unirest utiliza el request biblioteca.

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

Ejemplo:

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

contestado el 28 de mayo de 20 a las 20:05

Otro que encontré que se ve bastante bien es github.com/solicitud/solicitud que parece un poco más popular que los disturbios al menos al momento de escribir este artículo - Lochlán

Puedo dar fe de solicitarlo. Es una biblioteca muy buena. Creo que la solicitud proporciona una funcionalidad de nivel más bajo, por lo que es apropiado usarla para aplicaciones específicas. Cuando no necesariamente me preocupan las cosas de bajo nivel, encuentro que Unirest es adecuado. - levi roberts

¿Por qué unirest se consideraría liviano cuando depende de la solicitud? La solicitud en sí tiene 22 dependencias, no veo cómo esto es liviano. sigmawf

@raphadko Estoy seguro de que a lo largo de los años se ha producido un aumento de características. Asegúrese de verificar la marca de tiempo de cuando publiqué mi respuesta;) - levi roberts

También puedes usar Solicitar, un cliente HTTP realmente genial y simple que escribí para nodeJS + 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();
    });

Respondido 18 Jul 13, 19:07

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

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

respondido 11 mar '17, 17:03

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

Esta es la forma más sencilla que utilizo 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 'http' incorporado de Node.js para realizar la solicitud.

Respondido 27 Abr '16, 06:04

Esta biblioteca ha quedado obsoleta. - Yuri Tkachenko

Me gusta la sencillez de superagent (https://github.com/visionmedia/superagent). 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 búsqueda de nodo (https://www.npmjs.com/package/node-fetch), que tiene una API que coincide fetch de los navegadores; sin embargo, esto requiere la codificación manual de la cadena de consulta, no maneja automáticamente los tipos de contenido, o lo que hace cualquiera de los otros trabajos de superagent.

Respondido 15 Feb 19, 12:02

Y a diferencia de la aguja, unirest y co, se entrega por ser liviano (superagente: 16k, unirest: 1M, aguja: 530K) - Lars

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

  const axios = require('axios');

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

OR

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

Respondido 17 Feb 19, 12:02

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

Primero instale el paquete require en su consola por 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)
               }
    );

Respondido 19 Feb 15, 09:02

Nunca cree su propia cadena de consulta. Está descuidando codificar correctamente sus valores. Node.js tiene una biblioteca para este mismo propósito: nodejs.org/api/querystring.html - Brad

Esta biblioteca ha quedado obsoleta. - Yuri Tkachenko

Esta es mi solución para POST y GET.

Acerca de Post método:

Si el cuerpo es un objeto JSON, es importante deserializarlo con JSON.stringify y posiblemente establecer el Content-Lenght encabezado 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 Get y Post métodos:

El timeout puede ocurrir como un socket desconectar, por lo que debe registrar su controlador 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 que el request el manejador 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') );
        });

Sugiero encarecidamente que registre a ambos controladores.

El cuerpo de la respuesta está fragmentado, por lo que debe combinar fragmentos en el data manipulador:

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

En el end el body contendrá todo el cuerpo de 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...capturatheJSON.parse` ya que no puede estar seguro de que sea un json bien formateado en realidad y no hay forma de estar seguro en el momento de realizar la solicitud.

Módulos: 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') );
    });

contestado el 05 de mayo de 16 a las 17:05

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

Utiliza el módulo "http" predeterminado 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 enviarla, 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);

Respondido 07 ago 15, 03:08

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í. Muy en la línea de la respuesta aceptada, aquí hay un fragmento para realizar solicitudes HTTP y https POST 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
    });

}

Respondido 26 Oct 17, 06:10

¿Nunca usas post_data serializado? ¿Escribir como objeto js se convierte en búfer de forma predeterminada? - QueBrianDude

Axios es un cliente HTTP basado en promesas para el navegador y Node.js. Axios facilita el envío de solicitudes HTTP asincrónicas 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);
        })

Respondido el 11 de enero de 20 a las 10:01

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

Respondido el 21 de enero de 19 a las 12:01

request la biblioteca ha quedado obsoleta. - Yuri Tkachenko

Publicar otro ejemplo de axios de una solicitud axios.post que usa 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);
})

Respondido el 27 de enero de 18 a las 19:01

Mediante el uso solicita 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)
            }
        });

Respondido 10 Oct 18, 09:10

donde hace request ¿viene de? - CodyBugstein

Esta biblioteca ha quedado obsoleta. - Yuri Tkachenko

Request-Promise Proporciona una respuesta basada en promesas. Los códigos de respuesta http que no sean 2xx harán que se rechace la promesa. 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...
});

Respondido el 24 de enero de 19 a las 05:01

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.