node教程

第一章：node介绍安装

1.cmd命令窗口

-开始窗口—>运行–>cmd—>回车

常用的指令：

dir：列出当前目录下的所有文件

.表示当前目录
..表示上一级目录
在dos里面创建文件夹：目录为：md+文件夹的名称
rd+文件夹 删除文件夹
2.环境变量：就是window系统中的变量
path路径：
当在命令行窗口打开与文件或调用一个程序时，系统会首先在当前目录下寻找文件程序，如果找到了直接打开，如果没有找到就继续查找，还是没有找到就报错
因此我们可以将经常使用到文件或程序的文件添加到文件路径，这样可以省去很多麻烦

2.进程和线程

进程和线程：
进程：-进程负责为程序的运行提供必备的环境
						进程就相当于工厂里面的车间一样
线程:是计算机中最小的计算定位,线程负责执行程序

单线程:
		js是单线程
多线程:


node介绍:是员工能够在服务器端运行JavaScript代码的开源代码跨平台的js运行环境
node采用谷歌开发的v8引擎运行js代码,使用事件驱动,非阻塞和异步i/o模型等技术来提高性能，可优化应用程序的传输量和规模


node执行js文件：


JavaScript代码:
console.log("hello node");
var a=1;
var b=2;
for (var i = 0; i <100 ; i++) {
    console.log("hello Word！")
    console.log(a+b);

    
}

6.模块化介绍

/*定义员工模块math
* --在改模块中提供两个方法
* add（a,b）:求ab两个数的和
* mul（a,b）:求两个数的积
* */
exports.add=function (a,b) {


    return a+b;
};

exports.mul=function (a,b) {

    return a*b;

};

/*模块化：
* 把完整的程序分成一块块的代码
*
*js里面没有模块系统，标准库较少，没有标准接口，缺乏管理系统
* 模块化：如果程序设计的规模达到了一定的长度，则必须对其进行模块化
*
* 因此就使用CommonJS规范
* 定义十分简单：模块引用
* */
/*
* 在node中员工js文件就是员工模块
*
* */


//2.其它模块的引入
/*在node中通过require（）函数来引入外部的模块,可以传递员工文件路径作为参数，node会自动根据改路径来引入外部模块

这里路径，如果使用相对路径，必须以.或..开头
* */
//使用require引入模块后，改函数会返回员工对象，这个对象代表的是引入的模块
//在node中，每一个js文件中的js代码都是独立独立运行在员工函数中
//而不是全局作用域，所以一个模块中的变量和函数在其他模块中无法访问

var md= require("./1.nodeTest");
var i=require("./1.nodeTest");
//向外部暴露实现或方法
/*我们可以通过exports来向外部暴露变量和方法
* 只需要将需要暴露给外部的变量或方法设置为exports的属性
* */
exports.x="我是";

/调用模块方法：
var md=require("./3.math");
var math=require("./3.math");

console.log("和为",math.add(123,89));
console.log("积为",math.mul(1234,98));

//我们使用require(）引入外部模块时，使用的就是模块标识，我们可以通过模块标识来找到指定的模块
//模块分为两大类：核心模块
/*---由node引擎提供的模块
* ---核心模块的标识，就是模块的名字
* */
//文件模块：文件模块的标识就是文件的路径，（绝对路径，相对路径），相对路径要使用.开头
/*
* ---指由用户创建的模块
* */
//例如：
var fs=requires("fs");
console.log(fs);

var a=10;
/*在node中全局对象 global，他的作用和网页中的window类似
*   在全局中创建的变量都会作为global的属性保存
* 在全局中创建的函数都会作为global的方法保存
*
* */
a=10;
console.log(global.a);
/*
* argument.callee:属性：保存的是当前执行的函数对象
* */
// console.log(argument.callee);
//当node咋一致性模块中的代码时，他会首先在代码的最顶部，添加代码
// 在代码的最底部，添加{}，构成员工函数
//实际上模块中的代码都是包装在一个函数中去执行，并且在函数里面执行时，同时传入了5个实参
// console.log(argument.length);
/*exports-改对象将变量或函数暴露在外部
* require：是一个函数用来引入外部模块
* module:代表当前模块本省，exports就是module的属性
* 
* filename:当前模块的文件的完整路径
* */

