validacion - validar formulario javascript html5

¿Cómo recuperar los parámetros de consulta POST?

Question

Aquí está mi forma simple:

<form id="loginformA" action="userlogin" method="post">
    <div>
        <label for="email">Email: </label>
        <input type="text" id="email" name="email"></input>
    </div>
<input type="submit" value="Submit"></input>
</form>

Aquí está mi código Express.js /Node.js:

app.post(''/userlogin'', function(sReq, sRes){    
    var email = sReq.query.email.;   
}

Intenté sReq.query.email o sReq.query[''email''] o sReq.params[''email''] , etc. Ninguno de ellos funciona. Todos ellos vuelven undefined .

Cuando cambio a una llamada Get, funciona, entonces ... ¿alguna idea?

Answer 1

Para Express 4.1 y superior

Como la mayoría de las respuestas están utilizando Express, bodyParser, connect; donde multiparte está en desuso. Hay una forma segura de enviar objetos multiparte de forma sencilla.

Multer se puede usar como reemplazo para connect.multipart ().

Para instalar el paquete

$ npm install multer

Cárgalo en tu aplicación:

var multer = require(''multer'');

Y luego, agréguelo a la pila de middleware junto con el otro middleware de análisis de formularios.

app.use(express.json());
app.use(express.urlencoded());
app.use(multer({ dest: ''./uploads/'' }));

connect.json () maneja application / json

connect.urlencoded () maneja application / x-www-form-urlencoded

multer () maneja multipart / form-data

Answer 2

Actualización para Express 4.4.1

El middleware de lo siguiente se elimina de Express.

• bodyParser
• json
• urlencodificado
• multiparte

Cuando usa el middleware directamente como lo hizo en Express 3.0. Obtendrá el siguiente error:

Error: Most middleware (like urlencoded) is no longer bundled with Express and 
must be installed separately.

Para utilizar esos middleware, ahora necesita hacer npm para cada middleware por separado.

Dado que bodyParser está marcado como obsoleto, por lo tanto, recomiendo la siguiente forma de usar json, urlencode y multipart parser como formidable, connect-multiparty. (El middleware multiparte también está en desuso).

También recuerde, simplemente definiendo urlencode + json, los datos del formulario no se analizarán y req.body no estará definido. Es necesario definir un middleware para manejar la solicitud multiparte.

var urlencode = require(''urlencode'');
var json = require(''json-middleware'');
var multipart = require(''connect-multiparty'');
var multipartMiddleware = multipart();

app.use(json);
app.use(urlencode);
app.use(''/url/that/accepts/form-data'', multipartMiddleware);

Answer 3

Backend:

import express from ''express'';
import bodyParser from ''body-parser'';

const app = express();
app.use(bodyParser.json()); // add a middleware (so that express can parse request.body''s json)

app.post(''/api/courses'', (request, response) => {
  response.json(request.body);
});

Interfaz:

fetch("/api/courses", {
  method: ''POST'',
  body: JSON.stringify({ hi: ''hello'' }), // stringify JSON
  headers: new Headers({ "Content-Type": "application/json" }); // add headers
});

Answer 4

Dada alguna forma:

<form action=''/somepath'' method=''post''>
   <input type=''text'' name=''name''></input>
</form>

Usando expreso

app.post(''/somepath'', function(req, res) {

    console.log(JSON.stringify(req.body));

    console.log(''req.body.name'', req.body[''name'']);
});

Salida:

{"name":"x","description":"x"}
req.param.name x

Answer 5

Está utilizando ''req.query.post'' con el método incorrecto ''req.query.post'' funciona con ''method = get'' ''method = post'' funciona con body-parser.

Solo intenta esto cambiando post para obtener

<form id="loginformA" action="userlogin" method="get">
<div>
    <label for="email">Email: </label>
    <input type="text" id="email" name="email"></input>
</div>
<input type="submit" value="Submit"></input>  
</form>

Y en código expreso usar ''app.get''

Answer 6

Estaba buscando este problema exacto. Seguía todos los consejos anteriores pero req.body seguía devolviendo un objeto vacío {}. En mi caso, fue algo tan simple como que el html es incorrecto.

En el código HTML de su formulario, asegúrese de usar el atributo ''name'' en sus etiquetas de entrada, no solo ''id'' . De lo contrario, nada se analiza.

<input id=''foo'' type=''text'' value=''1''/>             // req = {}
<input id=''foo'' type=''text'' name=''foo'' value=''1'' /> // req = {foo:1}

Mi error idiota es tu beneficio.

Answer 7

Esto lo hará si desea construir la consulta publicada sin middleware:

app.post("/register/",function(req,res){
    var bodyStr = '''';
    req.on("data",function(chunk){
        bodyStr += chunk.toString();
    });
    req.on("end",function(){
        res.send(bodyStr);
    });

});

Eso enviará esto al navegador.

email=emailval&password1=pass1val&password2=pass2val

Sin embargo, es probable que sea mejor usar middleware para no tener que escribir esto una y otra vez en cada ruta.

Answer 8

Las cosas han changed una vez más al comenzar Express 4.16.0 , ahora puede usar express.json() y express.urlencoded() al igual que en Express 3.0 .

Esto fue different partir de Express 4.0 a 4.15 :

$ npm install --save body-parser

y entonces:

var bodyParser = require(''body-parser'')
app.use( bodyParser.json() );       // to support JSON-encoded bodies
app.use(bodyParser.urlencoded({     // to support URL-encoded bodies
  extended: true
})); 

El resto es como en Express 3.0 :

En primer lugar, debe agregar un poco de middleware para analizar los datos de publicación del cuerpo.

Agregue una o ambas de las siguientes líneas de código:

app.use(express.json());       // to support JSON-encoded bodies
app.use(express.urlencoded()); // to support URL-encoded bodies

Luego, en su controlador, use el objeto req.body :

// assuming POST: name=foo&color=red            <-- URL encoding
//
// or       POST: {"name":"foo","color":"red"}  <-- JSON encoding

app.post(''/test-page'', function(req, res) {
    var name = req.body.name,
        color = req.body.color;
    // ...
});

Tenga en cuenta que no se recomienda el uso de express.bodyParser() .

app.use(express.bodyParser());

...es equivalente a:

app.use(express.json());
app.use(express.urlencoded());
app.use(express.multipart());

Existen problemas de seguridad con express.multipart() , por lo que es mejor agregar explícitamente el soporte para el tipo de codificación específico que requiera. Si necesita codificación multiparte (por ejemplo, para cargar archivos), debería leer esto .

Answer 9

No debe utilizar app.use (express.bodyParser ()) . BodyParser es una unión de json + urlencoded + mulitpart. No deberías usar esto porque se eliminará el multiparte en la conexión 3.0.

Para resolver eso, puedes hacer esto:

app.use(express.json());
app.use(express.urlencoded());

Es muy importante saber que app.use (app.router) debe usarse después de json y urlencoded, de lo contrario no funciona.

Answer 10

Pude encontrar todos los parámetros usando el siguiente código para las solicitudes POST y GET .

 var express = require(''express'');
    var app = express();
    const util = require(''util'');  
    app.post(''/'', function (req, res) {
        console.log("Got a POST request for the homepage");
        res.send(util.inspect(req.query,false,null));
    })

Answer 11

Solicitud de streaming funcionó para mí

req.on(''end'', function() {
    var paramstring = postdata.split("&");
});

var postdata = "";
req.on(''data'', function(postdataChunk){
    postdata += postdataChunk;
});

Answer 12

usar el paquete express-fileupload

var app = require(''express'')();
var http = require(''http'').Server(app);
const fileUpload = require(''express-fileupload'')

app.use(fileUpload());

app.post(''/'', function(req, res) {
var email = req.body.email;
res.send(''<h1>Email :</h1> ''+email);
});

http.listen(3000, function(){
  console.log(''Running Port:3000'');
});

Answer 13

Nota para los usuarios de Express 4:

Si intentas y pones app.use(express.bodyParser()); en su aplicación, obtendrá el siguiente error cuando intente iniciar su servidor Express:

Error: la mayoría del middleware (como bodyParser) ya no se incluye con Express y debe instalarse por separado. Consulte different .

Tendrá que instalar el paquete body-parser separado de npm , luego use algo como lo siguiente (ejemplo tomado de la página de GitHub ):

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

var app = express();

app.use(bodyParser());

app.use(function (req, res, next) {
  console.log(req.body) // populated!
  next();
})

Answer 14

Nota : esta respuesta es para Express 2. Consulte here para Express 3.

Si está utilizando Connect / Express, debe usar el middleware BodyParser : se describe en la guía de Expressjs .

app.use(express.bodyParser());

Aquí está la versión original de sólo conexión:

app.use(express.urlencoded());
app.use(express.json());      // if needed

Tanto la cadena de consulta como el cuerpo se analizan utilizando el manejo de parámetros de estilo Rails ( qs ) en lugar de la biblioteca de querystring bajo nivel . Para analizar parámetros repetidos con qs , el parámetro debe tener corchetes: name[]=val1&name[]=val2 . También soporta mapas anidados. Además de analizar los envíos de formularios HTML, el bodyParser puede analizar las solicitudes JSON automáticamente.

Edición : leí en Express.js y modifiqué mi respuesta para que fuera más natural para los usuarios de Express.

Answer 15

Preocupación de seguridad utilizando express.bodyParser ()

Si bien todas las demás respuestas actualmente recomiendan el uso del middleware express.bodyParser() , esto es en realidad un envoltorio alrededor de los middlewares express.json() , express.urlencoded() y express.multipart() middlewares ( express.bodyParser() ). El análisis de los cuerpos de solicitud de formulario se realiza mediante el middleware express.urlencoded() y es todo lo que necesita para exponer sus datos de formulario en el objeto req.body .

Debido a un problema de seguridad con la forma en que express.multipart() / connect.multipart() crea archivos temporales para todos los archivos cargados (y no se recolecta basura), ahora se recommended no usar el contenedor express.bodyParser() sino usar Sólo los middlewares que necesitas.

Nota: connect.bodyParser() pronto se actualizará para incluir solo urlencoded y json cuando se urlencoded Connect 3.0 (lo que Express extiende).

Así que en definitiva, en lugar de ...

// example using express.js:
var express = require(''express'')
  , app = express.createServer();
app.use(express.bodyParser());
app.post(''/'', function(req, res){
  var email = req.param(''email'', null);  // second parameter is default
});

...Deberías usar

// example using just connect
var connect = require(''connect'');
var url = require(''url'');
var qs = require(''qs'');
var server = connect(
  connect.bodyParser(),
  connect.router(function(app) {
    app.post(''/userlogin'', function(req, res) {
      // the bodyParser puts the parsed request in req.body.
      var parsedUrl = qs.parse(url.parse(req.url).query);
      var email = parsedUrl.email || req.body.email;;
    });
  })
);

y si / cuando necesita manejar formularios multiparte (carga de archivos), use una biblioteca de terceros o middleware como multiparty, busboy, dicer, etc.

Answer 16

Post Parameters can be retrieved as follows-

app.post(''/api/v1/test'',Testfunction);
http.createServer(app).listen(port, function(){
console.log("Express server listening on port " + port)
});

function Testfunction(request,response,next)
{
   console.log(request.param("val1"));

   response.send(''HI'');
}

Answer 17

app.use(express.bodyParser());

Luego, para app.post solicitud de entrada, puede obtener valores de publicación a través de req.body.{post request variable} .

Answer 18

var express        =         require("express");
var bodyParser     =         require("body-parser");
var app            =         express();

app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());

app.get(''/'',function(req,res){
  res.sendfile("index.html");
});
app.post(''/login'',function(req,res){
  var user_name=req.body.user;
  var password=req.body.password;
  console.log("User name = "+user_name+", password is "+password);
  res.end("yes");
});
app.listen(3000,function(){
  console.log("Started on PORT 3000");
})