module.exports=function(grunt){
    //定义的任务
    grunt.initConfig({
        watch: {
            hbs: {
                files: ['views/**'],
                options: {
                    livereload: true
                }
            },
            js: {
                files: ['public/blog/**', 'models/**/*.js', 'schemas/**/*.js', 'db/schema/**'],
                options: {
                    livereload: true//文件改动重新启动
                }
            }
        },

        jshint: {
            options: {
                jshintrc: '.jshintrc',
                ignores: ['public/libs/**/*.js']
            },
            all: ['public/blog/*.js', 'db/*.js', 'db/schema/*.js']
        },

        nodemon: {
          // ```
        },
        //压缩配置
        less: {
            development: {
                options: {
                    compress: true,
                    yuicompress: true,
                    optimization: 2
                },
                files: {
                    // 'public/lib/adminlte/css/AdminLTE.min.css': 'public/stylesheets/index.less'
                }
            }
        },
        uglify: {
            development: {//压缩环境
                files: {
                    'public/build/common.min.js': 'public/blog/common.js',
                    'public/build/detail.js': [
                        'public/blog/comment.js','public/blog/public/blog/initBlog.js',
                        ````
                    ]
                }
            }
        },
        concurrent: {
            tasks: ['nodemon', 'watch'],
            options: {
                logConcurrentOutput: true
            }
        }
    });
    //插件加载
    grunt.loadNpmTasks('grunt-contrib-watch');//只要文件添加修改就会重新执行
    grunt.loadNpmTasks('grunt-nodemon');//实时监听app.js
    grunt.loadNpmTasks('grunt-concurrent');//针对慢任务
    grunt.loadNpmTasks('grunt-contrib-less');
    grunt.loadNpmTasks('grunt-contrib-uglify');
    grunt.loadNpmTasks('grunt-contrib-jshint');
    
    grunt.option('force',true);//防止中断整个任务
    grunt.registerTask('default',['concurrent']);//默认任务
};

var gulp = require('gulp');
var autoprefixer = require('gulp-autoprefixer');
gulp.task('styles',function() {
  gulp.src('public/lib/adminlte/css/AdminLTE.min.css')//处理文件
    .pipe(autoprefixer())
    .pipe(gulp.dest('public/stylesheets'))//输出目标文件
});

gulp.task('watch',function() {//监听文件
  gulp.watch('css/styles.css', ['styles']);
});

/* 评论定义 */
var commentSchema = new Schema({
    commentId: String,
    news: {type: ObjectId, ref: 'News'},//当前评论页面
    from: {type: ObjectId, ref: 'User'},//评论人
    to: {type: ObjectId, ref: 'User'},
    content: String,
    reply: [{//回复数组
        commentId: String, 
        from: {type: ObjectId, ref: 'User'},
        to: {type: ObjectId, ref: 'User'},
        content: String
    }],
   ....
    }
});

