Comment accéder aux paramètres GET après "?" dans Express?
Je sais comment obtenir les paramètres pour des requêtes comme celle-ci:
app.get('/sample/:id', routes.sample);
Dans ce cas, je peux utiliser req.params.id pour obtenir le paramètre (par exemple 2 dans /sample/2).
Cependant, pour une URL telle que /sample/2?color=red, comment puis-je accéder à la variable color?
J'ai essayé req.params.color mais cela n'a pas fonctionné.
Donc, après avoir vérifié le référence expresse , j'ai découvert que req.query.color me rendrait la valeur que je cherchais.
req.params fait référence aux éléments avec un ':' dans l'URL et req.query fait référence aux éléments associés à '?'
Exemple:
GET /something?color1=red&color2=blue
Puis en express, le gestionnaire:
app.get('/something', (req, res) => {
req.query.color1 === 'red' // true
req.query.color2 === 'blue' // true
})
Utilisez req.query pour obtenir la valeur dans le paramètre de chaîne de requête de la route. Reportez-vous à requête requise . Dites si dans une route, http: // localhost: 3000 /? Name = satyam vous voulez obtenir une valeur pour le paramètre name, votre gestionnaire de route "Get" se présentera ainsi: -
app.get('/', function(req, res){
console.log(req.query.name);
res.send('Response send to client::'+req.query.name);
});
Mise à jour: req.param() est maintenant obsolète. Par conséquent, n'utilisez pas cette réponse pour les années à venir.
Votre réponse est la manière préférée de le faire, mais je pensais préciser que vous pouvez également accéder aux paramètres url, post et route, le tout avec req.param(parameterName, defaultValue) .
Dans ton cas:
var color = req.param('color');
Du guide express:
la recherche est effectuée dans l'ordre suivant:
- req.params
- req.body
- demande
Notez que le guide indique les éléments suivants:
L'accès direct à req.body, req.params et req.query doit être privilégié pour plus de clarté - à moins que vous n'acceptiez vraiment les entrées de chaque objet.
Cependant, dans la pratique, j'ai trouvé que req.param() était suffisamment clair et rendait certains types de refactoring plus faciles.
La réponse de @ Zugwait est correcte. req.param() est obsolète. Vous devez utiliser req.params, req.query ou req.body.
Mais juste pour le rendre plus clair:
req.params sera rempli uniquement avec les valeurs de route. Autrement dit, si vous avez un itinéraire comme /users/:id, vous pouvez accéder à la id dans req.params.id ou req.params['id'].
req.query et req.body seront remplis avec tous params, qu'ils soient ou non sur la route. Bien entendu, les paramètres de la chaîne de requête seront disponibles dans req.query et les paramètres d'un corps de publication seront disponibles dans req.body.
Donc, pour répondre à vos questions, comme color ne figure pas dans la route, vous devriez pouvoir l'obtenir avec req.query.color ou req.query['color'].
La chaîne de requête et les paramètres sont différents.
Vous devez utiliser les deux en URL de routage unique
S'il vous plaît vérifier ci-dessous exemple peut être utile pour vous.
app.get('/sample/:id', function(req, res) {
var id = req.params.id; //or use req.param('id')
................
});
Obtenez le lien pour que votre deuxième segment soit votre exemple d'identifiant: http: // localhost: port/sample/12
Si vous rencontrez un problème, veuillez utiliser le passage de variables en tant que chaîne de requête en utilisant "?" opérateur
app.get('/sample', function(req, res) {
var id = req.query.id;
................
});
Obtenez le lien de votre exemple: http: // localhost: port/sample? Id = 12
Les deux dans un seul exemple
app.get('/sample/:id', function(req, res) {
var id = req.params.id; //or use req.param('id')
var id2 = req.query.id;
................
});
Obtenir un exemple de lien: http: // localhost: port/sample/123? Id = 12
Le manuel express dit que vous devez utiliser req.query pour accéder à QueryString.
// Requesting /display/post?size=small
app.get('/display/post', function(req, res, next) {
var isSmall = req.query.size === 'small'; // > true
// ...
});
const express = require('express')
const bodyParser = require('body-parser')
const { usersNdJobs, userByJob, addUser , addUserToCompany } = require ('./db/db.js')
const app = express()
app.set('view engine', 'pug')
app.use(express.static('public'))
app.use(bodyParser.urlencoded({ extended: false }))
app.use(bodyParser.json())
app.get('/', (req, res) => {
usersNdJobs()
.then((users) => {
res.render('users', { users })
})
.catch(console.error)
})
app.get('/api/company/users', (req, res) => {
const companyname = req.query.companyName
console.log(companyname)
userByJob(companyname)
.then((users) => {
res.render('job', { users })
}).catch(console.error)
})
app.post('/api/users/add', (req, res) => {
const userName = req.body.userName
const jobName = req.body.jobName
console.log("user name = "+userName+", job name : "+jobName)
addUser(userName, jobName)
.then((result) => {
res.status(200).json(result)
})
.catch((error) => {
res.status(404).json({ 'message': error.toString() })
})
})
app.post('/users/add', (request, response) => {
const { userName, job } = request.body
addTeam(userName, job)
.then((user) => {
response.status(200).json({
"userName": user.name,
"city": user.job
})
.catch((err) => {
request.status(400).json({"message": err})
})
})
app.post('/api/user/company/add', (req, res) => {
const userName = req.body.userName
const companyName = req.body.companyName
console.log(userName, companyName)
addUserToCompany(userName, companyName)
.then((result) => {
res.json(result)
})
.catch(console.error)
})
app.get('/api/company/user', (req, res) => {
const companyname = req.query.companyName
console.log(companyname)
userByJob(companyname)
.then((users) => {
res.render('jobs', { users })
})
})
app.listen(3000, () =>
console.log('Example app listening on port 3000!')
)
Une technique intéressante que j'ai commencé à utiliser avec certaines de mes applications sur express consiste à créer un objet qui fusionne les champs de requête, de paramètres et de corps de l'objet de requête d'expression.
//./express-data.js
const _ = require("lodash");
class ExpressData {
/*
* @param {Object} req - express request object
*/
constructor (req) {
//Merge all data passed by the client in the request
this.props = _.merge(req.body, req.params, req.query);
}
}
module.exports = ExpressData;
Ensuite, dans votre corps de contrôleur, ou n'importe où ailleurs dans le cadre de la chaîne de demandes express, vous pouvez utiliser quelque chose comme ci-dessous:
//./some-controller.js
const ExpressData = require("./express-data.js");
const router = require("express").Router();
router.get("/:some_id", (req, res) => {
let props = new ExpressData(req).props;
//Given the request "/592363122?foo=bar&hello=world"
//the below would log out
// {
// some_id: 592363122,
// foo: 'bar',
// hello: 'world'
// }
console.log(props);
return res.json(props);
});
Cela rend agréable et pratique de simplement "fouiller" dans toutes les "données personnalisées" qu'un utilisateur peut avoir envoyées avec sa demande.
Note
Pourquoi le champ "accessoires"? S'agissant d'un extrait réduit, j'utilise cette technique dans plusieurs de mes API. Je stocke également des données d'authentification/autorisation sur cet objet, exemple ci-dessous.
/*
* @param {Object} req - Request response object
*/
class ExpressData {
/*
* @param {Object} req - express request object
*/
constructor (req) {
//Merge all data passed by the client in the request
this.props = _.merge(req.body, req.params, req.query);
//Store reference to the user
this.user = req.user || null;
//API connected devices (Mobile app..) will send x-client header with requests, web context is implied.
//This is used to determine how the user is connecting to the API
this.client = (req.headers) ? (req.headers["x-client"] || (req.client || "web")) : "web";
}
}