邂逅Node.JS的那一夜

/** Node.js  
 *  Node.js（简称Node）是一个基于Chrome V8引擎的开源、跨平台的JavaScript运行时环境 
 *  因为和浏览器的内置API不同所以存在一些区别,没有: windwo、document...对象 同时拥有自己的模块 */
console.log("node Hello World");

/** Buffer的创建： */
const b1 = Buffer.alloc(10);        //从内存上获取一段长度为10byte空间赋值Buffer
console.log(b1);                    //<Buffer 00 00 00 00 00 00 00 00 00 00>	十六进制

const b2 = Buffer.allocUnsafe(10);  //随机获取内存上一段长度为10byte空间赋值Buffer,所以可能存在内存空间上的旧数据
console.log(b2);                    //<Buffer 59 8c 75 0b 6a 02 00 00 20 00>    有可能都是00 	十六进制

//通过字符|数组...参数创建Buffer
const b3 = Buffer.from('Node.js');
const b4 = Buffer.from([11, 54, 68, 37]);
console.log(b3);                    //直接console则展示每个字节元素对应的ASCLL码值的十六进制
console.log(b4);                    //默认其实是UNICODE码表,ASCLL完全兼容UNICODE,所以查询直接查找ASCLL

/** Buffer是一个类似于数组的对象，所以可以像数组一样操作元素的操作： */
const b3 = Buffer.from('Node.js');
// b3[0] = 110;                 //对应ASCLL小写n
console.log(b3[0]);             //[下标] 获取字节元素
console.log(b3.length);         //length Buffer内存字节长度
console.log(b3.toString());     //toString() 查看元素内容,默认 UTF-8编码格式
console.log(b3[0].toString(2)); //toString(2) 查看元素内容,并以二进制形式展示
//Buffer是一段固定长度连续的内存空间,因为是连续的内存空间所以快,也不方便删减内存元素...

/** Buffer关于中文的操作 */
const bus = Buffer.from('你好');     //中文一个字节占用3字节
console.log(bus);
console.log(bus.length);            //6
console.log(bus.toString());        //你好

const bu = Buffer.alloc(1);
bu[0] = 255;
console.log(bu);        //<Buffer ff>
bu[0] = 256;
console.log(bu);        //<Buffer 00>   ???怎么编成0了
/** 对于超出字节长度是赋值并不会报错,而是进行溢出操作：赋值元素二进制大于8位的内容舍弃(仅保留从右-左8位长度bit)
     *  255的二进制：1111 1111          =>保留结果: 11111111
     *  256的二进制: 0001 0000 0000     =>保留结果: 00000000 */

const fs = require('fs');	//require导入FS模块: fs变量接收模块对象

{   
    //file: 相对|绝对文件路径: 文件不存在默认创建,路径不存在则目录拼接至文件名上...找不到盘符则报错;
    fs.writeFile('.\www.txt','你好呀~',err =>{
        //写入成功|失败执行函数,并传入错误对象:写入成功err=null
        if (err) { return console.log('文件写入失败'); }
        console.log('文件写入成功');
    });
   	console.log('异步写入文件:不阻塞继续执行下面log');
}

/** fs.writeFileSync(file, data,[options])
 *  参数和上述类似:同步方法没有回调函数,报错就直接报错了... */
{
    fs.writeFileSync('.\wsm.txt','你好呀Sync~');
    console.log('同步写入阻塞程序文件写入完毕继续执行下面log');
    
    fs.writeFileSync('.\wsm.txt',"\nflag参数实现文件追加...",{flag:'a'});	//{flag:'a'} 文件内容追加
}

{
    //语法与writeFile语法完全相同
    fs.appendFile('./www.txt','123\n',err=>{
        if(err) { return console.log('文件写入失败'); }
        console.log('文件写入成功'); });

    fs.appendFile('./www.txt','456\n',err=>{
        if(err) { return console.log('文件写入失败'); }
        console.log('文件写入成功'); });
    console.log('异步写入文件:不阻塞继续执行下面');
}

