2.node基础知识笔记

1.Node.js Buffer(缓冲区)

JavaScript 语言自身只有字符串数据类型，没有二进制数据类型。

但在处理像TCP流或文件流时，必须使用到二进制数据。因此在 Node.js中，定义了一个 Buffer 类，该类用来创建一个专门存放二进制数据的缓存区。

• 实例化

  • Buffer.from(array)

  • Buffer.from(string)

  • Buffer.alloc(size)

• 功能方法（静态方法：通过类名调用.）

  • Buffer.isEncoding() 判断是否支持该编码

  • Buffer.isBuffer() 判断是否为Buffer

  • Buffer.byteLength() 返回指定编码的字节长度，默认utf8

  • Buffer.concat() 将一组Buffer对象合并为一个Buffer对象

• 实例方法

  • write() 向buffer对象中写入内容

  • slice() 截取新的buffer对象

  • toString() 把buf对象转成字符串

  • toJSON() 把buf对象转成json形式的字符串:

    不需要显式调用，当JSON.stringify（）方法调用时会自动调用toJSON方法。

    let buf=Buffer.from('hello');
    let json=JSON.stringify(buf);
    console.log(json);

2.核心模块API

先引入路径模块：

const path=require('path');

1. 路径操作：

• [path.basename(path, ext])：返回文件名称

• path.dirname(path)：返回路径

• path.extname(path)：返回扩展名

• path.format(pathObject)：将一个pathObject转化为一个字符串路径

• path.parse(path)：将一个字符串路径转化为路径对象

• path.isAbsolute(path)：判断是否为一个绝对路径。

（2）blobal超全局对象下的两个方法：

• __dirname:返回当前文件所在位置的目录；

• __filename:返回当前文件所在位置的全路径.

 

2. ​
   // 拼接路径（..表示上层路径；.表示当前路径）,在连接路径的时候会格式化路径
   // console.log(path.join('/foo', 'bar', 'baz/asdf', 'quux', '../../'));
   ​
   // 规范化路径
   // console.log(path.normalize('/foo/bar//baz/asdf/quux/..'));
   // console.log(path.normalize('C:\temp\\foo\bar\..\'));
   ​
   // 计算相对路径
   // console.log(path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb'));
   // console.log(path.relative('C:\orandea\test\aaa', 'C:\orandea\impl\bbb'));
   ​
   // 解析路径
   // console.log(path.resolve('wwwroot', 'static_files/png/', '../gif/image.gif'));
   ​
   // 两个特殊属性
   console.log(path.delimiter);//表示路径分隔符（windows是 Linux是/）
   console.log(path.sep);//环境变量分隔符(windows中使用; linux中使用:)

3. 异步与同步：

   于是，所有任务可以分成两种，一种是同步任务（synchronous），另一种是异步任务（asynchronous）。同步任务指的是，在主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务；异步任务指的是，不进入主线程、而进入"任务队列"（task queue）的任务，只有等主线程任务执行完毕，"任务队列"开始通知主线程，请求执行任务，该任务才会进入主线程执行。

   js在浏览器中执行存在的异步操作： 定时任务 事件处理 ajax回调处理。

   node.js 中的异步执行任务：文件I/O 网络I/O

2.文件操作：

1. 引入模块： const fs=require('fs');

2. fs.stat(param1,param2)

   param1:文件路径 param2: 回调函数 ( err,stats)两个参数都为对象，stats.isDirectory:判断是否为路径

   stats.isFile:判断是否为文件。 属性：ctime:文件状态发生改变时间，如权限 mtime:数据改变时间 atime:访问时间 birthtime:文件创造时间。

return null3.readFile()和writeFile();

/*读文件操作*/
const fs=require('fs');
const path=require('path');
let strpath=path.join(__dirname,'data.json');
/*异步方式*/
fs.readFile(strpath,(err,data)=>{
     if(err) return;
     console.log(data.toString());
});
/*同步方式*/
console.log(fs.readFileSync(strpath).toString());
/*写文件操作*/
 let buf=Buffer.from('hello');
 fs.writeFile(strpath,buf,'utf8',(err)=>{
       if(!err){
        console.log('写入成功');
       }
 })

4.大文件的流式操作：

/*大文件的流式操作*/
const path=require('path');
const fs =require('fs');
​
let spath =path.join(__filename);
let endPath=path.join('C:\Users\Administrator\Desktop','file.js');
let readStream=fs.createReadStream(spath);
let writeStream=fs.createWriteStream(endPath);
/*基于事件的处理方式*/
/*let num=0;
chunk:数据块
readStream.on('data',(chunk)=>{
    num++;
    writeStream.write(chunk);
});
readStream.on('end',()=>{
  console.log('文件处理完成'+num);
});
*/
// pipe():直接将输入流连接到输出流 pipe:管道
readStream.pipe(writeStream);

