Node_word

/*
1 node是什么
    node 一个以javascript为底层逻辑 允许跨平台允许js的应用程序
2 作用
    开发服务端 桌面端 等服务应用
3 启动项
    node fileName.js
    node file + tab键 自动补全
4 语法
    和web不同
    主要为 fs/url/http/util/console/定时器/path/等组成
    通过 gobalThis 可以查出根对象
    require 是当如node_module下的某些文件 如果没有 会查找上一级(不包含内置模块)
5 Baffer
    类似于Array的一个缓冲区 有固定length 不可以修改 用于处理2进制数据
    每个元素为一个字节
    创建Buffer： alloc allocUnsafe from  
        alloc  每个2进制都会归零  旧数据会清空   速度慢
            参数（length）
        allocUnsafe  每个2进制都会归零  危险 旧数据不会清空 可能会包含旧内存空间 例 空间length多一下每次打印数据不同 速度快
            参数（length）
        from 将参数转换成uniCode里所对应的数字再转成2进制  创建新的内存空间   console打印的为16进制  
            参数（[]||''）
    转化Buffer： 
        toString()  UTF-8格式转换   
        []下标（toString(2)进制转换 和方法不是一个意思）   内部值允许修改 类似const
    溢出
        2进制单个最大 255   超过8位会抛弃掉 361 =  0001 0110 1001  => 0110 1001    
    中文
        中文是 utf-8的中文 一个utf-8字符 1:3
6 fs 文件系统
    下载到某些文件 安装程序
    可以和硬盘进行交互 增删改查
    ----writeFile 异步写入
    ----writeFileSync 同步写入 
            参数： file文件路径 data写入数据 options 选项设置 callback(err) 写入回调 err === null 成功
            覆盖原有信息
            option :{ flag: 'a'}
                    r 读取并写入文件，如果文件不存在则抛出异常。
                    rs 读取并写入文件，指示操作系统绕开本地文件系统缓存。
                    w 写入文件，文件不存在会被创建，存在则清空后写入。
                    wx 写入文件，排它方式打开。
                    W+ 读取并写入文件，文件不存在则创建文件，存在则清空后写入。
                    WX+ 和w+类似，排他方式打开。
                    a 追加写入，文件不存在则创建文件。
                    ax 与a类似，排他方式打开。
                    a+ 读取并追加写入，不存在则创建。
                    ax+ a+类似，排他方式打开。
    ----appendFile 异步追加
    ----appendFileSync 同步追加
            参数：file文件路径 data写入数据 callback(err) 写入回调 err === null 成功
            \r\n 换行
    ----createWriteStream 流式写入  类似于socket
            const WS = FS.createWriteStream()
                参数：file文件路径
            write 写入
            close 关闭通道
    ----readFile 异步读取
    ----readFileSync 同步读取
            参数： file文件路径 文件格式utf8 callback(err) 写入回调 err === null 成功
    ----createReadStream 流式读取
            const FSFWS = FS.createReadStream()
                参数：file文件路径
            data 流 callback(chunk) 流值  每次读取最大 64kb数据
            end 读取结束 callback()
    ----复制 通过readFileSync读取后 writeFileSync创建新文件
    ----    通过 createFileStream创建读取流 createWriteFile 写入流
                const WS = FS.createWriteStream()
                const FSFWS = FS.createReadStream()
                WS.on('data',(chunk)=>{
                    FSFWS.write(chunk)
                })
    ----rename 重命名 = 移动   文件
            参数： file文件路径 文件新路径名 写入回调 err === null 成功
    ----unlink 删除文件
    ----rm 删除文件
            参数： file文件路径 
    ----mkdir 创建文件夹
            参数：file文件夹路径 options 写入回调 err === null 成功
                options
                    recursive: true 递归创建文件夹 （文件夹名称 './a/b/c'）
    ----readdir 读取文件夹
            参数：file文件夹路径 写入回调 err === null 成功
    ----rm 删除文件夹
            参数：file文件夹路径 写入回调 err === null 成功  文件夹内部有东西是删除失败的
             options
                    recursive: true 递归创建文件夹 （文件夹名称 './a'） 会删除内部全部东西
    ----stat 查询状态
    ----statSync 查询状态
            参数：file文件夹路径 写入回调 err === null 成功 data 值
            data.isFile()   是否是个文件
            data.isDirectory()   是否是个文件夹
            Stats {
              dev: 1955994538,
              mode: 33206,
              nlink: 1,
              uid: 0,
              gid: 0,
              rdev: 0,
              blksize: 4096,
              ino: 1688849861160755,
              size: 102, 文件大小
              atime: 2023-12-12T11:25:08.432Z, 创建时间
              mtime: 2023-12-12T11:25:08.432Z, 最后访问时间
              ctime: 2023-12-12T12:11:57.220Z, 最后修改时间
              birthtime: 2023-12-12T11:02:13.758Z 最后修改状态时间
            }
    ----路径问题
        相对路径 ./ / ../ ''
        绝对路径 以盘为起点 D:/ d盘下操作   C盘不允许写因为权限不够
        __dirname 当前输出的文件固定路径
7 http 服务端
    npm i -g nodemon    nodemon file  执行时候会检查代码是否发生更改 热更新node
    const http = http
    ---- createServer((request,response))=>{}) 创建服务对象
            request 请求
                method 请求类型
                httpVersion 请求版本
                url 请求路径
                headers 请求头
            response 响应
                setHearder('请求头名称','请求头值')
                    'content-type' , 'text/html;charset=utf-8' 返回响应体是html 字符集是uft-8 (中文乱码问题)
                        类型
                        html:'text/html'
                        css:'text:css'
                        js:'text/javascript'
                        png:'image/png'
                        jpg:'image/jpeg'
                        gif:'image/gif'
                        mp4:'video/mp4'
                        mp3:'audio/mpeg'
                        json:'application/json'
                        charset=utf-8  转换utf-8
                end 设置响应内容  必须且只有一个
                statusCode 设置状态码
                statusMessage 设置状态提示
                write 添加响应体  尽量不用  可以多次调用返回响应体
    const server = http.createServer(()=>{})
                listen('端口号',()={回调})
8 url 解析url
    解析http模块地址
    url.parse(request.url,true) 第二个参数true query就会变成对象
            {
              protocol: null,
              slashes: null,
              auth: null,
              host: null,
              port: null,
              hostname: null,
              hash: null,
              search: '?user=123213',
              query: 'user=123213',
              pathname: '/qqqq',  // 路径
              hash: null,
              search: null,
              query: null,
              pathname: '/favicon.ico',
              path: '/favicon.ico',
              href: '/favicon.ico'
            }
9 path 
    __dirname 固定路径
    extname 获取扩展名 带.
10 模块化 符合commonjs规范   相当于 js 和es规范的关系
    将复杂的应用程序差分出多个文件的过程称为模块化
    优点 ：防止命名冲突 高复用 高维护性
    同名优先导出js 再导入json
    暴露
        module.exports = function
    引入
        const fun = require('./exportFileUrl')
    1导出函数 可以导出任意数据
        module.exports = {
            dateFun,
            strFun
        };
    2按名导出 只能导出单个
        exports.nameFun = nameFun
    *
        exports = value  =  module.exports={}
    3 导入的是文件夹 就会检查文件下是否有 package.json下main属性的路径
        如果package没有就会查找 indexjs或indexjson 如果也没有找到就会报错
        导入node内置模块不需要路径
    4 导入模块流程
        将相对路径转换为绝对路径
        检查缓存
        读取文件代码
        通过arg.callee.toString()查询自执行
        缓存模块值
        module.exports
11 包管理工具
    package-lock 固定未来安装的包版本是相同的
    npm
        init 初始化包 -y 快速创建 都是默认值
            交互式创建 
                1 package名字是什么
                2 版本
                3 描述
                4 入口 默认index.js
                5 测试命令
                6 git地址
                7 关键字
                8 作者名字
                9 开源证书
                10 是否确认
        install || i 安装依赖包 -S 默认 生产和开发都允许访问  -D 只有开发才能访问  -g 全局安装  name
                name@版本号 指定版本安装
        remove || r 删除包
        root -g 查看全局安装包位置
        修改window执行策略
        以管理员身份运行 win+r cmd 执行 set-ExecutionPolicy remoteSigned
    发个包
        npm init
        创建npm账号
        修改镜像成源npm   nrm use npm
        npm login登录
        npm publish 提交包
        修改
            修改版本号
        删除 npm unpublist 是作者 小于24小时  并且没有别的包依赖它 并且每周下载量小于300 并只有一个维护者
        
*/

