我的个人博客

http版本区别

http1.0：

​ 采用非持续连接方式，每次浏览器请求一个文件都要与服务器建立TCP连接，当收到响应后就立即关闭连接。每次请求都要有2倍的RTT开销。

http1.1:

​ 采用持续连接的方式，发送响应后保持这条连接。还可以采用流水线的方式，使得在收到响应报文之前还可以发送多个请求报文。

Web缓存:

​ 当新请求到达时，若发现这个请求与暂存的请求相同，就返回暂存的响应，而不需要按URL的地址再次去英特网访问该资源。

http和https的区别

安全性不同：

​ 1、http是一个简单的请求-响应协议，特点是无状态和明文传输。如果网站采用http协议，因为该协议不加密，极容易遭遇中间人攻击，用户的个人隐私和一些敏感数据很容易泄露。

​ 2、https，实际上是http加上SSL协议组合形成的一种加密传输协议，会消耗更多的服务器资源。https则因为ssl协议的存在，会对网站与客户端之前传输的数据进行加密，不存在数据泄露的问题。

响应速度不同：

​ http响应速度更快，这是因为http只需三次握手，也就是3个包即可建立连接

​ https除了三次握手，还需进行ssl握手，一共需要12个包

连接端口：

​ http端口为80，https端口为443

<script>
      let p = new Promise((resolve, reject) => {
        setTimeout(() => {
          //resolve("OK");
          reject("err");
        }, 1000);
      });

      p.then((value) => {
        console.log(111);
        //中断Promise链，有且只有一个方法
        //返回一个pendding状态的Promise对象
        return new Promise(() => {});
      })
        .then((value) => {
          console.log(222);
        })
        .then((value) => {
          console.log(333);
        })
        .catch((reason) => {
          console.warn(reason);
        });
      //异常结果可以放在最后处理
    </script>

<script>
      let p = new Promise((resolve, reject) => {
        setTimeout(() => {
          resolve("OK");
        }, 1000);
      });

      p.then((value) => {
        return new Promise((resolve, reject) => {
          resolve("success");
        })
          .then((value) => {
            console.log(value); //1秒后输出success
          })
          .then((value) => {
            console.log(value); //undefined
          });
      });
    </script>

<script>
      let p = new Promise((resolve, reject) => {
        resolve("OK");
      });

      let result = p.then(
        (value) => {
          //1、抛出错误
          //throw "出错了"
          //2、返回结果是一个非Promise对象,结果为fulfilled
          //return 521;
          //3、返回结果是一个Promise对象，结果由Promise对象决定
          return new Promise((resolve, reject) => {
            reject("123");
          });
        },
        (reason) => {
          console.log(reason);
        }
      );
      console.log(result);
    </script>

<script>
      let p = new Promise((resolve, reject) => {
        //若是异步任务则先执行回调再改变状态
        //若是同步任务则先改变状态
        setTimeout(() => {
          resolve("OK");
        }, 1000);
      });

      p.then((value) => {
        console.log("wrong");
      });
    </script>

<script>
      let p = new Promise((resolve, reject) => {
        resolve("OK");
      });

      //若Promise的状态发生改变，所有的回调函数就会全部执行
      //若不改变，就不会执行

      p.then((value) => {
        console.log("wrong");
      });

      p.then((value) => {
        alert("wrong");
      });
    </script>

<script>
      //   let p1 = Promise.resolve(521);
      //   //如果传入的参数为非Promise类型的对象，则返回的就是成功的Promise对象
      //   //如果传入的参数为 Promise对象，那么参数的结果就决定了resolve的结果
      //   let p2 = Promise.resolve(
      //     new Promise((resolve, reject) => {
      //       //   resolve("OK");
      //       reject("err");
      //     })
      //   );
      //   console.log(p2);

      let p3 = Promise.reject(521);
      console.log(p3);
      //无论传什么，永远都是失败，且传入什么失败的结果就是什么
      let p4 = Promise.reject(
        new Promise((resolve, reject) => {
          resolve("OK");
        })
      );
      console.log(p4);
    </script>

<script>
      let p = new Promise((resolve, reject) => {
        setTimeout(() => {
          resolve("OK");
        }, 1000);
      });

      let p1 = Promise.reject("123");
      let p2 = Promise.resolve(123);
      let p3 = Promise.resolve("qwer");

      //谁先改变promise对象的状态就返回谁和谁的结果

      const result = Promise.race([p, p1, p2, p3]);
      console.log(result);
    </script>

<script>
      //
      let p1 = Promise.reject("123");
      let p2 = Promise.resolve(123);
      let p3 = Promise.resolve("qwer");

      let p = new Promise((resolve, reject) => {
        resolve("OK");
      });

      //只有全部成功才会返回成功结果，且成功结果为成功的Promise数组
      //只要有一个不成功就会返回失败，失败结果为失败的那个Promise对象

      const result = Promise.all([p1, p2, p3, p]);
      console.log(result);
    </script>

<script>
      let p = new Promise((resolve, reject) => {
        //同步调用，promise里面的函数会立即执行
        console.log(111);
        //修改promise对象的状态
        reject("err");
      });
      console.log(222);

      //执行catch方法
      p.catch((reason) => {
        console.log(reason);
      });
    </script>