Javascript TypeError:app.use（）需要中间件函数

这是我的server.js文件和api.js文件。排序函数中出现错误，我打算根据js对象的属性搜索它们。事件模式的属性有名称、位置、价格和评级。我试着按照他们的价格来分类

server.js

var express= require('express');
var bodyParser= require('body-parser');
var morgan = require('morgan');
var config=require('./config');
var app= express();
var mongoose=require('mongoose');
//var User=require('./database/user')
mongoose.connect('mongodb://localhost:27017/db',function(err){
    if(err){
        console.log(err);
    }
    else{
        console.log("connected!");
    }
});

app.use(bodyParser.urlencoded({extended: true })); //if false then parse only strings
app.use(bodyParser.json());
app.use(morgan('dev'));//log all the requests to the console
var api=require('./app/routes/api')(app,express);
app.use('/api',api);
app.get('*',function(req,res){
    res.sendFile(__dirname + '/public/views/index.html');
});   // * means any route

app.listen(config.port,function(err){
    if(err){enter code here
        console.log(err);
    }
    else{
        console.log("The server is running");
    }
});
module.exports = router;

var User = require('../models/user');
var Event = require('../models/event');
var config = require('../../config');
var secret = config.secretKey;

module.exports = function (app, express) {
    var api = express.Router();
    app.use()

    api.post('/signup', function (req, res) {
        var user = new User({
            name: req.body.name,
            username: req.body.username,
            password: req.body.password
        });
        user.save(function (err) {
            if (err) {
                res.send(err);
                return;
            }
            res.json({
                message: 'User created!'
            });
        });

    });

    api.get('/users', function (req, res) {
        User.find({}, function (err, users) {
            if (err) {
                res.send(err);
                return;
            }
            res.json(users);
        });
    });

    api.post('/eventfeed', function (req, res) {
        var event = new Event({
            name: req.body.name,
            location: req.body.location,
            description: req.body.description,
            price: req.body.price,
            rating: req.body.rating
        });

        event.save(function (err) {
            if (err) {
                res.send(err);
                return;
            }
            res.json({
                message: 'Event created!'
            });
        });
    });

    // utility function for sorting an array by a key in alpha order
    api.get('/sortby_price', function (err) {
        if (err) return err;
            // utility function for sorting an array by a key in parsed numeric order
        else {
            function sortArrayNum(arr, key) {
                arr.sort(function (a, b) {
                    return parseInt(a[key], 10) - parseInt(b[key], 10);
                });
            }

            var dicts = EventSchema.saved;
            for (var i = 0; i < dicts.length; i++) {
                var terms = dicts[i].terms;
                sortArrayNum(terms, "price");
            }
        }
        return api;
    });
}

api.js

var express= require('express');
var bodyParser= require('body-parser');
var morgan = require('morgan');
var config=require('./config');
var app= express();
var mongoose=require('mongoose');
//var User=require('./database/user')
mongoose.connect('mongodb://localhost:27017/db',function(err){
    if(err){
        console.log(err);
    }
    else{
        console.log("connected!");
    }
});

app.use(bodyParser.urlencoded({extended: true })); //if false then parse only strings
app.use(bodyParser.json());
app.use(morgan('dev'));//log all the requests to the console
var api=require('./app/routes/api')(app,express);
app.use('/api',api);
app.get('*',function(req,res){
    res.sendFile(__dirname + '/public/views/index.html');
});   // * means any route

app.listen(config.port,function(err){
    if(err){enter code here
        console.log(err);
    }
    else{
        console.log("The server is running");
    }
});
module.exports = router;

var User = require('../models/user');
var Event = require('../models/event');
var config = require('../../config');
var secret = config.secretKey;

module.exports = function (app, express) {
    var api = express.Router();
    app.use()

    api.post('/signup', function (req, res) {
        var user = new User({
            name: req.body.name,
            username: req.body.username,
            password: req.body.password
        });
        user.save(function (err) {
            if (err) {
                res.send(err);
                return;
            }
            res.json({
                message: 'User created!'
            });
        });

    });

    api.get('/users', function (req, res) {
        User.find({}, function (err, users) {
            if (err) {
                res.send(err);
                return;
            }
            res.json(users);
        });
    });

    api.post('/eventfeed', function (req, res) {
        var event = new Event({
            name: req.body.name,
            location: req.body.location,
            description: req.body.description,
            price: req.body.price,
            rating: req.body.rating
        });

        event.save(function (err) {
            if (err) {
                res.send(err);
                return;
            }
            res.json({
                message: 'Event created!'
            });
        });
    });

    // utility function for sorting an array by a key in alpha order
    api.get('/sortby_price', function (err) {
        if (err) return err;
            // utility function for sorting an array by a key in parsed numeric order
        else {
            function sortArrayNum(arr, key) {
                arr.sort(function (a, b) {
                    return parseInt(a[key], 10) - parseInt(b[key], 10);
                });
            }

            var dicts = EventSchema.saved;
            for (var i = 0; i < dicts.length; i++) {
                var terms = dicts[i].terms;
                sortArrayNum(terms, "price");
            }
        }
        return api;
    });
}

