Node.js的简单学习

模块分类

1.内置模块

内置模块是由Node.js官方所提高的模块，例如我们常用到的 buffer、fs、http 模块等，通过 require 将模块引入到程序中， buffer不需要 require 。

2.自定义模块

由用户自己创建的JavaScript文件，可以通过相对路径或者绝对路径引入到程序中。

3.第三方模块

由第三方开发出来的，需要将其下载同时使用 require 将其引入程序中。

// 通过 npm i axios ,下载 axios 请求库
// 引入第三方模块 axios 是请求库
// 路径是不需要指定，传模块名就行
// 会现在当前目录会在 node_modules 目录里
//当前目录没有会在祖先跟目录里查找
const axios = require('axios')
console.log(axios)
//简单使用
axios.get('请求对象').then(res=>{
    console.log(res.data)
})

模块的好处：

1. 提高代码的复用性；
2. 提高代码的可维护性；
3. 实现按需加载的特点。

文件中的属性、方法可以通过 exports 或者 module.export 进行导出

// commonjs规范：一个js就是一个独立的模块，模块可以通过export单个暴露出去，让其他模块能够通过require引入（使用）。
// 目前不能在node程序里面使用es6规范
export.a = function(){
    console.log('aaa')
}
export.b = 'bbb'
module.export = {
    name:'xxx',
    getAge(){
        console.log(18)
    }
}

exports 和 module.export同时存在时，要记住通过 require 得到的永远是 module.export 所指向的对象。

Node的内置对象

在新建的.js文件中输入下面代码：

console.log(arguments.callee.toString());

会得到下面的结果：

从结果中看出，我们的代码相当于被包裹在一个函数里面，该函数提供五个有意义的形参。之所以可以使用exports 或者 module.export 对属性、方法进行导出就是因为代码包裹在在该函数中。

输出五个形参便得到如下结果：

function(exports,require,module,__filename,__dirname){
    console.log(arguments.calle.toString)   // 函数体
    // 形参是内置对象
    // exports：初始为空对象，需要进行挂载
    // require：是函数，可以直接调用
    // module：module.exports
    // __filename：运行文件所在的路径名 + 文件名
    // __dirname：运行文件所在的目录名（绝对路径）
}

常用模块

buffer模块

buffer对象是Node处理二进制数据的一个接口，Node原生提供的全局对象，可以直接使用，因此不需要require('buffer')。

const str = 'hello'
const bf = Buffer.from(str)
console.log(typeof bf)
console.log(bf)
console.log(bf.toJSON())
console.log(bf.toString())

结果如图下所示：

const str = 'hello'
// 将来会废弃
const bf1 = new Buffer(str)
console.log(bf1)

// 给一个变量开辟内存，并指定内存的大小
const bf2 = Buffer.alloc(size:4)
console.log(bf2.length)   //字节

const bf3 = Buffer.allocUnsafe(size:4)    // 效率比较好，但是不安全，内存容易被“污染”
bf3.fill(size:0)                          // 对内存进行“打扫”，就不会存在内存被“污染”
console.log(bf3)

还有很多使用的方法，从官网中学习、了解、练习从而掌握( •̀ ω •́ )✧。

fs模块

读取文件

const fs = require('fs')

// 同步操作
try{
    const res = fs.statSync(path:'文件路径名')
}catch(e){
    console.log(e)
}

const fs = require('fs')

// 异步操作
fs.stat(path:'文件路径名',callback:function(err:ErrorException|null,stats:Stats){
  if(err)
    return console.log('文件或目录不存在')
  // 针对不同类型做不一样的处理
  console.log(stats)
})

创建文件夹

const fs = require('fs')

// 同步操作
try{
  const res = fs.mkdirSync(path:'文件夹名')
  // 成功了，返回undefined
}catch(e){
  console.log(e)
}

const fs = require('fs')

// 异步操作
fs.mkdir(path:'文件夹名',callback:function(err:ErrorException|null){
  console.log(err)
})

写入文件

const fs = require('fs')

fs.writeFile(path:'目录\文件名',data:'内容',option:{flag:'a'},callback:function(err:ErrorException|null,stats:Stats){
  if(err)
    return console.log('文件保存不成功')
  console.log('写入成功')
})

追加文件

const fs = require('fs')

fs.appendFile(path:'目录\文件名',data:'（追加的）内容',callback:function(err:ErrorException|null,stats:Stats){
  if(err)
    return console.log('文件保存不成功')
  console.log('写入成功')
})

读取文件

const fs = require('fs')

fs.readFile(path:'要读取的 目录+文件名',callback:function(err:ErrorException|null,data:Stats){
  if(err)
    return console.log('文件或目录不存在')
  // 针对不同类型做不一样的处理
  console.log(data)
})

读取目录里的文件

const fs = require('fs')

fs.readdir(path:'要读取的 目录',callback:function(err:ErrorException|null,files:String[]){
  if(err)
    return console.log('文件或目录不存在')
  // 针对不同类型做不一样的处理
  console.log(files)
})

删除目录

const fs = require('fs')

delDirFile('目录名')
function delDirFile(path){
    // 存放文件或文件夹名称
    let files = []
    if(fs.exitsSync(path){
       files = fs.reddirSync(path)
        files.forEach((file,index)=>{
            const currentPath = path + '/' + file
            if(fs.statSync(currentPath).isDirectory){
                // 如果是文件夹，则进入文件夹再次遍历文件进行删除
                delDirFile(currentPath)
            }else{
                // 是文件，就删除文件的方法
                fs.unlinkSync(currentPath)
            }
        })
    })
    // 如果是文件就直接删除
    fs.rmdirSync(path)
}

其他

