node核心模块--参考手册

path

path.basename() 获取路径中的基础名称

• 返回的就是接收路径当中的最后一部分
• 第二个参数表示扩展名，如果说没有设置则返回完整的文件名称带后缀
• 第二个参数做为后缀时，如果没有在当前路径中被匹配到，那么就会忽略
• 处理目录路径的时候如果说，结尾处有路径分割符，则也会被忽略掉

console.log(__filename)
// F:\node\path.js
console.log(path.basename(__filename))
// path.js
console.log(path.basename(__filename, '.js'))
// path
console.log(path.basename(__filename, '.css'))
// path.js
console.log(path.basename('/a/b/c'))
// c
console.log(path.basename('/a/b/c/'))
// c

path.dirname() 获取路径目录名 (路径)

• 返回路径中最后一个部分的上一层目录所在路径

console.log(__filename)
// F:\node\path.js
console.log(path.dirname(__filename))
// F:\node
console.log(path.dirname('/a/b/c'))
// \a\b
console.log(path.dirname('/a/b/c/'))
// \a\b

path.extname() 获取路径的扩展名

• 返回 path路径中相应文件的后缀名
• 如果 path 路径当中存在多个点，它匹配的是最后一个点，到结尾的内容

console.log(__filename)
// F:\node\path.js
console.log(path.extname(__filename))
// .js
console.log(path.extname('/a/b'))
// 
console.log(path.extname('/a/b/index.html.js.css'))
// .css
console.log(path.extname('/a/b/index.html.js.'))
// .

path.parse() 解析路径

• 接收一个路径
• 返回一个对象，包含不同的信息
  • root：根
  • dir：最后一个部分内容的上一层目录
  • base：最后一个部分内容
  • ext：最后一个部分的后缀名
  • name：最后一个部分的名称

const obj = path.parse('/a/b/c/index.html')
console.log(obj)
/*
    {
      root: '/',
      dir: '/a/b/c',
      base: 'index.html',
      ext: '.html',
      name: 'index'
    }
*/
const obj1 = path.parse('/a/b/c/')
console.log(obj1)
// { root: '/', dir: '/a/b', base: 'c', ext: '', name: 'c' }
const obj2 = path.parse('./a/b/c/')
console.log(obj2)
// { root: '', dir: './a/b', base: 'c', ext: '', name: 'c' }

path.format() 序列化路径

const obj = path.parse('./a/b/c/')
console.log(path.format(obj)) 
// ./a/b\c

path.isAbsolute() 判断当前路径是否为绝对

console.log(path.isAbsolute('foo'))
// fasle
console.log(path.isAbsolute('/foo'))
// true
console.log(path.isAbsolute('///foo'))
// true
console.log(path.isAbsolute(''))
// fasle
console.log(path.isAbsolute('.'))
// fasle
console.log(path.isAbsolute('./bar'))
// fasle
console.log(path.isAbsolute('../bar'))
// fasle

path.join() 拼接路径

console.log(path.join('a/b', 'c', 'index.html'))
// a\b\c\index.html
console.log(path.join('/a/b', 'c', 'index.html'))
// \a\b\c\index.html
console.log(path.join('/a/b', 'c', '../', 'index.html'))
// \a\b\index.html
console.log(path.join('/a/b', 'c', './', 'index.html'))
// \a\b\c\index.html
console.log(path.join('/a/b', 'c', '', 'index.html'))
// \a\b\c\index.html
console.log(path.join('')) 
// .

path.normalize() 规范化路径

console.log(path.normalize(''))
// .
console.log(path.normalize('a/b/c/d'))
// a\b\c\d
console.log(path.normalize('a///b/c../d'))
// a\b\c..\d
console.log(path.normalize('a//\\/b/c\\/d'))
// a\b\c\d
console.log(path.normalize('a//\b/c\\/d')) 
// a\c\d

path.resolve() 绝对路径

• resolve([from], to)

console.log(path.resolve())
// F:\node
console.log(path.resolve('/a', '../b'))
// F:\b
console.log(path.resolve('index.html'))
// F:\node\index.html

Buffer 缓冲区

Buffer让JavaScript可以操作二进制。