console.log()

//

exports.name="孙悟空";
exports.age=18;
exports.sayName=function () {
    console.log("我是孙悟空！");

}

module.exports = {

    name: "猪八戒",
    age: 28,
    sayName:function (){
        console.log("我是猪八戒！");

    }

}

/*exports暴露出来，然后我们去调用模块*/
var hello=require("./moduleTestfile/helloModule");
console.log(hello);
console.log(hello.age);

 var obj={}
obj.a={}
var a=obj.a;
// a和obj.a指向的是同一个对象
console.log(a==obj.a);
a.name="孙悟空！";
a=new Object();

console.log(obj.a.name);
console.log(a.name);

/*堆内存和栈内存*/
var m=10;
var n=100;
n++;
console.log("m的值"+m);
console.log("n的值"+n);
/*exports和module.exports
---通过exports只能使用.的方式来暴露内部变量，
exports.xxx=xxx
* --而module.exports既可以通过.的形式，也可以直接赋值
------module.exports.xxx=xxx
      module.exports={}

* */


var obj=new Object();
obj.name="孙悟空";
var obj2=obj;

obj2=null
console.log("obj"+obj.name);
console.log("obj2"+obj2);

第二章：包

/包的规范允许我们将一组相关的模块组合到一起，形成一组完整的工具，由包结构和包扫描文件两个部分组成

//包结构：用于组织包中的各种文件
/*包描述
* --描述包的相关信息，已供外部分析
* */

//包结构实际上就是员工压缩文件，解压后还原为目录，符合规范的目录，应该包含如下文件
//package.json 描述文件
//bin：可执行文件
//lib：js代码
//doc文档
//test：单元测试

npm介绍：

npm命令：
npm -v:查看版本
npm:帮助说吗
npm search 包名 ：搜索模块包
npm install 包名 ：在当前目录安装包
npm install 包 名称-g:全局模式安装包

npm remove 包名  ：删除包
npm install 包名 --save ：安装包并添加到依赖中
npm install  ：根据当前版本下载对应的依赖
npm install 包名 -g ：全局安装包

//包的规范允许我们将一组相关的模块组合到一起，形成一组完整的工具，由包结构和包扫描文件两个部分组成

//包结构：用于组织包中的各种文件
/*包描述
* --描述包的相关信息，已供外部分析
* */

//包结构实际上就是员工压缩文件，解压后还原为目录，符合规范的目录，应该包含如下文件
//package.json 描述文件
//bin：可执行文件
//lib：js代码
//doc文档
//test：单元测试

//注意:包描述文件里面不能出现任何的注射

//npm（node package Manger）:作用就是包规范理论，npm是一种实践，对于node而言，
// npm帮助其完成了第三方模块的发布，安装和依赖，借助npm与第三方
//形成了员工很好的生态系统

//例如下载一个math包，就可以调用
var math=require("math");
console.log(math);
console.log(math.add(1,2));
console.log(math.cos(1));




//配置cnpm镜像：命令行输入 npm -g cnpm --registry=https://registry.npm.taobao.org




//node搜索包：通过npm或者C npm下载的包都放到node_modules文件中
/*1.node在使用模块的名字来引入模块时，会首先在当前目录下的node_modules中寻找是否含有改模块，如果有则直接使用，如果没有则去上一级目录寻找，以此类推
* 直到找到磁盘根目录，如果还没有则报错
* */
//我们通过npm下的包，直接通过包名引入
console.log(math.cos(45));

第三章：node缓冲区

/*
* 1.buffer：缓冲区：buffer的结构和数组很像，操作方法和数组类似
*           --数组中是不能存储二进制文件，因此引入buffer，buffer就是娱乐赛存储二进制数组
*           --使用buffer不需要引入模块，直接使用就可以
* */
var str="Hello World "
//将一个字符串保存到buffer中
var buf=Buffer.from(str);
console.log(buf.length);//获取占用内存的大小
console.log(str.length);//获取的是长度

//前端输出快捷键：输出名称.log 回车就可以
//在buffer中存储的都是二进制数据，但是在显示时是以16进制显示，二进制太长了
console.log(buf);