Buffer

// 创建Buffer
const Buf = Buffer.alloc(10)
// console.log(Buf);
//<Buffer 00 00 00 00 00 00 00 00 00 00>
const BufUn = Buffer.allocUnsafe(10000)
// console.log(BufUn);
// <Buffer 00 00 00 00 00 00 00 00 00 00>
const BufFromStr = Buffer.from('您好')
const BufFromArr = Buffer.from(['11111111', '23', '嘿'])
// console.log(BufFromStr, BufFromArr);
// <Buffer e6 82 a8 e5 a5 bd>  <Buffer c7 17 00>
// 转换字符串
const BufFromILY = Buffer.from([105, 108, 111, 118, 101, 121, 111, 117])
console.log(BufFromILY.toString())
/**
console.log(Buffer)
 [Function: Buffer] {
  poolSize: 8192,
  from: [Function: from],
  copyBytesFrom: [Function: copyBytesFrom],
  of: [Function: of],
  alloc: [Function: alloc],
  allocUnsafe: [Function: allocUnsafe],
  allocUnsafeSlow: [Function: allocUnsafeSlow],
  isBuffer: [Function: isBuffer],
  compare: [Function: compare],
  isEncoding: [Function: isEncoding],
  concat: [Function: concat],
  byteLength: [Function: byteLength],
  [Symbol(kIsEncodingSymbol)]: [Function: isEncoding]
}
 */

