node.js学习笔记

1.命令行窗口、cmd、shell、dos窗口
        -常用指令：
                dir：列出当前目录下的所有文件
                cd+目录名：进入指定的目录
                md+目录名：创建文件夹
                rd+目录名：删除文件夹
        -目录：
                . 表示当前目录   .. 表示上一级目录
        -环境变量（windows系统中的变量）
                当我们用命令行窗口打开一个文件，或调用一个程序时，系统会首先在当前目录下寻找文件程序，如果找到了则直接打开，如果没有则依次到环境变量path的路径中寻找，直到找到为止

2.进程和线程
        进程
                -进程负责为程序的运行提供必备的环境
                -进程相当于工厂中的车间
        线程
                -线程是计算中最小的计算单位，线程负责执行进程中的程序
                -线程就相当于工厂中的工人
        单线程
                -JS是单线程的
        多线程

3.Node.js简介
        nodejs是一个能够在服务器端运行js的跨平台运行环境、单线程
4.模块化
        1.在node中，一个js文件就是一个模块，js文件中的所有代码都默认在一个function内执行，可用console.log(arguments.callee+“”)显示出来
        2.在node中，每一个js文件中的js代码都是独立运行在一个函数中，而不是全局作用域，所以一个模块中的变量和函数在其他模块中无法访问
        3.如果想向外部暴露，只需要将需要暴露给外部的变量或方法设置为exports的属性即可
        4.在node中，通过require（）函数来引入外部的模块， require中传递的文件路径并须使用相对路径，使用.或..开头
        5.使用require引用模块后，会返回一个对象，该对象代表的是引入的模块
        6.node会默认在最顶端加如下代码function (exports, require, module, __filename, __dirname) {，在最底端加 }，实际上我们使用的exports和require都是node为我们传递进来的实参，filename表示当前模块的完整路径，dirname表示所在文件夹的完整路径
        7.可使用module.exports = { }进行批量暴露
                exports只能使用.的方式来向外暴露内部变量，module可以直接赋值

5.模块标识
        1）核心模块
                -由node引擎提供的模块
                -核心模块的标识就是模块的名字，不用写路径，直接写名字
        2）文件模块
                -由用户自己创建的模块
                -文件模块的标识就是文件的路径（相对路径或绝对路径）

6.CommonJs的包规范由包结构和包描述文件
        package.json是最主要的成分，相当于包的简介
        json文件中不能写注释

7.NPM（Node Package Manager）
        NPM就是package包管理规范，NPM帮助node完成第三方模块的发布、安装和依赖，通过npm下载的包都放在node_modules文件夹中，直接通过包名引入即可
        1）npm -v 查看npm版本
        2）npm version 查看所有模块的版本
        3）npm search 包名 搜索名
        4）npm install / i 包名 安装包，同时下载当前项目所依赖的包
        5）npm remove / r 包名 删除包
        6）npm install 包名 --save 安装包并添加到依赖中
        7）npm install 包名 --g  全局安装包（一般都是一些工具，计算机使用的，不是项目使用的）

8.npm引入模块规则
        1）首先会在当前目录的node_modules中寻找该模块
        2）如果有则直接引用，如果没有则去上一级目录的node_modules中寻找
        3）一直往上，直到找到磁盘的根目录，如果依然没有则报错

9.Buffer(缓冲区)
        1）Buffer的结构和数组很像，操作的方法也和数组类似
        2）数组中不能存储二进制的文件，而buffer就是专门用来存储二进制数据
        3）使用buffer不需要引入模块，直接使用即可
        4）在buffer中存储的都是二进制数据，而计算机显示时都是以16进制的形式显示，但打印数字时，控制台只显示10进制，非数字的则可以通过toString(进制数)进行输出
        5）Buffer中每一个元素的范围是从00 - ff，buffer.length返回的是占用内存的大小
        6）new Buffer（数字）创建指定大小（字节）的Buffer对象，但是已经被废弃了
        7）Buffer.alloc(数字) 为常用的创建方法，通过索引来操作buf的元素，Buffer.allocUnsafe(size)创建的Buffer不清除之前的内存数据，可能存在敏感数据
        8）Buffer的大小一旦确定，则不能修改，扩充会导致内存不连续，不利于性能维护
        9）Buffer中存储的数据，如果大小越界，则取二进制的后8位
        10）buf.toString() 将缓冲区中的数据转换为字符串