JavaScript语言起初服务于浏览器平台，内部主要操作的是字符串。而随着node.js的出现，使得JavaScript可以实现IO操作。IO行为操作的就是二进制数据。Stream流操作并非Node.js独创。当使用大数据传输的时候，就可以使用Stream流操作，可以避免由于操作的数据内存过大，而出现把数据内存在短时间内占满的情况。流操作配合管道实现数据分段传输。典型的应用就是在观看视频时，我们都是边下载边看的过程。
Buffer是Node.js中无需require的一个全局变量，实现Node.js平台下的二进制数据操作。Node.js中Buffer是一片内存空间，不占据V8堆内存大小，内存的使用有Node来控制，由V8的GC回收。一般配合Stream流使用，充当数据缓冲区。

创建Buffer实例

• alloc：创建指定字节大小的buffer
• allocUnsafe：创建指定大小的buffer（不安全）

const b1 = Buffer.alloc(10)
const b2 = Buffer.allocUnsafe(10)

console.log(b1)
// <Buffer 00 00 00 00 00 00 00 00 00 00>
/** 上面输出的是内存空间数据类型在当前控制面板中的展示形式 */
console.log(b2) 
// <Buffer 00 00 00 00 00 00 00 00 00 00>

• from：用于创建包含指定字符串，数组或缓冲区的新缓冲区
  • Buffer.from( object, encoding )
    • object 此参数可以包含字符串，缓冲区，数组或arrayBuffer。
    • encoding 如果对象是字符串，则用于指定其编码。它是可选参数。其默认值为utf8。

// from 
const b1 = Buffer.from('中')
console.log(b1)
// <Buffer e4 b8 ad>
console.log(b1.toString())
// 中

const b2 = Buffer.alloc(3)
const b3 = Buffer.from(b3)
console.log(b2)
// <Buffer 00 00 00>
console.log(b3)
// <Buffer 00 00 00>

const a1 = Buffer.alloc(3)
const a2 = Buffer.from(a1)
a1[0] = 1
console.log(a1)
// <Buffer 01 00 00>
console.log(a2)
// <Buffer 00 00 00>

Buffer实例方法

• fill：使用数据填充buffer buffer.fill( string, offset, end, encoding )

参数： 此方法接受上述和以下所述的四个参数：

1. string: 它保存您需要放入缓冲区的数据。
2. offset: 您需要从中开始填充缓冲区的索引。其默认值为0。
3. end: 需要填充缓冲区的索引。默认值为buffer.length
4. encoding: 如果数据为字符串格式，则对数据进行编码。默认值为utf8。

返回值： 此方法返回包含值的缓冲区对象。

let buf = Buffer.alloc(6)

buf.fill(123)
console.log(buf)
// <Buffer 7b 7b 7b 7b 7b 7b>
console.log(buf.toString())
// {{{{{{

• write：向buffer中写入数据 buffer.write(string, offset, length, encoding)

参数： 此方法接受上述和以下所述的四个参数：

1. string: 它保存您需要放入缓冲区的数据。
2. offset: 您需要从中开始填充缓冲区的索引。其默认值为0。
3. length: 要写入的字节数。默认值为buffer.length - offset
4. encoding: 如果数据为字符串格式，则对数据进行编码。默认值为utf8。

返回值： 此方法返回包含值的缓冲区对象。

let buf = Buffer.alloc(6)

buf.write('123', 1, 4)
console.log(buf)
// <Buffer 00 31 32 33 00 00>
console.log(buf.toString())
// 123

• toString：从buffer中提取数据 buffer.toString(encoding, start, end)

参数： 此方法接受上述和以下所述的三个参数：

1. encoding: 解码使用的字符编码。默认：utf8
2. start: 开始解码的字节偏移量。默认：0
3. end: 结束解码的字节偏移量（不包含）。默认：buf.length 根据 encoding 指定的字符编码解码 buf 成一个字符串。 start 和 end 可传入用于只解码 buf 的一部分。

返回值： 字符串

let buf = Buffer.alloc(6)

buf = Buffer.from('前端教育')
console.log(buf) 
// <Buffer e5 89 8d e7 ab af e6 95 99 e8 82 b2>
console.log(buf.toString('utf-8', 3, 9)) 
// 端教

• slice：截取buffer buffer.slice(start, end)

参数： 此方法接受上述和以下所述的两个参数：

1. start: 新建的 Buffer 开始的位置，默认：0
2. end: 新建的 Buffer 结束的位置，默认： buf.length

