网站首页 > 技术文章正文

细品原生JS从初级到高级知识点汇总(四)

hmc789 2024-11-13 11:32:17 技术文章 2 ℃

作者：火狼1

转发链接：https://juejin.im/post/5daeefc8e51d4524f007fb15

5.算法篇

5.1 冒泡算法

冒泡排序，选择排序，插入排序，此处不做赘述.

5.2 斐波那契

特点：第三项等于前面两项之和

function fibonacci(num) { 
    if (num === 1 || num === 2) { 
        return 1
    }
    return fibonacci(num - 1) + fibonacci(num - 2)
  }
复制代码

5.3 动态规划

特点：通过全局规划,将大问题分割成小问题来取最优解案例：最少硬币找零美国有以下面额(硬币）：d1=1, d2=5, d3=10, d4=25 如果要找36美分的零钱，我们可以用1个25美分、1个10美分和1个便士（ 1美分)

class MinCoinChange {

constructor(coins) {
    this.coins = coins
    this.cache = {}
}

makeChange(amount) {
    if (!amount) return []
    if (this.cache[amount]) return this.cache[amount]
    let min = [], newMin, newAmount
    this.coins.forEach(coin => {
        newAmount = amount - coin
        if (newAmount >= 0) {
            newMin = this.makeChange(newAmount)
        }
        if (newAmount >= 0 && 
             (newMin.length < min.length - 1 || !min.length) && 
             (newMin.length || !newAmount)) {
            min = [coin].concat(newMin)
        }
    })
    return (this.cache[amount] = min)
}
}

const rninCoinChange = new MinCoinChange([1, 5, 10, 25])
console.log(rninCoinChange.makeChange(36))
// [1, 10, 25]
const minCoinChange2 = new MinCoinChange([1, 3, 4])
console.log(minCoinChange2.makeChange(6))
// [3, 3]
复制代码

5.4 贪心算法

特点：通过最优解来解决问题用贪心算法来解决2.3中的案例

function MinCoinChange(coins) {
var coins = coins;
var cache = {};
this.makeChange = function(amount) {
  var change = [],
    total = 0;
  for (var i = coins.length; i >= 0; i--) {
    var coin = coins[i];
    while (total + coin <= amount) {
      change.push(coin);
      total += coin;
    }
  }
  return change;
};
复制代码

}

var minCoinChange = new MinCoinChange([1, 5, 10, 25]); console.log(minCoinChange.makeChange(36)); console.log(minCoinChange.makeChange(34)); console.log(minCoinChange.makeChange(6));

6 设计模式

设计模式如果应用到项目中，可以实现代码的复用和解耦，提高代码质量。本文主要介绍14种设计模式写UI组件,封装框架必备

6.1 简单工厂模式

1.定义：又叫静态工厂方法，就是创建对象，并赋予属性和方法 2.应用：抽取类相同的属性和方法封装到对象上 3.代码：

    let UserFactory = function (role) {
  function User(opt) {
    this.name = opt.name;
    this.viewPage = opt.viewPage;
  }
  switch (role) {
    case 'superAdmin':
      return new User(superAdmin);
      break;
    case 'admin':
      return new User(admin);
      break;
    case 'user':
      return new User(user);
      break;
    default:
      throw new Error('参数错误, 可选参数:superAdmin、admin、user')
  }
}

//调用
let superAdmin = UserFactory('superAdmin');
let admin = UserFactory('admin') 
let normalUser = UserFactory('user')
//最后得到角色,可以调用
复制代码

6.2工厂方法模式

1.定义：对产品类的抽象使其创建业务主要负责用于创建多类产品的实例 2.应用:创建实例 3.代码:

var Factory=function(type,content){
  if(this instanceof Factory){
    var s=new this[type](content);
    return s;
  }else{
    return new Factory(type,content);
  }
}

//工厂原型中设置创建类型数据对象的属性
Factory.prototype={
  Java:function(content){
    console.log('Java值为',content);
  },
  PHP:function(content){
    console.log('PHP值为',content);
  },
  Python:function(content){
    console.log('Python值为',content);
  },
}

