七.流 目前最常用

• 可写流 ws.write();写入的内容 string or buffer
• 流 stream

let fs = require("fs")
let Stream = require("stream")
let rs = fs.createReadStream("./1.txt")

• 可读流继承的是 Readable 重写_read 可写流继承 writeable 重写_write

• 双工流

• fd 标准出

process.stdout.write("hello") //可写流

• fd2 错误输出 process.stderr.write('hello')

• 标准输入

• fd 0 标准输入 监听 可读流

process.stdin.on("data", function(data) {
  console.log(daat)
})

let { Duplex } = require("stream")
class MyDuplex extends Duplex {
  //读和写可能没有关系，也可能是有关系
  _read() {
    this.push()
  }
  _write(chunk, encoding, clearBuffer) {
    console.log(chunk)
    clearBuffer()
  }
}
let my = new MyDuplex()
my.on("data", function(data) {
  console.log(data)
})
my.write("hello")
my.write("hello")

• 转化流 用的比较多的是压缩

class MyTransfer extends Transform {
  _transform(chunk, encoding, clearBuffer) {
    //参数和可写流是一样的
    let str = chunk.toString().toUpperCase()
    this.push(str)
    clearBuffer()
  }
}
let my = new MyTransfer()
//会监听可读流中的内容 把内容写入到可读流中
//应用场景压缩
process.stdin.pipe(my).pipe(process.stdout)

http 协议和 tcp 协议

• ip 地址-解析-ip-tcp 通信

1.长链接

管线化

• 一个浏览器默认同时发送 6 个请求

uri 和 url

• uri：统一资源标识符
• url：统一资源定位符 https:80 http:443

  let str = "username:password@https://www.baidu.com:80/index.html?a=1#top"
  

  • URL 模块

    let url = require("url")
    //把字符串转化成对象
    let { pathname, query, hostname } = url.parse(str, true)
    console.log(pathname, query.a)
    

• URN:统一资源命名符

• http 基于 tcp（http 头信息的作用 http 常见的状态吗）
• 状态码类别
  • 2xx 成功
    • 200（ok 客户端发过来的）
    • 206
  • 3xx
    • 304
• 206 一般叫范围请求 断点续传
  • curl cmd 中

curl -v --header 'Range:bytes=0-3'http://baidu.com

• 304 服务端实现缓存（强制缓存 对比缓存）

• 401 没有权限

• 403

• 404

• 常见的方法(resful)

  • get 获取
  • post 增加
  • put 修改
  • delete 删除
  • options preflight 预发射

• 跨域问题（协议域名端口号）

  • （前端） webpack 启动一个服务 3000 后端 4000

响应报文

client.js

let http = require("http")
//建立客户端 有get request
// 可以爬虫 可以做中间层
let client = http.request(
  {
    method: "POST",
    hostname: "localhost",
    path: "/a=1#top",
    headers: {
      "Contetn-Type": "application/x-www-form-urlencoded",
    },
    port: 3000,
  },
  function(res) {
    console.log(res.headers)
    res.on("data", function(chunk) {
      console.log(chunk)
    })
  }
)
//把请求真正的发出
//end方法中可以写入请求体
client.end('{ "name":"zpxf" }')

server.js

//node为了实现服务器
let http = require("http") //http内置模块
let querystring = require("querystring")
//req 指的是客户端的请求 可读流on('data')
//res 指的是 服务端的相应 可写流 write end
let server = http.createServer((req, res) => {
  //监听函数，客户端请求到了后会执行回调函数
  let arr = []
  //方法
  let method = req.method
  console.log("方法", method)
  //url
  let url = req.url
  console.log(url)
  //版本号
  let version = req.httpVersion
  //获取请求头，对象的所有key都是小写的
  let headers = req.headers
  console.log("请求头", headers)
  req.on("data", function(chunk) {
    arr.push(chunk)
  })
  req.on("end", function() {
    let str = Buffer.concat(arr).toString()
    let obj
    if (headers["content-type"] === "application/x-www-form-urlencoded") {
      obj = querystring.parse(str)
    } else {
      obj = JSON.parse(obj)
    }
    //设置状态
    res.statusCodeCode = 200
    //设置头
    res.setHeader("Content-Type", "application/json")
    res.setHeader("a", "1")
    //在给客户端写入响应体
    res.end(JSON.stringify(obj))
    console.log(str)
  })
})
//listen EADDRINUSE :::3000端口被占用
let port = 3000
server.listen(port, function(err) {
  console.log(`${port}端口连接成功`)
  server.on("error", function(err) {
    if (err.errno === "EADDRINUSE") {
      port++
      server.listen(port)
    }
  })
})
//nodemon 自动启动node服务
//

//查询字符串 希望把a=b&c=d 格式转成对象格式{a:b,c:d}
// let querystring = require("querystring");
// let obj = querystring(str, "$", "==");
// let s = querystring.stringify(obj);
// console.log(obj, s);

// str.replace(/([^&=]*)=([^&=]*)/g,function(){
//     obj[arguments]
// });

//req
//req.method
//req.url
//req.headers
//req.on('data')

//res
//res.statusCode=200
//
//