var str = "hello buffer";
var str1 = "hello 缓冲区"
var buf = Buffer.from(str);
var buf1 = Buffer.from(str1);
console.log(buf.length);//13
console.log(buf1.length)//15
var buf3 = Buffer.alloc(10);
buf3[0] =88;
buf3[1] = 255;
buf3[2] = 0xaa;
buf3[10] = 25;
buf3[3] = 256;
console.log(buf3);//<Buffer 58 ff aa 00 00 00 00 00 00 00>
var buf4 = Buffer.allocUnsafe(10);//<Buffer 85 a1 00 36 00 00 00 00 00 00>
console.log(buf4);
console.log(buf1.toString());//hello 缓冲区

10.同步异步文件和简单文件的写入
        1）同步文件的写入

/*   
    同步文件的写入
        1）打开文件
            fs.openSync(path,flags[,mode])
                -path 要打开文件的路径，相对路径或绝对路径，路径中的斜杠\需要再添加\进行转义，或者直接使用/
                -flags 打开文件要做的操作的类型 r（只读的） w（可写的） 
                -mode 设置文件的操作权限，一般不传
                -返回值，该方法会返回一个文件的描述符作为结果，通过结果进行操作
        2）向文件中写入内容
            fs.writeSync(fd,string[,position[,encoding])
                -fd 文件的描述符，需要传递要写入的文件的描述符
                -string 要写入的内容
                -position 写入的起始位置
                -encoding 编码方式，一般不写
        3）保存并关闭文件
            fs.closeSync(fd)  
*/
var fs = require("fs");
//打开文件
var fd = fs.openSync("hello.txt","w");
//向文件中写入内容
fs.writeSync(fd,"今天天气真不错",2);
//关闭文件
fs.closeSync(fd);

        2）异步文件的写入
 

/*       
    异步文件的写入
        1）打开文件
            fs.open(path,flags[,mode]，callback)
                -callback不能省略，且必须是一个函数
                -异步调用的方法，结果都是通过回调函数的参数arguments返回的
                -回调函数有两个参数：
                    err 错误对象，如果没有错误则为null
                    fd 文件的描述符
        2）向文件中写入内容,该命令写在open的回调函数的if语句中
            fs.write(fd,string[,position[,encoding],callback)
        3）保存并关闭文件,该命令写在write的回调函数的if语句中
            fs.closeSync(fd) 
*/
//引入fs模块
var fs = require("fs");
//打开文件
fs.open("hello2.txt","w",function(err,fd){
    console.log("回调函数中的代码执行~~~")//回调函数callback中的代码后执行
    //判断是否出错
    if(!err){
        //如果没有出错，则对文件进行写入操作
        fs.write(fd,"这是异步操作要写入的内容",function(err){
            if(!err){
                console.log("写入成功");}
            //关闭文件
            fs.close(fd,function(err){
                if(!err){
                    console.log("文件已关闭~~~");}})})
                }else{console.log(err);}
    });
console.log("open下的代码执行~~~")

 3）简单文件写入
 

/*
    简单文件写入
        fs.writeFile(file,data[,options],callback)
        fs.writeFileSync(file,data[,options])
            -file 要操作的文件的路径
            -data 要写入的数据
            -options 选项，可以对写入进行一些设置
            -callback 当写入完成以后执行的函数
            -flag：r只读  w可写  a追加
*/
//引入fs模块
var fd = require("fs");

fd.writeFile("hello3.txt","这是通过writeFile写入的内容",{flag:"a"},function(err){
    if(!err){
        console.log("写入成功~~~");
    }
})
//writeFile方式中，读取方式写在options中，用{flag:""}表示，其中
//r 读取文件   w 写入文件  a 追加文件

11.流式文件写入
 