/** fs.appendFileSync(file, data,[options])
 *  参数和上述类似:同步方法没有回调函数,报错就直接报错了... */
{
    fs.appendFileSync('.\wsm.txt','123\n');
    fs.appendFileSync('.\wsm.txt','456\n');
    console.log('同步写入阻塞程序文件写入完毕继续执行下面log');
}

{
    //1.导入FS模块
    //2.根据路径创建对应的文件流对象
    const ws = fs.createWriteStream('./wsm.txt', { flags: 'a' });
    ws.write('123\n');    //3.使用文件流对象写入文件...
    ws.write('456\n');
    ws.write('789\n');
    ws.end();         	  //4.文件写入文本关闭文件流资源: nodeJS也会自动关闭资源
}

/** fs.readFile(path,[options],callback) 
 *  path: 路径+文件名,文件不存在则读取失败
 *  [options]: 可选参数配置,读取文件编码格式
 *  callback(err,data){ 回调函数当文件数据全读取,回调执行: data数据默认buffer类型 } */
{
    //Demo:建议提前准备好要读取的文件;
    fs.readFile('./wsm.txt', (err, data) => {
        if (err) { return console.log('文件读取异常...'); }
        console.log(data);
        console.log(data.toString());   //buffer.toString(); 转UTF-8
    });
}

/** 同步读取:
 *  fs.readFileSync(path,[options]) 返回值：String|Buffer*/
{
    const rb = fs.readFileSync('./wsm.txt');
    const sb = fs.readFileSync('./wsm.txt', 'utf-8');   //[options]设置读取文件编码格式;
    console.log(rb);
    console.log(sb);
    console.log('同步读取文件: 读取结束继续执行下面log');
}

{
    //1 引入FS模块
    //2 根据文件路径创建文件读取流对象--这里需要更换自己的文件路径
    const rs = fs.createReadStream('./resource/男娘.MP3');   //提前准备大文件: 图片/视频...
    //3 给读取流对象 绑定data事件
    rs.on('data', chunk => {
        console.log(chunk); //默认块: 65536字节byte => 64KB 最后一块不满足会比较小;
        //这样每次读取一块数据,对每块数据进行操作用完即回收减少内存开销,提高程序性能...
    });
    
    //4 [可选]:文件读取完成
    rs.on('end', () => { console.log('文件读取结束'); })
}

/** 文件的删除:
 *  fs.unlink(path, callback)   同步删除 如果路径文件不存在则报错
 *  fs.unlinkSync(path)         异步删除 */
{
    fs.unlink('./wsm.txt', err => {
        if (err) return console.log('unlink删除失败');
        console.log('unlink删除成功');
    });
	//同步方法并没有回调函数,原地返回相应结果,所以需要传统try-catch捕获异常
    try { 
        fs.unlinkSync('./wsmm.txt');
        console.log('unlinkSync删除成功');
     } catch (error) { console.log('unlinkSync删除失败'); }
}

/** node14.4新增删除方法
 *  rm|rmSync 异步|同步的删除方法... */
{
    /** 吐槽一下啊：本人想要复刻重复删除成功的过程始终没有实现,求路过的大佬指点一下： */
    fs.rm('./wsm', { recursive: true ,maxRetries: 50, retryDelay: 100 }, err => {
        if (err) return console.log('rm删除失败');
        console.log('rm删除成功');
    });

    try { 
        fs.rmSync('./wsmm.txt'); 
        console.log('rmSync删除成功');
    } catch (error) { console.log('rmSync删除失败'); }
}

/** 文件的重命名|移动 
 *  fs.rename(oldPath, newPath, callback) 异步
 *  fs.renameSync(oldPath, newPath) 同步
 *  oldPath :表示要修改的文件资源,不存在则报错;
 *  newPath :表示修改后的文件地址,单纯文件名发生改变——>重命名,文件路径|名改变——>剪切|重命名;    */
{
    //异步重命名|移动
    fs.rename('./wwsm.txt', './www/wsmup.txt', err => console.log(err));  //移动的路径要存在则报错
    //同步重命名|移动
    // fs.renameSync('./wwsm.txt', './www/wsmup.txt');
}