var User=require（'../models/User'）；
var Event=require（'../models/Event'）；
var config=require（'../../config'）；
var secret=config.secretKey；
module.exports=函数（应用程序、express）{
var api=express.Router（）；
app.use（）
api.post（'/signup'，函数（req，res）{
var user=新用户({
名称：req.body.name，
用户名：req.body.username，
密码：req.body.password
});
user.save（函数（err）{
如果（错误）{
res.send（err）；
返回；
}
res.json({
消息：“用户已创建！”
});
});
});
获取（'/users'，函数（req，res）{
User.find（{}，函数（err，users）{
如果（错误）{
res.send（err）；
返回；
}
res.json（用户）；
});
});
api.post（'/eventfeed'，函数（req，res）{
var事件=新事件({
名称：req.body.name，
位置：req.body.location，
描述：req.body.description，
价格：需求主体价格，
额定值：要求主体额定值
});
event.save（函数（err）{
如果（错误）{
res.send（err）；
返回；
}
res.json({
消息：“已创建事件！”
});
});
});
//用于按字母顺序按键对数组排序的实用函数
api.get（'/sortby_price'，函数（err）{
if（err）返回err；
//用于按已解析数字顺序按键对数组排序的实用函数
否则{
函数sortArrayNum（arr，key）{
arr.sort（函数（a，b）{
返回parseInt（a[key]，10）-parseInt（b[key]，10）；
});
}
var dicts=EventSchema.saved；
对于（变量i=0；i

这是我的错误。我是第一次用这个做网页。请帮助我这个错误说明了什么

TypeError:app.use（）需要中间件函数
在EventEmitter.use（c:\Users\MY APY\webstoreprojects\Main\node\u modules\express\lib\application.js:209:11）
在module.exports（c:\Users\MY LAPY\webstoreprojects\Main\app\routes\api.js:10:9）
反对。（c:\Users\MY LAPY\webstoreprojects\Main\server.js:20:36）
在模块处编译（模块js:460:26）
在Object.Module._extensions..js（Module.js:478:10）
在Module.load（Module.js:355:32）
在Function.Module.\u加载（Module.js:310:12）
位于Function.Module.runMain（Module.js:501:10）
启动时（node.js:129:16）
在node.js:814:3

---

中间件是一个可以访问请求对象（req）、响应对象（res）和应用程序请求-响应周期中的下一个中间件的函数，通常由名为next的变量表示

中间件可以：

• 执行任何代码
• 对请求和响应对象进行更改
• 结束请求-响应周期
• 调用堆栈中的下一个中间件

如果当前中间件没有结束请求-响应周期，它必须调用next（）将控制权传递给下一个中间件，否则请求将挂起

在api.js中，第10行无效

app.use()

app.use必须具有具有3个参数的函数

// a middleware with no mount path; gets executed for every request to the app
app.use(function (req, res, next) {
   console.log('Time:', Date.now());
   next();
});

如果您只希望选择几个路径来使用这个中间件，那么您可以这样做

// a middleware mounted on /user/:id; will be executed for any type of HTTP request to /user/:id
app.use('/user/:id', function (req, res, next) {
   console.log('Request Type:', req.method);
   next();
});

// a route and its handler function (middleware system) which handles GET requests to /user/:id
app.get('/user/:id', function (req, res, next) {
   res.send('USER');
});

看看expressjs文档，它非常好。

---

应用程序。使用

需要向其传递一个函数，然后将其用作中间件。您有两个不这样做的实例，这将导致此错误；它们都在

api.js

中

api.js:10

app.use（）

您没有将函数传递给

。use（）

，因此这将导致错误。这就是你在帖子中看到的错误

但是，您将得到另一个错误：

var api=require('./app/routes/api')(app,express);
app.use('/api',api);

本节尝试将

/app/routes/api

模块函数的返回值装载为中间件。但是，我们可以在代码中看到，您实际上并没有从api.js中的函数返回值；而是从路由处理程序内部返回路由器

// utility function for sorting an array by a key in alpha order
api.get('/sortby_price', function (err) {
    if (err) return err;
        // utility function for sorting an array by a key in parsed numeric order
    else {
        function sortArrayNum(arr, key) {
            arr.sort(function (a, b) {
                return parseInt(a[key], 10) - parseInt(b[key], 10);
            });
        }

        var dicts = EventSchema.saved;
        for (var i = 0; i < dicts.length; i++) {
            var terms = dicts[i].terms;
            sortArrayNum(terms, "price");
        }
    }
    return api; // <- this will be returned inside the app.get call
});

//用于按字母顺序按键对数组排序的实用函数
api.get（'/sortby_price'，函数（err）{
if（err）返回err；
//用于按已解析数字顺序按键对数组排序的实用函数
否则{
函数sortArrayNum（arr，key）{
arr.sort（函数（a，b）{
返回parseInt（a[key]，10）-parseInt（b[key]，10）；
});
}
var dicts=EventSchema.saved；
对于（变量i=0；ireturn api；//我在退出时遇到了这个问题

module.exports = router;

在my Routes.js中，我们需要导出所有路由

在我的server.js中，我

var mainRoutes = require('./Routes.js')
app.use(mainRoutes)

所以，请检查您的“app/routes/api”文件，看看它是否具有正确的导出功能。
您需要在路由文件的底部导出路由器

像这样
module.exports=router；

并在app.js文件中使用

const mainRoutes = require('./Routes.js')
app.use(mainRoutes)

享受！
你看过吗？
应用程序。使用
不需要有3个参数。它只需要有你感兴趣的参数