node学习

顶层对象

js中的顶层对象是window
node中顶层对象是global 没有window这个概念

node的模块化

在node中一个文件就是一个模块 每一个模块都有自己的作用域 每一个模块都是属于当前作用域的而不是全局的 全局的作用域

var a=1;
console.log(a)  //1
global.a=100;
console.log(a)  //1
console.log(global.a)  //100

但是在2.js仍然不能使用global.js

每一个模块都有自己的全局 __filename 就会得到文件当前的位置
这就是node 的本身的模块化的机制

node加载其他的模块

require("./1.js") 引入1.js这个模块
在加载其他的模块的时候
1、首先按照加载的模块文件名称进行查找
2、如果没有找到 在模块文件名称后边加上.js 进行查找
3、如果还没有找到 在模块文件名称后边加上.json 进行查找
4、如果还没有找到 在模块文件名称后边加上.node 进行查找 如果还没有找到就会报错

module 和module.exorts

在一个模块中通过var定义的变量 其作用域范围是当前模块 外部模块是不能够直接访问这个变量 如果我们想让在外边去访问这个模块变量 可以使用
1、全局挂载的方式 把这个变量作为global的属性
1.js中

global.a=1;

2.js中

require("./1.js")
console.log(__filename)
console.log(a)  //1   访问到了1.js中的a的值

就可以访问到global.a
但是这样的做法是不推介的
2、使用模块对象 module对象 每一个模块都会有这个module对象
module对象 保存提供和当前模块有关的一些信息 访问这个对象可以得到以下的信息
id: '.', 当前模块的唯一标识
exports: {}, 通过这个对象 将一个模块中的局部变量暴露出来
parent: null,
filename: 'G:\gitworkspace\node\2.js',
loaded: false,
children:
[ Module {

   id: 'G:\\gitworkspace\\node\\1.js',
   exports: {},
   parent: [Circular],
   filename: 'G:\\gitworkspace\\node\\1.js',
   loaded: true,
   children: [],
   paths: [Object] } ],

paths:
[ 'G:\gitworkspace\node\node_modules',

 'G:\\gitworkspace\\node_modules',
 'G:\\node_modules' ] }
 

在这个module有一个很重要的子对象 exports 对象 可以通过这个对象将模块中的局部对象暴露
1.js

var a=1;
module.exports.a=a;

2.js

var m1=require("./1.js")
console.log(m1.a)   //就可以输出1了

在模块作用域内 还有一个内置的模块对象 全局的exports 其实就是module.exports
console.log(exports===module.exports) //true
但是在使用的过程中需要注意小细节 不要让module.exports的引用断开

1.js中

var a=1;
module.exports=[1,2,3];   //断开了module.exports的引用
exports.a=a;

2.js中

var m1=require("./1.js")   //require的返回对象就是1.js模块中的module
console.log(m1.a)   //undefined   这里就访问不到了a
console.log(exports===module.exports)

同时在模块作用域内，还有一个内置的模块对象，exports 他其实就是module.exports 如上
所以在使用模块化的时候 尽量是在module.exports或者exports添加属性 而不是具体的更改引用地址

__filename

每一个模块作用域下边都有这样的一个属性 代表的是这个文件所在目录的路径 蛋挞不是全局的属性 只是模块作用域的一个固有的属性

__dirname

返回的是当前文件解析后的绝对路径 不带文件本身 也是模块的固定属性不是global的属性
setInterval函数 clearInterval()
setTimeout函数 clearTimeout() 这四个函数都可以使用

process全局对象

是global对象的属性 通过对process对象的访问 可以得到访问当前的进程 使我们可以对当前运行的程序的进程进行访问和控制 process对象有如下的属性
stdin stdout 标准输入输出流 默认情况输入流是关闭的 所以使用的时候先开启
标准输入设备：键盘 鼠标 摄像头 扫描仪

process.stdin.resume();
process.stdin.on("data",function (data) {
    process.stdout.write(data)
})