//测试用例
Factory('Python','我是Python');
复制代码

6.3原型模式

1.定义:设置函数的原型属性 2.应用:实现继承 3.代码:

function Animal (name) {
  // 属性
  this.name = name || 'Animal';
  // 实例方法
  this.sleep = function(){
    console.log(this.name + '正在睡觉！');
  }
}
// 原型方法
Animal.prototype.eat = function(food) {
  console.log(this.name + '正在吃：' + food);
};

function Cat(){ 
}
Cat.prototype = new Animal();
Cat.prototype.name = 'cat';

//?Test Code
var cat = new Cat();
console.log(cat.name);//cat
console.log(cat.eat('fish'));//cat正在吃：fish  undefined
console.log(cat.sleep());//cat正在睡觉！ undefined
console.log(cat instanceof Animal); //true 
console.log(cat instanceof Cat); //true  
复制代码

6.4单例模式

1.定义:只允许被实例化依次的类 2.应用:提供一个命名空间 3.代码:

let singleCase = function(name){
    this.name = name;
};
singleCase.prototype.getName = function(){
    return this.name;
}
// 获取实例对象
let getInstance = (function() {
    var instance = null;
    return function(name) {
        if(!instance) {//相当于一个一次性阀门,只能实例化一次
            instance = new singleCase(name);
        }
        return instance;
    }
})();
// 测试单体模式的实例,所以one===two
let one = getInstance("one");
let two = getInstance("two");   
复制代码

6.5外观模式

1.定义:为子系统中的一组接口提供一个一致的界面 2.应用:简化复杂接口 3.代码: 外观模式

6.6适配器模式

1.定义:将一个接口转换成客户端需要的接口而不需要去修改客户端代码，使得不兼容的代码可以一起工作 2.应用:适配函数参数 3.代码: 适配器模式

6.7装饰者模式

1.定义:不改变原对象的基础上,给对象添加属性或方法 2.代码

let decorator=function(input,fn){
  //获取事件源
  let input=document.getElementById(input);
  //若事件源已经绑定事件
  if(typeof input.onclick=='function'){
    //缓存事件源原有的回调函数
    let oldClickFn=input.onclick;
    //为事件源定义新事件
    input.onclick=function(){
      //事件源原有回调函数
      oldClickFn();
      //执行事件源新增回调函数
      fn();
    }
  }else{
    //未绑定绑定
    input.onclick=fn;
  }
}

//测试用例
decorator('textInp',function(){
  console.log('文本框执行啦');
})
decorator('btn',function(){
  console.log('按钮执行啦');
})
复制代码

6.8桥接模式

1.定义:将抽象部分与它的实现部分分离，使它们都可以独立地变化 2.代码桥接模式

6.9模块方法模式

1.定义:定义一个模板,供以后传不同参数调用 2.代码: 模块方法模式

6.10.观察者模式

1.作用:解决类与对象,对象与对象之间的耦合 2.代码:

let Observer=
  (function(){
    let _message={};
    return {
      //注册接口,
        //1.作用:将订阅者注册的消息推入到消息队列
        //2.参数:所以要传两个参数,消息类型和处理动作,
        //3.消息不存在重新创建,存在将消息推入到执行方法
        
      regist:function(type,fn){
        //如果消息不存在,创建
        if(typeof _message[type]==='undefined'){
          _message[type]=[fn];
        }else{
          //将消息推入到消息的执行动作
          _message[type].push(fn);
        }
      },

      //发布信息接口
        //1.作用:观察这发布消息将所有订阅的消息一次执行
        //2.参数:消息类型和动作执行传递参数
        //3.消息类型参数必须校验
      fire:function(type,args){
        //如果消息没有注册,则返回
        if(!_message[type]) return;
          //定义消息信息
          var events={
            type:type, //消息类型
            args:args||{} //消息携带数据
          },
          i=0,
          len=_message[type].length;
          //遍历消息
          for(;i<len;i++){
            //依次执行注册消息
            _message[type][i].call(this,events);
          }
      },

      //移除信息接口
        //1.作用:将订阅者注销消息从消息队列清除
        //2.参数:消息类型和执行的动作
        //3.消息参数校验
      remove:function(type,fn){
        //如果消息动作队列存在
        if(_message[type] instanceof Array){
          //从最后一个消息动作序遍历
          var i=_message[type].length-1;
          for(;i>=0;i--){
            //如果存在该动作在消息队列中移除
            _message[type][i]===fn&&_message[type].splice(i,1);
          }
        }
      }
    }
  })()