//dbHelper 评论
exports.addComment = function(data, cb) {
    //将markdown格式的新闻内容转换成html格式
    data.content = md.render(data.content);
    if(data.comment) {//新增回复
        Comment.findById(data.comment, function (err, comment) {
            console.log(comment);
            var reply = new Comment({
              ......
            });
            comment.reply.push(reply);
            comment.save(function (err, doc) {
              ......
    }
    else {//新增评论
        var comment = new Comment({
          .....
        });
        comment.save(function(err,doc){
           .....
        })
    }

};

//查找评论
exports.findComment = function (id, cb) {
    Comment.find({news: id})
        .populate('from')//酱紫前段就可以调用from内部数据
        .populate('reply.from reply.to', 'username')//populate真神奇呀
        .exec(function (err, docs) {
            cb(true,docs);
        })
};

//comment.js
$('[data-toggle="select"]').on('click', function (e) {
    e.preventDefault();
    var $this = $(this);
    var cid = $this.data('cid');//主评论id，即comment-id
    var rid = $this.data('rid');//当前评论人id即to-id
//评论显示
    //判断input隐藏域是否有了
    if($('#cid').length > 0) {
        $('#cid').val(cid);//赋值
    }
    else {
        //插入的隐藏域
        $('<input>').attr({//传入对象，有多个键值对
            id: 'cid',
            type: 'hidden',
            value: cid
        }).appendTo('#commentForm');//插入表单
    }
//回复显示
        if($('#rid').length > 0) {
        $('#rid').val(rid);
    }
    else {
        $('<input>').attr({
            id: 'rid',
            type: 'hidden',
            value: rid
        }).appendTo('#commentForm');
    }
});
function doRespond() {
    $.ajax({
        type: "POST",
        url: "/addComment",
        contentType: "application/json",
        dataType: "json",
        data: JSON.stringify({
            'news': $("#news").val(),
            'content': $("#resContent").val(),
            'from': $.cookie('id'),
            'to': $("#rid").val(),
            'comment': $("#cid").val()
        }),
        ······
}

 News.update({_id:id},{$inc:{pv:1}},function (err) {//每次查找自动更新pv使其自增1
        if(err)
            console.log(err)
    });

////返回通过标题关键字查询的所有文章信息
exports.findNewsContent = function(req, pattern, cb) {
    News.findOne({title:pattern})//将得到的pattern进行模糊查询
        .populate('author')
        .exec(function(err, docs) {
            var docs = (docs !== null) ? docs : '';
            cb(true,docs);
        });
};
router.get('/search',function (req, res, next) {
  var keyword = req.query.keyword;
  var pattern = new RegExp(keyword, "i");
  //正则表达式：对字符串执行模式匹配  
  //属性i 执行对大小写不敏感的匹配。
  dbHelper.findNewsContent(req, pattern, function (success, data) {
    res.render('blog', {
      layout: 'main',
      entries: data
    });
  })
});

<input type="email" class="form-control" placeholder="E-mail" id="new-email" name="email" required>
//要求输入邮箱满足一定的格式要求
...
<input type="password" class="form-control" placeholder="密码" id="new-pwd" required minlength="3" maxlength="10">
//要求密码满足一定的长度要求

 $("#signupForm").validate({
      rules: {
        firstname: "required",//必填
        lastname: "required",
        username: {
          required: true,
          minlength: 2
        }

var cookieParser = require('cookie-parser');
var session = require('express-session');

app.use(cookieParser());
app.use(session({
  name:'Blog',//表示cookie的name，默认cookie的name是：connect.sid。
  maxAge: 30 * 1000,//cookie过期时间，毫秒。
  secret: 'mia-web-node-secret-key',//用来对session数据进行加密的字符串.这个属性值为必须指定的属性。
  resave: false,//每次请求都重新设置session cookie,过期,请求都会再设置。
  saveUninitialized: false//每次请求都设置个session cookie ，默认给个标示为 connect.sid
}));

req.session['message'] = "";//写入session
res.redirect(req.session.lastpage);//从session中读取

module.exports = {
    isAuthenticated: function (req, res, next) {
        if(typeof(req.session.user) != 'undefined') {//查看session中user是否定义
            return next();
        }else{
            res.redirect('/login');//否则，跳转到登陆界面
        }
    }
};

socket.join('sessionId');

//路由渲染新闻列表时新建一个msg将其写入session
router.get('/newsList', function(req, res, next) {
  var msg = req.session['message'] || '';
  req.session['message'] = "";
  ....}
//执行操作的时候将信息写入msg
exports.deleteNews = function(id, cb) {
    News.findById(id, function (err, doc) {
        if (doc) {
            doc.remove(function (err, doc) {
                if (err) {
                    entries.msg = err;
                    cb(false,entries);
                }else{
                    entries.msg = '删除新闻成功！';
                    cb(true,entries);
            ....
//路由 如果msg不为空，则弹出框
$(init);
function init() {
  var msg = $(".box-msg").text();
  if (msg!=="") {
    notifyInfo(msg);
    $(".box-msg").text("");
  }
}
//前端 
<div class="box-msg hidden">{{message}}</div>
}

entries.data = doc.toObject();//addnews时将doc转为对象，并将数据传给entries
cb(true,entries);
location.href = '/pdf/blogPdf/'+ result.data._id;//回掉函数返回

function init() {
  var socket = io();
  socket.on('uploadProgress' , function(percent){
    console.log(percent);
    $(".pg-bar").progressbar( "option", "value", parseInt(percent));
    $(".pg-info").text( percent + '%');
  });
  $(".pg-bar").progressbar({value: 0});
  $(".pg-bar").progressbar( "option", "max", 100 );
  $("body").on('click', '#addNewsBtn', doAddNews);
  $("body").on('click', '#UploadBtn', doUpload);
  $("body").on('change', '#uploadFile', preUpload);
}

function preUpload() {
  $("#UploadBtn").removeClass('disabled');//上传按钮生效
}
function doUpload() {
  $(".pg-wrapper").show();//进度条显示
  var file = $("#uploadFile")[0].files[0];
  var form = new FormData();
  form.append("file", file);
  $.ajax({
    url: "/admin/uploadImg",
    type: "POST",
    data: form,
    async: true,
    processData: false,
    contentType: false,
    success: function(result) {
      startReq = false;
      if (result.code == 0) {
        var picUrl = $.format("![Alt text]({0})",result.data);
        $("#newsContent").insertAtCaret(picUrl);//插入图片
        $(".pg-wrapper").hide();//进度条图层隐藏
        // console.log(result.data);
      }
    }
  });
}

var formidable = require('formidable');//载入 formidable
router.post('/uploadImg', function(req, res, next) {
  var io = global.io;
  var form = new formidable.IncomingForm();//创建新的表单
  var path = "";
  var fields = [];
  form.encoding = 'utf-8';//编码方式
  form.uploadDir = "./public/upload";//保存路径
  form.keepExtensions = true;//包含源文件的扩展名
  form.maxFieldsSize = 30000 * 1024 * 1024;//限制的内存量。如果超过此值，“错误”事件被发射。
  var uploadprogress = 0;//进度条
  console.log("start:upload----"+uploadprogress);
  form.parse(req);//会转换请求中所包含的表单数据
  form.on('field', function(field, value) {//每当一个字段/值对已经收到时会触发该事件
    console.log(field + ":" + value); //上传的参数数据
  })
      .on('file', function(field, file) {//每当文件已经接收到，便会触发该事件
        path = '\\' + file.path; //上传文件路径
      })
      .on('progress', function(bytesReceived, bytesExpected) {//当有数据块被处理之后会触发该事件，对于创建进度条非常有用。
        uploadprogress = (bytesReceived / bytesExpected * 100).toFixed(0);//计算进程
        console.log("upload----"+ uploadprogress);
        io.sockets.in('sessionId').emit('uploadProgress', uploadprogress);
      })
      .on('end', function() {// 当所有的请求已经接收到，且所有的文件都已上传到服务器中，该事件会触发。
        console.log('-> upload done\n');// //上传完发送成功的json数据
        entries.code = 0;
        entries.data = path;
        res.writeHead(200, {
          'content-type': 'text/json'
        });
        res.end(JSON.stringify(entries));
      })
      .on("err",function(err){//当上传流中出现错误便会触发该事件
        var callback="<script>alert('"+err+"');</script>";
        res.end(callback);//这段文本发回前端就会被同名的函数执行
      }).on("abort",function(){
    var callback="<script>alert('"+ttt+"');</script>";
    res.end(callback);
  });
});

exports.pageQuery = function (page, pageSize, Model, populate, queryParams, sortParams, callback) {
    var start = (page - 1) * pageSize;
    var $page = {
        pageNumber: page//当前页码
    };
    async.parallel({//并行:parallel 
                   //的原理是同时并行处理每一个流程,最后汇总结果,如果某一个流程出错就退出.
        count: function (done) {  // 查询数量
            Model.exec(function (err, count) {  
                done(err, count);
            });
        },
        records: function (done) {   // 查询一页的记录
            Model.find(queryParams).skip(start).limit(pageSize).populate(populate).sort(
            sortParams).exec(function (err, doc) {
                done(err, doc);//通过skip,limit进行分页。
// 关于skip效率问题，10W以下的记录，是可以接受的，10w以上的记录需要根据排序的字段，通过索引定位查询
            });
        }
    }, function (err, results) {
        var newsList=new Array();
        for(var i=0;i<results.records.length;i++) {
            newsList.push(results.records[i].toObject());
        }
        var count = results.count;
        $page.pageCount = parseInt((count - 1) / pageSize + 1);//算总页数
        $page.results = newsList;//当前页的记录
        $page.count = count;
        callback(err, $page);
    });
};

npm install --save remarkable
npm install --save highlight.js

var Remarkable = require('remarkable');
var hljs = require('highlight.js');

 Remarkable: function () {
        return new Remarkable('full', {
            linkify: true,         // 自动转换链接
            highlight: function (str, lang) {
                if (lang && hljs.getLanguage(lang)) {
                    try {return hljs.highlight(lang, str).value;
                    } catch (err) {
                    }
                }try {
                    return hljs.highlightAuto(str).value;
                } catch (err) {}
               return ''; // 使用外部默认溢出
            }
        });
    }
};

var md = webHelper.Remarkable();
data.content = md.render(data.content);

exports.addUser = function(data, cb) {
    if (data.usr === "") {                //未输入用户名
        entries.code = 99;
        entries.msg = '请输入用户名 ！';
        cb(false, entries);
    }
    else if (data.password === "") {...} //未输入密码
    else if (data.email === "") {...}    //未输入邮箱
    else {User.findOne({username: data.usr}, function (err, usr) {
            if (err) { ...}
            else if (usr) {...}          //当用户存在
              else {
                var user = new User({...});
                user.save(function (err, usr) {
                    if (err) {...}
                    else {
                        entries.code = 0;
                        entries.msg = '注册成功 ！';
                        cb(true, entries);
                        ...

author: {
  type: Schema.Types.ObjectId,
  ref: 'User'

data: JSON.stringify({
  'usr': $("#usr").val(),
  'pwd': $("#pwd").val()

exports.addNews = function(data, cb) {
     data.content = md.render(data.content); //这与highlight相关
      var news = new News({
        title: data.title,
        content: data.content,
        author:data.id
    }); 
     news.save(function(err,doc){
        if (err) {
            cb(false,err);
        }else{
            cb(true,entries);
        }
    })
};

exports.findNewsOne = function(req, id, cb) {
    News.findOne({_id: id})
        .populate('author')
        .exec(function(err, docs) {
            cb(true,docs.toObject());
        });
};

router.get('/news', function(req, res, next) {
  res.render('./admin/news', { title: 'Express', layout: 'admin' });
});
router.post('/news', function(req, res, next) {
  dbHelper.addNews(req.body, function (success, doc) {
    res.send(doc);
  })
});

var Schema = mongoose.Schema;
/* 用户定义 */
var userSchema = new Schema({
    username: String,
    password: String,
    email:    String,
    address:  String,
    meta: {
        updateAt: {type:Date, default: Date.now()},
        createAt: {type:Date, default: Date.now()}
    }
});

$(init);
function init() {
  $("body").on('click', '#loginBtn', doLogin);
}
function doLogin() {
  $.ajax({
    type: "POST",
    url: "/login",//路径
    contentType: "application/json",
    dataType: "json",
    data: JSON.stringify({
      'usr': $("#usr").val(),//用于从一个对象解析出字符串!
      'pwd': $("#pwd").val()//改变当前地址
    }),
    success: function(result) {
      if (result.code == 99) {//表示成功
        $(".login-box-msg").text(result.msg);
      } else {
        $.cookie('username', result.data.username, {expires:30});
        //将result.data.username写入cookies中的username去
        ...
        location.href = "/blog";
      }
    }
  })
}

exports.findUsr = function(data, cb) {
    User.findOne({
        username: data.usr
    }, function(err, doc) {
        var user = (doc !== null) ? doc.toObject() : '';
        //将user转为一个对象(在密码和用户名匹配的前提下)
       else if (user.password === data.pwd) {
         ....
            cb(true, entries);
}

router.get('/login', function(req, res, next) {
    res.render('login', { layout: 'lg' });
});

router.post('/login', function(req, res, next) {
    dbHelper.findUsr(req.body, function (success, doc) {//`callback`函数
        res.send(doc);
    })
});

//obj就是要格式化的对象,[options]表示可选参数, [sep]指分隔符(默认&),[eq]指分配符(默认=),obj{}
querystring.stringify(obj, [sep], [eq]) //对象格式化成参数字符串(序列化)
querystring.parse(str, [sep], [eq], [options])//参数字符串格式化成对象(反序列化)，option默认参数为1000个，maxKeys <number>属性值将其设为0，那么就没有个数限制了
querystring.escape  //转译
querystring.unescape //反转译
//例子
var param="哈哈";
console.log(querystring.escape(param));
console.log(querystring.unescape(querystring.escape(param)));

// GET /user/tj
req.params.name
// => "tj"
app.post('/user/signup/:userid',function(req,res){
  req.params.userid;
})

// GET /file/javascripts/jquery.js
req.params[0]
// => "javascripts/jquery.js"

app.post('/user/signup',function(req,res){
  var _user = req.body.user;
})
// POST user[name]=tobi&user[email][email protected]
req.body.user.name
// => "tobi"
req.body.user.email
// => "[email protected]"
// POST { "name": "tobi" }
req.body.name
// => "tobi"。

//query是querystring说明req.query不一定是get
// GET /search?q=tobi+ferret
req.query.q
// => "tobi ferret"
// GET /shoes?order=desc&shoe[color]=blue&shoe[type]=converse
req.query.order
// => "desc"
req.query.shoe.color
// => "blue"
req.query.shoe.type
// => "converse"

// POST /search?q=tobi+ferret
{a:1,b:2}
req.query.q
// => "tobi ferret"

//1.app.set(name,value)
app.set('views', path.join(__dirname, 'views')); //设置了模版文件夹的路径,__dirname表取当前执行文件的路径
app.set('view engine', 'ejs');  //设置使用的模版引擎
// 通过express应用的use（all），把Middleware同router路径上的所有HTTP方法绑定：
//2.app.use([path], function)
var users = require('./routes/users');
app.use('/users', users);///users访问时，调用routes目录下users.js文件
//通过express应用的http.verb，把Middleware同router路径上的特定的HTTP方法绑定：
//3.app.get(name)//获取名为name的项的值
app.get('/', function(req, res){
  res.send('hello world');
});
app.post('/', function(req, res){  
  res.send('hello world'); })
//4.路由文件index.js
router.get('/homepage', function(req, res, next) {
  res.render('homepage', { newList: 'Express', layout: 'main' });//render表示调用模版引擎解析名
});

app.use(express.static(path.join(__dirname, 'public')));//现在，public 目录下面的文件就可以访问了。
//所有文件的路径都是相对于存放目录的，因此，存放静态文件的目录名不会出现在 URL 中。

app.get('/search', function (req, res) {
  // Simulating async operation
  setImmediate(function () {
    var jsonStr = req.query.params;
    try {
      var jsonObj = JSON.parse(jsonStr);
      res.send('Success');
    } catch (e) {
      res.status(400).send('Invalid JSON string');
    }
  });
});
//try-catch 仅适用于同步代码。而由于 Node 平台主要采用异步方式（尤其在生产环境中），因此 try-catch 不会捕获大量异常

app.get('/', function (req, res, next) {
  // do some sync stuff
  queryDb()
    .then(function (data) {
      // handle data
      return makeCsv(data)
    })
    .then(function (csv) {
      // handle csv
    })
    .catch(next);
});

app.use(function (err, req, res, next) {
  // handle error
});

hbs.registerPartials(__dirname + '/views/partials');

{ {#> layout } }
  My Content
{ {/layout} }//layout分页不存在则显示块内的内容My Content。

{
  title: "My first post!",
  author: {
    firstName: "Charles",
    lastName: "Jolley"
  }
}

{
  people: [
    "Yehuda Katz",
    "Alan Johnson",
    "Charles Jolley"
  ]
}

{{#list people}}{{firstName}} {{lastName}}{{/list}}

{
  people: [
    {firstName: "Yehuda", lastName: "Katz"},
    {firstName: "Carl", lastName: "Lerche"},
}

Handlebars.registerHelper('list', function(items, options) {
  var out = "<ul>";
  for(var i=0, l=items.length; i<l; i++) {
    out = out + "<li>" + options.fn(items[i]) + "</li>";
  }
  return out + "</ul>";
});

TestModel.create({username: '张三', password: 'md5-pass'}, 
function(err, user){
 if(!err){
     console.log(user.username + ' 保存成功!');
 }else{
    console.log('数据保存失败：' + err);
 }
});

var Entity = new TestModel({});
Enity.save(function(error,doc){
console.log(doc);});

TestModel.find({'age' : 28},function(error,data) {
console.log(data);
})//无查询参数时默认查出表中所有数据
findOne(Conditions,callback);//单条数据查询
findById(_id, callback);//单条数据查询，但它只接收文档的_id作为参数
//可以使用$gt(>)、$lt(<)、$lte(<=)、$gte(>=)操作符进行排除性的查询

User.findOneAndUpdate({_id: req.params.userId}, {
 username: newUsername
}, function (err, raw) {
...
});

SendDeliverySchema = new Schema({
  ...
  user_from: {
    type: Schema.ObjectId,
    ref: 'UserModel'
  },
  ...
});

Send.findOne({ status:2 }).populate('user_from').exec(function (err,doc){
  console.log(doc.user_from.username);
});

.populate('user', 'name') // only return the Persons name

.populate('user_from').populate('express')
.then(function (sendReqs){
})

UserSchema.statics.find_by_openid = function(openid, cb) {
  return this.findOne({
    openid: openid
  }, cb);
};

User.find_by_openid(openid, cb)

UserSchema.methods.is_exist = function(cb) {
  var query;
  query = {
    username: this.username,
    password: this.password
  };
  return this.model('UserModel').findOne(query, cb);
};

UserSchema.pre('save', function(next) {
    var user = this;
    if (!user.isModified('password')) return next();
    bcrypt.genSalt(SALT_WORK_FACTOR, function(err, salt) {
      if (err) return next(err);
      bcrypt.hash(user.password, salt, function (err, hash) {
        if (err) return next(err);
          user.password = hash;
          next();
        });
    });
});

ContactSchema = new Schema({
    ...
    owner: {
      type: Schema.ObjectId,
      required: true,
      index: true
    }
});

async.waterfall([
  function (callback){
    var a=5;
    console.log('OK1'); 
    setTimeout(function (){callback(null,a*2)},1000);},
  function(data,callback){
    console.log('OK2');
    setTimeout(function(){callback(null,data+7,data)},2000);},
  function(result1,result2,callback){
    console.log('OK3');
    setTimeout(function (){callback(null,result1-9,result2)},3000);}
],function(err,kk,jj){console.log(kk);console.log(jj);})，所以第一个函数的callback就是他后面的那个函数，
//自然数组最后一个函数的callback是finalFunction，对应递归写法的callback。
//除了这点还有一点需要注意，callback的第一个参数表示错误的信息，即使没错误，也要填上null，
//后面才是你想要传递的数据，而且除了finalFunction都不能显示接收错误信息，虽然callback有显式传递，waterfall的运行机制是只要数组中的任意一个函数出错立马跳到finalFunction，finalFunction会接收错误信息
//所以第一个函数的callback就是他后面的那个函数，自然数组最后一个函数的callback是finalFunction，对应递归写法的callback。

async.auto({
result1:function(callback){setTimeout(function(){
  callback(null,'functionResult1')},2000)},
result2:function(callback){setTimeout(function(){
  callback(null,'functionResult2')},1000)},//result1与result2是独立的，result3依赖于result1和result2
result3:['result1','result2',function(callback,replyData){  
  setTimeout(function(){callback(null,replyData.result1+replyData.result2);},1000)}]
  //注意result3的执行函数的参数输入与参数引用
},function(err,data){console.log(data)});

{
result2:functionResult2,
result1:functionResult1,
result3:functionResult1functionResult2
}
//结果是一个对象，和输入是函数组成的对象一样，对象元素出现的先后顺序决定于哪个结果先得到，当然依赖于另一个函数的计算结果的函数的结果当然就在其所依赖的后面。

npm install -g node-inspector

node-inspector &

node —debug[=port] filename //指定端口(默认5858)
node —debug-brk[=port] filename //强调断点在第一行

//服务端
var app = require('express')(); //Express服务
var server = require('http').Server(app); //原生Http服务
var io = require('socket.io')(server); //Socket.io服务
io.on('connection', function(socket){
    /* 具体操作 */
});
server.listen(3000);