/** 创建文件夹
 *  path: 指点创建的文件路径,文件存在则报错
 *  options: 可选配置完成特殊操作
 *  callback: 回调函数... */
fs.mkdir('./wsm',err=>{ console.log(err); });    //同级目录创建wsm文件夹,如果存在会报错;
fs.mkdir('./wsm/sss',{recursive:true},err=>{ console.log(err); });  //配置:可创建多级目录 目录存在并不会报错;

//回调函数接收两个参数: err(异常有值|无异常null)、data(数组数据结构:返回当前路径下所有文件名|目录)
fs.readdir('./wsm',(err,data)=>{
    if(err) return console.log(err);
    console.log(data);
});

// 默认:文件夹非空不允许删除
// fs.rmdir('./wwww',err=>{ console.log(err); });   
// 设置{recursive:true}递归true 则文件非空|多级目录可以删除;
fs.rmdir('./wwww',{recursive:true},err=>{ console.log(err); }); 

//回调函数接收两个参数: err(异常有值|无异常null)、data(对象数据结构:返回当前文件资源的状态对象)
fs.stat('./resource/男娘.MP3',(err,data)=>{
    if(err) console.log(err);
    console.log(data);
});

//同步获取文件资源信息:——方法返回文件资源对象
// const statFile = fs.statSync('./resource/男娘.MP3');
// console.log("是否文件夹:" + statFile.isFile());

stats.nlink：文件的硬链接数
stats.mode：	文件的权限和类型
stats.ino：	文件的 inode 号
stats.gid：	文件的所有者的组标识符
stats.uid：	文件的所有者的用户标识符
stats.size：	文件的大小，以字节为单位
stats.dev：	文件所在的设备的数字标识符
stats.blocks：	文件占用的文件系统块的数量
stats.atime：	文件的上次访问时间的 Date 对象
stats.mtime：	文件的上次修改时间的 Date 对象
stats.blksize：	用于 I/O 操作的文件系统块的大小
stats.ctime：	文件的上次状态变更时间的 Date 对象
stats.atimeMs：	文件的上次访问时间的时间戳，以毫秒为单位
stats.mtimeMs：	文件的上次修改时间的时间戳，以毫秒为单位
stats.rdev：		如果文件是特殊文件，表示其设备的数字标识符
stats.ctimeMs：	文件的上次状态变更时间的时间戳，以毫秒为单位
stats.birthtime：	文件的创建时间的 Date 对象
stats.birthtimeMs：	文件的创建时间的时间戳，以毫秒为单位

stats.isFile()：			如果文件是文件，返回 true
stats.isDirectory()：	如果文件是目录，返回 true
stats.isFIFO()：			如果文件是 FIFO，返回 true
stats.isSocket()：		如果文件是套接字，返回 true
stats.isBlockDevice()：	如果文件是块设备，返回 true
stats.isSymbolicLink()：	如果文件是符号链接，返回 true
stats.isCharacterDevice()：如果文件是字符设备，返回 true

//相对路径指相对于某个基准路径的路径，它通常以 . 或  .. 开头，表示当前目录或上级目录
fs.mkdirSync('./newdire', { recursive: true });         //./创建同级
fs.mkdirSync('../newdire', { recursive: true });        //../创建上一级
fs.mkdirSync('../newdire/dire', { recursive: true });   //上一级递归创建多级目录

//绝对路径指从根目录开始的完整的路径，它通常以 / 或 盘符 开头，表示系统的根目录或分区
fs.mkdirSync('D:/newdire0', { recursive: true });       //D盘创建
fs.mkdirSync('C:/newdire0', { recursive: true });       //C盘创建(系统盘可能因为权限不足获取失败!)
fs.mkdirSync('/newdire2', { recursive: true });         //对于不同的操作系统无法固定盘符: / 默认系统盘路径

//获取当前文件的绝对路径|+文件名,实际开发中通过用这个来规定路径完善
console.log(__dirname);     //C:\Users\wsm17\Desktop\ls\NodeStudy\01FS模块
console.log(__filename);    //C:\Users\wsm17\Desktop\ls\NodeStudy\01FS模块\09相对绝对路径.js

