node.js基础（二）

个人博客搭建完成，欢迎大家来访问哦
黎默丶lymoo的博客

node.js的回调函数

node.js 异步编程的直接体现就是回调，异步编程依托于回调来实现

例1：服务器的回调

var http = require("http");
var server = http.createServer(function (req, res) {
    res.writeHead(200, {"Content-Type": "text/html; charset=utf-8"});
    console.log("服务运行中");
    res.end("服务结束");
});
// listen(端口, 域名, 成功的回调)
server.listen(8080, "localhost", function () {
    console.log("服务开启成功");  // 这条会在之后先打印
});

console.log("我是服务下的");  // 这条会最先打印

例2：读取文件的操作

var fs = require("fs");
fs.readFile("test.txt", "utf-8", function (err, data) {
    if (err) {
        console.error(err);
    }
    console.log(data);  // 这条会在之后先打印
});
console.log("我是读取操作之后的");  // 这条会最先打印

这里也介绍一下同步的写法

var data = fs.readFileSync("test.txt", "utf-8");
console.log(data);     // 先执行文件内容
console.log("我是读取操作之后的");  // 再执行后续内容

node.js的一些常用模块

util

util是一个工具函数包，这个模块保存了利于其他模块的工具，使用最多的有这三种：

1、实现对象的原型继承

var util = require("util");
function Parent(name, age) {
    this.name = name;
    this.age = age;
    this.sayHello = function () {
        console.log("hello");
    }
}
Parent.prototype.sayName = function () {
    console.log(this.name);
}
function Child(name, age) {
    // 构造函数继承
    Parent.apply(this, arguments);
}
util.inherits(Child, Parent); // 对象的原型继承
var dad = new Parent("老爸", 48);
var son = new Child("儿子", 28);
son.sayHello();
son.sayName();

2、把一个对象作为字符串输出

// 接着上面的案例
var str = util.inspect(son);  // 将对象转化成字符串
console.log(typeof str);      // 输出string

3、数据类型的检测

var util = require("util");
console.log(util.isArray([])); // 判断其是否为数组，输出true

event

事件：又称为发布订阅模式或者观察者模式

获取事件模块的方法：

var events = require("events").EventEmitter(); // 旧版写法
var events = require("events");          // 新版写法

注册事件

1.on
2.addListener
3.once

移除事件

removeListener

设置最大监听数

setMaxListeners(Number);

发出事件

emit

实例

var events = require("events"); 
var util = require("util");
// 创建事件的发布者以及事件的观察者
function Girl () {
    // 假设女孩饿了
};

function Boy (name, response) {
    this.name = name;
    this.response = response;
};

util.inherits(Girl, events);  // 继承来自于events原型上的方法

var goddess = new Girl();
var boy1 = new Boy("男生1", function () {
    console.log("点饿了么");
});
var boy2 = new Boy("男生2", function () {
    console.log("上美团点外卖");
});
var boy3 = new Boy("男生3", function () {
    console.log("带你去吃饭");
});
// 绑定事件监听者
goddess.on("ele", boy1.response);
goddess.addListener("ele", boy3.response); // on和addListener是等价的
goddess.once("ele", boy3.response);        // once 只绑定一次 
goddess.emit("ele");  // emit 表示发出事件

buffer

buffer：缓存的数据格式，缓存区
出现的原因：JavaScript本身不存在二进制的传输，只有字符串的，为了保存和处理二进制数据
buffer的形式是一个数组，而数组中的每一项是一个以16进制展示的8位字节
buffer是一个类，它能实例出一个全局对象
buffer的每一位它的取值范围0-255

创建buffer的方法

直接创建

var buff = new Buffer(12); // 参数为number，表示buffer的长度
console.log(buff); // 此时里面是随机的，由系统生成
// 填充 后两个参数表示从第几位开始第几位结束
buff.fill("a", 3, 6);

通过数组创建

var buff = new Buffer([1, 34, 074, 0xa6]);

通过字符串创建

var buff = new Buffer("我是缓存区");

转成字符串

var buff = new Buffer([0xe4, 0xbb, 0x8a]);
console.log(buff4.toString()); // 输出"今"

拼接buffer

var buff1 = new Buffer([0xe4, 0xbb, 0x8a, 0xe5]);
console.log(buff1.toString());  // 输出乱码
var buff2 = new Buffer([0xa4, 0xa9, 0xe5, 0xa4, 0xa9]);
console.log(buff2.toString());  // 输出乱码

// 把buffer拼接起来解决输出乱码的问题(concat)
console.log(Buffer.concat([buff1, buff2]).toString()); // 输出今天天

但是这个方法太过于消耗内存
这里有一个更好的方法StringDecoder

// 接上面的例子
var StringDecoder = require("string_decoder").StringDecoder; // 返回一个类
var decode = new StringDecoder();
var str = decode.write(buff1);
console.log(str);  // 输出今
var str2 = decode.write(buff2);
console.log(str2);  // 输出今天天

fs

只包括一些文件以及目录的操作，并提供了这些操作的同步和异步的方法