返回值： 一个指向相同原始内存的新建的 Buffer，但做了偏移且通过 start 和 end 索引进行裁剪。

let buf = Buffer.alloc(6)

buf = Buffer.from('前端教育')
console.log(buf)
// <Buffer e5 89 8d e7 ab af e6 95 99 e8 82 b2>
let b1 = buf.slice(-3)
console.log(b1)
// <Buffer e8 82 b2>
console.log(b1.toString()) 
// 育

• indexOf：在buffer中查找数据 buffer.indexOf( value, start, encoding )

参数： 此方法接受上述和以下所述的三个参数：

1. value: 此参数保存您要在缓冲区中找到的值。
2. start: 它是一个可选参数。它是指从中搜索输入缓冲区元素的起始索引。默认值为0。
3. encoding: 它是一个可选参数。如果所需的值为字符串，则可以添加编码类型。默认值为utf-8。

返回值： 从搜索值开始的索引。如果缓冲区中不存在该值，则返回-1。

let buf = Buffer.alloc(6)

buf = Buffer.from('我爱前端，爱大家，爱所有')
console.log(buf)
// <Buffer e6 88 91 e7 88 b1 e5 89 8d e7 ab af ef bc 8c e7 88 b1 e5 a4 a7 e5 ae b6 ef bc 8c e7 88 b1 e6 89 80 e6 9c 89>
console.log(buf.indexOf('爱')) 
// 3
console.log(buf.indexOf('爱qd', 4)) 
// -1

• copy：拷贝buffer中数据 buffer.copy(target, targetStart, sourceStart, sourceEnd)

参数： 此方法接受上述和以下所述的四个参数：

1. target: 要拷贝进的 Buffer 或 Uint8Array
2. targetStart: target 中开始拷贝进的偏移量。 默认: 0
3. sourceStart: buf 中开始拷贝的偏移量。 默认: 0
4. sourceEnd: buf 中结束拷贝的偏移量（不包含）。 默认: buf.length

返回值： 被拷贝的字节数

let b1 = Buffer.alloc(6)
let b2 = Buffer.from('教育')
console.log(b1)
// <Buffer 00 00 00 00 00 00>
console.log(b2)
// <Buffer e6 95 99 e8 82 b2>

let b3 = b2.copy(b1, 3, 3, 6)
console.log(b1.toString())
// 育
console.log(b2.toString())
// 教育
console.log(b3)
// 3

Buffer静态方法

• concat：将多个buffer拼接成一个新的buffer Buffer.concat( list, length )

参数： 该方法接受上述和以下所述的两个参数：

1. list: 包含要连接的缓冲区列表。
2. length: 它定义了级联缓冲区的长度。此参数是可选的

返回值： 拼接成的新的buffer

let b1 = Buffer.from('前端')
let b2 = Buffer.from('教育')

let b = Buffer.concat([b1, b2], 9)
console.log(b)
// <Buffer e5 89 8d e7 ab af e6 95 99>
console.log(b.toString())
// 前端教

• isBuffer：判断当前数据是否为buffer Buffer.isBuffer(obj)

let b1 = '123'
console.log(Buffer.isBuffer(b1))
// false

let b1 = Buffer.from('前端')
console.log(Buffer.isBuffer(b1))
// true

自定义Buffer--split

ArrayBuffer.prototype.split = function (sep) {
  let len = Buffer.from(sep).length
  let ret = []
  let start = 0
  let offset = 0

  while( offset = this.indexOf(sep, start) !== -1) {
    ret.push(this.slice(start, offset))
    start = offset + len
  }
  ret.push(this.slice(start))
  return ret
}

let buf = '我爱唱歌，你爱跳舞，他们爱看'
let bufArr = buf.split('爱')
console.log(bufArr)
// [ '我', '唱歌，你', '跳舞，他们', '看' ]

FS

FS是Node.js内置的核心模块，提供文件系统操作的API。

文件的读写与拷贝操作

• readFile：从指定文件中读取数据 fs.readFile(filename,encoding,callback(err,data))

参数： 该方法接受上述和以下所述的三个参数：

1. filename（必选），表示要读取的文件名。
2. encoding（可选），表示文件的字符编码。
3. callback 是回调函数，用于接收文件的内容。