const fs = require('fs')

fs.existsSync()   // 判断目录、文件是否存在

path模块

path.join()       // 用来将多个路径片段拼接成一个完整的路径字符串
path.basename()   // 用来从路径字符串在，将文件名解析出来
path.extname()    // 获取路径中的扩展名部分

const path = require('path')

const pathStr = path.join('/a','/b/c','../','e')    // '../'会抵消一层路径，'./'是没有抵消功能的
console.log(pathStr)

结果如下：

比用“+”拼接好，会减少一些潜在的错误。

const path = require('path')

// 两个参数：path：路径名，ext：扩展名
const str = '/a/b/c/d/e.html'
const fullName = path.basename(str)
console.log(fullName)

const name = path.basename(str,'html')
console.log(name)

结果如下：

const path = require('path')

const str = '/a/b/c/d/e.html'
const fileExt = path.extname(str)
console.log(fileExt)

结果如下：

events模块

const {EventEmitter} = require('events')
const eEmitter = new EventEmitter()  // 大写的要么是类，要么是构造函数
eEmitter.on('handleClick',(data)=>{
  // 监听到此事件，取执行任务
  console.log(data)
})
// 假设在某一个时间点出发这个handleClick时间
setTimeout(()=>{
  eEmitter.emit('handleClick',{msg:'nodejs events'})
},2000)

通过events，可以解决异步问题，得到数据

const fs = require('fs')

const {EventEmitter} = require('events')
const eEmitter = new EventEmitter()
eEmitter.emit('senData',(data)=>{
  //去做任务
  console.log(data)
})
function rdFile(){
  fs.readFile('./a.txt',(err,data)=>{
    if(err) 
      return '文件不存在'
    //callback(data.toString())
    // 用户想要做什么
    eEmitter.emit('senData',data.toString())
  })
}
rdFile()

URL模块

使用URL模块

const url = require('url')

const newUrl = new url.URL('路径','网址')   // 拼接形成新的URL
// 解析地址
const urlStr = '网址'
const parseUrl = new urlURL(urlStr)
const searchParams = parseUrl.searchParams
console.log(searchParams.get('属性'))   // 不能直接searchParams.'属性'

const {search} = new url.URL(urlStr)
console.log(url.parse(search,true))  // true：query就变成对象，不加则仍是链接
const {query} = url.parse(search,true)
console.log(query.'属性')
// 可以使用[]，或者在里面解构赋值
console.log(query['属性'])
const {query:{ie,wd}} = url.parse(search,true)

decodeURL与encodeURL函数对数据进行解码与编码

// URL：是带http://协议的域名
// /后面是路由
// ? 查询字符串 路由参数 通过不同的参数，返回不同的数据
// 解码 解析成人可以认识的字符
decodeURI()
// 编码 编译成计算机认识的
encodeURI()

atob与btoa函数对base64数据进行解码与编码

// base64：A-Z、a-z、0-9、+=/ 组成的字符串，共64位
// 把数据编译成 data:base64 编码
let str = 'hello'
console.log(window.btoa(str))   // 编译成计算机识别的编码
let str0 = 'aGVsbG8='
console.log(window.atob(str0))    // 解析成我们能够识别的数据
// 不能对中文进行编码，要先进行 base64 编码，然后在使用 btoa

在js文件中没有window对象，所以直接在浏览器的控制台进行，结果如下图所示：

读写流

可写流

const fs = require('fs')

// 创建一个可写流
const ws = fs.createWriteStream('文件名')
// 打开那一刻
ws.on('open',()=>{
  console.log('可写流打开了')
})
// 写完那一刻
ws.on('close',()=>{
  console.log('可写流关闭了')
})
// 触发某个任务执行数据写入
ws.write('123456789')
ws.close()

可读流

const fs = require('fs')

// 创建一个可读流
// options <string> | <Object>flags <string> 请参阅对文件系统 flags 的支持。默认值: 'w'。
// encoding <string> 默认值: 'utf8'
// fd <integer> | <FileHandle> 默认值: null
// mode <integer> 默认值: 0o666
// autoClose <boolean> 默认值: true
// emitClose <boolean> 默认值: true
// start <integer>
// fs <Object>|<null> 默认值: null
const rs = fs.createReadStream('文件名',{
    start:65536*5,
    end:65536*10,
    highWaterMark:65536
})
const ws = fs.createWriteStream('路径名')
// 打开那一刻
rs.on('open',()=>{
    console.log('可读流打开了')
})
// 读完那一刻
rs.on('close',()=>{
    console.log('可读流关闭了')
})
// 打开那一刻
ws.on('open',()=>{
    console.log('可写流打开了')
})
// 写完那一刻
ws.on('data',(data)=>{
    //console.log(data.length)
    ws.write(data)
})

管道

const fs = require('fs')

const fs = fs.createReadStream('读取的文件名')
const ws = fs.createWriteStream('要写入的文件名')
rs.pipe(ws)

同步代码

//同步阻塞，从上往下执行，前面没有执行完后面是不会执行的
console.log(1)
console.log(2)
console.log(3)

异步代码

//异步代码，不会阻塞后续代码执行，异步不能保证代码的执行
fs.readFile('./a/txt',(err,data)=>{
  if(err)
    return console.log('文件不存在')
  console.log(5)
})
console.log(6)

及时函数

//写即时函数前最好加 ;
;(async ()=>{
  try{
    const res = fs.readFileSync('./a.txt')
    console.log(7)
  }catch(e){
    console.log(e.massage)
  }
})()
console.log(8)

附录

Node.jsAPI文档：​​http://nodejs.cn/api/​​

axios文档：​​http://axios-js.com/docs/​​