//测试用例
  //1.订阅消息
  Observer.regist('test',function(e){
    console.log(e.type,e.args.msg);
  })

  //2.发布消息
  Observer.fire('test',{msg:'传递参数1'});
  Observer.fire('test',{msg:'传递参数2'});
  Observer.fire('test',{msg:'传递参数3'});
复制代码

6.11状态模式

1.定义:一个对象状态改变会导致行为变化 2.作用:解决复杂的if判断 3.代码状态模式

6.12策略模式

1.定义:定义了一系列家族算法，并对每一种算法单独封装起来，让算法之间可以相互替换，独立于使用算法的客户 2.代码策略模式

6.13.访问模式

1.定义:通过继承封装一些该数据类型不具备的属性, 2.作用:让对象具备数组的操作方法 3.代码: 访问者模式

6.14中介者模式

1.定义:设置一个中间层,处理对象之间的交互 2.代码: 中介者模式

7. HTTP

1.1 什么是 HTTP

HTTP 是一个连接客户端，网关和服务器的一个协议。

7.2 特点

支持客户/服务器模式：可以连接客户端和服务端；简单快速：请求只需传送请求方法，路径和请求主体；灵活：传输数据类型灵活；无连接：请求结束立即断开；无状态：无法记住上一次请求。

7.3 怎么解决无状态和无连接

无状态：HTTP 协议本身无法解决这个状态，只有通过 cookie 和 session 将状态做贮存，常见的场景是登录状态保持；

无连接：可以通过自身属性 Keep-Alive。

7.4 请求过程

HTTP(S) 请求地址 → DNS 解析 → 三次握手 → 发送请求 → 四次挥手

三次握手过程图片来源 CSDN）

在这里插入图片描述

四次挥手过（图片来源 CSDN）在这里插入图片描述

7.5 HTTP 0.9~3.0 对比

7.5.1 HTTP 0.9

只允许客户端发送 GET 这一种请求；且不支持请求头，协议只支持纯文本；无状态性，每个访问独立处理，完成断开；无状态码。

7.5.2 HTTP 1.0

有身份认证，三次握手；请求与响应支持头域；请求头内容；

属性名含义 Accept 可接受的 MIME 类型 Accept-Encoding 数据可解码的格式 Accept-Language 可接受语言 Connection 值 keep-alive 是长连接 Host 主机和端口 Pragma 是否缓存,指定 no-cache 返回刷新 Referer 页面路由 If-Modified-Since 值为时间

响应头内容；

属性名含义 Connection 值 keep-alive 是长连接 Content-Type 返回文档类型,常见的值有 text/plain,text/html,text/json Date 消息发送的时间 Server 服务器名字 Last-Modified 值为时间,s 返回的最后修改时间 Expires 缓存过期时间,b 和 s 时间做对比

注意

expires 是响应头内容，返回一个固定的时间,缺陷是时间到了服务器要重新设置; 请求头中如果有 If-Modified-Since，服务器会将时间与 last-modified 对比，相同返回 304; 响应对象以一个响应状态行开始; 响应对象不只限于超文本; 支持 GET、HEAD、POST 方法; 有状态码; 支持长连接（但默认还是使用短连接）、缓存机制以及身份认证。

7.5.3 HTTP 1.1

请求头增加 Cache-Control

属性名含义 Cache-Control 在1.1 引入的方法,指定请求和响应遵循的缓存机制,值有:public(b 和 s 都缓存),private(b 缓存),no-cache(不缓存),no-store(不缓存),max-age(缓存时间,s 为单位),min-fresh(最小更新时间),max-age=3600 If-None-Match 上次请求响应头返回的 etag 值响应头增加 Cache-Control，表示所有的缓存机制是否可以缓存及哪种类型 etag 返回的哈希值,第二次请求头携带去和服务器值对比