3.目录结构：

/*目录操作*/
const path=require('path');
const fs=require('fs');
​
/*创建目录*/
// fs.mkdir(path.join(__dirname,'abc'),(err)=>{
//   console.log(err);
// });
/*同步创建目录*/
// fs.mkdirSync(path.join(__dirname,'def'));
​
/*删除目录*/
// fs.rmdir(path.join(__dirname,'def'),(err)=>{})
​
//读取目录
fs.readdir(__dirname,(err,files)=>{
    files.forEach((item,index)=>{
        fs.stat(path.join(__dirname,item),(err,stat)=>{
            if(stat.isFile()){
                console.log(item+"文件");
            }else if(stat.isDirectory()){
                console.log(item+"目录");
            }
        }); 
    });
});

4.包：

1. npm: node.js package management (全球最大的模块生态系统，也是node.js的包管理工具。)

2. npm全局安装（安装包在node.js环境的modules目录下，一般用于命令行工具）

   • 安装包： npm install -g 包名称@版本 (全局安装) 本地安装则不需要 参数 g

   • 更新包 npm update 包名称

   • 删除包： npm uninstall 包名称

   • npm清除缓存：pm cache clean --force

3.npm本地安装：

​ 初始化包 npm init -y (1) 运行 node (2)指定pakage.json中test值 npm run test 执行

• 添加依赖 ： 开发环境 安装包的同时 末尾加上 --save

• 生产环境：安装包的同时 末尾加上 --save-dev

• 已有package.json中的dependencies 安装直接 npm install production

  已有DevDependencies 安装直接 npm install

4.yarn工具的安装：

​

​ yarn工具基本使用

安装yarn工具：npm install -g yarn
​
1、初始化包
npm init
yarn init
2、安装包
npm install xxx --save
yarn add xxx
3、移除包
npm uninstall xxx
yarn remove xxx
4、更新包
npm update xxx
yarn upgrade xxx
5、安装开发依赖的包
npm install xxx --save-dev
yarn add xxx --dev
6、全局安装
npm install -g xxx
yarn global add xxx
7、设置下载镜像的地址
npm config set registry url
yarn config set registry url
8、安装所有依赖
npm install
yarn install
9、执行包
npm run
yarn run

5.自定义包：

如果严格按照规范来说 包目录应包含以下文件或目录

• package.json：包描述文件

• bin：存放可执行二进制文件的目录

• lib：存放js代码的目录

• doc：存放文档的目录

• test：存放单元测试用例代码的目录

5.node.js实现简单服务器：

（1）区别:

传统的动态网站开发需要应用软件
PHP ： Apache + php模块
java ：Tomcat 、Weblogic
Node.js  : 不需要应用软件（可以自己实现）

(2)

/*简单实现服务器功能*/
const http=require('http');
​
// 创建服务器实例对象
let server=http.createServer();
/*绑定请求事件*/
server.on('request',(req,res)=>{
        res.end('hello');
});
// 监听端口号
server.listen(3000);
// 简单写法：
http.createServer((req,res)=>{
   res.end('welcome to this');
}).listen(3000,'192.168.229.1',()=>{
    console.log('running...');
});
​
​
- 处理get方式请求参数：
​
- ```javascript

• 处理get请求方式参数：

  
  (1) const url=require('url');
  (2) let param=url.parse(req.url,true).query

​

• 处理post方式参数：

  1. const querystring = require('querystring');

  2. 
     let pdata='';
     req.on('data',(chunk)=>{
         pdata+=chunk;
     });
     req.on('end',()=>{
         //定义一个存放post发送请求请求体内容的对象。
         let obj=querystring.parse(pdata);
     })

 

6. art-template的使用：

   
   /*art-template的使用*/
   ​
   var template = require('art-template');
   /*第一种使用方法*/
   /*var html = template(__dirname + '/mytpl.art', {
       user: {
           name: '汪龙',
           age:'18',
           hometown:"lantian"
       }
   });
   ​
   console.log(html);*/
   /*方法2*/
   let tpl =`{{if user}}
     <h2>{{user.name}}</h2>
     <h2>{{user.age}}</h2>
     <h2>{{user.hometown}}</h2>
   {{/if}}'`;
   let tpl2=`
   <!DOCTYPE html>
   <html lang="en">
   <head>
       <meta charset="UTF-8">
       <title>成绩结果</title>
   </head>
   <body>
       <ul>
           <li>语文：{{chinese}}</li>
           <li>数学：{{math}}</li>
           <li>英语：{{english}}</li>
           <li>综合：{{summary}}</li>
       </ul>
   </body>
   </html>`;
   let render=template.compile(tpl);
   ​
   let ret=render({
        user: {
           name: '汪龙',
           age:'18',
           hometown:"lantian"
       }
   });
    console.log(ret);
    // 方法3
   let score= template.render(tpl2,{
       chinese:'148',
       math:'149',
       english:'139',
       summary:'289'
    } );
    console.log(score);