/** Path系统路径模块 */
const fs = require('fs');
const path = require('path');

//获取当前文件的绝对路径|+文件名,实际开发中通过用这个来规定路径完善
console.log(__dirname);     //C:\Users\wsm17\Desktop\ls\NodeStudy\01FS模块
console.log(__filename);    //C:\Users\wsm17\Desktop\ls\NodeStudy\01FS模块\09相对绝对路径.js

/** 上述__xxXX局部属性获取的路径是 \ 而我们正常使用的是 / 
 *  虽然不影响正常使用(系统会自动进行处理操作系统识别的路径) 但这样对路径进行拼接就会不可读 */
{
    console.log(__dirname+'/wsm');  //C:\Users\wsm17\Desktop\ls\NodeStudy\01FS模块/wsm
}

/** Path常用函数: */
{   
    //path.sep 是 path模块中的一个属性,用于表示操作系统的路径分隔符
    console.log(path.sep);  //不同的操作系统上文件路径的分隔符是不同的: windows是\ 在 Linux|Unix是/

    //path.resolve([...paths])	解析为绝对路径,相对于当前工作目录
    console.log(path.resolve(__dirname,'./wsm'));   //C:\Users\wsm17\Desktop\ls\NodeStudy\01FS模块\wsm
    console.log(path.resolve(__dirname,'../wsm'));  //C:\Users\wsm17\Desktop\ls\NodeStudy\wsm

    //path.parse(pathString)	将路径解析为对象包含:目录、根目录、基本名称、扩展名等信息
    console.log(path.parse('/path/wsm/qq540.txt'));
}

Content-Type: application/x-www-form-urlencoded
Content-Type: multipart/form-data

key1=value1&key2=value2

Content-Type: application/json

{
  "key1": "value1",
  "key2": "value2"
}

Content-Type: multipart/form-data; boundary=----WebKitFormBoundary

------WebKitFormBoundary
Content-Disposition: form-data; name="file"; filename="example.txt"
Content-Type: text/plain

... contents of the file ...
------WebKitFormBoundary--

<!DOCTYPE html>
<html>
    <head> <title>Example HTML</title> </head>
    <body> <h1>Hello, World!</h1> </body>
</html>

{ "name": "John Doe", "city": "Example City"}

This is a plain text response.

 const http = require('http');   //require导入HTTP模块: 和FS一样Node.JS使用模块都需要进行导入

const server = http.createServer((request, response) => {
    response.end('Hello HTTP Server');
});

//使用 server服务器对象监听端口,启动服务：
server.listen(5400, () => {
    //服务启动成功的描述信息;
    console.log('node Server 启动！！');	
})

response.setHeader('content-type', 'text/html;charset=utf-8');

//导入HTTP模块
const http = require('http');

//创建服务器对象
const server = http.createServer((request, response) => {
    //request获取请求行
    console.log(request.url);           //获取请求的 URL
    console.log(request.method);        //获取请求方法: GET、POST...
    console.log(request.httpVersion);   //获取请求的HTTP版本: 1.1 2.0

    //request获取请求头: 
    console.log(request.headers);               //headers是对象结构属性|值形式展示
    console.log(request.headers.host);
    console.log(request.headers.connection);    //headers.connection 获取对应的属性数值

    //response设置响应报文
    response.setHeader('content-type', 'text/html;charset=utf-8');
    response.end('Hello HTTP Server 服务响应!');
});

//创建监听端口,启动服务：
server.listen(5400, () => {
    console.log('node Server 启动！！');
})

/** 获取HTTP请求报文 */
const http = require('http');

/** request获取请求体: 
 *  设置参数body接收请求体
 *  绑定data事件:因为请求体大小不确定避免内存过大溢出,分块传输多次监听
 *  绑定end 事件:当请求体的所有数据都接收完毕时,触发回调函数,获取完整的请求体 */