注意

Cache-Control 的 max-age 返回是缓存的相对时间 Cache-Control 优先级比 expires 高缺点：不能第一时间拿到最新修改文件

7.5.4 HTTP 2.0

采用二进制格式传输; 多路复用，其实就是将请求数据分成帧乱序发送到 TCP 中。TCP 只能有一个 steam，所以还是会阻塞; 报头压缩; 服务器推送主动向 B 端发送静态资源，避免往返延迟。

7.5.5 HTTP 3.0

1.是基于 QUIC 协议，基于 UDP 2.特点: 自定义连接机制：TCP 以 IP/端口标识,变化重新连接握手，UDP 是一 64 位 ID 标识，是无连接；自定义重传机制：TCP 使用序号和应答传输，QUIC 是使用递增序号传输；无阻塞的多路复用：同一条 QUIC 可以创建多个 steam。

7.5.6 HTTPS

1.https 是在 http 协议的基础上加了个 SSL； 2.主要包括：握手(凭证交换和验证)和记录协议(数据进行加密)。

7.5.7 缓存

1.按协议分：协议层缓存和非 http 协议缓存： 1.1协议层缓存：利用 http 协议头属性值设置； 1.2非协议层缓存：利用 meta 标签的 http-equiv 属性值 Expires,set-cookie。

2.按缓存分：强缓存和协商缓存： 2.1强缓存：利用 cache-control 和 expires 设置，直接返回一个过期时间，所以在缓存期间不请求，If-modify-since； 2.2协商缓存：响应头返回 etag 或 last-modified 的哈希值，第二次请求头 If-none-match 或 IF-modify-since 携带上次哈希值，一致则返回 304。

3.协商缓存对比： etag 优先级高于 last-modified； 4.etag 精度高，last-modified 精度是 s，1s 内 etag 修改多少次都会被记录； last-modified 性能好，etag 要得到 hash 值。

5.浏览器读取缓存流程：会先判断强缓存；再判断协商缓存 etag(last-modified)是否存在；存在利用属性 If-None-match(If-Modified-since)携带值；请求服务器,服务器对比 etag(last-modified)，生效返回 304。

F5 刷新会忽略强缓存不会忽略协商缓存，ctrl+f5 都失效

7.5.8 状态码

序列详情 1XX(通知) 2XX(成功) 200(成功)、201(服务器创建)、202(服务器接收未处理)、203(非授权信息)、204(未返回内容)、205(重置内容)、206(部分内容) 3XX(重定向) 301(永久移动)、302(临时移动)、303(查看其他位置)、304(未修改)、305(使用代理)、307(临时重定向) 4XX(客户端错误) 400(错误请求)、401(未授权)、403(禁止)、404(未找到)、405(方法禁用)、406(不接受)、407（需要代理授权） 5XX(服务器错误) 500(服务器异常)、501（尚未实施）、502（错误网关）、503（服务不可用）、504（网关超时）、505（HTTP 版本不受支持）

7.5.9 浏览器请求分析

7.5.10 总结

协议

版本内容 http0.9 只允许客户端发送 GET 这一种请求;且不支持请求头,协议只支持纯文本;无状态性,每个访问独立处理,完成断开;无状态码 http1.0 解决 0.9 的缺点,增加 If-modify-since(last-modify)和 expires 缓存属性 http1.x 增加 cache-control 和 If-none-match(etag)缓存属性 http2.0 采用二进制格式传输;多路复用;报头压缩;服务器推送 http3.0 采用 QUIC 协议,自定义连接机制;自定义重传机制;无阻塞的多路复用

缓存

类型特性强缓存通过 If-modify-since(last-modify)、expires 和 cache-control 设置，属性值是时间，所以在时间内不用请求协商缓存通过 If-none-match(etag)设置，etag 属性是哈希值，所以要请求和服务器值对比

8.总结

这只是 JS 原生从初级到高级的梳理; 整理码字不易,欢迎点赞+关注!

本篇已完结

网站首页 > 技术文章 正文