Node笔记(二)

在 2016年9月8日上张贴由 BestLove

# stream
// 在node中，流也是一个对象，我们只需要响应流的事件就行了
// data事件：流的数据已经可以读取了(可能会有多次，每次传递chunk是流的一部分数据)
// end事件：流已经到末尾了
// error事件：出错了
'use strict';
var fs = require('fs');
var rs = fs.createReadStream('test.php', 'utf-8');
rs.on('data', function(chunk){
    // 异步返回的数据，必须在回调中操作
    // 不要用全局变量赋值，可能会是undefined
    streamWrite('test1.php', 'utf-8', chunk);
    console.log(chunk);
});
rs.on('end', function() {
    console.log('over');
});
rs.on('error', function(err) {
    console.log(err);
});
function streamWrite(dir, charset, data) {
    var ws1 = fs.createWriteStream(dir, charset);
    ws1.write(data);
    ws1.write('\necho 22');
    ws1.end();
}
// 写入二进制流
var ws2 = fs.createWriteStream('2.png');
ws2.write(new Buffer('use stream write bin'), 'utf-8');
ws2.end();

# pipe
// 所有可以读取数据的流都继承自stream.Readable，所有可以写入的流都继承自stream.Writable
// 就像两根水管可以串起来一样，一个Readable和一个Writable也可以串起来
// 所有的数据自动从Readable流进入Writalbe流，这种操作就叫pipe
// Node.js的Readable有一个pipe()，就是用来干这事的
// 下面几行代码实际上就是个复制操作
'use strict';
var fs = require('fs');
var rs = fs.createReadStream('sample.txt');
var ws = fs.createWriteStream('copied.txt');
rs.pipe(ws);
// 默认情况下，当Readable流的数据读取完毕后，end事件就会触发，将自动关闭Writable流
readable.pipe(writable, { end: false });        //传入参数，不让它自动关闭

# http
// http服务器demo，输出hello world
'use strict';
// 导入http模块
var http = require('http');
// 创建http server并传入回调函数
var server = http.createServer(function(request, response){
    console.log(request.method + ':' + request.url);
    response.writeHead(200, {'Content-Type':'text/html'});
    response.end('<h1>hello world</h1>');
});
server.listen(8888);
console.log('server is running in 127.0.0.1:8888');

// 文件服务器 v1.0
'use strict';
// 导入http模块
var http = require('http');
var url = require('url');
var fs = require('fs');
// 创建http server并传入回调函数
var server = http.createServer(function(request, response){
    var pathname = url.parse(request.url).pathname;
    try {
        var data = fs.readFileSync(pathname);
        response.writeHead(200, {'Content-Type':'image/x-png'});
        response.end(data);
    } catch(e) {
        console.log(e);
    }
    response.writeHead(404, {'Content-Type':'text/html'});
    response.end('not found');
});
server.listen(8888);
console.log('server is running in 127.0.0.1:8888');

// url.parse
console.log(url.parse('http://user:pass@host.com:8080/path/to/file?query=string#hash'));
Url {
    protocol: 'http:',
    slashes: true,
    auth: 'user:pass',
    host: 'host.com:8080',
    port: '8080',
    hostname: 'host.com',
    hash: '#hash',
    search: '?query=string',
    query: 'query=string',
    pathname: '/path/to/file',
    path: '/path/to/file?query=string',
    href: 'http://user:pass@host.com:8080/path/to/file?query=string#hash'
}

// 本地文件处理 可以用path模块(兼容不同操作系统的/)
'use strict';
var path = require('path');
// 解析当前目录 D:\wnmp\www\public\js
var workDir = path.resolve('.');
// D:\wnmp\www\public\js\pub\test\index.php
var filePath = path.join(workDir, 'pub', 'test', 'index.php');