// data.txt
1234567890

const fs = require('fs')
const path = require('path')
fs.readFile(path.resolve('data.txt'), 'utf-8', (err, data) => {
  console.log(err) 
  if (!null) {
    console.log(data)
  }
})
// null
// 1234567890

• writeFile：向指定文件中写入数据 fs.writeFile(filename,data,options,callback(err))

参数： 该方法接受上述和以下所述的四个参数：

1. filename：文件名称
2. data：将要写入的内容，可以使字符串 或 buffer数据。
3. options：option数组对象，包含：
   • encoding：可选值，默认 ‘utf8′，当data使buffer时，该值应该为 ignored。
   • mode：文件读写权限，默认值 438【十进制】
   • flag：默认值 ‘w'
4. callback：回调，传递一个异常参数err。

// 原data.txt
1234567890

fs.writeFile('data.txt', '123', {
  mode: 438,
  flag: 'w+',
  encoding: 'utf-8'
}, (err) => {
  if (!err) {
    fs.readFile('data.txt', 'utf-8', (err, data) => {
      console.log(data)
    })
  }
})
// 123

• appendFile：追加的方式向指定文件中写入数据 fs.appendFile(filename,data,options,callback(err,data))

参数： 该方法接受上述和以下所述的四个参数：

1. filename：文件名称
2. data：将要写入的内容，可以使字符串 或 buffer数据。
3. options：option数组对象，包含：
   • encoding：可选值，默认 ‘utf8′，当data使buffer时，该值应该为 ignored。
   • mode：文件读写权限，默认值 438【十进制】
   • flag：默认值 ‘w'
4. callback：回调，传递一个异常参数err。

// 原data.txt
123

const fs = require('fs')
const path = require('path')
fs.appendFile('data.txt', 'hello node.js',{},  (err) => {
  console.log('写入成功')
})
// 写入成功

// 现data.txt
123hello node.js

• copyFile：将某个文件中的数据拷贝至另一文件 fs.copyFile( src, dest, mode, callback )

参数： 该方法接受上述和以下所述的四个参数：

1. src：它是一个字符串，缓冲区或URL，表示要复制的源文件名。
2. dest：它是一个字符串，缓冲区或URL，表示复制操作将创建的目标文件名。
3. mode：它是一个整数，指定复制操作的行为。可以为这些值提供预定义的常量，这些常量具有各自的行为：
   • fs.constants.COPYFILE_EXCL：该常数指定如果目标文件名已经存在，则复制操作将失败。
   • fs.constants.COPYFILE_FICLONE：该常数指定复制操作将尝试创建copy-on-write reflink。如果平台不支持copy-on-write，则使用回退机制。
   • fs.constants.COPYFILE_FICLONE_FORCE：该常数指定复制操作将尝试创建copy-on-write reflink。如果平台不支持copy-on-write，则失败将失败，与之前的平台不同。
4. callback：该方法执行时将调用该函数。

// 原data.txt
123hello node.js

const fs = require('fs')
const path = require('path')
fs.copyFile('data.txt', 'test.txt', () => {
  console.log('拷贝成功')
})
// 拷贝成功

// test.txt
123hello node.js

• watchFile：对指定文件进行监控 fs.watchFile(filename, options, listener)

参数： 该方法接受上述和以下所述的三个参数：

1. filename：它是一个字符串，缓冲区或URL，表示要监视的文件的文件名。
2. options：它是一个对象，可用于修改方法的行为。它是一个可选参数。它具有以下参数：
   • bigint：它是一个布尔值，用于将fs.Stat对象的数值指定为BigInt值。默认值为false。
   • persistent：它是一个布尔值，用于指定只要正在监视文件，该过程是否应该继续。默认值是true。
   • interval：它是整数，指定每次轮询到目标之间的时间间隔。以毫秒为单位指定。默认值为5007。
3. listener：访问或修改文件时将调用该函数。
   • current：这是一个fs.Stats对象，它表示文件被访问或修改后的当前状态。
   • previous：这是一个fs.Stats对象，它表示文件被访问或修改之前的先前状态。

// data.txt
1234567890

const fs = require('fs')
const path = require('path')
fs.watchFile('data.txt', {interval: 20}, (curr, prev) => {
  if (curr.mtime !== prev.mtime) {
    console.log('文件被修改了')
    fs.unwatchFile('data.txt')
  }
})
// 修改data.txt中的数据为123，此时会监听到文件的变化，执行console操作
// 文件被修改了

