node.js笔记

global -全局对象

1. __dirname 返回当前运行文件的文件夹目录

2. __filename 返回当前运行文件路径

3. clearImmediate(immediateObject)

4. clearInterval(intervalObject)

5. clearTimeout(timeoutObject)

6. console

7. exports

8. global

9. module

10. process

 process.cwd()  返回当前nodejs进程的工作目录
 process.exit()  强制退出当前node进程
 process.argv   获取命令中的所有参数
 process.platform   获取当前的操作系统
 process.kill(pid)   根据进程ID杀死进程
 process.env   获取环境变量对象
 

11. queueMicrotask(callback)

12. require()

有一些静态方法：

• require.cache
• require.resolve(request[, options]) 把运行文件的相对路径解析成绝对路径

request 要解析的模块路径。

options <对象>
第二个参数是一个对象，对象的属性名为path
返回：

• require.resolve.paths(request)
• require.main 返回主模块module 对象
• require.extensions

13. setImmediate(callback[, …args])

14. setInterval(callback, delay[, …args])

15. setTimeout(callback, delay[, …args])

16. TextDecoder

17. TextEncoder

18. URL

19. URLSearchParams

20. WebAssembly

__dirname，__filename 并非是global的属性

os 、path、url、util模块

require.resolve() 和 path.resolve() ，path.join([…paths])的区别

require.resolve() 返回的是当前运行文件的绝对路径，require.resolve 还会在拼接好路径之后检查该路径是否存在, 如果 resolve 的目标路径不存在, 就会抛出错误.

** path.resolve( ‘./a.js’）** 把一系列路径或路径段解析为绝对路径，是路径解析

path.resolve('/foo/bar', './baz')   // returns '/foo/bar/baz'
path.resolve('/foo/bar', 'baz')   // returns '/foo/bar/baz'
path.resolve('/foo/bar', '/baz')   // returns '/baz'
path.resolve('/foo/bar', '../baz')   // returns '/foo/baz'
path.resolve('home','/foo/bar', '../baz')   // returns '/foo/baz'
path.resolve('home','./foo/bar', '../baz')   // returns '/home/foo/baz'
path.resolve('home','foo/bar', '../baz')   // returns '/home/foo/baz'

从后向前，若字符以 / 开头，不会拼接到前面的路径(因为拼接到此已经是一个绝对路径)；

　　　　　若以 ../ 开头，拼接前面的路径，且不含最后一节路径；

　　　　    若以 ./ 开头 或者没有符号 则拼接前面路径；

需要注意的是：如果在处理完所有给定的 path 片段之后还未生成绝对路径，则再加上当前工作目录。

**path.join([…paths]) **就是把各个路径拼接成绝对路径，如果任何路径段都不是字符串，则抛出错误

path.join（）和path.resolve（）不会检查生成的路径是否存在

注意：node环境中的相对路径，指的是相对的是使用node命令时命令行的路径（相对于process.cwd()）， 只有 require（'./'）导入文件时才是相对当前文件（模块）

fs 模块

fs模块下大部分都是异步的
每个api 对应的aync，都是同步函数，会导致程序阻塞，通常会在程序启动时运行

删除文件，fs.unlink

fs.promises 返回一个promise

引入是可以使用 require('fs/promises')

文件流

用fs.createReadStream()创建一个可以读流， 返回一个可读流 类（class）

使用fs.createWriteStream() 时注意背压问题，由于可写流每次传输会默认为16KB，会导致背压，大量占用内存

背压

const ws = fs.createWriteStream()
ws.write(‘数据’) 会返回一个flag，flag 为true时表示，还可以继续写入，flag为false时，表示管道已满，会产生背压


drain事件 触发后管道可以继续被写入数据
使用drain事件（），可以处理背压问题

把test文件夹下1.txt文件 复制到 src文件夹下2.txt

// 方法一 
async function method1(){
    const fromFileName = path.resolve(__dirname,'./test/1.txt')
    const content= await fs.promises.readFile(fromFileName)
    const toFileName = path.resolve(__dirname,'./src/2.txt')
    fs.promises.writeFile(toFileName,content)
}


// 方法二：
 function method2(){
    const fromFileName = path.resolve(__dirname,'./test/1.txt')
    const toFileName = path.resolve(__dirname,'./src/2.txt')
    const rs = fs.createReadStream(fromFileName)
    const ws = fs.createWriteStream(toFileName)
    rs.on('data',chunk=>{
       const  flag = ws.write(chunk)
       if(!flag){
            rs.pause()   
       }
    })
    ws.on('drain',()=>{
        rs.resume()
    })
}
function method2(){
    const fromFileName = path.resolve(__dirname,'./test/1.txt')
    const toFileName = path.resolve(__dirname,'./src/2.txt')
    const rs = fs.createReadStream(fromFileName)
    const ws = fs.createWriteStream(toFileName)
    rs.on('data',chunk=>{
       const  flag = ws.write(chunk)
       if(!flag){
            rs.pause()   
       }
    })
    ws.on('drain',()=>{
        rs.resume()
    })
   
    
}

function method3(){
    const fromFileName = path.resolve(__dirname,'./test/1.txt')
    const toFileName = path.resolve(__dirname,'./src/2.txt')
    const rs = fs.createReadStream(fromFileName)
    const ws = fs.createWriteStream(toFileName)
    rs.pipe(ws)
   
    
}
method3()

方法一：会大量占用内存，方法二和三只会一点一点读取，占用内存较少

net

socket

socket 是一个特殊的文件,他负责向网卡传输内容，是个双工流

http

http.request(url[, options][, callback]) 作为客户端，发送一个请求

类： http.ClientRequest 作为客户端，发送请求

客户端发送给服务器

http.request（） 会返回一个对象request，request的方法和事件用于处理消息头、消息体的 设置、发送 等

类： http.ServerResponse

服务器响应给客户端

类： http.IncomingMessage

表示即将接收到的消息，即可以是服务端，也可以是客户端发送来的消息

是一个可读流， 由http.Server 或者 http.ClientRequest 返回 ，用于获取响应消息的状态，消息头，消息体
该对象是由HTTP服务器在内部创建的，而不是由用户创建的。它作为第二个参数传递给’request’事件。

http.createServer([options][, requestListener]) 作为服务器

客户端发送请求：
http.request(url[, options][, callback]) 返回 请求对象<http.ClientRequest>
callback的参数是服务器响应的http.IncomingMessage 对象

const  requset = http.request('http://baidu.com',{
  method:'GET'
},resp=>{
   console.log(resp.heards)
})
    request.write()  //写消息体
    request.end()  //发送请求，必须完成发送

http 总结：

作为客户端发送请求是，得到的响应就是http.IncomingMessage ；
http.request（）返回的是http.ClientRequest客户端请求对象
作为服务器，接受的请求就是http.IncomingMessage；响应的结果是http.ServerResponse响应对象

生命周期

生命周期详见：

官网：https://nodejs.org/zh-cn/docs/guides/event-loop-timers-and-nexttick/

网友：https://segmentfault.com/a/1190000016019979