• node.js web开发相关内容总结：

  
  1.nodejs不需要第三方软件，可以自己实现服务器功能。
  2.实现静态资源分配
  3.路由处理
  4.动态网站
  5.模板引擎
  6.get和post参数处理
  ​
  web开发框架：express.

6.express框架：

• 实现简单服务器测试

  
  /*express测试*/
  const express=require('express');
  const app=express();
  ​
  let server=app.get('/',(req,res)=>{
      res.send('hello world');
  });
  server.listen(3000,'localhost',()=>{
      console.log('running...');
  });

• 静态文件托管：

/*托管静态文件*/
// 可以指定虚拟目录
// 可以指定多个目录
var express = require('express');
var app = express();
​
app.use(express.static('public'));
app.use(express.static('www'));
app.listen(3000,()=>{
    console.log('running....');
});
​

• 路由处理：

  
  /*路由（根据请求方式和请求路径进行路径分发处理）*/
  /*
   http常用请求方式：
   1.get 查询
   2.post 添加
   3. put 更新
   4. delete 删除
    restful api(一种url格式)
  */
  const express=require('express');
  const app=express();
  /*四种基本的路由请求方式*/
  /*app.get('/',(req,res)=>{
      res.send('get data');
  });
  app.post('/',(req,res)=>{
      res.send('post data');
  });
  app.put('/',(req,res)=>{
      res.send('put data');
  });
  app.delete('/',(req,res)=>{
      res.send('delete data');
  });*/
  // 直接使用use可以处理所有的路由请求分发
  app.use('/',(req,res)=>{
    res.send('hello');
  });
  app.listen(3000,()=>{
   console.log('running....');
  });

• 中间件(就是处理过程中的一个环节（本质上相当于一个函数）)：

​ // 中间件的挂载方式// use 路由(get post put delete);// next('route');跳转到下一路由

const express=require('express');
const app=express();
let acessNum=0;
//监听所有路径
app.use('',(req,res,next)=>{
    /*记录访问时间*/
    console.log('哈哈，你怎么又来看我了');
    next()
});
app.use('/user',(req,res,next)=>{
    /*记录访问时间*/
    console.log(Date.now());
    next()
});
app.use('/user',(req,res,next)=>{
    /*记录访问日志*/
    console.log('welcome to this');
    next()
});
app.use('/user',(req,res)=>{
    /*记录访问次数*/
    acessNum++;
    console.log('访问量：'+acessNum);
    res.send('hello');
    
});

• 应用中间件：

  
  //登录验证
  /*中间件的应用，第3方中间件，body-parse的使用*/
  const express=require('express');
  const app=express();
  const bodyParser = require('body-parser');
  // 托管静态资源
  app.use(express.static('public'));
  // 处理get请求方式参数
  ​
  //挂载body-parser中间件
  app.use(bodyParser.urlencoded({ extended: false }));
  //当data为json格式的时候需要加载下面代码
  //app.use(bodyParser.json())
  app.get('/login',(req,res)=>{
      // 通过req.query属性获得get方式参数
        let data=req.query;
          if(data.username=='admin'&&data.password=='123'){
               res.send('success');
          }else{
               res.send('failure');
          }
       
  });
  //处理post请求、
  app.post('/login',(req,res)=>{
      let data=req.body;
      console.log(data);
        if(data.username=='admin'&&data.password=='123'){
               res.send('success');
          }else{
               res.send('failure');
          }
    
  });
  app.listen(3000,()=>{
   console.log('running....');
  });

• express中使用art-template模板：

  1.安装包：

  
  npm install --save art-template
  npm install --save express-art-template

  2.使用:

  
  // 设置模板的路径
  app.set('views',path.join(__dirname,'views'));
  // 设置模板引擎
  app.set('view engine','art');
  // 使express兼容art-template模板引擎
  app.engine('art', require('express-art-template'));
  // 参数一：模板名称；参数二：渲染模板的数据
      res.render('list',data);

  ​

  ​