文件操作

读取文件

// 异步操作
// readFile(第一个参数为读取的文件名，第二个为配置参数，第三个为回调函数)
fs.readFile("test.txt", "utf-8", function (err, data) {
    if (err) {
        console.error(err);  // 如果有错误便弹出错误
    }
    console.log(data);  // 输出文件的内容
});

// 同步操作
var data2 = fs.readFileSync("test.txt", "utf-8");
console.log(data2); // 输出文件的内容

写入文件

// writeFile中的参数类似readFile
// 其中第三个参数为配置参数：flag表示的是一个读取的模式 不写默认是w为写入，a是追加写入，r为读取
fs.writeFile("test.txt", "我是写入进去的内容", {flag: "a"}, function (err) {
    if (err) {
        console.error(err);
    }
    console.log("写入成功了");
});

追加写入

fs.appendFile("test.txt", "我是追加进去的内容", {flag: "w"}, function (err) {
    if (err) {
        console.error(err);
    }
    console.log("追加成功了");
});

复制文件

复制文件的原理则是先读取出文件的内容在写入到另外一个文件之中

// 复制文件(异步)
function copy (src, dest) {
    fs.readFile(src, "utf-8", function (err, data) {
        if (err) {
            console.error(err);
            return;
        }
        fs.writeFile(dest, data, function (err) {
            if (err) {
                console.error(err);
                return;
            }
            console.log("复制成功");
        })
    });
};

// 复制文件(同步)
function copy (src, dest) {
    fs.writeFileSync(dest, fs.readFileSync(src, "utf-8"), "utf-8");
}
copy("test.txt", "test2.txt");

目录操作

创建目录

var fs = require("fs");
// 第二个参数为权限的设置，它是一个3位8进制数，每一位数字由1，2，4组成，1是可执行、2是可写、4是可读
fs.mkdir("test", 0555, function (err) {
    if (err) {
        console.error(err);
    }
    console.log("创建成功");
});

删除目录

fs.rmdir("test", function (err) {
    if (err) {
        console.error(err);
    }
    console.log("删除成功");
});

读取目录

输出该目录下除了.和..的所有文件组成的数组

fs.readdir("./", function (err, files) {
    if (err) {
        console.error(err);
    } else {
        console.log(files);
    }
});

查看文件或者目录详情

fs.stat("./test.txt", function (err, stat) {
    if (err) {
        console.error(err);
    } else {
        console.log(stat);
    }
});

判断文件是否存在

fs.exists("test", function (exists) {
    console.log(exists);
    // 如果存在回调为TRUE，反之为FALSE
});

相对路径获取绝对路径

fs.realpath("test", function (err, path) {
    if (err) {
        console.log(err);
    } else {
        console.log(path);  // path即为获取到的绝对路径
    }
});

修改文件名

fs.rename("test", "newTest", function (err) {
    if (err) {
        console.error(err);
    } else {
        console.log("重命名成功");
    }
});

stream

stream:流，它的出现是为了处理大数据，把一个大的文件截取成若干个大小为64K的小文件存储

var fs = require("fs");
function copy(src, dest) {
    fs.writeFileSync(dest, fs.readFileSync(src));
}
copy("1.png", "2.png");

上面是一个对文件拷贝的代码，看似没什么问题，也的确在处理小文件的时候没什么大问题，但是一旦处理数量级很大的文件的时候可以看出，先将数据读取出来，在写入，内存作为中转，如果文件太大就会产生问题。如果是大文件就得使用file system的另外几个API，createReadStream和createWriteStream，将文件作为一块一块小的数据流进行处理，而不是一整块大型数据。

// 创建可读流
var rs = fs.createReadStream("1.png");
// 创建可写流
var ws = fs.createWriteStream("4.png");
//每一个可读流具有data事件
var times = 0;
rs.on("data", function (chunk) {
    // 每64k会触发一次事件
    times ++;
    // console.log(times);
    // console.log(chunk);
    ws.write(chunk, function () {
        // console.log("chunk写入成功");
    });
});
rs.on("end", function () {
    console.log(times);
});

当然上面的方法也可能产生内存爆仓，写入速度跟不上读取速度，一直读取的文件不断放入内存中，但是两个的操作的速度是肯定不一样的，导致未被写入的数据在内存中越来越大，才会是内存爆仓。
node中有一个较为简便的解决方法：pipe管道连接

rs.pipe(ws);

path

path：里面封装了一些对文件的路径的操作
可以使用normalize规范化字符串路径

var path = require("path");
var pathstr = "a/../b/./c/../d/f/./e";
console.log(path.normalize(pathstr)); // 打印结果为b/d/f/e

__dirname显示当前绝对路径

console.log(__dirname);

join将多个参数值字符串结合成一个路径字符串

console.log(path.join(__dirname, "a", "..b", "..c/e/./d", "text.txt"));

resolve把一连串的路径解析成绝对路径

console.log(path.resolve("baidu", "a/..", "n/..", "test.html"));

原文链接