1、前置概念

异步非阻塞I/O

  • 隔壁王大爷(不是隔壁老王，hhhhh~~)有个水壶，王大爷经常用它来烧开水。 王大爷把水壶放到火上烧，然后啥也不干在那等，直到水开了王大爷再去搞别的事情。(同步阻塞)
  • 王大爷觉得自己有点憨，不打算等了。把水壶放上去之后大爷就是去看电视，时不时来瞅一眼有没有开 (同步非阻塞)
  • 王大爷去买了个响水壶，他把响水壶放在火上，然后也是等着水开，水开的时候水壶会发出声响(异步 阻塞)
  • 王大爷又觉得自己有点憨，他把响水壶放在火上然后去看电视，这时他不用是不是来瞅一眼，因为水开 的时候水壶会发出声音通知大爷。(异步非阻塞)

    2、运行环境

    ```javascript // 1 资源：cpu 内存 process.memoryUsage() process.cpuUsage()

// 2 运行环境：运行目录、node环境、cpu架构、用户环境、系统平台 console.log(process.cwd()) console.log(process.version) console.log(process.versions) console.log(process.arch) console.log(process.env.NODE_ENV) console.log(process.env.PATH) console.log(process.env.USERPROFILE) console.log(process.platform)

// 3 运行状态：启动参数、PID、运行时间 console.log(process.argv) console.log(process.argv0) console.log(process.pid)

  1. <a name="J8kYa"></a>
  2. # 3、path
  4. <a name="O6JwM"></a>
  5. ## 3.1 获取路径中基础名称
  6. ```javascript
  7. /**
  8.  * 01 返回的就是接收路径当中的最后一部分 
  9.  * 02 第二个参数表示扩展名，如果说没有设置则返回完整的文件名称带后缀
  10.  * 03 第二个参数做为后缀时，如果没有在当前路径中被匹配到，那么就会忽略
  11.  * 04 处理目录路径的时候如果说，结尾处有路径分割符，则也会被忽略掉
  12.  */
  14. path.basename(__filename) // path.js
  15. path.basename(__filename, '.js') // path
  16. path.basename(__filename, '.css') // path
  17. path.basename('/a/b/c')  // c

3.2 获取路径目录名

  1. // 返回路径中最后一个部分的上一层目录所在路径
  3. path.dirname(__filename)    // /.../上级完整的目录
  4. path.dirname('/a/b/c')  // /a/b

3.3 获取路径扩展名

  1. /**
  2.  * 01 返回 path路径中相应文件的后缀名
  3.  * 02 如果 path 路径当中存在多个点，它匹配的是最后一个点，到结尾的内容
  4.  */
  6. path.extname(__filename)  // .js
  7. path.extname('/a/b')   // 返回空
  8. path.extname('/a/b/index.html.js.css') // .css
  9. path.extname('/a/b/index.html.js.') // .

3.4 解析路径

  1. /**
  2.  * 01 接收一个路径，返回一个对象，包含不同的信息
  3.  * 02 root dir base ext name
  4.  */
  6. const obj = path.parse('/a/b/c/index.html') 
  7. console.log(obj.root)  // /
  8. console.log(obj.dir)  // /a/b/c

3.5 路径拼接

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

3.6 绝对路径

  1. console.log(path.resolve('index.html'))  // /.../index.html

4、文件操作

4.1 读文件

  1. // 同步调用
  2. const data = fs.readFileSync('./a.txt'); //代码会阻塞在这里
  5. // 异步调用
  6. fs.readFile(path.resolve('a.txt'), 'utf-8', (err, data) => {
  7.   console.log(err) 
  8.   if (!null) {
  9.     console.log(data)
  10.   }
  11. })

4.2 写文件

  1. // writeFile 
  2. fs.writeFile('data.txt', '1223', function (error, data) {
  3.   if(!error){
  4.     console.log('写入成功！')
  5.   }
  6. })
  9. // appendFile
  10. fs.appendFile('data.txt', 'hello node.js',{},  (err) => {
  11.   console.log('写入成功')
  12. })

5、promisify

把callback转换成promise

  1. // promisify
  2. const { promisify } = require('util')
  3. const readFile = promisify(fs.readFile) 
  4. readFile('./conf.js').then(data=>console.log(data))
  6. // fs Promises API node v10
  7. const fsp = require("fs").promises; 
  8. fsp
  9.   .readFile("./confs.js")
  10.   .then(data => console.log(data))
  11.   .catch(err => console.log(err));
  13. // async/await
  14. (async () => {
  15.     const fs = require('fs')
  16.     const { promisify } = require('util') 
  17.   const readFile = promisify(fs.readFile) 
  18.   const data = await readFile('./index.html') 
  19.   console.log('data',data)
  20. })()

6、http服务

  1. // 创建基础服务
  2. const http = require('http');
  3. const server = http.createServer((request, response) => {
  4.     console.log('there is a request');
  5.     response.end('a response from server'); 
  6. });
  7. server.listen(3000);
  10. // 写一个请求
  11. const { url, method } = request;
  12. if (url === '/' && method === 'GET') {
  13.   fs.readFile('index.html', (err, data) => {
  14.     if (err) {
  15.       response.writeHead(500, { 'Content-Type': 'text/plain;charset=utf-8' });
  16.       response.end('500，服务器错误');
  17.       return;
  18.     }
  19.     response.statusCode = 200; response.setHeader('Content-Type', 'text/html'); response.end(data);
  20.   });
  21. } else {
  22.   response.statusCode = 404;
  23.   response.setHeader('Content-Type', 'text/plain;charset=utf-8'); response.end('404, 页面没有找到');
  24. }

7、Buffer缓冲区

Buffer - 用于在 TCP 流、文件系统操作、以及其他上下文中与八位字节流进行交互。 八位字节组成的数组，可以有效的在JS中存储二进制数据；

  1. // 创建一个长度为10字节以0填充的
  2. const buf1 = Buffer.alloc(10); 
  3. console.log(buf1);  // <Buffer 00 00 00 00 00 00 00 00 00 00>
  5. // 写入Buffer数据 
  6. buf1.write('hello'); 
  7. console.log(buf1);
  9. // 读取Buffer数据 
  10. console.log(buf3.toString());
  12. // 合并Buffer
  13. const buf4 = Buffer.concat([buf1, buf3]);
  17. // 根据数组创建一个buffer对象
  18. let buf1 = Buffer.from([98, 97, 96]) // <Buffer 62 61 60>
  20. // 根据字符串创建buffer对象
  21. let buf2 = Buffer.from('allsll') // <Buffer 61 6c 6c 73 6c 6c>

8、stream

stream - 是用于与node中流数据交互的接口

  1. //二进制，图片操作
  2. const fs = require('fs')
  3. const rs2 = fs.createReadStream('./01.jpg') 
  4. const ws2 = fs.createWriteStream('./02.jpg')
  5. rs2.pipe(ws2);
  6. //响应图片请求
  7. const {url, method, headers} = request;
  8. if (method === 'GET' && headers.accept.indexOf('image/*') !== -1) { 
  9.    fs.createReadStream('.'+url).pipe(response);
  10. }
  1. <br />             <br />         <br />      <br />      <br />                 <br />             <br />         <br />