//buffer中的每一个元素的分为是从00--ff
//计算机中员工0 或一个1称为1位（bit）
//8bit=1byte（字节）
// for (let i = 0; i < 100; i++) {
//     console.log(buf);
// }
//buffer中的员工元素就占用1个字节
//1024byte=1kb
//1024 kb=1mb
//1024mb=1gb

//创建员工指定大小的buffer
// var buf2=new Buffer(1024);//创建一个长度为1024字节的buffer
// console.log(buf.length);
//注意：buffer的所有构造函数都不推荐使用的

//使用类方法
//创建一个10字节的buffer
var buf2=Buffer.alloc(10);
console.log(buf);


//通过索引来操作buf中的元素
buf2[0]=88;
buf2[1]=255;
console.log("第一个是"+buf2);
//buffer中的大小一旦确定，则不能修改，buffer实际上是对底层的直接操作

//只要数字在控制台或页面中输出就一定是10进制
console.log(buf2[1].toString(16));//把这个转换为16进制

//遍历
for (var i=0;i<buf2.length;i++){
    console.log(buf2[i].toString(10));
}


//创建员工指定大小的buffer，但是buffer中可能含有敏感数据
var buf3=Buffer.allocUnsafe(10);
console.log(buf3);
/*
* Buffer.form(str) 将一个字符串转换buffer
* Buffer.alloc(size)：创建一个指定大小的Buffer
* Buffer.alloUnsafe(size)创建一个指定大小的buffer，但是可能包含敏感数据
* */


var buf4=Buffer.from("我是一段文本数据！");
console.log(buf4);
console.log(buf4.toString());

同步文件写入：
/*1.文件系统：（File System）——简单来说就是通过node来操作系统中文件
*--在node中，与文件系统进行交互是非常重要的，服务器的本质就是将本地的文件发送给远程的客户端
* --node通过fs模块来和文件系统进行交互
* --该模块提供了一些标准文件访问api来打开，读取
* */

//1.要使用文件系统，需要使用fs模块
//fs是核心模块，直接引入不需要下载
 var fs=require("fs");
 const path = require("path");
//
// console.log(fs);

//2.同步和异步调用
//同步文件系统会阻塞程序的运行，也就是除非操作完毕，负责不会向下执行代码
//异步文件系统不会阻塞程序的执行


//文件的写入：手动操作：打开文件  --向文件中写入内容---保存并关闭文件
//同步文件的写入：
//*var fd= fs.openSync(path,flags[,mode])
// --path:要打开文件的路径
// --flags 打开文件要做的操作的类型
//        r 只读
//          w 可写
//    mode---设置文件的操作权限
// */
//1.打开文件
var fd= fs.openSync("hellTest.text","w");

//返回值：该方法会返回一个文件的描述作为结果，我们可以通过改描述符来对文件进行各种操作\
console.log(fd);
//2.向文件中写入内容:fs.writeFileSync(fd,string[, position[, encoding]])
/*--fd:文件的描述符，需要传入写入的文件的描述符
* --string需要写入的内容
*  --position:要写入的起始位置
* --encoding：写入的编码 ，默认utf-8
* */

//2.向文件中写入员工内容
 fs.writeSync(fd,"你好啊！今天天气真不错");

 //3.保存并关闭文件
fs.closeSync(fd);

异步文件写入


//1引入fs模块
var fs=require("fs");

//2.打开文件

/*fs.open()
* ---参数：第一个参数是文件描述路径
* ----第二个参数是读写操作
* ----第三参数是员工函数
* */
//异步方法不能有返回值
//异步调用的方法：结果都是通过回调函数返回的
//回调函数有两个参数：
//--err 错误的对象，如果没有错误则为null
//fd 文件的描述符
fs.open("hello2.text","w",function (err,fd)

{
    if (!err)
    {
        //2.异步写入员工文件
        /*
        * fs.write()
        * */
        //如果没有出错，则在这里写入内容
        fs.write(fd,"这个是异步写入的内容",function (err) {
            if (!err){
                console.log("写入成功！");

            }

//保存并关闭文件
            fs.close(fd,function (err) {
                if (!err){
                    console.log("文件已关闭")
                    
                }
            })
        })
        console.log(  "成功！"+fd);
    }else {
        console.log(err);
    }
});