实现了 用户输入什么 回车的时候就会输出什么
标准输出设备：显示器 绘图仪
想控制太输出 process.stdout.write("sas")
1、argv
数组 包含命令行参数的数组
会输出
[ 'C:\Program Files\nodejs\node.exe', //运行改程序的编译器
'G:\gitworkspace\node\2.js' ] //当前的.js文件
2、env
会得道用户的运行环境 所以这里也可以看出js操作的是浏览器 node操作的是系统
3、version
返回node的版本
4、pid
返回当前进程的pid
5、title
返回当前进程显示的名称
6、platform
返回操作平台的信息
7、exit()
退出这个进程

Buffer

一个用于更好的操作二进制数据的类 从文件或输入流中读取内容
使用方法
1、 var buffer=new Buffer(10) //创建一个buffer对象 并为这个对象分配一个大小
当我们一个buffer分配空间以后 其长度是固定的 不能更改
2、使用数组来新建一个buffer var bb=new Buffer([1,2,3])
这种方式声明的buffer的长度也是固定的
3、使用字符串声明一个buffer var ss=new Buffer(string,'utf-8');
把字符串转化为二进制格式的
将16进制的编码转化为字符 String.fromCharCode()
buffer的方法
1、buffer的write方法

var ss=new Buffer("sasasa");
for(var i=0;i<ss.length;i++){
    console.log(String.fromCharCode(ss[i]))
}

buffer.write(string,[offset] )作用是根据参数offset来指定开始添加字符串的

var ss="miaov"
var bf=new Buffer(5);
bf.write(ss)
console.log(bf)  //<Buffer 6d 69 61 6f 76>

但是指定了offset以后

var ss="miaov"
var bf=new Buffer(5);
bf.write(ss,2)
console.log(bf)  //<Buffer 04 00 6d 69 61>

2、buffer.toString() 方法 将buffer转换成字符串

var ss="miaov"
var bf=new Buffer(5);
bf.write(ss)
console.log(bf.toString())  //miaov

var ss="妙味"
var bf=new Buffer(ss);
console.log(bf)  //<Buffer e5 a6 99 e5 91 b3>

所以在node中一个汉字占3个字节
3、buffer.tojson()
将buffer中的内容转化为json格式数据
4、buffer.slice(start,end)
截取buffer中的一部分 但是和原来的老的buffer引用的是一个地址 改变这个新的buffer就会改变原来的5、5、buffer.copy(复制内容到的新区域)
但是这个新区域的引用地址和原来的地址不是同一个地址 所以更改新的区域不会更改原来的buffer
6、buffer的静态方法 不需要在实例上边调用的方法
检测 Buffer是否支持某种编码 Buffer.isEncoding('utf-8') 检测是否支持utf-8编码
检测 某个变量是否是Buffer Buffer.isBuffer(变量)
Buffer.concat(存着buffer的数组) 返回这个数组内每一个元素拼接好的buffer

文件系统 File System

首先要引入 fs模块
1、fs.open方法 异步的方式打开文件 不会阻塞后边代码的执行 通过回调函数对读取结果进行处理
fs.open(path,flags,[model],callback)
path 所在的路径
flags 打开文件的方式 r读的方式 r+读写方式
model 设置文件的模式 读/写/执行 4/2/1
callback 当通过open方法以后 调用callback 有两个参数 error fd(文件的标识)
文件的标识是唯一的标识这个文件 以便于后边通过这个编号来操作这个打开的文件 从3开始
2、fs.openSync(path,flags) 会阻塞后边代码的执行 通过这个方法返回值对读取结果进行处理
3、fs.read(fd,buffer,offset,length,position,callback)

fs.open('1.txt','r',function (error,fd) {
    if(error){
        console.log("文件打开失败")
    }
      //fs.read(fd,buffer,offset,length,position,callback)
    //刚才读取成功的文件的唯一标识fd
    var bf1=new Buffer(10);
    //offset   新的内容添加到的buffer的起始位置
    //length   读取的长度
    //position  从文件的哪里开始
    //callback  回调函数  的参数error newbf的length newbf新的buffer
    fs.read(fd,bf1,0,4,null,function (error,len,newbf) {
        console.log(error)  //null
        console.log(len)  //4
        console.log(newbf)  //<Buffer 65 72 65 77 00 00 00 00 00 00>
    })
})