// 文件服务器 v1.1
'use strict';
var fs = require('fs');
var path = require('path');
var http = require('http');
var url = require('url');
// 启动脚本时传入根目录
var rootPath = path.resolve(process.argv[2] || '.');
var server = http.createServer(function(request, response) {
    var filePath = path.join(rootPath, url.parse(request.url).pathname);
    fs.stat(filePath, function(err, stat) {
        if (!err && stat.isFile()) {
            response.writeHead(200);
            fs.createReadStream(filePath).pipe(response);
        } else {
            response.writeHead(404);
            response.end('not found');
        }
    });
});
server.listen(8888);

# crypto
// MD5等
'use strict';
const crypto = require('crypto');
// 可以传入md5 sha1 sha256 sha512...
const hash = crypto.createHash('md5');
hash.update('123456');
// 以16进制字符串表示签名(通常是hex和base64格式)
console.log(hash.digest('hex'));    //e10adc3949ba59abbe56e057f20f883e

// Hmac也是一种hash算法，可以利用MD5等，需要一个密钥
'use strict';
const crypto = require('crypto');
const hmac = crypto.createHmac('sha256', 'your sign key');
hmac.update('123456');
// 91e953f62f88a32a293a6ee8bd470a69ae77e4bb5549b1e43bd9bcf40f2e3ac3
console.log(hmac.digest('hex'));

// AES对称加密
'use strict';
const crypto = require('crypto');
function aesEncrypt(data, key) {
    const cipher = crypto.createCipher('aes192', key);
    var crypted = cipher.update(data, 'utf8', 'hex');
    crypted += cipher.final('hex');
    return crypted;
}
function aesDecrypt(data, key) {
    const decipher = crypto.createDecipher('aes192', key);
    var decrypted = decipher.update(encrypted, 'hex', 'utf8');
    decrypted += decipher.final('utf8');
    return decrypted;
}
var data = 'Hello, this is a secret message!';
var key = 'Password!';
var encrypted = aesEncrypt(data, key);
var decrypted = aesDecrypt(encrypted, key);
console.log('Plain text: ' + data);
console.log('Encrypted text: ' + encrypted);
console.log('Decrypted text: ' + decrypted);

/*
    Diffie-Hellman
    DH算法是一种密钥交换协议，它可以让双方在不泄漏密钥的情况下协商出一个密钥来
    DH算法基于数学原理，比如小明和小红想要协商一个密钥，可以这么做
    小明先选一个素数p=23(p必须是素数，否则可能被整除)和一个底数g=5(底数可以任选)和一个秘密整数a=6
    A = g^a % p = 8 (5的6次方模23=8) 然后告诉小红 p=23 g=5 A=8
    小红根据pgA，也选一个秘密整数b=15 算出：B = g^b % p = 19 然后把B告诉小明
    小明算出 s = B^a % p =2  小红算出 s = A^b % p = 2
    所以最终协商的密钥 s = 2
    第三方只能知道p=23，g=5，A=8，B=19，不知道双方的秘密整数a=6和b=15，所以无法计算出密钥2
*/
'use strict';
const crypto = require('crypto');
// 根据给定的位长度，创建小明的DiffieHellman对象
var ming = crypto.createDiffieHellman(512);
// 生成密钥和公钥(底数和秘密整数)
var ming_keys = ming.generateKeys();
// 返回质数
var prime = ming.getPrime();
// 返回生成器
var generator = ming.getGenerator();
// 根据小明的质数和生成器创建小红的DiffieHellman对象
var hong = crypto.createDiffieHellman(prime, generator);
// 生成密钥和公钥(底数和秘密整数)
var hong_keys = hong.generateKeys();
// 分别算出小明、小红的协商密钥s
var ming_secret = ming.computeSecret(hong_keys);
var hong_secret = hong.computeSecret(ming_keys);
// 生成的密钥是一个Buffer，转成16进制字符串后应该是相等的
console.log(ming_secret.toString('hex')  === hong_secret.toString('hex'));

// crypto模块也可以处理数字证书、RSA等

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

# stream