简单文件写入：
/*
* 简单文件写入:参数
* --file 要操作的文件路径
* --data 要写入的数据
* --option选项，可以对写入进行一些设置
* --callback 当写入完成以后执行的函数
* */

//1.引入fs模块
var fs=require("fs");

fs.writeFile("hello3.text","我是这个文件里面的内容",{flag:"a"},function (err) {
    if (!err){
        console.log("简单文件写入成功！");

    }
})
//flag 操作符
//a 代表的是追加内容
//w 是可读
//r 是只读

流式文件写入
/*
* 同步，异步，，简单文件的写入都不适合大文件的写入，性能较差，任意导致内存溢出
*
* */
var fs=require("fs");
//流式文件的写入
//1.创建一个可写流
/*
* fs.createWriteStream()
*       --可以创建一个可写流
*       --参数：path  文件的路径
*           options 配置的参数
*
* */
var ws=fs.createWriteStream("hello3.text");

//通过ws向文件中输出内容
ws.write("通过可写流写入文件的内容");
ws.write("我是一只小鸭子，咿呀咿呀哟！");

//可以通过监听流的open和lose事件来监听流的打开和关闭
ws.on("open",function () {
    console.log("流打开了，我来监听！");
})
/*
* on(事件字符串,回调函数)--这个方法可以为对象绑定员工事件
* 
* 
* once(事件字符串，回调函数)
        --可以为对象绑定一个一次性事件，该事件将会在触发一次后失效 
* */


//关闭流调用end方法
ws.end();

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

var  fs=require("fs");


//创建一个可读流
var rs=fs.createReadStream("hello2.text");

//绑定监听流
rs.once("open",function (err) {
    console.log("可读流打开了");
})

rs.once("close",function (err) {
    console.log("可读流关闭了");
})


//如果要读取一个可读流中的数据，必须要为可读流绑定员工data事件，data事件绑定完毕，他会自动读取数据
rs.on("data",function (data) {
    console.log(data);
});

//创建一个可写流
var ws=fs.createWriteStream("hello2.text");
ws.once("open",function (data) {
    //将读取到的数据写入到可写流中
    ws.write(data);
    

    console.log("可写流打开了");
})

ws.once("close",function (err) {
    console.log("可写流关闭了");
})



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

var  fs=require("fs");


//创建一个可读流
var rs=fs.createReadStream("hello3.text");
//创建一个可写流
var ws=fs.createWriteStream("hello2.text");
//pipe（）可以将可读流中的内容，直接输出到可写流中
rs.pipe(ws);

var fs=require("fs");

/*fs.existsSync(path)
* --检查员工文件是否存在
* */
var j=fs.existsSync("hello2.text");
console.log(j);

/*fs.stat(path,callback)
--获取文件的状态
--这个方法会返回员工对象，这个对象中保存了当前对象的状态相关信息
* */
fs.stat("hello2.text",function (err,stat) {
    console.log(stat);
});
//isFile()判断是否是一个文件
//isDirectory（）判断是否一个文件夹或目录


/*
* 方式、.unlink(path,callback)
* fs.unlinkSync(path)------------------------------------------删除文件
*       files是一个字符串数组，母婴馆元素就是文件夹或文件的名字
* */


/*
* fs.readdir(path,{},callback)
*           读取一个目录结构
* */
fs.readdir(".",function (err,files) {
    if (!err){
        console.log(files);

    }
})

//截断文件:将文件设置为指定的大小：这里设置为10个字节
fs.truncateSync("hello2.text",10);

//建立目录
fs.mkdirSync("hello");

//删除目录
fs.rmdirSync("hello");

//重命名文件
fs.rename("hello2","新的文件名字",function (err) {
    if (!err){
        console.log("修改成功！");
        
    }
})


//监视文件的修改
//interval :100监听文件变化的间隔
fs.watchFile("hell2",{interval :100},function (curr,prev) {
    console.log("文件变化")
})
//在回调函数中有两个参数:curr 当前文件的参数  prev修改前文件的对象  这两个对象都是stat对象