类型错误：未定义不是nodejs中的函数

这是我的 users.js 模型。

var mongoose = require('mongoose')
  , crypto = require('crypto')
  , mongoTypes = require('mongoose-types');

mongoTypes.loadTypes(mongoose, 'email');
mongoose.connect('mongodb://localhost/popbroker');

function hash1 (msg, key) { 
  return crypto.createHmac('sha256', key).update(msg).digest('hex');
};

function required(val) { return val && val.length; }

var Schema = mongoose.Schema
  , ObjectId = Schema.ObjectId;

var UserSchema = new Schema({
    username: {
      type: String,
      validate: [required,"Username is required"],
      index: {unique: true}
    },
    email: {
        type: mongoose.SchemaTypes.Email,
        validate: [required, 'Email required'],
        index: { unique: true }
    },
    password: {
        type: String,
        validate: [required, 'Password required'],
    },
    socialauth:{
      type:String,

    createdAt: {
        type: Date,
        'default': Date.now
    }
});


var UserApiSchema = new Schema({
    user :ObjectId,
    apiKey: {
        type: String,
        validate: [required, 'Senha é obrigatório'],
    },
    createdAt: {
        type: Date,
        'default': Date.now
    }
});


UserSchema.path('email').validate(function (v, fn) {
    User.count({email: v}, function (err, val) {
        if (err) fn(false);
        fn(val==0);
    });
}, 'Email exists!'); 

UserSchema.path('username').validate(function(v,fn){
  User.count({username:v},function(err,val){
    if(err) fn(false);
    fn(val==0);
  });
},'Username exists');

UserApiSchema.path('apiKey').validate(function(v,fn){
  UserApi.count({apiKey:v},function(err,val){
    if(err) fn(false);
    fn(val == 0);
  });
}, 'Api Key wrong');


UserSchema.statics.authenticate = function (email, password, fn) {
    this.findOne({email: email}, function (err, user) {
        if (!user) return fn(new Error('cannot find user'));
        if (user.password == hash1(password, conf.secret)) return fn(null, user);
        // Otherwise password is invalid
        fn(new Error('invalid password'));
    })
;};

UserApiSchema.statics.createApi = function(user,fn){
  var instance = new UserApi();
  instance.user = user;
  instance.apiKey = "asdasdacas121213dasasd";
  console.log("username is " + user.username);
  instance.save(function(err){
    fn(err,instance);

  });
};


UserSchema.statics.getUser = function(userid){
  var user = mongoose.model('User', UserSchema);
  var query = user.findOne({'_id':userid})
  query.exec(function (err, user) {
  if (err) return handleError(err);
  console.log(user.username);
  return user;
});
}


UserApiSchema.statics.getUser = function(apiKey,fn){
  var usAp = UserApiSchema
  var userApi = mongoose.model('UserApi', UserApiSchema);
  var user = mongoose.model('User', UserSchema);
  var query = userApi.findOne({ 'apiKey': apiKey });


  query.exec(function (err, userApi) {
  if (err) return handleError(err);
  console.log(userApi.user);
  user = user.getUser(userApi.user);
  fn(err, userApi);;// Space Ghost is a talk show host.
});
};

UserSchema.statics.newUser = function (email, password,username, fn) {
    var instance = new User();
    var apiInstance = new UserApi();
    instance.email = email;
    instance.password = require('crypto').createHash('sha256').update(password).update('salt').digest('hex');
    instance.username = username;

    instance.save(function (err) {
        fn(err, instance);
    });
};

UserSchema.statics.resetPassword = function(userId, callback) {
    var newPassword = '';
    newPassword = newPassword.randomString(6);
    var cripto = password;
    var data = {} 
        data.password = crypto;

    this.update({_id: userId}
        , {$set: data}
        , {multi:false,safe:true}
        , function( error, docs ) {
            if (error) {
                callback(error);
            }
            else {
                callback(null, newPassword);
            }
        });
}


var LinkSchema = new Schema({

  user: ObjectId,

  text: {
      type: String,
      validate: [required,"Text is required"],
      index: {unique: true}
    },
    body: {
        type: String,
        validate: [required, 'Body is required'],
        index: { unique: true }
    },
    createdAt: {
        type: Date,
        'default': Date.now
    }
})

/*
Exporting findByid function to return back a link based on an id.
*/

LinkSchema.statics.newLink = function (text, body,user, fn) {
    var instance = new Link();
    instance.text = text;
    instance.body =body;
    instance.user = user;

    instance.save(function (err) {
        fn(err, instance);
    });
};


/*
Export findAll function to return back all the links. 
*/

exports.findAll = function(req,res){
  console.log("Retrieving all the links");
  db.collection('links',function(err,collection){
    collecction.find().toArray(function(err,items){
      res.send(items);

    });
  });
};



Link = mongoose.model('Link', LinkSchema);

exports.Link = Link;


User = mongoose.model('User', UserSchema);
UserApi = mongoose.model('UserApi',UserApiSchema);
exports.UserApi = UserApi;
exports.User = User;

由于我是 Nodejs 新手，很难理解这个错误的含义或原因。那么，该错误意味着什么以及如何消除它？

编辑：这是我的 newUser 通话。

app.post(
        '/signup/',
        function(req, res) {
             {console.log(req.body.username);
                User.newUser(

                    req.body.email, req.body.password,req.body.username,req.body.apiKey,"pocket",
                    function (err, user) {
                        if ((user)&&(!err)) {
                            console.log(user.username)

                            UserApi.createApi(
                                    user,function(err,userapi){
                                        if((!err)){
                                            console.log("Api created");
                                            res.send("APi created");

                                        }
                                        else{
                                            if(err.errors.apiKey){
                                                res.send(err);
                                            }
                                        }


                                    });
                            req.session.regenerate(function(){
                                req.session.user = user._id;
                                //res.send("Success here!"); 

                            });
                        } else {
                            if (err.errors.email) {
                              res.send(err) 
                              console.log(req.body.password);
                              console.log(req.body.email);
                              console.log(req.body);
                            }                           
                           if (err.errors.username) {
                              res.send(err) 
                              console.log(req.body.password);
                              console.log(req.body.email);
                              console.log(req.body);
                            }   
                        }
                    });


            } 
        });

通过您的编辑，您传递的参数多于的问题newUser正在期待。这导致fn被设置的值req.body.apiKey，这显然是undefined:

UserSchema.statics.newUser = function (email, password, username, fn) {
    // ...
});