const server = http.createServer((request, response) => {
    let body = '';
    request.on('data', chunk => { body += chunk });
    request.on('end', () => { console.log(body); });

    //response设置响应报文
    response.setHeader('content-type', 'text/html;charset=utf-8');
    response.end('Hello HTTP Server 服务响应!');
});

//使用 server服务器对象监听端口,启动服务：
server.listen(5400, () => {
    console.log('node Server 启动！！');
})

/** 模块导入 */
const http = require('http');
const url = require('url');

/** HTTP解析请求路径: url.parse()方法可以将一个URL字符串解析成一个对象,包含了URL的各个组成部分 */
const server = http.createServer((request, response) => {
    response.setHeader('content-type', 'text/html;charset=utf-8');  //解决中文乱码;
    let res = url.parse(request.url, true);
    console.log(res.pathname)   //获取请求路径
    console.log(res.query)      //获取请求参数对象

    if (res.pathname == '/login') {
        response.end('login登录页面');
    } else if (res.pathname == '/register') {
        if (Object.keys(res.query).length !== 0) response.end(JSON.stringify(res.query));
        else response.end('register注册页面');
    } else { response.end('未知路径请求'); }
});

//使用 server服务器对象监听端口,启动服务：
server.listen(5400, () => { console.log('node Server 启动！！'); })

/** 实例化URL的对象解析 */
{
    // URL 字符串
    const urlString = 'https://www.example.com:8080/path?query=123#fragment';
    // 使用 url.parse() 方法解析 URL 字符串并生成 URL 对象
    const parsedUrl = new URL(urlString);
    // 输出 URL 对象的属性
    console.log('hash:', parsedUrl.hash); // '#fragment'
    console.log('protocol:', parsedUrl.protocol); // 'https:'

    console.log('port:', parsedUrl.port); // '8080'
    console.log('host:', parsedUrl.host); // 'www.example.com:8080'
    console.log('hostname:', parsedUrl.hostname); // 'www.example.com'

    console.log('pathname:', parsedUrl.pathname); // '/path'
    console.log('search:', parsedUrl.search); // '?query=123'
    console.log('searchParams:', parsedUrl.searchParams); // URLSearchParams{ 'query' => '123' } 对象
}

/** HTTP 设置响应报文 */
const server = http.createServer((request, response) => {
    //设置响应头|行:
    response.statusCode = 540;
    response.statusMessage = 'WSM'; //随机设置响应:实际开发中Code|Message相互匹配
    response.setHeader('content-type', 'text/html;charset=utf-8');  //解决中文乱码;

    //设置响应体:
    response.write('writerOne');
    response.write('writerTwo');    //向响应体中写入数据块
    response.end('未知路径请求');    	//每个请求结束响应,将响应发送给客户端,必须end 则请求未响应;
});

/** HTTP 设置响应资源报文 */
const server = http.createServer((request, response) => {
  response.setHeader('Content-Type', 'text/html;charset=utf-8');	//并设置资源的编码格式;
  response.write(`
  <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>Node.js HTTP Server</title>
    </head>`
  );
  response.end(`
  <body>
    <h1>Hello, Node.js!</h1> 
    <script>
      // 嵌入的 JavaScript 代码
      alert('This is JavaScript running on the server!');
    </script>
  </body>
  </html>`
  );
});

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Hello World Page</title>
    <style>
        body {
            margin: 0;
            height: 100vh;
            display: flex;
            font-size: 120px;
            align-items: center;
            justify-content: center;
            font-family: Arial, sans-serif; /* 设置字体 */ }
        #helloText { cursor: pointer; /* 添加光标指示可点击 */ }
    </style>
</head>
<body> 
    <div id="helloText">Hello World!</div>

    <script>
        // JavaScript代码，点击文本时变色
        document.getElementById('helloText').addEventListener('click', function() {
            var randomColor = getRandomColor();
            this.style.color = randomColor;
        });
        // 随机创建文本颜色
        function getRandomColor() {
            var color = '#';
            var letters = '0123456789ABCDEF';
            for (var i = 0; i < 6; i++) { color += letters[Math.floor(Math.random() * 16)]; }
            return color;
        }
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Hello World Page</title>
    <link rel="stylesheet" href="css/styles.css">
