# node

  r.size 文件的大小
  r.isDirectory() 判断文件是不是目录
  r.isFile() 判断文件是不是文件

      //'r' 做什么  flag:'r'/'w'			
      //回调  fdr 打开文件的标示 是一个数字
    fs.read(fdr,buf,0,bufLength,null,(err,bytesRead,data)=>{})
      //fdr 			打开文件 的一个标示
      //buf 			临时存储的一个流空间
      //0   			读取buf的开始位子
      //bufLength 读取buf的长度
      //null      文件开始读取的位子
      //回调      bytesRead参数是 实际读取的字节数
    fs.write(fdr,buf,0,bufLength,null,(err,data)=>{}) //参数同上
    fs.close(fdr)

  path.resolve和path.join区别(第二个参数是否带/)
  path.resolve(__dirname,'/index.html') //e:\index.html
  path.join(__dirname,'/index.html') //e:\study\node\index.html

  process.stdout.write('123') //在控制台输入123
   // 0d 0a  代表换行 回撤

let {pathname,query} = url.parse('http://www.baidu.com:8080/s?a==1',true)
console.log(pathname,query) // /s { a: '=1' }

let b = 2;
console.log('b',b) // 2
let fn = `(function a(){let b = 1;console.log('b2',b)})()`;
let vm = require('vm');
vm.runInThisContext(fn); //2

  //concat用法
    concat([a1,a2,a3],n)
      例子(a1等代表的是Buffer,n代表的是截取多少字节,不写就是全部)
      let a1 = Buffer.from('我')
      let a2 = Buffer.from('ni')
      let r = Buffer.concat([a1,a2],n)
  //重写split方法
  Buffer.prototype.split = function(p){
    let arr = []
    let buf = Buffer.from(this)
    let len = Buffer.from(p).length
    let offset = 0
    let index = buf.indexOf(p)

    while(-1 != index){
      let target = this.slice(offset,index)
      arr.push(target)
      offset = len + index
      index = buf.indexOf(p,offset)
    }
    arr.push(this.slice(offset))
    return arr.toString()
  }

  //读流
  let rs = fs.createReadStream('./a.md',options)
    options(对象)
      flags:'r',
      encoding:null,
      autoClose:true,
      start:0,
      end:6, // 包前又包后
      highWaterMark:3 //默认64K 每次读取64k
      //默认情况下 非流动模式 如果监听了on('data')事件 就变成流动模式 
      //不停的读取文件 将文件读取完毕(最快的速度),之后触发on('end')事件
      rs.on('open',()=>{})
      rs.on('data',()=>{})
      rs.on('resume',()=>{})
      rs.on('pause',()=>{})
      rs.on('end',()=>{})
      rs.on('close',()=>{})
      rs.on('error',()=>{})
  //写流
  let ws = fs.createWriteStream('1.txt',options)
      options(对象)
        flags: 'w',
        encoding: 'utf8',
        autoClose: true,
        highWaterMark: 2 //默认16K 不是代表的每次能写16k  预计我用16k来写
      ws.write(Buffer.from('1'),'utf8',()=>{})
      ws.on('drain',()=>{})//drain 只有当我们写入的内容大于我们的预期，并且被清空后才会触发事件
  //pipe 边读边写
  let fs = require('fs')

  let rs = fs.createReadStream('1.txt',{
    highWaterMark:1
  })

  let ws = fs.createWriteStream('2.txt',{
    highWaterMark:4
  })
  //边读边写
  rs.pipe(ws)
  // 双工流
  const {Duplex} = require('stream');
  const inoutStream = new Duplex({
      write(chunk, encoding, callback) {
          console.log(chunk.toString());
          callback();
      },
      read(size) {
          this.push((++this.index)+'');
          if (this.index > 3) {
              this.push(null);
          }
      }
  });

  inoutStream.index = 0;
  process.stdin.pipe(inoutStream).pipe(process.stdout);

    http://user:pass@www.example.jp:80/dir/index.html?uid=1#ch1
    http            协议方案名
    user:pass       登陆信息(认证)
    www.example.jp  服务器地址
    80              端口
    dir/index.html  带层次的文件路径
    uid             查询字符串
    ch1             片段标识符(后端拿不到这个值)    

  常用状态码:
    1XX(信息状态码 websocket才用)
    2XX(Success 成功状态码)
      200:正常返回
      204:返回的结果只有请求头 没有响应体
      206:分段传输
    3XX(Redirection 重定向)
      301:永久重定向
      302:临时重定向
      304:缓存
    4XX(Client Error 客户端错误状态码)
      401:没有权限
      403:登陆了 还是没有权限
      404:找不到资源
    5XX(Server Error 服务器错误状态码)
      500:服务器挂了
      503:负载均衡超标