LoạiError: undefined không phải là một chức năng trong nodejs

Question

Đây là mô hình người dùng của tôi.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; 

Vì tôi mới làm quen với nodej, rất khó hiểu ý nghĩa của lỗi này hoặc lý do xảy ra lỗi. Vì vậy, những gì hiện có nghĩa là lỗi và làm thế nào để thoát khỏi nó?

Chỉnh sửa: Đây là cuộc gọi người dùng mới của tôi.

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); 
          } 
         } 
        }); 


      } 
     }); 

Answer 1

Với sự chỉnh sửa của bạn, vấn đề bạn đang chuyển nhiều đối số hơn newUser được mong đợi. kết quả trong fn này được thiết lập giá trị của req.body.apiKey, đó là rõ ràng 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] 
     // ... 
    } 
}); 

Bạn sẽ hoặc là muốn chỉnh sửa các chức năng để đặt tên cho các đối số bổ sung hoặc loại bỏ chúng khỏi cuộc gọi nếu họ không thực sự cần thiết (vì bạn đang tạo một cá thể UserApi cả bên trong newUser và trong cuộc gọi dự định).

---

[ban]

Các lỗi có nghĩa là bạn đang cố gắng để gọi một giá trị của undefined.

Một khả năng là đối số fn như newUser sẽ cố gắng gọi nó cho dù nó thực sự là một function hay không:

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

Nhưng, giá trị của fn phụ thuộc vào cách bạn gọi newUser:

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

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

Vì vậy, bạn sẽ muốn thử nghiệm rằng fn là function trước khi thử gọi:

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

Hoặc bạn có thể vượt qua fn trực tiếp đến Model#save, mà đã xử lý khi fn là undefined:

instance.save(fn);