Je suis préoccupé par mon code, bien que cela fonctionne.
Comme le dit le titre, est-ce accepté? Parce que dans ma base de données, je dois remplir la promesse 1 avant de procéder à la promesse 2 car je dois accéder aux variables et les résultats de la promesse 1. P>
si bref ce qui se passe dans ma base de données est la suivante: p>
Notez que dans LOGIN_TBL, une colonne est une clé étrangère de user_tbl. Je dois donc finir d'insertion dans user_tbl en premier, sinon il y aura une erreur. P>
Au fait, j'utilise PostgreSQL, Knex.js et BCRYPT Voici mon code: P>
//This is the function that handles the signup
const handleSignup = (req, res, db, bcrypt) => {
const { employeeId, username, password, firstName, lastName, positionSelect } = req.body;
const hash = bcrypt.hashSync(password);
if (!employeeId || !username || !password || !firstName || !lastName || !positionSelect) {
res.json({
haveEmpty: true
})
}
else{
db.transaction((trx) => {
db.select('*').from('user').where('employee_id', '=', employeeId)
.then(data => {
if(!data[0]){
db('user')
.returning('*')
.insert({
employee_id: employeeId,
username: username,
first_name: firstName,
last_name: lastName,
status: "Active",
position_id: positionSelect
})
.then(user =>{
db('login')
.returning('*')
.insert({
employee_id: employeeId,
username: username,
hash: hash
})
.then(login => {
if(login[0]){
res.json({
isSuccess: true
})
}else{
res.json({
isSuccess: false
})
}
})
.then(trx.commit)
.catch(trx.rollback);
})
.then(trx.commit)
.catch(trx.rollback);
}
else {
res.json('User already Exist!')
}
})
.then(trx.commit)
.catch(trx.rollback);
})
.catch(err => console.error(err));
}
}
3 Réponses :
Le problème pourrait être à l'intérieur du Vous pouvez modifier votre code comme suit: p> .Chen (data => { code> partie. Vous créez une nouvelle promesse là-bas, mais vous ne le retournez pas à un autre enchaînement. Je pourrais arriver, ça Cette promesse ne sera pas résolue, car la promesse de wrapper ne fait aucune tentative de le faire car elle n'est pas retournée. Promise.resolve('abc')
.then(res => { return Promise.resolve(res.toUpperCase()); })
.then(res => console.log(res) /*prints ABC*/);
Dans ce cas, ils sont parfois résolus. Il utilise alors / attrape sur les données Feth, mais commettre ne peut pas être résolu
@ Bato3 Je suis un peu nouveau dans les promesses. Alors, puis-je demander comment commettre ne peut pas être résolu?
@Ardi je suis erreur. Ils sont résolus. (Il y a des problèmes existentiels associés à une mauvaise matinée)
Alors La fonction enveloppe une valeur renvoyée dans une promesse, si la valeur est déjà une promesse, sera aplatie. promess.Resolve (true) (res => promess.resolve (res)) est identique à celui promess.Resolve (true) .Chen (res => res) . Je modifie ma réponse pour une explication plus poussée.
Pour en faire une chaîne, votre code devrait ressembler davantage à ceci:
db.transaction((trx) => {
return db.select('*').from('user').where('employee_id', '=', employeeId).then(data =>{
if(data[0]) {
res.json('User already Exist!')
//if it's possible use `return` instead `else`
return null;
}
return db('user')
.returning('*')
.insert({
employee_id: employeeId,
username: username,
first_name: firstName,
last_name: lastName,
status: "Active",
position_id: positionSelect
}).then(user=>{
return db('login')
.returning('*')
.insert({
employee_id: employeeId,
username: username,
hash: hash
})
}).then(login =>{
if(login[0]){
res.json({
isSuccess: true
})
}else{
res.json({
isSuccess: false
})
}
return true
}).then(trx.commit)
.catch(trx.rollback)
})
}).catch(err=> {
console.error(err)
res.status(500).json({error: true})
})
Si les promesses ne dépendent pas les unes des autres? Ce qui signifie que vous n'avez pas besoin de l'information de la première promesse avant de pouvoir récupérer le second, puis vous pouvez les chaîner ensemble.
const Promise1 = fetch('https://API_URL_1');
const Promise2 = fetch('https:/API_URL_2');
Promise
.all([Promise1,Promise2])
.then(responses => {
return Promise.all(responses.map(res => res.json()))
})
.then(responses => {
console.log(responses)
})
.catch(err => {
console.error(error)
})
Vous pouvez utiliser async / attendre pour rendre plus propre et facile à entretenir
Ce n'est pas accepté, c'est absolument conseillé. Les promesses étaient principalement nées pour éviter le enfer problème, et c'est exactement ce que vous avez
Il n'y a rien de mal à enchaîner les promesses, ils sont conçus pour fonctionner de cette façon, tant que vous devez . N'oubliez pas d'éviter les pièges communs (recherche de l'enfer de promesse JavaScript, trop d'articles pour en choisir un pour relier ici).
Vous ne faites pas de chaînes promesses, vous les êtes immergés.