var fs = require('fs');
fs.readFile('./resource.json',function(er,data){
    console.log(data)
})

var http = require('http');
http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World\n');
}).listen(3000);
console.log('Server running at http://localhost:3000/');

//异步 监听request
var http = require('http');
var server = http.createServer();
server.on('request', function (req, res) {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    res.end('Hello World\n');
})
server.listen(3000);
console.log('Server running at http://localhost:3000/');

var stream = fs.createReadStream('./resource.json')     //创建流数据
stream.on('data', function (chunk) {
    console.log(chunk)
})
stream.on('end', function () {
    console.log('finished')
})

var http = require('http');
var fs = require('fs');
http.createServer(function (req, res) {
    res.writeHead(200, {'Content-Type': 'image/png'});
    fs.createReadStream('./image.png').pipe(res);       //重点在这里呦
}).listen(3000);
console.log('Server running at http://localhost:3000/');

var http = require('http');     //内置的 http 模块提供了HTTP服务器和客户端功能
var fs = require('fs');         //内置的 path模块提供了与文件系统路径相关的功能
var path = require('path');     //内置的path模块提供了与文件系统路径相关的功能
var mime = require('mime');     //附加的 mime 模块有根据文件扩展名得出 MIME 类型的能力
var cache = {};                 //用来缓存文件内容的对象
var request = require('request');       //经过简化的HTTP客户端，可以用它获取RSS数据
var htmlparser = require('htmlparser'); // htmlparser 模块能把原始的RSS数据转换成JavaScript数据结构。
var exec = require('child_process').exec;  //获得执行的命令
var http = require('http');
var parse = require('url').parse;
var join = require('path').join;        //吧url的几部分连接起来
var fs = require('fs');
const LRU = require('lru-cache')    // vue 缓存组件用
const compression = require('compression') // 压缩成gzip
const cookieParse = require('cookie-parser')  // 解析cookie
var log4js = require('log4js');    //  日志
var root = __dirname;
var qs = require('querystring');
var obj = qs.parse(body);  //body为表单提交的数据
var args = process.argv.splice(2);    //获取命令行 node server.js 之后的参数
var argv = require('yargs').argv;     //获取命令行组件
const commander = require('commander'); // 命令行工具
const argv = require('minimist')(process.argv.slice(2));  // 格式化命令行
const semver = require('semver');      // 比较版本工具 
const prompt = require('prompt');      // 修饰命令行工具
const crypto = require('crypto');      // 加密算法
const opn = require('opn');         // 用于跨平台打开网站，文件等
const MFS = require('memory-fs');  // 一个简单的内存文件系统。在javascript对象中保存数据

//currency.js
exports.USToCanadian = function(us) {
    return roundTwoDecimals(us / canadianDollar);
}
//引入
var currency = require('./currency');

socket.on('data', handleData);

var EventEmitter = require('events').EventEmitter;      //引入事件发射器模块
var channel = new EventEmitter();                       //定义一个channel事件发射器
channel.on('join', function() {                         //自定义了一个join事件，后边需要触发这个事件
    console.log("Welcome!");
});
//发射事件
channel.emit('join');                   //必须发射事件，否则join回调永远不会被调用

var events = require('events');
var net = require('net');
var channel = new events.EventEmitter();
channel.clients = {};
channel.subscriptions = {};
channel.on('join', function(id, client) {    //添加 join 事件的监听器，保 存用户的 client 对象，以便 程序可以将数据发送给用户
    this.clients[id] = client;
    this.subscriptions[id] = function(senderId, message) {
        if (id != senderId) {                   //忽略发出这一广播数据的用户
            this.clients[id].write(message);
        }
    }
    this.on('broadcast', this.subscriptions[id]);   //添加一个专门针对当前用户 的 broadcast 事件监听器
});
var server = net.createServer(function (client) {
    var id = client.remoteAddress + ':' + client.remotePort;
    client.on('connect', function() {              //都是建立在原生事件基础之上的
        channel.emit('join', id, client);       //当有用户连到服务器上来时发出一个 join 事件，指明用户ID和 client 对象
    });
    client.on('data', function(data) {
        data = data.toString();
        channel.emit('broadcast', id, data);    //当有用户发送数据时，发出一个 频道 broadcast 事件，指明用户 ID和消息
    });
});
server.listen(8888);

telnet 127.0.0.1 8888

channel.on('leave', function(id) {              //创建 leave 事件的监听器
    channel.removeListener('broadcast', this.subscriptions[id]);        //移除指定客户端的 broadcast 监听器
    channel.emit('broadcast', id, id + " has left the chat.\n");
});
var server = net.createServer(function (client) {
    //...
    client.on('close', function() {         //都是建立在原生事件基础之上的
        channel.emit('leave', id);          //在用户断开连接时发出 leave事件
    });
});
server.listen(8888);

channel.on('shutdown', function() {                 //这个shutdown是自定义的，是用户命令敲的
    channel.emit('broadcast', '', "Chat has shut down.\n");
    channel.removeAllListeners('broadcast');
});

client.on('data', function(data) {
    data = data.toString();
    if (data == "shutdown\r\n") {
        channel.emit('shutdown');
    }
    channel.emit('broadcast', id, data);
});