demo--md转html实现

// index.md
### 标题一
* 列表项2
* 列表项3
### 标题二

const fs = require('fs')
const path = require('path')
const marked = require('marked')
const browserSync = require('browser-sync')

/**
 * 01 读取 md 和 css 内容
 * 02 将上述读取出来的内容替换占位符，生成一个最终需要展的 Html 字符串 
 * 03 将上述的 Html 字符写入到指定的 Html 文件中
 * 04 监听 md 文档内容的变经，然后更新 html 内容 
 * 05 使用 browser-sync 来实时显示 Html 内容
 */

let mdPath = path.join(__dirname, process.argv[2])
let cssPath = path.resolve('github.css')
let htmlPath = mdPath.replace(path.extname(mdPath), '.html')

fs.watchFile(mdPath, (curr, prev) => {
  if (curr.mtime !== prev.mtime) {
    fs.readFile(mdPath, 'utf-8', (err, data) => {
      // 将 md--》html
      let htmlStr = marked(data)
      fs.readFile(cssPath, 'utf-8', (err, data) => {
        let retHtml = temp.replace('{{content}}', htmlStr).replace('{{style}}', data)
        // 将上述的内容写入到指定的 html 文件中，用于在浏览器里进行展示
        fs.writeFile(htmlPath, retHtml, (err) => {
          console.log('html 生成成功了')
        })
      })
    })
  }
})

browserSync.init({
  browser: '',
  server: __dirname,
  watch: true,
  index: path.basename(htmlPath)
})

const temp = `
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title></title>
        <style>
            .markdown-body {
                box-sizing: border-box;
                min-width: 200px;
                max-width: 1000px;
                margin: 0 auto;
                padding: 45px;
            }
            @media (max-width: 750px) {
                .markdown-body {
                    padding: 15px;
                }
            }
            {{style}}
        </style>
    </head>
    <body>
        <div class="markdown-body">
            {{content}}
        </div>
    </body>
    </html>
`

执行结果：

文件的打开与关闭

• open：打开文件 fs.open( filename, flags, mode, callback )

参数： 该方法接受上述和以下所述的四个参数：

1. filename：它保存要读取的文件名或完整路径(如果存储在其他位置)。
2. flag：必须在其中打开文件的操作。
3. mode：设置文件的模式，即r-read，w-write，r + -readwrite。它将默认设置为读写。
4. callback：这是在读取文件后调用的回调函数。它带有两个参数：
   • err：如果发生任何错误。
   • data：文件内容。打开操作执行后调用。

// data.txt
1234567890

const fs = require('fs')
const path = require('path')
fs.open(path.resolve('data.txt'), 'r', (err, fd) => {
  console.log(fd)
})
// 3

• close：关闭文件 fs.close( fd, callback )

参数： 该方法接受上述和以下所述的两个参数：

1. fd：文件open时传递的文件描述符。
2. callback：回调函数。

// data.txt
1234567890

const fs = require('fs')
const path = require('path')
fs.open('data.txt', 'r', (err, fd) => {
  console.log(fd)
  fs.close(fd, err => {
    console.log('关闭成功')
  })
})
// 3
// 关闭成功

文件的读与写

• read：读操作，就是将数据从磁盘文件中写入到 buffer 中 fs.read(fd,buffer,offset,length,position,callback(err,readBytes,buffer))

参数： 该方法接受上述和以下所述的六个参数：

1. fs：文件描述符
2. buffer：缓冲区，数据将被读取。
3. offset：buffer读取的偏移量
4. length：指定文件读取字节数长度
5. position：指定文件读取的起始位置，如果该项为null，将从当前文件指针的位置开始读取数据。
6. callback：回调传递了三个参数，err， readBytes， buffer
   • err：异常
   • readBytes：读取的字节数
   • buffer：缓冲区对象

// data.txt
1234567890

const fs = require('fs')
const buf = Buffer.alloc(10)
fs.open('data.txt', 'r', (err, rfd) => {
  console.log(rfd)
  fs.read(rfd, buf, 1, 4, 3, (err, readBytes, data) => {
    console.log(readBytes)
    console.log(data)
    console.log(data.toString())
  })
})
// 3
// 4
// <Buffer 00 34 35 36 37 00 00 00 00 00>
// 4567