// 在node中，流也是一个对象，我们只需要响应流的事件就行了

// data事件：流的数据已经可以读取了(可能会有多次，每次传递chunk是流的一部分数据)

// end事件：流已经到末尾了

// error事件：出错了

'use strict';

var fs = require('fs');

var rs = fs.createReadStream('test.php', 'utf-8');

rs.on('data', function(chunk){

// 异步返回的数据，必须在回调中操作

// 不要用全局变量赋值，可能会是undefined

streamWrite('test1.php', 'utf-8', chunk);

console.log(chunk);

});

rs.on('end', function() {

console.log('over');

});

rs.on('error', function(err) {

console.log(err);

});

function streamWrite(dir, charset, data) {

var ws1 = fs.createWriteStream(dir, charset);

ws1.write(data);

ws1.write('\necho 22');

ws1.end();

}

// 写入二进制流

var ws2 = fs.createWriteStream('2.png');

ws2.write(new Buffer('use stream write bin'), 'utf-8');

ws2.end();

# pipe

// 所有可以读取数据的流都继承自stream.Readable，所有可以写入的流都继承自stream.Writable

// 就像两根水管可以串起来一样，一个Readable和一个Writable也可以串起来

// 所有的数据自动从Readable流进入Writalbe流，这种操作就叫pipe

// Node.js的Readable有一个pipe()，就是用来干这事的

// 下面几行代码实际上就是个复制操作

'use strict';

var fs = require('fs');

var rs = fs.createReadStream('sample.txt');

var ws = fs.createWriteStream('copied.txt');

rs.pipe(ws);

// 默认情况下，当Readable流的数据读取完毕后，end事件就会触发，将自动关闭Writable流

readable.pipe(writable, { end: false }); //传入参数，不让它自动关闭

# http

// http服务器demo，输出hello world

'use strict';

// 导入http模块

var http = require('http');

// 创建http server并传入回调函数

var server = http.createServer(function(request, response){

console.log(request.method + ':' + request.url);

response.writeHead(200, {'Content-Type':'text/html'});

response.end('<h1>hello world</h1>');

});

server.listen(8888);

console.log('server is running in 127.0.0.1:8888');

// 文件服务器 v1.0

'use strict';

// 导入http模块

var http = require('http');

var url = require('url');

var fs = require('fs');

// 创建http server并传入回调函数

var server = http.createServer(function(request, response){

var pathname = url.parse(request.url).pathname;

try {

var data = fs.readFileSync(pathname);

response.writeHead(200, {'Content-Type':'image/x-png'});

response.end(data);

} catch(e) {

console.log(e);

}

response.writeHead(404, {'Content-Type':'text/html'});

response.end('not found');

});

server.listen(8888);

console.log('server is running in 127.0.0.1:8888');

// url.parse

console.log(url.parse('http://user:pass@host.com:8080/path/to/file?query=string#hash'));

Url {

protocol: 'http:',

slashes: true,

auth: 'user:pass',

host: 'host.com:8080',

port: '8080',

hostname: 'host.com',

hash: '#hash',

search: '?query=string',

query: 'query=string',

pathname: '/path/to/file',

path: '/path/to/file?query=string',

href: 'http://user:pass@host.com:8080/path/to/file?query=string#hash'

}

// 本地文件处理可以用path模块(兼容不同操作系统的/)

'use strict';

var path = require('path');

// 解析当前目录 D:\wnmp\www\public\js

var workDir = path.resolve('.');

// D:\wnmp\www\public\js\pub\test\index.php

var filePath = path.join(workDir, 'pub', 'test', 'index.php');

// 文件服务器 v1.1

'use strict';

var fs = require('fs');

var path = require('path');

var http = require('http');

var url = require('url');

// 启动脚本时传入根目录

var rootPath = path.resolve(process.argv[2] || '.');