fs

const FS = require('fs');
// ---写入
// FS.writeFile('./nodeCreateWriteFile.txt', 'node创建的txt内容', (err) => {
//   err ? console.log('写入失败') : console.log('写入成功')
// })

// ---添加
// ------\r\n 换行
// FS.appendFile('./nodeCreateWriteFile.txt', '\r\n,这是node追加的内容', (err) => {
//   err ? console.log('写入失败') : console.log('写入成功')
// })

// ---流式写入
// const FSCWS = FS.createWriteStream('./nodeCreateWriteFile流式写入.txt', {})
// FSCWS.write('1流式写入\r\n')
// FSCWS.write('2流式写入\r\n')
// FSCWS.write('3流式写入\r\n')
// FSCWS.write('4流式写入\r\n')
// FSCWS.close()

// ---读取
// FS.readFile('./nodeCreateWriteFile流式写入.txt', 'utf8', (err, data) => {
//   if (!err) {
//     console.log(data.toString());
//   }
// })

// ---流式读取
// const FSFWS = FS.createReadStream('./nodeCreateWriteFile流式写入.txt', {})
// FSFWS.on('data', (chunk) => {
//   console.log(chunk.toString(),chunk.length); //每次读取最大 64kb数据
// })
// FSFWS.on('end', () => {
//   console.log('读取结束');
// })

// ----复制
// const readData = FS.readFileSync('./nodeCreateWriteFile.txt')
// FS.writeFileSync('./nodeCreateWriteFileFile-copy2.txt', readData, () => { })

// ----重命名
// FS.rename('./node重命名文件.txt', './node重命名文件的文件名字', () => {})

// ----移动
// FS.rename('./node移动文件.txt', './transFileWord/node重命名文件的文件名字.txt', () => {})

// ----操作文件夹
// 创建文件夹
// FS.mkdir('./newCreateWord', () => {})

// 读取文件夹
// FS.readdir('./', (err, files) => {})

// 删除文件夹
// FS.rmdir('./newCreateWord', (err, files) => {})

// 查看状态
// FS.stat('./nodeCreateWriteFile.txt', (err, stats) => {
//   console.log(stats);
// })
// ----批量修改allEditName文件夹下的文件名称
const files = FS.readdirSync('./allEditName', (err, files) => { })
const dirName = __dirname + '/allEditName'
files.forEach((item) => {
  const fileNameArr = item.split('-')
  const [num, name] = fileNameArr
  const newName = `${num > 9 ? num : '0' + num}-${name}`
  FS.rename(`${dirName}/${item}`, `${dirName}/${newName}`, () => { })
})

http

const http = require('http');
// 创建服务
const server = http.createServer((request, response) => {
    // 获取method request.method
    // 获取url 包含路径和 查询字符串  request.url
    // 获取http 版本号 request.httpVersion
    // 获取请求头 request.headers
    // 获取请求体
    // let body = ''
    // request.on('data', (chunk) => body += chunk)
    // 获取url  和 参数
    // const url = require('url')
    // console.log(url.parse(request.url,true))
    // console.log(new URL(request.url, 'http://' + request.headers.host), 'sass');

    // 修改请求头
    response.setHeader('content-type', 'text/html;charset=utf-8')
    // 返回值
    response.end("错了哦");
});
// 运行
server.listen(9999, () => {
    console.log('server服务启动了,当前ip：9999');
});

export
08-export01.js

const dateFun = function () {
    return new Date()
}
const strFun = function () {
    return 'module.export strFun'
}

// 导出函数
module.exports = {
    dateFun,
    strFun
};
// 按名导出
// exports.dateFun = dateFun
// exports.strFun = strFun

08-export02.js

const { dateFun, strFun } = require('./08-export01')
console.log(dateFun())
console.log(strFun())