• write：写操作，就是将缓冲区里的内容写入到磁盘文件中 fs.write(fd, buffer, offset, length, position, callback(err, bytesWritten, buffer))

参数： 该方法接受上述和以下所述的六个参数：

1. fs：文件描述符
2. buffer：缓冲区，数据将被写入。
3. offset：buffer写入的偏移量
4. length：指定文件写入字节数长度
5. position：指定文件写入的起始位置，如果该项为null，将从当前文件指针的位置开始写入数据。
6. callback：回调传递了三个参数，err， bytesWritten， buffer
   • err：异常
   • bytesWritten：写入的字节数
   • buffer：缓冲区对象

// 原data.txt
1234567890

const fs = require('fs')
const buf = Buffer.from('abcdefg')
fs.open('data.txt', 'w', (err, wfd) => {
  fs.write(wfd, buf, 2, 4, 0, (err, written, buffer) => {
    fs.close(wfd)
  })
})

// 现data.txt
cdef

目录操作

• access：判断文件或目录是否具有操作权限 fs.access(path, mode, callback)

参数： 该方法接受上述和以下所述的三个参数：

1. path：它是一个字符串，缓冲区或URL，表示必须对其权限进行测试的文件或目录的路径。
2. mode：要检查的权限掩码。逻辑OR运算符可用于分隔多个权限。它可以具有值fs.constants.F_OK【文件是对于进程是否可见，可以用来检查文件是否存在。也是mode 的默认值】，fs.constants.R_OK【文件对于进程是否可读】，fs.constants.W_OK【文件对于进程是否可写】和fs.constants.X_OK【文件对于进程是否可执行。（Windows系统不可用，执行效果等同fs.F_OK）】。它是一个可选参数。
3. callback：该方法执行时将调用该函数。
   • err：如果方法失败，将抛出此错误。

const fs = require('fs')
fs.access('a.txt', (err) => {
  if (err) {
    console.log(err)
  } else {
    console.log('有操作权限')
  }
})

• stat：获取目录及文件信息 fs.stat(path, callback(err, stats))

参数： 该方法接受上述和以下所述的两个参数：

1. path：文件路径
2. mode：callback 回调，传递两个参数，异常参数err, 文件信息数组 stats

const fs = require('fs')
fs.stat('a.txt', (err, stats) => {
  console.log(stats)
  //是否是文件
  console.log(stats.isFile())

  //是否是目录
  console.log(stats.isDirectory())

  //判断文件类型是否是块设备
  console.log(stats.isBlockDevice())

  //判断文件类型是否是字符设备
  console.log(stats.isCharacterDevice())
})

• mkdir：创建目录 fs.mkdir(path, mode, callback(err))

参数： 该方法接受上述和以下所述的三个参数：

1. path：将创建的目录路径
2. mode：目录权限（读写权限），默认0777
3. callback：回调，传递异常参数err

const fs = require('fs')
fs.mkdir('a/b/c', {recursive: true}, (err) => {
  if (!err) {
    console.log('创建成功')
  }else{
    console.log(err)
  }
})

• rmdir：删除目录 fs.rmdir(path, callback(err))

参数： 该方法接受上述和以下所述的两个参数：

1. path：将创建的目录路径
2. callback：回调，传递异常参数err

const fs = require('fs')
fs.rmdir('a', {recursive: true}, (err) => {
  if (!err) {
    console.log('删除成功')
  } else {
    console.log(err)
  }
})

• readdir：读取目录中内容 fs.readdir(path, mode, callback(err,files))

参数： 该方法接受上述和以下所述的两个参数：

1. path：将创建的目录路径
2. callback：回调，传递两个参数 err 和 files，files是一个包含“指定目录下所有文件名称的”数组

const fs = require('fs')
fs.readdir('a/b', (err, files) => {
  console.log(files)
})

• unlink：删除指定文件 fs.unlink(path, callback(err))

参数： 该方法接受上述和以下所述的两个参数：

1. path：将创建的目录路径
2. callback：回调，传递异常参数err

const fs = require('fs')
fs.unlink('a/a.txt', (err) => {
  if (!err) {
    console.log('删除成功')
  }
})