channel.on('join', function(id, client) {
    var welcome = "Welcome!\n"
        + 'Guests online: ' + this.listeners('broadcast').length;   //this.listeners('broadcast')获取监听器数组
    client.write(welcome + "\n");
}

function Watcher(watchDir, processedDir) {
    this.watchDir = watchDir;
    this.processedDir = processedDir;
}
var events = require('events')
    , util = require('util');
util.inherits(Watcher, events.EventEmitter);  //Watcher.prototype = new events.EventEmitter();
var fs = require('fs')
    , watchDir = './watch'
    , processedDir = './done';
Watcher.prototype.watch = function() {
    var watcher = this;
    fs.readdir(this.watchDir, function(err, files) {
        if (err) throw err;
        for(var index in files) {
            watcher.emit('process', files[index]);
        }
    })
}
Watcher.prototype.start = function() {
    var watcher = this;
    fs.watchFile(watchDir, function() {
        watcher.watch();
    });
}
var watcher = new Watcher(watchDir, processedDir);
watcher.on('process', function process(file) {
    var watchFile = this.watchDir + '/' + file;
    var processedFile = this.processedDir + '/' + file.toLowerCase();
    fs.rename(watchFile, processedFile, function(err) {         //rename 重命名代替移动，因为原生没有移动
        if (err) throw err;
    });
});

setTimeout(function() {
    console.log('I execute first.');
    setTimeout(function() {
        console.log('I execute next.');
        setTimeout(function() {
            console.log('I execute last.');
        }, 100);
    }, 500);
}, 1000);

var flow = require('nimble');
flow.series([               //注意这里是数组[，flow.series是模块方法
    function (callback) {   //将所有需要同步的函数，分别放入function(callback){}中
        setTimeout(function() {
            console.log('I execute first.');
            callback();
        }, 1000);
    },
    function (callback) {
        setTimeout(function() {
            console.log('I execute next.');
            callback();
        }, 500);
    },
    function (callback) {
        setTimeout(function() {
            console.log('I execute last.');
            callback();
        }, 80);
    }
]);

//只写了一个逻辑函数，只做说明用
function checkForRSSFile () {
    fs.exists(configFilename, function(exists) {
        if (!exists)
            return next(new Error('Missing RSS file: ' + configFilename));
        next(null, configFilename);         //这里调用next() 方法
    });
}
function next(err, result) {    
    if (err) throw err;
    var currentTask = tasks.shift();        //重中之重！！这里获得数组删掉的值，此时数组变了，而且还能取到删掉的值！太棒了
    if (currentTask) {
        currentTask(result);
    }
}
next();

var fs = require('fs');
var completedTasks = 0;
var tasks = [];
var wordCounts = {};
var filesDir = './text';
function checkIfComplete() {
    completedTasks++;       
    if (completedTasks == tasks.length) {       //重点！！不等于tasks.length的时候不执行，所以只有等都完成的时候，才一起统计！！
        for (var index in wordCounts) {
            console.log(index +': ' + wordCounts[index]);
        }
    }
}
function countWordsInText(text) {
    var words = text
        .toString()
        .toLowerCase()
        .split(/\W+/)
        .sort();
    for (var index in words) {
        var word = words[index];
        if (word) {
            wordCounts[word] =
                (wordCounts[word]) ? wordCounts[word] + 1 : 1;
        }
    }
}
fs.readdir(filesDir, function(err, files) {
    if (err) throw err;
    for(var index in files) {
        var task = (function(file) {
            return function() {
                fs.readFile(file, function(err, text) {
                    if (err) throw err;
                    countWordsInText(text);
                    checkIfComplete();
                });
            }
        })(filesDir + '/' + files[index]);
        tasks.push(task);
    }
    for(var task in tasks) {
        tasks[task]();
    }
});

var flow = require('nimble')
var exec = require('child_process').exec;
function downloadNodeVersion(version, destination, callback) {
    var url = 'http://nodejs.org/dist/node-v' + version + '.tar.gz';
    var filepath = destination + '/' + version + '.tgz';
    exec('curl ' + url + ' >' + filepath, callback);
}
flow.series([               //模块固定方法
    function (callback) {   //这里是同步执行--下载
        flow.parallel([     //这里是定义 异步 
            function (callback) {       //异步1
                console.log('Downloading Node v0.4.6...');
                downloadNodeVersion('0.4.6', '/tmp', callback);
            },
            function (callback) {       //异步2
                console.log('Downloading Node v0.4.7...');
                downloadNodeVersion('0.4.7', '/tmp', callback);
            }
        ], callback);
    },
    function(callback) {            //同步执行--归档
        console.log('Creating archive of downloaded files...');
        exec(
            'tar cvf node_distros.tar /tmp/0.4.6.tgz /tmp/0.4.7.tgz',
            function(error, stdout, stderr) {
                console.log('All done!');
                callback();
            }
        );
    }
]);

var http = require('http');
var server = http.createServer(function(req, res){
    res.write('Hello World');
    res.end();
});

res.end('Hello World');

var body = 'Hello World';
res.setHeader('Content-Length', body.length);
res.setHeader('Content-Type', 'text/plain');
res.end(body);

$ curl -d 'buy groceries' http://localhost:3000

$ curl http://localhost:3000/static.js -i

req.setEncoding('utf8')     //现在的数据块不再是 Buffer 对象，而是一个 utf8  字符串
req.on('data', function(chunk){
    console.log(chunk);
});

var http = require('http');
var url = require('url');
var items = [];                             //用一个常规的JavaScript数组存放数据
var server = http.createServer(function(req, res){
    switch (req.method) {
        case 'POST':
            var item = '';               //为进来的事项设置字符串缓存
            req.setEncoding('utf8');
            req.on('data', function(chunk){
                item += chunk;          //将数据块拼接到缓存上
            });
            req.on('end', function(){
                items.push(item);       //将完整的新事项压入事项数组中
                res.end('OK\n');
            });
            break;
    }
});

var body = items.map(function(item, i){
    return i + ') ' + item;
}).join('\n');
res.setHeader('Content-Length', Buffer.byteLength(body));           //这里呦
res.setHeader('Content-Type', 'text/plain; charset="utf-8"');
res.end(body);

$ node
> require('url').parse('http://localhost:3000/1?api-key=foobar')
{   protocol: 'http:',
    slashes: true,
    host: 'localhost:3000',
    port: '3000',
    hostname: 'localhost',
    href: 'http://localhost:3000/1?api-key=foobar',
    search: '?api-key=foobar',
    query: 'api-key=foobar',
    pathname: '/1',
    path: '/1?api-key=foobar' 
}

var http = require('http');
var parse = require('url').parse;
var join = require('path').join;
var fs = require('fs');
var root = __dirname;
var server = http.createServer(function(req, res){
    var url = parse(req.url);
    var path = join(root, url.pathname);        //构造绝对路径
    var stream = fs.createReadStream(path);     //创建fs.ReadStream   
    stream.on('data', function(chunk){          //将文件数据写到响应中
        res.write(chunk);
    });
    stream.on('end', function(){
        res.end();                              //文件写完后结束响应
    });
});
server.listen(3000);

ReadableStream#pipe(WritableStream);

var readStream = fs.createReadStream('./original.txt')
var writeStream = fs.createWriteStream('./copy.txt')
readStream.pipe(writeStream);

var server = http.createServer(function(req, res){
    var url = parse(req.url);
    var path = join(root, url.pathname);
    var stream = fs.createReadStream(path);
    stream.pipe(res);
});

stream.pipe(res);
stream.on('error', function(err){
    res.statusCode = 500;
    res.end('Internal Server Error');
});

var server = http.createServer(function(req, res){
    var url = parse(req.url);
    var path = join(root, url.pathname);
    fs.stat(path, function(err, stat){
        if (err) {
            if ('ENOENT' == err.code) {     //检查文件是否存在
                res.statusCode = 404;
                res.end('Not Found');
            } else {
                res.statusCode = 500;
                res.end('Internal Server Error');
            }
        } else {
            res.setHeader('Content-Length', stat.size);  //用 stat 对象的属性设置Content-Length
            var stream = fs.createReadStream(path);
            stream.pipe(res);
            stream.on('error', function(err){
                res.statusCode = 500;
                res.end('Internal Server Error');
            });
        }
    });
});

var http = require('http');
var items = [];
var server = http.createServer(function(req, res){
    if ('/' == req.url) {
        switch (req.method) {
            case 'GET':
                show(res);
                break;
            case 'POST':
                add(req, res);
                break;
            default:
                badRequest(res);
        }
    } else {
        notFound(res);
    }
});
server.listen(3000);

$ node
> var qs = require('querystring');
> var body = 'item=take+ferrets+to+the+vet';
> qs.parse(body);
{ item: 'take ferrets to the vet' }

{ size: 28638,
    path: '/tmp/d870ede4d01507a68427a3364204cdf3',
    name: 'clock.png',
    type: 'image/png',
    lastModifiedDate: Sun, 05 Jun 2011 02:32:10 GMT,
    length: [Getter],
    filename: [Getter],
    mime: [Getter],
...
}

var form = new formidable.IncomingForm();
form.parse(req, function(err, fields, files){
    console.log(fields);                //直接打印这个对象
    console.log(files);                 //直接打印这个对象
    res.end('upload complete!');
});

form.on('progress', function(bytesReceived, bytesExpected){    //收到字节，期望字节
    var percent = Math.floor(bytesReceived / bytesExpected * 100);
    console.log(percent);
});

openssl genrsa 1024 > key.pem

openssl req -x509 -new -key key.pem > key-cert.pem

var https = require('https');
var fs = require('fs');
var options = {
    key: fs.readFileSync('./key.pem'),          //作为配置项的SSL秘钥和证书
    cert: fs.readFileSync('./key-cert.pem')     //作为配置项的SSL秘钥和证书
};
https.createServer(options, function (req, res) {   //第一个传入的就是配置项对象
    res.writeHead(200);
    res.end("hello world\n");
}).listen(3000);

var http = require('http');
var counter = 0;        //内存存储-存储在变量内
var server = http.createServer(function(req, res) {
    counter++;
    res.write('I have been accessed ' + counter + ' times.');
    res.end();
}).listen(8888);

var fs = require('fs');
var path = require('path');
var args = process.argv.splice(2);
var command = args.shift();                 //取出第一个参数（命令）
var taskDescription = args.join(' ');      //合并剩余的参数为字符串
var file = path.join(process.cwd(), '/.tasks');    //process.cwd() 为当前工作目录

switch (command) {
    case 'list':                        //'list' 会列出所有已保存的任务
        listTasks(file);
        break;
    case 'add':                         //'add' 会添加新任务
        addTask(file, taskDescription);         
        break;
    default:                            //其他任何参数都会显示帮助
        console.log('Usage: ' + process.argv[0]
            + ' list|add [taskDescription]');
}

function loadOrInitializeTaskArray(file, cb) {
    fs.exists(file, function(exists) {
        var tasks = [];
        if (exists) {
            fs.readFile(file, 'utf8', function(err, data) {  //从.tasks文件中读取待办事项数据
                if (err) throw err;
                var data = data.toString();
                var tasks = JSON.parse(data || '[]');       //把用JSON编码的待办事项数据解析到任务对象中
                cb(tasks);
            });
        } else {
            cb([]);     //如果.tasks文件不存在，则创建空的任务数组
        }
    });
}

function listTasks(file) {
    loadOrInitializeTaskArray(file, function(tasks) {
        for(var i in tasks) {               //循环任务列表并打印
            console.log(tasks[i]);
        }
    });
}

function storeTasks(file, tasks) {
    fs.writeFile(file, JSON.stringify(tasks), 'utf8', function(err) {
        if (err) throw err;
        console.log('Saved.');
    });
}

function addTask(file, taskDescription) {
    loadOrInitializeTaskArray(file, function(tasks) {
        tasks.push(taskDescription);
        storeTasks(file, tasks);
    });
}

npm install redis

var redis = require('redis');
var client = redis.createClient(6379, '127.0.0.1');
client.on('error', function (err) {
    console.log('Error ' + err);
});

client.set('color', 'red', redis.print);            //print 函数输出操 作的结果，或在出错时输出错误。
client.get('color', function(err, value) {
    if (err) throw err;
    console.log('Got: ' + value);
});

client.hmset('camping', {                   //设定哈希表元素
    'shelter': '2-person tent',
    'cooking': 'campstove'
}, redis.print);
client.hget('camping', 'cooking', function(err, value) {        //获取元素 "cooking" 的值
    if (err) throw err;
    console.log('Will be cooking with: ' + value);
});
client.hkeys('camping', function(err, keys) {           //获取哈希表的键
    if (err) throw err;
    keys.forEach(function(key, i) {
        console.log(' ' + key);
    });
});

var net = require('net');
var redis = require('redis');
var server = net.createServer(function(socket) {
    var subscriber;
    var publisher;
    socket.on('connect', function() {
        subscriber = redis.createClient();
        subscriber.subscribe('main_chat_room');
        subscriber.on('message', function(channel, message) {
            socket.write('Channel ' + channel + ': ' + message);
        });
        publisher = redis.createClient();
    });
    socket.on('data', function(data) {
        publisher.publish('main_chat_room', data);
    });
    socket.on('end', function() {
        subscriber.unsubscribe('main_chat_room');
        subscriber.end();
        publisher.end();
    });
});
server.listen(3000);

npm install hiredis
npm rebuild hiredis   //重新编译hiredis

npm install mongodb

var mongodb = require('mongodb');
var server = new mongodb.Server('127.0.0.1', 27017, {});
var client = new mongodb.Db('mydatabase', server, {w: 1});

npm install mongoose

var mongoose = require('mongoose');
var db = mongoose.connect('mongodb://localhost/tasks');

mongoose.disconnect();

var Schema = mongoose.Schema;
var Tasks = new Schema({
    project: String,
    description: String
});
mongoose.model('Task', Tasks);    //设置数据结构

var Task = mongoose.model('Task');
var task = new Task();
task.project = 'Bikeshed';
task.description = 'Paint the bikeshed red.';
task.save(function(err) {           //保存
    if (err) throw err;
    console.log('Task saved.');
});

var Task = mongoose.model('Task');
Task.find({'project': 'Bikeshed'}, function(err, tasks) {
    for (var i = 0; i < tasks.length; i++) {
        console.log('ID:' + tasks[i]._id);      //_id  唯一的ID 是自动添加的
        console.log(tasks[i].description);
    }
});

var Task = mongoose.model('Task');
Task.update(
    {_id: '4e65b793d0cf5ca508000001'},              //用内部ID更新
    {description: 'Paint the bikeshed green.'},
    {multi: false},                                 //只更新一个文档
    function(err, rows_updated) {
        if (err) throw err;
        console.log('Updated.');
    }
);

var Task = mongoose.model('Task');
Task.findById('4e65b3dce1592f7d08000001', function(err, task) {
    task.remove();                  //删除它
});

$ npm install connect

var connect = require('connect');
var app = connect();
app.listen(3000);

function logger(req, res, next) {
    console.log('%s %s', req.method, req.url);
    next();
}
var connect = require('connect');
var app = connect();
app.use(logger);                //app.use调用
app.listen(3000);

connect()
    .use(logger)
    .use(hello)
    .listen(3000);

//可写成
var app = connect();
app.use(logger);
app.use(hello);
app.listen(3000);

var connect = require('connect');
connect()
    .use(logger)
    .use('/admin', restrict)            //当. use() 的第一个参数是个字符串时， 只有URL前缀与之匹配时，Connect才 会调用后面的中间件
    .use('/admin', admin)
    .use(hello)
    .listen(3000);

function restrict(req, res, next) {
    var authorization = req.headers.authorization;      //HTTP请求头中的authorization
    if (!authorization) return next(new Error('Unauthorized'));
    var parts = authorization.split(' ')
    var scheme = parts[0]
    var auth = new Buffer(parts[1], 'base64').toString().split(':')
    var user = auth[0]
    var pass = auth[1];
    authenticateWithDatabase(user, pass, function (err) {       //根据数据库中的记录检查认证信息的函数
        if (err) return next(err);                          //告诉分派器出错了
        next();                                 //如果认证信息有效， 不带 参数调用 next()
    });
}

function admin(req, res, next) {
    switch (req.url) {          //简单的路由功能
        case '/':       
            res.end('try /users');
            break;
        case '/users':
            res.setHeader('Content-Type', 'application/json');
            res.end(JSON.stringify(['tobi', 'loki', 'jane']));
            break;
    }
}

var connect = require('connect');
connect()
    .use(logger)
    .use('/blog', blog)
    .use('/posts', blog)
    .use(hello)
    .listen(3000);

function setup(options) {

    // 设置逻辑
    //在这里做中间件的初始化
    return function(req, res, next) {
    
        // 中间件逻辑
        //即使被外部函数返回了，仍然可以访问 options
    }
}

app.use(setup({some: 'options'}))

var app = connect()
    .use(logger(':method :url'))
    .use(hello);

function setup(format) {            //setup 函数可以用不 同的配置调用多次
    var regexp = /:(\w+)/g;         //logger组件用正则表达式匹配请求属性
    return function logger(req, res, next) {                //Connect使用的真 实 logger 组件
        var str = format.replace(regexp, function(match, property){     //用正则表达式格式化请求的日志条目
            return req[property];
        });
        console.log(str);
        next();
    }
}
module.exports = setup;

//用法
var connect = require('connect');
var router = require('./middleware/router');            //路由器组件，稍后定义
var routes = {                                          //定义路由的对象
    GET: {
        '/users': function(req, res){
            res.end('tobi, loki, ferret');
        },
        '/user/:id': function(req, res, id){            //其中的每一项都是对请求URL的映射，并包含要调用的回调函数
            res.end('user ' + id);
        }
    },
    DELETE: {
        '/user/:id': function(req, res, id){
            res.end('deleted user ' + id);
        }
    }
};
connect()
    .use(router(routes))                    //将路由对象传给路由器的 setup 函数
    .use(router(require('./routes/user')))          // 可删除，做例子
    .use(router(require('./routes/admin')))          // 可删除，做例子
    .listen(3000);

var parse = require('url').parse;
module.exports = function route(obj) {
    return function(req, res, next){
        if (!obj[req.method]) {         //检查以确保 req.method 定义了
            next();
            return;                     //如果未定义，调用 next() ， 并停止一切后续操作
        }
        var routes = obj[req.method]        //查找 req.method 对应的路径
        var url = parse(req.url)            //解析URL， 以 便 跟 pathname 匹配
        var paths = Object.keys(routes)     //将 req.method 对应的路径存放到数组中
        for (var i = 0; i < paths.length; i++) {        //遍历路径
            var path = paths[i];
            var fn = routes[path];
            path = path
                .replace(/\//g, '\\/')
                .replace(/:(\w+)/g, '([^\\/]+)');
            var re = new RegExp('^' + path + '$');      //构造正则表达式
            var captures = url.pathname.match(re)
            if (captures) {                     //尝试跟 pathname 匹配
                var args = [req, res].concat(captures.slice(1));        //传递被捕获的分组
                fn.apply(null, args);           
                return;                         //当有相匹配的函数时，返回， 以防止后续的 next() 调用
            }
        }
        next();
    }
};

var path = url.parse(req.url).pathname;
function rewrite(req, res, next) {
    var match = path.match(/^\/blog\/posts\/(.+)/)
    if (match) {                                        //只针对/blog /posts 请 求 执行查找
        findPostIdBySlug(match[1], function(err, id) {
            if (err) return next(err);          //如果查找出错，则通知错误处理器并停止处理
            if (!id) return next(new Error('User not found'));      //如果没找到跟缩 略名相对应的 ID， 则带着 “User not found”的错 误 参 数 调 用 next()
            req.url = '/blog/posts/' + id;          //重写 req.url 属性， 以便后续中间件可 以使用真实的ID
            next();
        });
    } else {
        next();
    }
}

var connect = require('connect')
connect()
    .use(function hello(req, res) {
        foo();
        res.setHeader('Content-Type', 'text/plain');
        res.end('hello world');
    })
    .listen(3000)

function errorHandler() {
    var env = process.env.NODE_ENV || 'development'; 
    return function(err, req, res, next) {      //错误处理中间件定义四个参数
        res.statusCode = 500;
        switch (env) {                          //errorHandler中间件组 件根据 NODE_ENV 的值 执行不同的操作
            case 'development':
                res.setHeader('Content-Type', 'application/json');
                res.end(JSON.stringify(err));
                break;
            default:
                res.end('Server error');
        }
    }
}

var express = require('express');
var app = express();
app.get('/', function(req, res){
    res.send('Hello');
});
app.listen(3000);

$ npm install -g express

express -e photo
//补  4.0版本需要安装express-generator才能生成程序了
npm install -g express-generator
express -e photo

$ NODE_ENV=production node app

$ set NODE_ENV=production
$ node app

app.configure(function(){
    app.set('views', __dirname + '/views');
    app.set('view engine', 'ejs');
    ...
});
app.configure('development', function(){
    app.use(express.errorHandler());
});

var env = process.env.NODE_ENV || 'development';        //默认为“development”
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');              //所有环境  
...
if ('development' == env) {                 //仅开发环境，用if语句 代替 app.configure
    app.use(express.errorHandler());
}

var assert = require('assert');
var Todo = require('./todo');
var todo = new Todo();
var testsCompleted = 0;

function deleteTest () {
    todo.add('Delete Me');      //添加一些数据以便测试删除
    assert.equal(todo.getCount(), 1, '1 item should exist');    //重点：断言数据被正确添加
    todo.deleteAll();
    assert.equal(todo.getCount(), 0, 'No items should exist');
    testsCompleted++;
}

function addTest () {
    todo.deleteAll();
    todo.add('Added');
    assert.notEqual(todo.getCount(), 0, '1 item should exist');
    testsCompleted++;
}

//测试看 doAsync 回调传入的是否为 true
function doAsyncTest (cb) {
    todo.doAsync(function (value) {         //value就是doAsync里的cb
        assert.ok(value,'Callback should be passed true');   //断言值为 true
        testsCompleted++;           //记录测试已完成
        cb();                       //完成后激活回调函数
    })
}

//测试看缺少参数时add是否会抛出错误
function throwsTest (cb) {
    assert.throws(todo.add, /requires/);
    testsCompleted++
}

$ npm install -g mocha

$ mkdir -p memdb/test       //-p 是创建一个子目录
$ cd memdb
$ touch index.js            //新建一个不存在的文件
$ touch test/memdb.js

var memdb = require('..');              //要测试的文件是当前目录下的index.js文件
var assert = require('assert');
describe('memdb', function(){           //描述memdb 功能                        *1
    describe('.save(doc)', function(){  //描述 .save() 方法的功能
        it('should save the document', function(){      //期望值               *2             
            var pet = { name: 'Tobi' };
            memdb.save(pet);
            var ret = memdb.first({ name: 'Tobi' });
            assert(ret == pet);                 //确保找到了pet                  *3
        })
    })
})

describe('.save(doc)', function(){
    it('should save the document', function(done){              //传入done
        var pet = { name: 'Tobi' };
        memdb.save(pet, function(){
            var ret = memdb.first({ name: 'Tobi' });
            assert(ret == pet);                 //断言文档正确保存了
            done();                             //告诉Mocha你已经完成这个测试用例了
        });
    });
});

var ejs = require('ejs');
var template = '<%= message %>';                
var context = {message: 'Hello template!'};
console.log(ejs.render(template, {locals: context}));   //render第二个参数locals，包含渲染选项以及上下文数据

var ejs = require('ejs');
var template = '<%= message %>';
var context = {message: "<script>alert('XSS attack!');</script>"};
console.log(ejs.render(template, context));
// 转移后就是下边这样
&lt;script&gt;alert('XSS attack!');&lt;/script&gt;

var ejs = require('ejs');
var template = '<%=: movies | last %>';         //最后一个 
var context = {'movies': [
    'Bambi',
    'Babe: Pig in the City',
    'Enter the Void'
]};
console.log(ejs.render(template, context));

//把标题截成只有20个字符的**字符串**
<%=: title | truncate:20 %>
//把标题截成只有2个单词
<%=: title | truncate_words:2 %>

<%=: weight | replace:'kilogram','kg' %>

//按字母顺序--当movies是数组
<%=: movies | sort | first %>
//按字母顺序--当movies是数组
<%=: movies | sort_by:'name' | first | get:'name' %>

<%=: movies | map: 'name' | sort | first %>

var ejs = require('ejs');
var template = '<%=: price * 1.145 | round:2 %>';
var context = {price: 21};
ejs.filters.round = function(number, decimalPlaces) {           //在 ejs.filters 对象上定义一个函数
    number = isNaN(number) ? 0 : number;
    decimalPlaces = !decimalPlaces ? 0 : decimalPlaces;
    var multiple = Math.pow(10, decimalPlaces);
    return Math.round(number * multiple) / multiple;
};
console.log(ejs.render(template, context));

var ejs = require('ejs');
var fs = require('fs');
var http = require('http');
var filename = './template/students.ejs';           //模板引擎的位置
var students = [                                    //传给引擎的数据
    {name: 'Rick LaRue', age: 23},
    {name: 'Sarah Cathands', age: 25},
    {name: 'Bob Dobbs', age: 37}
];
var server = http.createServer(function(req, res) {     //创建一个服务器
    if (req.url == '/') {
        fs.readFile(filename, function(err, data) {     //从文件中读取模板
            var template = data.toString();
            var context = {students: students};
            var output = ejs.render(template, context);  //渲染模板
            res.setHeader('Content-type', 'text/html');
            res.end(output);                            //发送http响应
        });
    } else {
        res.statusCode = 404;
        res.end('Not found');
    }
});
server.listen(8000);

<% if (students.length) { %>
<ul>
    <% students.forEach(function(student) { %>
        <li><%= student.name %> (<%= student.age %>)</li>
        <% }) %>
    </ul>
    <% } %>

var cache = process.env.NODE_ENV === 'production';
var output = ejs.render(
    template,
    {students: students, cache: cache, filename: filename}      //后边多了cache和filename
);

<html>
<head>
    <title>EJS example</title>
    <script src="ejs.js"></script>
    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.8/jquery.js"></script>
</head>
<body>
<div id='output'></div>             //用来渲染模板输出的占位标签
<script>
    var template = "<%= message %>";        //渲染内容用的模板
    var context = {message: 'Hello template!'};             //用在模板中的数据
    $(document).ready(function() {      //等着浏览器加载数据
        $('#output').html(
                ejs.render(template, context)   //将模板渲染到ID为"output" 的div中
        );
    });
</script>
</body>
</html>

sudo npm install -g forever

forever start server.js

forever stop server.js

forever list

forever -w start server.js

//ubuntu
sudo apt-get install upstart
//centos
sudo yum install upstart

var cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().length;          //确定服务器的内核数
if (cluster.isMaster) {
    for (var i = 0; i < numCPUs; i++) {                 
        cluster.fork();                             //每个内核创建一个fork
    }
    cluster.on('exit', function(worker, code, signal) {
        console.log('Worker ' + worker.process.pid + ' died.');
    });
} else {
    http.Server(function(req, res) {                //定义每个工人的工作
        res.writeHead(200);
        res.end('I am a worker running in process ' + process.pid);
    }).listen(8000);
}

var cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().length;
var workers = {};
var requests = 0;
if (cluster.isMaster) {
    for (var i = 0; i < numCPUs; i++) {
        workers[i] = cluster.fork();
        (function (i) {
            workers[i].on('message', function(message) {            //监听来自工人的消息
                if (message.cmd == 'incrementRequestTotal') {
                    requests++;
                    for (var j = 0; j < numCPUs; j++) {
                        workers[j].send({                           //将新的请求总数发送给所有工人
                            cmd: 'updateOfRequestTotal',
                            requests: requests
                        });
                    }
                }
            });
        })(i);                                                       //用闭包保留工人的值           
    }
    cluster.on('exit', function(worker, code, signal) {
        console.log('Worker ' + worker.process.pid + ' died.');
    });
} else {
    process.on('message', function(message) {                       //监听来自主进程的消息
        if (message.cmd == 'updateOfRequestTotal') {
            requests = message.requests;                            //用主进程的消息更新请求计数
        }
    });
    http.Server(function(req, res) {
        res.writeHead(200);
        res.end('Worker in process ' + process.pid
            + ' says cluster has responded to ' + requests
            + ' requests.');
        process.send({cmd: 'incrementRequestTotal'});               //让主进程知道请求总数应该增加了
    }).listen(8000);
}

http {
    upstream my_node_app {
        server 127.0.0.1:8000;          //Node程序的IP地址和端口
    }
    server {
        listen 80;                      //代理接收请求的端口
        server_name localhost domain.com;
        access_log /var/log/nginx/my_node_app.log;
        location ~ /static/ {           //处理URL路径以/static/开头的文件请求
            root /home/node/my_node_app;
            if (!-f $request_filename) {
                return 404;
            }
        }
        location / {                    //定义由代理响应的URL路径
            proxy_pass http://my_node_app;
        proxy_redirect off;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header X-NginX-Proxy true;
    }
    }
}

var app = require('http').createServer(handler);
var io = require('socket.io').listen(app);          //将普通的HTTP服务器升级为Socket.IO服务器
var fs = require('fs');
var html = fs.readFileSync('index.html', 'utf8');
function handler (req, res) {
    res.setHeader('Content-Type', 'text/html');
    res.setHeader('Content-Length', Buffer.byteLength(html, 'utf8'));
    res.end(html);
}
function tick () {
    var now = new Date().toUTCString();             //取得当前时间的UTC表示
    io.sockets.send(now);                           //将时间发送给所有连接上来的客户端
}
setInterval(tick, 1000);                            //每秒运行一次 tick 函数
app.listen(8080);                                   //app来监听端口

<!DOCTYPE html>
<html>
<head>
    <script type="text/javascript" src="/socket.io/socket.io.js">
    </script>
    <script type="text/javascript">
        var socket = io.connect();
        socket.on('message', function (time) {
            document.getElementById('time').innerHTML = time;
        });
    </script>
</head>
<body>Current server time is: <b><span id="time"></span></b>
</body>
</html>

var fs = require('fs');
var url = require('url');
var http = require('http');
var path = require('path');
var express = require('express');
var app = express();
var server = http.createServer(app);                      //创建http服务器
var io = require('socket.io').listen(server);             //包装HTTP服务器创建Socket.IO实例
var root = __dirname;
app.use(function (req, res, next) {                 //用中间件开始监测 由 static 中间件 返回的文件
    req.on('static', function () {                  //注册由 static() 中 间 件 发 射 的 static 事件
        var file = url.parse(req.url).pathname;
        var mode = 'stylesheet';
        if (file[file.length - 1] == '/') {
            file += 'index.html';
            mode = 'reload';
        }
        createWatcher(file, mode);
    });
    next();
});
app.use(express.static(root));              //将服务器设置为基本的静态文件服务器
var watchers = {};                          //保存被监测的活动文件清单
function createWatcher (file, event) {
    var absolute = path.join(root, file);
    if (watchers[absolute]) {
        return;
    }
    fs.watchFile(absolute, function (curr, prev) {
        if (curr.mtime !== prev.mtime) {            //检查 mtime ( 最后修改时间)是否有变化； 如果变了， 激发Socket.IO事件
            io.sockets.emit(event, file);           //激发reload 
        }
    });
    watchers[absolute] = true;
}
server.listen(8080);

<!DOCTYPE html>
<html>
<head>
    <title>Socket.IO dynamically reloading CSS stylesheets</title>
    <link rel="stylesheet" type="text/css" href="/header.css" />
    <link rel="stylesheet" type="text/css" href="/styles.css" />
    <script type="text/javascript" src="/socket.io/socket.io.js">
    </script>
    <script type="text/javascript">
        window.onload = function () {
            var socket = io.connect();
            socket.on('reload', function () {
                window.location.reload();
            });
            socket.on('stylesheet', function (sheet) {
                var link = document.createElement('link');
                var head = document.getElementsByTagName('head')[0];
                link.setAttribute('rel', 'stylesheet');
                link.setAttribute('type', 'text/css');
                link.setAttribute('href', sheet);
                head.appendChild(link);
            });
        }
    </script>
</head>
<body>
<h1>This is our Awesome Webpage!</h1>
<div id="body">
    <p>If this file (<code>index.html</code>) is edited, then the
        server will send a message to the browser using Socket.IO telling
        it to refresh the page.</p>
    <p>If either of the stylesheets (<code>header.css</code> or
        <code>styles.css</code>) are edited, then the server will send a
        message to the browser using Socket.IO telling it to dynamically
        reload the CSS, without refreshing the page.</p>
</div>
<div id="event-log"></div>
</body>
</html>

var b = new Buffer("121234869");
console.log(b.length);
9
console.log(b);
<Buffer 31 32 31 32 33 34 38 36 39>

//
var b = new Buffer(4);
b.writeInt32LE(121234869, 0);
console.log(b.length);
4
console.log(b);
<Buffer b5 e5 39 07>

var net = require('net');
net.createServer(function (socket) {
    socket.write('Hello World!\r\n');
    socket.end();
}).listen(1337);
console.log('listening on port 1337');

$ node server.js
listening on port 1337

$ telnet localhost 1337
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
Hello World!
Connection closed by foreign host.

socket.on('data', function (data) {
    console.log('got "data"', data);
});

var net = require('net');
var socket = net.connect({ host: process.argv[2], port: 22 });
socket.setEncoding('utf8');
socket.once('data', function (chunk) {
    console.log('SSH server version: %j', chunk.trim());
    socket.end();
});

socket.pipe(socket);

socket.on('close', function () {
    console.log('client disconnected');
});

var net = require('net');
net.createServer(function (socket) {
    console.log('socket connected!');
    socket.on('data', function (data) {
        console.log('"data" event', data);
    });
    socket.on('end', function () {
        console.log('"end" event');
    });
    socket.on('close', function () {
        console.log('"close" event');
    });
    socket.on('error', function (e) {
        console.log('"error" event', e);
    });
    socket.pipe(socket);                //返给客户端
}).listen(1337);

var net = require('net');
var socket = net.connect({ port: 1337, host: 'localhost' });
socket.on('connect', function () {
// begin writing your "request"
    socket.write('HELO local.domain.name\r\n');
    ...
});

var net = require('net');
var host = process.argv[2];
var port = Number(process.argv[3]);         //从命令行参数中解析出主机和端口
var socket = net.connect(port, host);       //创建 socket 实例并开 始连接服务器
socket.on('connect', function () {          //到服务器的连接建立好 后处理 connect 事件
    process.stdin.pipe(socket);             //将进程的stdin传给socket
    socket.pipe(process.stdout);            //将 socket 的 数据传给进 程的stdout
    process.stdin.resume();                 //在stdin上调用 resume() ， 开始读取数据
});
socket.on('end', function () {      
    process.stdin.pause();                  //当发生 event 事件 时中断stdin
});

var debug;
if (process.env.DEBUG) {            //根据环境变量DEBUG定义 debug 函数
    debug = function (data) {       //如果设定了DEBUG， debug 函数会将参数输出到 stderr 中
        console.error(data);
    };
} else {
    debug = function () {};         //如果没设定DEBUG， debug函数为空，什么也不做
}
debug('this is a debug call');      //在代码中各处调用 debug 函数
console.log('Hello World!');
debug('this another debug call');

$ DEBUG=1 node debug-mode.js

process.on('exit', function (code) {
    console.log('Exiting...');
});

process.on('uncaughtException', function (err) {
    console.error('got uncaught exception:', err.message);
    process.exit(1);            //必须包含
});

process.on('SIGINT', function () {
    console.log('Got Ctrl-C!');
    server.close();             //阻止杀死进程，只让其退出并关闭进程就可以了
});

var fs = require('fs');
module.exports = function move (oldPath, newPath, callback) {
    fs.rename(oldPath, newPath, function (err) {        //调用 fs.rename() 并希望它能用
        if (err) {
            if (err.code === 'EXDEV') {     //如果出现EXDEV错误，用备用的复制技术
                copy();                     //执行复制操作
            } else {
                callback(err);              //callback是自定义的回调函数
            }
            return;
        }
        callback();
    });
    function copy () {
        var readStream = fs.createReadStream(oldPath);
        var writeStream = fs.createWriteStream(newPath);
        readStream.on('error', callback);
        writeStream.on('error', callback);
        readStream.on('close', function () {
            fs.unlink(oldPath, callback);
        });
        readStream.pipe(writeStream);
    }
}

var fs = require('fs');
fs.watchFile('/var/log/system.log', function (curr, prev) {
    if (curr.mtime.getTime() !== prev.mtime.getTime()) {
        console.log('"system.log" has been modified');
    }
});

fstream
    .Reader("path/to/dir")                  //读
    .pipe(fstream.Writer({ path: "path/to/other/dir", filter: isValid )         //写
// 检查即将写入的文件并返回它是否应该被复制
function isValid () {
// 忽略TextMate之类的文本编辑器创建的临时文件
    return this.path[this.path.length - 1] !== '~';
}