</head>
<body> 
    <div id="helloText">Hello World!</div>
    <script src="js/script.js" ></script>
</body>
</html>

/** 设置HTTP响应报文 */
const fs = require('fs');
const http = require('http');

/** HTTP 设置响应资源报文 */
const server = http.createServer((request, response) => {
    response.setHeader('Content-Type', 'text/html;charset=utf-8');
    let html = fs.readFileSync(__dirname+'/resource/index.html');    
    response.end(html);
});

//使用 server服务器对象监听端口,启动服务：
server.listen(5400, () => { console.log('node Server 启动！！'); })

/** 设置HTTP响应报文 */
const fs = require('fs');
const http = require('http');

/** HTTP 设置响应资源报文 */
const server = http.createServer((request, response) => {
    //获取请求URL 解析来判断响应页面资源;
    let { pathname } = new URL(request.url,'http://127.0.0.1');
    if(pathname === '/index' ){
        let h5 = fs.readFileSync(__dirname+'/resource/index.html');    
        response.end(h5);
    }else if(pathname === '/js/script.js'){
        let js = fs.readFileSync(__dirname+'/resource/js/script.js');    
        response.end(js);
    }else if(pathname === '/css/styles.css'){
        let css = fs.readFileSync(__dirname+'/resource/css/styles.css');    
        response.end(css);
    }else{ response.statusCode = 404; response.end('<H1> 404 NOT FOUND </H1>'); }
});

//使用 server服务器对象监听端口,启动服务：
server.listen(5400, () => { console.log('node Server 启动！！'); });

/** 设置HTTP响应报文 */
const fs = require('fs');
const path = require('path');
const http = require('http');

let mimes = {   
    html: 'text/html',
    css: 'text/css',
    png: 'image/png',
    mp4: 'video/mp4',
    gif: 'image/gif',
    jpg: 'image/jpeg',
    mp3: 'audio/mpeg',
    js: 'text/javascript',
    json: 'application/json' }  //变量: 常见的文件响应类型,目前的浏览器都有自动识别资源类型的功能了

/** HTTP 设置响应资源报文 */
const server = http.createServer((request, response) => {
    //获取请求URL 解析来判断响应页面资源	 变量: 服务器资源路径
    let { pathname } = new URL(request.url,'http://127.0.0.1');
    let filePath = __dirname + '/resource'+pathname;
    //读取路径文件 fs 异步 API 是否存在,给予异常捕获
    fs.readFile(filePath, (err, data) => {
        if(err){ //判断错误的代号
          response.setHeader('content-type','text/html;charset=utf-8');
          switch(err.code){
            case 'ENOENT':
              response.statusCode = 404;
              return response.end('<h1>404 Not Found</h1>');
            case 'EPERM':
              response.statusCode = 403;
              return response.end('<h1>403 Forbidden</h1>');
            default:
              response.statusCode = 500;
              return response.end('<h1>Internal Server Error</h1>'); } 
            }

        let ext = path.extname(filePath).slice(1); //获取文件的后缀名
        let type = mimes[ext]; //获取对应的类型
        if(type){
          if(ext === 'html'){  response.setHeader('content-type', type + ';charset=utf-8'); 
          }else{ response.setHeader('content-type', type);    }
        }else{
            response.setHeader('content-type', 'application/octet-stream');  //没有匹配到
        }
        //响应文件内容
        response.end(data);
      });
});

//使用 server服务器对象监听端口,启动服务：
server.listen(5400, () => { console.log('node Server 启动！！'); });

<body>
  <!-- 绝对路径 -->
  <a href="https://www.baidu.com">百度</a>
  <a href="//jd.com">京东</a>
  <a href="/search">搜索</a>
  <hr>
  <!-- 相对路径 -->
  <a href="./css/app.css">访问CSS</a>
  <a href="js/app.js">访问JS</a>
  <a href="../img/logo.png">访问图片</a>
  <a href="../../img/logo.png">访问图片</a>
</body>