User.newUser(               // set to...
    req.body.email,         // => email
    req.body.password,      // => password
    req.body.username,      // => username
    req.body.apiKey,        // => fn
    "pocket",               // => (unnamed), arguments[4]
    function(err, user) {   // => (unnamed), arguments[5]
        // ...
    }
});

您要么想要编辑函数来命名附加参数，要么将它们从调用中删除（如果它们实际上不是必需的）（因为您正在创建一个UserApi实例都在里面newUser并在预期的回调内）。

[起初]

该错误意味着您正在尝试调用以下值undefined.

一种可能性是fn论证为newUser将尝试调用它是否实际上是function or not:

UserSchema.statics.newUser = function (email, password,username, fn) {
    //...
        fn(err, instance);
    //...
});

但是，的价值fn取决于你如何打电话newUser:

// fn = undefined
User.newUser('email@domain', 'password', 'username');

// fn = function
User.newUser('email@domain', 'pass', 'user', function (err, user) { });

所以，你要么想测试一下fn is a function在尝试调用它之前：

instance.save(function (err) {
    if (typeof fn === 'function') {
        fn(err, instance);
    }
});

或者你可以通过fn直接到Model#save http://mongoosejs.com/docs/api.html#model_Model-save，它已经处理了fn is undefined:

instance.save(fn);