4、fs.writeSync() fs的同步版本
5、fs.write(fd,buffer,offset,length,position,callback)

buffer  要写入的数据
offset  buffer对象中要写入的数据起始位置
length  buffer对象中要写入的数据的长度
position  fd中的起始位置  文件中开始写的位置
callback  回调函数  error  buffer的length 写入的buffer

fs.write另一种使用方法 fs.write(fd,'wqds找室内设计师',5,'utf-8')

fs.open('1.txt','w',function (error,fd) {
     if(error){
         console.log("文件打开失败")
     }
    else{
         var bf=new Buffer('123');
         fs.write(fd,bf,0,3,0,function (error,length) {
              console.log(arguments)
         })
     }
})

6、fs.writeSync() buffer的同步的版本
7、fs.close(fd,callback) 文件打开以后 一定要对文件进行关闭
以上方法都是在文件打开以才能执行的 下面这些方法自带打开文件的方法
8、fs.writeFile(filename,data,[options],callback) 如果文件不存在就回新建一个文件 而不会报错
如果文件存在 则新的data会直接覆盖原有的内容

var fileName="2.txt";
fs.writeFile(fileName,"sasa",function () {
      
})

以上的方法就会新建一个2.txt
9、fs.writeFileSync(filename,data,[options]) 同步版本
10、fs.appendFile(filename，data，callback) 异步的向文件写入数据
如果文件不存在就回新建一个文件 而不会报错
如果文件存在 则新的data会追加到原有的内容后边
当然也有同步版本
11、fs.exists(path，callback) 检查指定的目录是否存在 当然也有同步版本
12、fs.readFile(fileName,callback)
如果直接输出data 会得到的是一个buffer

fs.readFile('1.txt',function (error,data) {
    if(error){
        console.log("读取失败")
    }
    else{
        console.log(data.toString())
    }
})

当然也有同步的版本
13、fs.unlink(fileName,callback) 删除这个文件

var fileName="2.txt";
fs.unlink(fileName,function (error) {
    if(error){
        console.log(error) 
    }
})

就会删除2.txt
13、fs.rename(fileName,newName,callback)
14、fs.sat(filename,callback) 会在callback中得到文件的信息
15、fs.mkdir(path,[mode],callback) 创建文件夹
16、fs.rmdir(path,callback) 删除文件夹

node实现web开发-->http模块

客户端发送一个http请求到指定的服务器端->服务器端接受并处理请求->返回数据到客户端
使用http模块就可以搭建一个web服务器
1、这个模块下有一个createServer(回调函数)来创建一个服务器
2、服务器调用.listen(端口号,[主机名],[callback]) 来实现监听某一窗口
3、server.on(error,callback) 当服务器开启发生错误了 就会触发这个事件
5、server.on('listening',callback) 当服务器正式监听的时候就会触发这个事件
6、server.on('request',callback) 当有客户端发起请求的时候 就会触发这个事件
request
这个里边有一个对象IncomingMessage 包含以下的信息
得到客户端发送过来的信息 url method
response
res.write(data)
res.end() 服务器的响应已经发送完成了 必须调用
res.writeHead(状态码，描述,头信息) 设置头信息
头信息：{‘content-type’:'text/html;charset=utf-8'}

    text/html  按照html处理   text/plain   告诉客户端按照文本处理

当然如果不希望写在头信息 这一部分的话 也就是上边的那个键值对里边
也可以调用 res.setHeader(key,value)

url的处理

通过req得到url req.url
在url中 ?后面的内容叫做查询字符串
在node中有专门处理url的模块 引入url模块

var http=require('http');
var url=require("url");
var server=http.createServer(function (req,res) {
      var urlString=url.parse(req.url);
      console.log(urlString)
      res.write("sasa");
      res.end();
})
server.listen(3000);

在这个urlString中包 协议 主机 端口

                hash  哈希值部分#后面的内容 
                search  ?+后面的内容
                query   ？后面的内容