/*
    同步、异步、简单文件的写入都不适合大文件的写入，性能较差，容易导致内存溢出
*/
var fs = require("fs");
//流式文件写入
//创建一个可写流
/*
    fs.createWriteStream(path[,options])
        -可以用来创建一个可写流
        -path，文件路径
        -options 配置的参数，一般不写
    fs.write(string)
    fs.close()
*/
var ws = fs.createWriteStream("hello3.txt");
//可以通过监听流的open和close事件来监听流的打开和关闭
ws.once("open",function(){//on和once都可以绑定事件，on绑定长期有效的事件，once绑定一次生效的事件
    console.log("流打开了~~");
})
ws.once("close",function(){
    console.log("流关闭了~~~");
})
//通过ws向文件中输出内容
ws.write("通过可写流写入文件的内容");
ws.write("2");
//关闭流
ws.close();

 12.文件读取
        1）简单文件读取

/*
    1.同步文件读取
    2.异步文件读取
    3.简单文件读取
    fs.readFile(path[,options],callback)
    fs.readFileSync(path[,options])
        -path要读取的文件的路径
        -options 读取的选项
        -callback 对调函数，通过回调函数将读取到的内容返回
            err 错误对象
            data 读取到的数据，会返回一个buffer
    4.流式文件读取
*/
var fs = require("fs");
fs.readFile("sign_bg.db29b0fb.png",function(err,data){
    if(!err){
        //console.log(data);
        //将data写入到文件中
        fs.writeFile("hello.jpg",data,function(err){
            if(!err){
                console.log("文件写入成功")
            }
        })
    }
});

        2）流式文件读取
 

/*
    流式文件读取也适用于一些比较大的文件，可以分多次将文件读取到内存中
*/

var fs = require("fs");
//创建一个可读流
var rs = fs.createReadStream("sign_bg.db29b0fb.png");
//创建一个可写流
var ws = fs.createWriteStream("hello1.jpg");
//监听流的开启和关闭
rs.once("open",function(){
    console.log("可读流打开了");
})
rs.once("close",function(){
    console.log("可读流关闭了");
    //数据读取完毕，关闭可写流
    ws.end();
})
ws.once("open",function(){
    console.log("可写流打开了");
})
ws.once("close",function(){
    console.log("可写流关闭了");
})
/*如果要读取一个可读流中的数据，必须要为可读流绑定一个data事件，
data事件绑定完毕，它会自动开始读取数据*/
rs.on("data",function(data){
    console.log(data.length);
    //将读取到的数据写入到可写流中
    ws.write(data);

})

13.终极版流式文件处理

//引入fs模块
var fs = require("fs");
//创建一个可读流
var rs = fs.createReadStream("sign_bg.db29b0fb.png");
//创建一个可写流
var ws = fs.createWriteStream("hell4.jpg");
//pipe()可以将可读流中的内容，直接输出到可写流中
rs.pipe(ws);

14.fs模块中的其他方法
 

var fs = require("fs");
//检查一个文件是否存在
var isExists = fs.existsSync("hello.txt");
console.log(isExists);
//获取文件状态
fs.stat("hello.txt",function(err,stat){
    /*
        .size 文件的大小
        .isFile() .isDirectory() 文件/文件夹
    */
    console.log(stat.size);
})
/*
fs.unlink(path,callback) -异步删除文件
fs.unlinkSync(path) -同步删除文件
fs.readdir(path[,options],callback) -读取一个目录的目录结构
fs.readdirSync(path[,options])  -回调函数中的files是一个字符串数组，每一个元素就是一个文件夹或文件的名字
fs.truncate(path,len,callback)
fs.truncateSync(path,len) -截断文件，将文件修改为指定的大小
fs.mkdir(path[,mode],callback)
fs.rmdir(path,callback)
fs.rename(oldpath,newpath,callback)
fs.watchFile(filename[,options],listener)
    -监视文件的修改
    -参数：
        filename 要监视的文件的名字
        options 配置选项，可修改程序等待的间隔时间{interval：1000}，改为1s一次
        listener 回调函数，当文件发生变化时，回调函数会执行
        回调函数中有两个参数，curr和prev，两个都是stat对象，可调用stat的方法
*/