var server = http.createServer(function(request, response) {

var filePath = path.join(rootPath, url.parse(request.url).pathname);

fs.stat(filePath, function(err, stat) {

if (!err && stat.isFile()) {

response.writeHead(200);

fs.createReadStream(filePath).pipe(response);

} else {

response.writeHead(404);

response.end('not found');

}

});

server.listen(8888);

# crypto

// MD5等

'use strict';

const crypto = require('crypto');

// 可以传入md5 sha1 sha256 sha512...

const hash = crypto.createHash('md5');

hash.update('123456');

// 以16进制字符串表示签名(通常是hex和base64格式)

console.log(hash.digest('hex')); //e10adc3949ba59abbe56e057f20f883e

// Hmac也是一种hash算法，可以利用MD5等，需要一个密钥

'use strict';

const crypto = require('crypto');

const hmac = crypto.createHmac('sha256', 'your sign key');

hmac.update('123456');

// 91e953f62f88a32a293a6ee8bd470a69ae77e4bb5549b1e43bd9bcf40f2e3ac3

console.log(hmac.digest('hex'));

// AES对称加密

'use strict';

const crypto = require('crypto');

function aesEncrypt(data, key) {

const cipher = crypto.createCipher('aes192', key);

var crypted = cipher.update(data, 'utf8', 'hex');

crypted += cipher.final('hex');

return crypted;

}

function aesDecrypt(data, key) {

const decipher = crypto.createDecipher('aes192', key);

var decrypted = decipher.update(encrypted, 'hex', 'utf8');

decrypted += decipher.final('utf8');

return decrypted;

}

var data = 'Hello, this is a secret message!';

var key = 'Password!';

var encrypted = aesEncrypt(data, key);

var decrypted = aesDecrypt(encrypted, key);

console.log('Plain text: ' + data);

console.log('Encrypted text: ' + encrypted);

console.log('Decrypted text: ' + decrypted);

Diffie-Hellman

DH算法是一种密钥交换协议，它可以让双方在不泄漏密钥的情况下协商出一个密钥来

DH算法基于数学原理，比如小明和小红想要协商一个密钥，可以这么做

小明先选一个素数p=23(p必须是素数，否则可能被整除)和一个底数g=5(底数可以任选)和一个秘密整数a=6

A = g^a % p = 8 (5的6次方模23=8) 然后告诉小红 p=23 g=5 A=8

小红根据pgA，也选一个秘密整数b=15 算出：B = g^b % p = 19 然后把B告诉小明

小明算出 s = B^a % p =2 小红算出 s = A^b % p = 2

所以最终协商的密钥 s = 2

第三方只能知道p=23，g=5，A=8，B=19，不知道双方的秘密整数a=6和b=15，所以无法计算出密钥2

'use strict';

const crypto = require('crypto');

// 根据给定的位长度，创建小明的DiffieHellman对象

var ming = crypto.createDiffieHellman(512);

// 生成密钥和公钥(底数和秘密整数)

var ming_keys = ming.generateKeys();

// 返回质数

var prime = ming.getPrime();

// 返回生成器

var generator = ming.getGenerator();

// 根据小明的质数和生成器创建小红的DiffieHellman对象

var hong = crypto.createDiffieHellman(prime, generator);

// 生成密钥和公钥(底数和秘密整数)

var hong_keys = hong.generateKeys();

// 分别算出小明、小红的协商密钥s

var ming_secret = ming.computeSecret(hong_keys);

var hong_secret = hong.computeSecret(ming_keys);

// 生成的密钥是一个Buffer，转成16进制字符串后应该是相等的

console.log(ming_secret.toString('hex') === hong_secret.toString('hex'));

// crypto模块也可以处理数字证书、RSA等

Node笔记(一)

在 2016年9月7日上张贴由 BestLove

# 下载地址
// 官网地址
https://nodejs.org/en/
// 国内镜像
http://pan.baidu.com/s/1kU5OCOB#path=%252Fpub%252Fnodejs

# 安装
// 在Windows上安装时务必选择全部组件，包括勾选Add to Path
// npm是Node.js的包管理工具(package manager)
node -v         //v6.5.0
npm -v          //3.10.3
node            //进入Node.js交互环境，退出按两下Ctrl+C

# 测试
// test.js    node test.js
'use strict';
console.log('hello world');

# Visual Studio Code
// 官方网站
https://code.visualstudio.com
// 国内镜像
http://pan.baidu.com/s/1kU5OCOB#path=%252Fpub%252Fnodejs
// 安装(全部勾选)
// 设置
// 右下角把CRLF改成LF(兼容linux系统)
// 调试(左边第4个图案) 没有配置的情况下点右边过来第2个图案
// 然后设置json，下面2个附加直接删了，program的文件名改成要调试的文件名
// 点击开始箭头就能调试了，需要手动按结束(方块图案)中止

# sublime Node插件
// 下载地址
https://github.com/tanepiper/SublimeText-Nodejs
// 解压后改名为Nodejs
// sublime -> Perferences -> Browse Packages 打开插件文件夹
// 将Nodejs剪切进来
// 打开Nodejs.sublime-build文件修改配置
// "encoding": "cp1252" -> "encoding": "utf8"
// "cmd": ["taskkill /F /IM node.exe & node", "$file"] -> "cmd": ["node", "$file"]
// 打开Nodejs.sublime-settings文件修改配置
// node_command": false -> "node_command": "D:\\Program Files\\nodejs\\node.exe"
// "npm_command": false -> "npm_command": "D:\\Program Files\\nodejs\\npm.cmd"
// 然后就能用ctrl+B运行node代码了

# 模块
// node中一个文件就是一个模块，文件名就是它的模块名
// 不同模块的变量可以重名，用闭包来实现的(function(){xx.js})();
// hello.js
'use strict';
var s = 'Hello';
function greet(name) {
    console.log(s + ', ' + name + '!');
}
// 把函数greet作为模块的输出暴露出去，这样其他模块就可以使用greet函数了
// 输出的变量可以是任意对象、函数、数组等
module.exports = greet;

// main.js
'use strict';
// 引入hello模块 变量greet就是在hello.js中用module.exports = greet;输出的greet函数
// 记得写路径 如果直接写'hello' 依次在内置模块、全局模块和当前模块下查找hello.js
var greet = require('./hello');
var s = 'Michael';
greet(s);   // Hello, Michael!

// exports输出(因为node中module.exports默认是一个空对象)
module.exports = {                  //可以赋值，可以.语法
    hello: hello,
    greet: greet
};
exports.hello = hello;              //只能.语法
exports.greet = greet;

# 基本模块
// js中的全局变量是window node中也有个全局变量global
// node交互界面 可以看到console的方法
> global.console

// process(代表当前Node.js进程)
// test.js
// process.nextTick()将在下一轮事件循环中调用
process.nextTick(function () {
    console.log('nextTick callback!');
});
console.log('nextTick was set!');
// node test.js 根据输出发现，process.nextTick不是立刻执行而是等到下一次事件轮询
// nextTick was set!
// nextTick callback!

// Node.js进程本身的事件就由process对象来处理
// 程序即将退出时的回调函数
process.on('exit', function (code) {
    console.log('about to exit with code: ' + code);
});

# 判断js执行环境是浏览器还是Node
if (typeof(window) === 'undefined') {
    console.log('node.js');
} else {
    console.log('browser');
}

# fs Node.js内置的file system
// 正常读取时，err为null data为读取到的string
// 读取错误时，err是一个错误对象 data为undefined
// 这是node的标准回调函数，第一个参数：错误信息 第二个参数：结果
'use strict';
var fs = require('fs');
fs.readFile('./test.php', 'utf-8', function(err, data){
    if (err) {
        console.log(err);
    } else {
        console.log(data);
    }
});

// 不传入编码，读取的是二进制文件，回调函数将返回一个Buffer对象
'use strict';
var fs = require('fs');
fs.readFile('./1.png', function(err, data){
    if (err) {
        console.log(err);
    } else {
        console.log(data);
        console.log(data.length + ' bytes');
    }
});
// Buffer -> String
var text = data.toString();
// String -> Buffer
var buf = new Buffer('text', 'utf-8');

// 同步读文件
'use strict';
var fs = require('fs');
try {
    var data = fs.readFileSync('test.php', 'utf-8');
    console.log(data); 
} catch(e) {
    console.log(e);
}

// 写文件 回调函数只关心成功与否，所以只需要第一个参数
// 同样，也有同步写文件方法 writeFileSync
fs.writeFile('test.php', 'if string then utf-8, if Buffer then bin', function (err) {
    if (err) {
        console.log(err);
    } else {
        console.log('ok');
    }
});

// 获取文件信息 同样，也有同步方法 statSync
fs.stat('test.php', function (err, stat) {
    if (err) {
        console.log(err);
    } else {
        // 是否是文件:
        console.log('isFile: ' + stat.isFile());
        // 是否是目录:
        console.log('isDirectory: ' + stat.isDirectory());
        if (stat.isFile()) {
            // 文件大小:
            console.log('size: ' + stat.size);
            // 创建时间, Date对象:
            console.log('birth time: ' + stat.birthtime);
            // 修改时间, Date对象:
            console.log('modified time: ' + stat.mtime);
        }
    }
});

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

# 下载地址

// 官网地址

https://nodejs.org/en/

// 国内镜像

http://pan.baidu.com/s/1kU5OCOB#path=%252Fpub%252Fnodejs

# 安装

// 在Windows上安装时务必选择全部组件，包括勾选Add to Path

// npm是Node.js的包管理工具(package manager)

node -v //v6.5.0

npm -v //3.10.3

node //进入Node.js交互环境，退出按两下Ctrl+C

# 测试

// test.js node test.js

'use strict';

console.log('hello world');

# Visual Studio Code

// 官方网站

https://code.visualstudio.com

// 国内镜像

http://pan.baidu.com/s/1kU5OCOB#path=%252Fpub%252Fnodejs

// 安装(全部勾选)

// 设置

// 右下角把CRLF改成LF(兼容linux系统)

// 调试(左边第4个图案) 没有配置的情况下点右边过来第2个图案

// 然后设置json，下面2个附加直接删了，program的文件名改成要调试的文件名

// 点击开始箭头就能调试了，需要手动按结束(方块图案)中止

# sublime Node插件

// 下载地址

https://github.com/tanepiper/SublimeText-Nodejs

// 解压后改名为Nodejs

// sublime -> Perferences -> Browse Packages 打开插件文件夹

// 将Nodejs剪切进来

// 打开Nodejs.sublime-build文件修改配置

// "encoding": "cp1252" -> "encoding": "utf8"

// "cmd": ["taskkill /F /IM node.exe & node", "$file"] -> "cmd": ["node", "$file"]

// 打开Nodejs.sublime-settings文件修改配置

// node_command": false -> "node_command": "D:\\Program Files\\nodejs\\node.exe"

// "npm_command": false -> "npm_command": "D:\\Program Files\\nodejs\\npm.cmd"

// 然后就能用ctrl+B运行node代码了

# 模块

// node中一个文件就是一个模块，文件名就是它的模块名

// 不同模块的变量可以重名，用闭包来实现的(function(){xx.js})();

// hello.js

'use strict';

var s = 'Hello';

function greet(name) {

console.log(s + ', ' + name + '!');

}

// 把函数greet作为模块的输出暴露出去，这样其他模块就可以使用greet函数了

// 输出的变量可以是任意对象、函数、数组等

module.exports = greet;

// main.js

'use strict';

// 引入hello模块变量greet就是在hello.js中用module.exports = greet;输出的greet函数

// 记得写路径如果直接写'hello' 依次在内置模块、全局模块和当前模块下查找hello.js

var greet = require('./hello');

var s = 'Michael';

greet(s); // Hello, Michael!

// exports输出(因为node中module.exports默认是一个空对象)

module.exports = { //可以赋值，可以.语法

hello: hello,

greet: greet

};

exports.hello = hello; //只能.语法

exports.greet = greet;

# 基本模块

// js中的全局变量是window node中也有个全局变量global

// node交互界面可以看到console的方法

> global.console

// process(代表当前Node.js进程)

// test.js

// process.nextTick()将在下一轮事件循环中调用

process.nextTick(function () {

console.log('nextTick callback!');

});

console.log('nextTick was set!');

// node test.js 根据输出发现，process.nextTick不是立刻执行而是等到下一次事件轮询

// nextTick was set!

// nextTick callback!

// Node.js进程本身的事件就由process对象来处理

// 程序即将退出时的回调函数

process.on('exit', function (code) {

console.log('about to exit with code: ' + code);

});

# 判断js执行环境是浏览器还是Node

if (typeof(window) === 'undefined') {

console.log('node.js');

} else {

console.log('browser');

}

# fs Node.js内置的file system

// 正常读取时，err为null data为读取到的string

// 读取错误时，err是一个错误对象 data为undefined

// 这是node的标准回调函数，第一个参数：错误信息第二个参数：结果

'use strict';

var fs = require('fs');

fs.readFile('./test.php', 'utf-8', function(err, data){

if (err) {

console.log(err);

} else {

console.log(data);

}

});

// 不传入编码，读取的是二进制文件，回调函数将返回一个Buffer对象

'use strict';

var fs = require('fs');

fs.readFile('./1.png', function(err, data){

if (err) {

console.log(err);

} else {

console.log(data);

console.log(data.length + ' bytes');

}

});

// Buffer -> String

var text = data.toString();

// String -> Buffer

var buf = new Buffer('text', 'utf-8');

// 同步读文件

'use strict';

var fs = require('fs');

try {

var data = fs.readFileSync('test.php', 'utf-8');

console.log(data);

} catch(e) {

console.log(e);

}

// 写文件回调函数只关心成功与否，所以只需要第一个参数

// 同样，也有同步写文件方法 writeFileSync

fs.writeFile('test.php', 'if string then utf-8, if Buffer then bin', function (err) {

if (err) {

console.log(err);

} else {

console.log('ok');

}

});

// 获取文件信息同样，也有同步方法 statSync

fs.stat('test.php', function (err, stat) {

if (err) {

console.log(err);

} else {

// 是否是文件:

console.log('isFile: ' + stat.isFile());

// 是否是目录:

console.log('isDirectory: ' + stat.isDirectory());

if (stat.isFile()) {

// 文件大小:

console.log('size: ' + stat.size);

// 创建时间, Date对象:

console.log('birth time: ' + stat.birthtime);

// 修改时间, Date对象:

console.log('modified time: ' + stat.mtime);

}

});

node入门

在 2016年1月7日2016年1月8日上张贴由 BestLove

// node版本较旧 先凑合用下
yum -y install gcc make gcc-c++ openssl-devel wget
wget http://nodejs.org/dist/v0.10.26/node-v0.10.26.tar.gz
tar -zvxf node-v0.10.26.tar.gz
cd node-v0.10.26
./configure --prefix=/usr/local/node
make
make install
ln /usr/local/node/bin/node /usr/local/bin/node
node -v

// node版本较旧先凑合用下

yum -y install gcc make gcc-c++ openssl-devel wget

wget http://nodejs.org/dist/v0.10.26/node-v0.10.26.tar.gz

tar -zvxf node-v0.10.26.tar.gz

cd node-v0.10.26

./configure --prefix=/usr/local/node

make

make install

ln /usr/local/node/bin/node /usr/local/bin/node

node -v

// index.js 入口文件
// 命令行执行 node index.js 就可以挂起服务
var server = require("./server");
var router = require("./router");
server.start(router.route);

/************************************************************************************/

//server.js 启动服务文件
// http url 是node内置的模块
var http = require("http");
var url = require("url");

function start(route, handle) {  
    function onRequest(request, response) {    
        var pathname = url.parse(request.url).pathname;
        route(pathname, response);
    }
    //创建服务，监听8888端口
    http.createServer(onRequest).listen(8888);
}
// 使用exports.functionName 就可以在外部调用server.start(route, handle);
exports.start = start;

/************************************************************************************/

// router.js 路由文件
function route(pathname, response) {
    try {
        // 这里随便写写，比较乱。。
        var pathArr = pathname.split('/');
        var controller = require("./" + pathArr[1] + "/" + pathArr[2]);
        var params = '{';
        for(var i=4; i<pathArr.length; i+=2) {
            params = params + '"' + pathArr[i] + '":"' + pathArr[i+1] + '",'; 
        }
        params = params.substring(0, params.length-1);
        params += '}';
        // 响应响应信息
        response.writeHead(200, {"Content-Type" : "text/plain"});
        response.write(controller.action(pathArr[3], params));
        response.end();
    } catch (err) {
        // 响应错误信息
        response.writeHead(404, {"Content-Type" : "text/plain"});
        response.write('not fount');
        response.end();
    }
}
exports.route = route;

/************************************************************************************/

// ./user/user.js 用户模块
// 统一操作调度方法 可写到父类中
function action(method, params) {
    method = eval(method);
    return method(params);
}

// 解析GET参数 可写到父类中
function parseGet(params) {
    return JSON.parse(params);
}

// 具体操作方法
// http://localhost:8888/user/user/show/test/helloworld
// 第1个user为user目录 第2个user为user.js 后面是GET参数 key=>value 形式
function show(params) {
    params = parseGet(params);  
    return params.test;
}
exports.action = action;

// index.js 入口文件

// 命令行执行 node index.js 就可以挂起服务

var server = require("./server");

var router = require("./router");

server.start(router.route);

/************************************************************************************/

//server.js 启动服务文件

// http url 是node内置的模块

var http = require("http");

var url = require("url");

function start(route, handle) {

function onRequest(request, response) {

var pathname = url.parse(request.url).pathname;

route(pathname, response);

}

//创建服务，监听8888端口

http.createServer(onRequest).listen(8888);

}

// 使用exports.functionName 就可以在外部调用server.start(route, handle);

exports.start = start;

/************************************************************************************/

// router.js 路由文件

function route(pathname, response) {

try {

// 这里随便写写，比较乱。。

var pathArr = pathname.split('/');

var controller = require("./" + pathArr[1] + "/" + pathArr[2]);

var params = '{';

for(var i=4; i<pathArr.length; i+=2) {

params = params + '"' + pathArr[i] + '":"' + pathArr[i+1] + '",';

}

params = params.substring(0, params.length-1);

params += '}';

// 响应响应信息

response.writeHead(200, {"Content-Type" : "text/plain"});

response.write(controller.action(pathArr[3], params));

response.end();

} catch (err) {

// 响应错误信息

response.writeHead(404, {"Content-Type" : "text/plain"});

response.write('not fount');

response.end();

}

exports.route = route;

/************************************************************************************/

// ./user/user.js 用户模块

// 统一操作调度方法可写到父类中

function action(method, params) {

method = eval(method);

return method(params);

}

// 解析GET参数可写到父类中

function parseGet(params) {

return JSON.parse(params);

}

// 具体操作方法

// http://localhost:8888/user/user/show/test/helloworld

// 第1个user为user目录第2个user为user.js 后面是GET参数 key=>value 形式

function show(params) {

params = parseGet(params);

return params.test;

}

exports.action = action;

唐晓锋–BLOG

This is just a personal note.

分类：node

Node笔记(二)

Node笔记(一)

node入门