5000/groups/create可以工作，但是5000/groups/:id返回404

Question

我到5000/groups/:id的路由返回404not found。

当我对相同的路由执行delete请求时，一切都很正常。

即使我只访问5000/groups/:id，我仍然可以看到cannot GET /groups/:id

在前端，我使用axios从react应用程序发送请求。在前端，我正在获取要在url中显示的id，但是当我的应用程序触发对http://localhost:5000/groups/:id的get请求时，它是一个cannot get响应，但是对相同路由的delete请求可以很好地工作。

同样，前端调度得很好，只是在执行get请求时路由似乎不存在？

这是我的前端action.js

export const groupById = (GroupId, dispatch) => {
         try{
         console.log(GroupId)
        return async function(dispatch) {
                dispatch({type: GROUP_DETAILS_REQUEST})
                const {data} = await axios
                .get(`http://localhost:5000/groups/${GroupId}`)
                .then(res => console.log(res))
                
        }
       
} catch(error) {
                       dispatch({type: GROUP_DETAILS_FAIL,
                       payload:
                       error.message && error.response.data.message 
                       ? error.response.data.message :
                       error.message
                       })
                       
                }
        }

这是我的index.js文件

const express = require('express');
const mongoose = require('mongoose');
const cookieSession = require('cookie-session');
const passport = require('passport');
const bodyParser = require('body-parser')
const keys = require('./config/keys');
const cors = require('cors')
require("dotenv").config();
require('./models/GoogleUserModel'); // the user model must be placed before this services passport// this must be ran after requiring model bcuz this needs the model. ORDER
require('./models/UserModel');
require('./models/Contact');
require('./models/Template');
require('./models/UserProfile')
require('./services/passport');

const corsOptions = {
    origin:"http://localhost:3000", 
    credentials: true,      //access-control-allow-credentials:true
    optionSuccessStatus:200
}
const app = express();

app.use(cors(corsOptions))

mongoose.Promise = global.Promise;
mongoose.connect(keys.mongoURI, {
    useNewUrlParser: true,
    useCreateIndex: true,
    useUnifiedTopology: true
})
mongoose.connection.on('error', () => {
    throw new Error (`unable to connect to database: ${keys.mongoURI}`)
});


app.use(bodyParser.json({limit: '10mb'}))
app.use(express.urlencoded( { extended: true }))
app.use(
    cookieSession({
        maxAge: 30 * 24 * 60 * 60 * 1000,
        keys: [keys.cookieKey]
    })
)
app.use(passport.initialize());
app.use(passport.session());


require('./routes/googleAuthRoutes')(app);
require('./routes/userRoutes')(app);
require('./routes/messageRoutes')(app)
// we are passing in the route functions, THEN calling the functions with the app object



app.use((err, req, res, next) => {
    if (err.name === 'UnauthorizedError') {
        res.status(401).json({"error" : err.name + ": " + err.message})
    } else if (err) {
        res.status(400).json({"error" : err.name + ": " + err.message})
        console.log(err)
    }
})
const PORT = process.env.PORT || 5000;
app.listen(PORT);

这是我的userRoutes.js

const express = require( 'express')
const userCtrl = require( '../controllers/userController')
const authCtrl = require('../controllers/authController')
const cors = require('cors');
const requireLogin = require('../middlewares/requireLogin')
const router = express.Router();
const bodyParser = require('body-parser');


module.exports = (router) => {
    
router.route('/api/find-a-number').post(userCtrl.findANumber)

router.route('/contacts/create').post(userCtrl.createContact).get(userCtrl.listContacts)
router.route('/contacts/:id').get(userCtrl.contactByID).delete(userCtrl.deleteContact).put(userCtrl.updateContact)

router.route('/templates/create').post(userCtrl.createTemplate).get(userCtrl.listTemplate)
router.route('/templates/:id').delete(userCtrl.deleteTemplate)

router.route('/groups/create').get(userCtrl.listGroup).post(userCtrl.createGroup)
router.route('/groups/:id').get(userCtrl.groupById).delete(userCtrl.deleteGroup)

router.route('/fields/create').get(userCtrl.listField).post(userCtrl.createField)
router.route('/fields/:id').delete(userCtrl.deleteField).put(userCtrl.updateField)
router.route('/fields').put(userCtrl.updateField)

router.route('/files/create').get(userCtrl.listFiles).post(userCtrl.createFiles)
router.route('/files/:id').delete(userCtrl.deleteFiles)

router.route('/auth/signin').post(authCtrl.signin)

router.route('/auth/signout').get(authCtrl.signout)

router.route('/api/users').get(userCtrl.list).post(userCtrl.create)

router.route('/api/users/:userId').get(userCtrl.read).put(userCtrl.update).delete(userCtrl.remove)

router.route('/profile/update').post(userCtrl.updateProfile).get(userCtrl.getProfile)

router.param('userId', userCtrl.userByID)

}

这是我的userController.js

const mongoose = require('mongoose');
const extend = require('lodash');
const keys = require('../config/keys');
const User = require('../models/UserModel');
const Template = require('../models/Template');
const Contact = require('../models/Contact');
const Group = require('../models/GroupModel');
const Field = require('../models/FieldModel');
const Files = require('../models/ImportedFilesModel');
const ProfileUpdater = require('../models/UserProfile');
const passport = require('passport');
const dbErrorHandler = require( '../helpers/dbErrorHandler');


 const groupById = async (req, res, next, id) => {
            // when I put a console.log here nothing is logged.
            try {
               
                let group = await Group.findById(id)
                if(!group)
                return res.status(400).json({error: "Group not found"})
                
                res.json(group)
                next()
            } catch(err) {
                return res.status('400').json({
                    error: 'could not retrieve user'
                })
            }
        }

 module.exports =  { 
          
            groupById        

Answer 1

好了，我解决了我的问题。groupById函数在调用next()时出现问题。

当我删除next时，我的新错误是一个400错误的请求，这意味着路由在这里工作，是更新后的groupById工作

我将阅读更多关于next()函数如何工作的内容。

现在让我们来谈谈对我来说很奇怪的其他事情。

const groupById = (req, res, id <-- this id will still register as the next function if I console.log(id).

我发现这很奇怪，不管我叫它什么，计算机都会将id作为下一个函数读取。

req，res，hamburger仍然显示函数still if I console.log(hamburger) I the groupById function。

下面是最终的解决方案

 const groupById = async (req, res) => {
            
            try {
               console.log(req.params.id)
                let group = await Group.findById(req.params.id)
                if(!group)
                return res.status(400).json({error: "Group not found"})
                
                res.json(group)
                
            } catch(err) {
                return res.status('400').json({
                    error: 'could not retrieve user'
                })
            }
        }