前言

是时候撸一波 JS 基础啦,撸熟了,银十速拿 offer; 本文不从传统的问答方式梳理,而是从知识维度梳理,以便形成知识网络; 包括函数,数组,对象,数据结构,算法,设计模式和 http.

1. 函数

1.1函数的3种定义方法

1.1.1 函数声明

  1. //ES5
  2. function getSum(){}
  3. function (){}//匿名函数
  4. //ES6
  5. ()=>{}//如果{}内容只有一行{}和return关键字可省,
  6. 复制代码

1.1.2 函数表达式(函数字面量)

  1. //ES5
  2. var sum=function(){}
  3. //ES6
  4. let sum=()=>{}//如果{}内容只有一行{}和return关键字可省,
  5. 复制代码

1.1.3 构造函数

  1. const sum = new Function('a', 'b' , 'return a + b')
  2. 复制代码

1.1.4 三种方法的对比

1.函数声明有预解析,而且函数声明的优先级高于变量; 2.使用Function构造函数定义函数的方式是一个函数表达式,这种方式会导致解析两次代码,影响性能。第一次解析常规的JavaScript代码,第二次解析传入构造函数的字符串

1.2.ES5中函数的4种调用

在ES5中函数内容的this指向和调用方法有关

1.2.1 函数调用模式

包括函数名()和匿名函数调用,this指向window

  1. function getSum() {
  2. console.log(this) //这个属于函数名调用,this指向window
  3. }
  4. getSum()
  5. (function() {
  6. console.log(this) //匿名函数调用,this指向window
  7. })()
  8. var getSum=function() {
  9. console.log(this) //实际上也是函数名调用,window
  10. }
  11. getSum()

1.2.2 方法调用

对象.方法名(),this指向对象

  1. var objList = {
  2. name: 'methods',
  3. getSum: function() {
  4. console.log(this) //objList对象
  5. }
  6. }
  7. objList.getSum()

1.2.3 构造器调用

new 构造函数名(),this指向实例化的对象

  1. function Person() {
  2. console.log(this); //是构造函数调用,指向实例化的对象personOne
  3. }
  4. var personOne = new Person();

1.2.4 间接调用

利用call和apply来实现,this就是call和apply对应的第一个参数,如果不传值或者第一个值为null,undefined时this指向window

  1. function foo() {
  2. console.log(this);
  3. }
  4. foo.apply('我是apply改变的this值');//我是apply改变的this值
  5. foo.call('我是call改变的this值');//我是call改变的this值

1.3 ES6中函数的调用

箭头函数不可以当作构造函数使用,也就是不能用new命令实例化一个对象,否则会抛出一个错误 箭头函数的this是和定义时有关和调用无关 调用就是函数调用模式

  1. (() => {
  2. console.log(this)//window
  3. })()
  4. let arrowFun = () => {
  5. console.log(this)//window
  6. }
  7. arrowFun()
  8. let arrowObj = {
  9. arrFun: function() {
  10. (() => {
  11. console.log(this)//this指向的是arrowObj对象
  12. })()
  13. }
  14. }
  15. arrowObj.arrFun();

1.4.call,apply和bind

1.IE5之前不支持call和apply,bind是ES5出来的; 2.call和apply可以调用函数,改变this,实现继承和借用别的对象的方法;

1.4.1 call和apply定义

调用方法,用一个对象替换掉另一个对象(this) 对象.call(新this对象,实参1,实参2,实参3…..) 对象.apply(新this对象,[实参1,实参2,实参3…..])

1.4.2 call和apply用法

1.间接调用函数,改变作用域的this值 2.劫持其他对象的方法

  1. var foo = {
  2. name:"张三",
  3. logName:function(){
  4. console.log(this.name);
  5. }
  6. }
  7. var bar={
  8. name:"李四"
  9. };
  10. foo.logName.call(bar);//李四
  11. //实质是call改变了foo的this指向为bar,并调用该函数

3.两个函数实现继承

  1. function Animal(name){
  2. this.name = name;
  3. this.showName = function(){
  4. console.log(this.name);
  5. }
  6. }
  7. function Cat(name){
  8. Animal.call(this, name);
  9. }
  10. var cat = new Cat("Black Cat");
  11. cat.showName(); //Black Cat

4.为类数组(arguments和nodeList)添加数组方法push,pop

  1. (function(){
  2. Array.prototype.push.call(arguments,'王五');
  3. console.log(arguments);//['张三','李四','王五']
  4. })('张三','李四')

5.合并数组

  1. let arr1=[1,2,3];
  2. let arr2=[4,5,6];
  3. Array.prototype.push.apply(arr1,arr2); //将arr2合并到了arr1中

6.求数组最大值

  1. Math.max.apply(null,arr)

7.判断字符类型

  1. Object.prototype.toString.call({})

1.4.3 bind

bind是function的一个函数扩展方法,
bind以后代码重新绑定了func内部的this指向,返回一个函数,不会调用方法,不兼容IE8

  1. var name = '李四'
  2. var foo = {
  3. name: "张三",
  4. logName: function(age) {
  5. console.log(this.name, age);
  6. }
  7. }
  8. var fooNew = foo.logName;
  9. var fooNewBind = foo.logName.bind(foo);
  10. fooNew(10)//李四,10
  11. fooNewBind(11)//张三,11 因为bind改变了fooNewBind里面的this指向
  12. 复制代码

1.4.4 call,apply和bind原生实现

call实现:

  1. Function.prototype.newCall = function(context, ...parameter) {
  2. if (typeof context === 'object' || typeof context === 'function') {
  3. context = context || window
  4. } else {
  5. context = Object.create(null)
  6. }
  7. context[fn] = this
  8. const res =context[fn](...parameter)
  9. delete context.fn;
  10. return res
  11. }
  12. let person = {
  13. name: 'Abiel'
  14. }
  15. function sayHi(age,sex) {
  16. console.log(this.name, age, sex);
  17. }
  18. sayHi.newCall (person, 25, '男'); // Abiel 25 男

apply实现:

  1. Function.prototype.newApply = function(context, parameter) {
  2. if (typeof context === 'object' || typeof context === 'function') {
  3. context = context || window
  4. } else {
  5. context = Object.create(null)
  6. }
  7. let fn = Symbol()
  8. context[fn] = this
  9. const res=context[fn](...parameter);
  10. delete context[fn]
  11. return res
  12. }
  13. let person = {
  14. name: "Abiel"
  15. };
  16. function sayHi(age, sex) {
  17. console.log(this.name, age, sex);
  18. }
  19. sayHi.newApply (person,[ 25, '男']) //Abiel 25 男

call 和 apply 封装对比:其实核心代码是一样的,只不过 call 需要对第二个形参解构
bind实现:

  1. Function.prototype.bind = function (context,...innerArgs) {
  2. var me = this
  3. return function (...finnalyArgs) {
  4. return me.call(context,...innerArgs,...finnalyArgs)
  5. }
  6. }
  7. let person = {
  8. name: 'Abiel'
  9. }
  10. function sayHi(age,sex) {
  11. console.log(this.name, age, sex);
  12. }
  13. let personSayHi = sayHi.bind(person, 25)
  14. personSayHi('男')

1.4.5 三者异同

同:都是改变this指向,都可接收参数 异:bind和call是接收单个参数,apply是接收数组

1.5.函数的节流和防抖

类型 概念 应用
节流 事件触发后每隔一段时间触发一次,可触发多次 scroll,resize事件一段时间触发多次
防抖 事件触发动作完成后一段时间触发一次 scroll,resize事件触发完后一段时间触发

节流:

1.5.1 节流

  1. // html 部分
  2. <style>
  3. *{padding:0;margin:0;}
  4. .scroll-box{
  5. width : 100%;
  6. height : 500px;
  7. background:blue;
  8. overflow : auto;
  9. }
  10. .scroll-item{
  11. height:1000px;
  12. width:100%;
  13. }
  14. </style>
  15. <body>
  16. <div class="scroll-box">
  17. <div class="scroll-item"></div>
  18. </div>
  19. </body>
  20. // js 部分
  21. let throttle = function (func, delay) {
  22. let timer = null;
  23. return function(){
  24. if (!timer) {
  25. timer = setTimeout(() => {
  26. func.apply(this, arguments);
  27. // 或者直接 func()
  28. timer = null;
  29. }, delay);
  30. }
  31. };
  32. };
  33. // 处理函数
  34. function handle() {
  35. console.log(arguments)
  36. console.log(Math.random());
  37. }
  38. // 测试用例
  39. document.getElementsByClassName('scroll-box')[0].addEventListener("scroll", debounce(handle,3000));

1.5.2 防抖

  1. // html 部分同上
  2. // js 部分
  3. let debounce = function (fn, wait) {
  4. let timeout = null;
  5. return function () {
  6. if (timeout !== null) clearTimeout(timeout);//如果多次触发将上次记录延迟清除掉
  7. timeout = setTimeout(() => {
  8. fn.apply(this, arguments);
  9. // 或者直接 fn()
  10. timeout = null;
  11. }, wait);
  12. };
  13. }
  14. // 处理函数
  15. function handle() {
  16. console.log(arguments)
  17. console.log(Math.random());
  18. }
  19. // 测试用例
  20. document.getElementsByClassName('scroll-box')[0].addEventListener("scroll", debounce(handle, 3000));

1.6.原型链

1.6.1 定义

对象继承属性的一个链条

1.6.2构造函数,实例与原型对象的关系

掘金1.5W字 - 图1

  1. var Person = function (name) { this.name = name; }//person是构造函数
  2. var o3personTwo = new Person('personTwo')//personTwo是实例
  3. 复制代码

掘金1.5W字 - 图2
原型对象都有一个默认的constructor属性指向构造函数

1.6.3 创建实例的方法

1.字面量

  1. let obj={'name':'张三'}

2.Object构造函数创建

  1. let Obj=new Object()
  2. Obj.name='张三'

3.使用工厂模式创建对象

  1. function createPerson(name){
  2. var o = new Object();
  3. o.name = name;
  4. return o;
  5. }
  6. var person1 = createPerson('张三');

4.使用构造函数创建对象

  1. function Person(name){
  2. this.name = name;
  3. }
  4. var person1 = new Person('张三');

1.6.4 new运算符

1.创了一个新对象;
2.this指向构造函数;
3.构造函数有返回,会替换new出来的对象,如果没有就是new出来的对象
4.手动封装一个new运算符

  1. var new2 = function (func) {
  2. var o = Object.create(func.prototype);//创建对象
  3. var k = func.call(o);//改变this指向,把结果付给k
  4. if (k && k instanceof Object) {//判断k的类型是不是对象
  5. return k;&emsp;//是,返回k
  6. } else {
  7. return o;//不是返回返回构造函数的执行结果
  8. }
  9. }

1.6.5 对象的原型链

掘金1.5W字 - 图3

1.7 继承的方式

JS是一门弱类型动态语言,封装和继承是他的两大特性

1.7.1 原型链继承

将父类的实例作为子类的原型 1.代码实现 定义父类:

  1. // 定义一个动物类
  2. function Animal (name) {
  3. // 属性
  4. this.name = name || 'Animal';
  5. // 实例方法
  6. this.sleep = function(){
  7. console.log(this.name + '正在睡觉!');
  8. }
  9. }
  10. // 原型方法
  11. Animal.prototype.eat = function(food) {
  12. console.log(this.name + '正在吃:' + food);
  13. };

子类:

  1. function Cat(){
  2. }
  3. Cat.prototype = new Animal();
  4. Cat.prototype.name = 'cat';
  5. //&emsp;Test Code
  6. var cat = new Cat();
  7. console.log(cat.name);//cat
  8. console.log(cat.eat('fish'));//cat正在吃:fish undefined
  9. console.log(cat.sleep());//cat正在睡觉! undefined
  10. console.log(cat instanceof Animal); //true
  11. console.log(cat instanceof Cat); //true

2.优缺点 简单易于实现,但是要想为子类新增属性和方法,必须要在new Animal()这样的语句之后执行,无法实现多继承

1.7.2 构造继承

实质是利用call来改变Cat中的this指向 1.代码实现 子类:

  1. function Cat(name){
  2. Animal.call(this);
  3. this.name = name || 'Tom';
  4. }
  5. 复制代码

2.优缺点 可以实现多继承,不能继承原型属性/方法

1.7.3 实例继承

为父类实例添加新特性,作为子类实例返回 1.代码实现 子类

  1. function Cat(name){
  2. var instance = new Animal();
  3. instance.name = name || 'Tom';
  4. return instance;
  5. }

2.优缺点 不限制调用方式,但不能实现多继承

1.7.4 拷贝继承

将父类的属性和方法拷贝一份到子类中 1.子类:

  1. function Cat(name){
  2. var animal = new Animal();
  3. for(var p in animal){
  4. Cat.prototype[p] = animal[p];
  5. }
  6. Cat.prototype.name = name || 'Tom';
  7. }

2.优缺点 支持多继承,但是效率低占用内存

1.7.5 组合继承

通过调用父类构造,继承父类的属性并保留传参的优点,然后通过将父类实例作为子类原型,实现函数复用 1.子类:

  1. function Cat(name){
  2. Animal.call(this);
  3. this.name = name || 'Tom';
  4. }
  5. Cat.prototype = new Animal();
  6. Cat.prototype.constructor = Cat;

1.7.6 寄生组合继承

  1. function Cat(name){
  2. Animal.call(this);
  3. this.name = name || 'Tom';
  4. }
  5. (function(){
  6. // 创建一个没有实例方法的类
  7. var Super = function(){};
  8. Super.prototype = Animal.prototype;
  9. //将实例作为子类的原型
  10. Cat.prototype = new Super();
  11. })();

1.7.7 ES6的extends继承

ES6 的继承机制是先创造父类的实例对象this(所以必须先调用super方法),然后再用子类的构造函数修改this

  1. //父类
  2. class Person {
  3. //constructor是构造方法
  4. constructor(skin, language) {
  5. this.skin = skin;
  6. this.language = language;
  7. }
  8. say() {
  9. console.log('我是父类')
  10. }
  11. }
  12. //子类
  13. class Chinese extends Person {
  14. constructor(skin, language, positon) {
  15. //console.log(this);//报错
  16. super(skin, language);
  17. //super();相当于父类的构造函数
  18. //console.log(this);调用super后得到了this,不报错,this指向子类,相当于调用了父类.prototype.constructor.call(this)
  19. this.positon = positon;
  20. }
  21. aboutMe() {
  22. console.log(`${this.skin} ${this.language} ${this.positon}`);
  23. }
  24. }
  25. //调用只能通过new的方法得到实例,再调用里面的方法
  26. let obj = new Chinese('红色', '中文', '香港');
  27. obj.aboutMe();
  28. obj.say();
  29. 复制代码

1.8.高阶函数

1.8.1定义

函数的参数是函数或返回函数

1.8.2 常见的高阶函数

map,reduce,filter,sort

1.8.3 柯里化

1.定义:只传递给函数一部分参数来调用它,让它返回一个函数去处理剩下的参数

  1. fn(a,b,c,d)=>fn(a)(b)(c)(d)
  2. 复制代码

2.代码实现:

  1. const currying = fn => {
  2. const len = fn.length
  3. return function curr (...args1) {
  4. if (args1.length >= len) {
  5. return fn(...args1)
  6. }
  7. return (...args2) => curr(...args1, ...args2)
  8. }
  9. }
  10. 复制代码

1.8.4 反柯里化

1.定义:

  1. obj.func(arg1, arg2)=>func(obj, arg1, arg2)
  2. 复制代码

2.代码实现:

  1. Function.prototype.uncurrying = function() {
  2. var that = this;
  3. return function() {
  4. return Function.prototype.call.apply(that, arguments);
  5. }
  6. };
  7. function sayHi () {
  8. return "Hello " + this.value +" "+[].slice.call(arguments);
  9. }
  10. let sayHiuncurrying=sayHi.uncurrying();
  11. console.log(sayHiuncurrying({value:'world'},"hahaha"));
  12. 复制代码

1.8.5偏函数

1.定义:指定部分参数来返回一个新的定制函数的形式 2.例子:

  1. function foo(a, b, c) {
  2. return a + b + c;
  3. }
  4. function func(a, b) {
  5. return foo(a,b,8);
  6. }
  7. 复制代码

2.对象

2.1.对象的声明方法

2.1.1 字面量

  1. var test2 = {x:123,y:345};
  2. console.log(test2);//{x:123,y:345};
  3. console.log(test2.x);//123
  4. console.log(test2.__proto__.x);//undefined
  5. console.log(test2.__proto__.x === test2.x);//false
  6. 复制代码

2.1.2 构造函数

  1. var test1 = new Object({x:123,y:345});
  2. console.log(test1);//{x:123,y:345}
  3. console.log(test1.x);//123
  4. console.log(test1.__proto__.x);//undefined
  5. console.log(test1.__proto__.x === test1.x);//false
  6. 复制代码

new的作用: 1.创了一个新对象; 2.this指向构造函数; 3.构造函数有返回,会替换new出来的对象,如果没有就是new出来的对象

2.1.3 内置方法

Obejct.create(obj,descriptor),obj是对象,describe描述符属性(可选)

  1. let test = Object.create({x:123,y:345});
  2. console.log(test);//{}
  3. console.log(test.x);//123
  4. console.log(test.__proto__.x);//3
  5. console.log(test.__proto__.x === test.x);//true
  6. 复制代码

2.1.4 三种方法的优缺点

1.功能:都能实现对象的声明,并能够赋值和取值
2.继承性:内置方法创建的对象继承到proto属性上
3.隐藏属性:三种声明方法会默认为内部的每个成员(属性或方法)生成一些隐藏属性,这些隐藏属性是可以读取和可配置的,属性分类见下面
4.属性读取:Object.getOwnPropertyDescriptor()或getOwnPropertyDescriptor()
5.属性设置:Object.definePropertype或Object.defineProperties

2.2.对象的属性

2.2.1 属性分类

1.数据属性4个特性: configurable(可配置),enumerable(可枚举),writable(可修改),value(属性值)
2.访问器属性2个特性: get(获取),set(设置)
3.内部属性 由JavaScript引擎内部使用的属性; 不能直接访问,但是可以通过对象内置方法间接访问,如:[[Prototype]]可以通过 Object.getPrototypeOf()访问; 内部属性用[[]]包围表示,是一个抽象操作,没有对应字符串类型的属性名,如[[Prototype]].

2.2.2 属性描述符

1.定义:将一个属性的所有特性编码成一个对象返回 2.描述符的属性有:数据属性和访问器属性 3.使用范围: 作为方法Object.defineProperty, Object.getOwnPropertyDescriptor, Object.create的第二个参数,

2.2.3 属性描述符的默认值

1.访问对象存在的属性

特性名 默认值
value 对应属性值
get 对应属性值
set undefined
writable true
enumerable true
configurable true

所以通过上面三种声明方法已存在的属性都是有这些默认描述符 2.访问对象不存在的属性

特性名 默认值
value undefined
get undefined
set undefined
writable false
enumerable false
configurable false

2.2.3 描述符属性的使用规则

get,set与wriable,value是互斥的,如果有交集设置会报错

2.2.4 属性定义

1.定义属性的函数有两个:Object.defineProperty和Object.defineProperties.例如: Object.defineProperty(obj, propName, desc)
2.在引擎内部,会转换成这样的方法调用: obj.[DefineOwnProperty]

2.2.5 属性赋值

1.赋值运算符(=)就是在调用[[Put]].比如: obj.prop = v;
2.在引擎内部,会转换成这样的方法调用: obj.[Put]

2.2.6 判断对象的属性

名称 含义 用法
in 如果指定的属性在指定的对象或其原型链中,则in 运算符返回true ‘name’ in test //true
hasOwnProperty() 只判断自身属性 test.hasOwnProperty(‘name’) //true
.或[] 对象或原型链上不存在该属性,则会返回undefined test.name //“lei” test[“name”] //“lei”

2.3.Symbol

2.3.1概念

是一种数据类型; 不能new,因为Symbol是一个原始类型的值,不是对象。

2.3.2 定义方法

Symbol(),可以传参 var s1 = Symbol(); var s2 = Symbol(); s1 === s2 // false

  1. // 有参数的情况
  2. var s1 = Symbol("foo");
  3. var s2 = Symbol("foo");
  4. s1 === s2 // false
  5. 复制代码

2.3.3 用法

1.不能与其他类型的值进行运算; 2.作为属性名

  1. let mySymbol = Symbol();
  2. // 第一种写法
  3. var a = {};
  4. a[mySymbol] = 'Hello!';
  5. // 第二种写法
  6. var a = {
  7. [mySymbol]: 'Hello!'
  8. };
  9. // 第三种写法
  10. var a = {};
  11. Object.defineProperty(a, mySymbol, { value: 'Hello!' });
  12. // 以上写法都得到同样结果
  13. a[mySymbol] // "Hello!"
  14. 复制代码

3.作为对象属性名时,不能用点运算符,可以用[]

  1. let a = {};
  2. let name = Symbol();
  3. a.name = 'lili';
  4. a[name] = 'lucy';
  5. console.log(a.name,a[name]);
  6. 复制代码

4.遍历不会被for…in、for…of和Object.keys()、Object.getOwnPropertyNames()取到该属性

2.3.4 Symbol.for

1.定义:在全局中搜索有没有以该参数作为名称的Symbol值,如果有,就返回这个Symbol值,否则就新建并返回一个以该字符串为名称的Symbol值 2.举例:

  1. var s1 = Symbol.for('foo');
  2. var s2 = Symbol.for('foo');
  3. s1 === s2 // true
  4. 复制代码

2.3.5 Symbol.keyFor

1.定义:返回一个已登记的Symbol类型值的key 2.举例:

  1. var s1 = Symbol.for("foo");
  2. Symbol.keyFor(s1) // "foo"
  3. var s2 = Symbol("foo");
  4. Symbol.keyFor(s2) // undefined
  5. 复制代码

2.4.遍历

2.4.1 一级对象遍历方法

方法 特性
for … in 遍历对象自身的和继承的可枚举属性(不含Symbol属性)
Object.keys(obj) 返回一个数组,包括对象自身的(不含继承的)所有可枚举属性(不含Symbol属性)
Object.getOwnPropertyNames(obj) 返回一个数组,包括对象自身的所有可枚举和不可枚举属性(不含Symbol属性)
Object.getOwnPropertySymbols(obj) 返回一个数组,包含对象自身的所有Symbol属性
Reflect.ownKeys(obj) 返回一个数组,包含对象自身的所有(不枚举、可枚举和Symbol)属性
Reflect.enumerate(obj) 返回一个Iterator对象,遍历对象自身的和继承的所有可枚举属性(不含Symbol属性)

总结:1.只有Object.getOwnPropertySymbols(obj)和Reflect.ownKeys(obj)可以拿到Symbol属性 2.只有Reflect.ownKeys(obj)可以拿到不可枚举属性

2.4.2 多级对象遍历

数据模型:

  1. var treeNodes = [
  2. {
  3. id: 1,
  4. name: '1',
  5. children: [
  6. {
  7. id: 11,
  8. name: '11',
  9. children: [
  10. {
  11. id: 111,
  12. name: '111',
  13. children:[]
  14. },
  15. {
  16. id: 112,
  17. name: '112'
  18. }
  19. ]
  20. },
  21. {
  22. id: 12,
  23. name: '12',
  24. children: []
  25. }
  26. ],
  27. users: []
  28. },
  29. ];
  30. 复制代码

递归:

  1. var parseTreeJson = function(treeNodes){
  2. if (!treeNodes || !treeNodes.length) return;
  3. for (var i = 0, len = treeNodes.length; i < len; i++) {
  4. var childs = treeNodes[i].children;
  5. console.log(treeNodes[i].id);
  6. if(childs && childs.length > 0){
  7. parseTreeJson(childs);
  8. }
  9. }
  10. };
  11. console.log('------------- 递归实现 ------------------');
  12. parseTreeJson(treeNodes);
  13. 复制代码

2.5.深度拷贝

2.5.1 Object.assign

1.定义:将源对象(source)的所有可枚举属性,复制到目标对象(target) 2.用法:

  1. 合并多个对象
  2. var target = { a: 1, b: 1 };
  3. var source1 = { b: 2, c: 2 };
  4. var source2 = { c: 3 };
  5. Object.assign(target, source1, source2);
  6. 复制代码

3.注意: 这个是伪深度拷贝,只能拷贝第一层

2.5.2 JSON.stringify

1.原理:是将对象转化为字符串,而字符串是简单数据类型

2.5.3 递归拷贝

  1. function deepClone(source){
  2. const targetObj = source.constructor === Array ? [] : {}; // 判断复制的目标是数组还是对象
  3. for(let keys in source){ // 遍历目标
  4. if(source.hasOwnProperty(keys)){
  5. if(source[keys] && typeof source[keys] === 'object'){ // 如果值是对象,就递归一下
  6. targetObj[keys] = source[keys].constructor === Array ? [] : {};
  7. targetObj[keys] = deepClone(source[keys]);
  8. }else{ // 如果不是,就直接赋值
  9. targetObj[keys] = source[keys];
  10. }
  11. }
  12. }
  13. return targetObj;
  14. }
  15. 复制代码

2.6.数据拦截

定义:利用对象内置方法,设置属性,进而改变对象的属性值

2.6.1 Object.defineProterty

1.ES5出来的方法; 2.三个参数:对象(必填),属性值(必填),描述符(可选); 3.defineProterty的描述符属性

  1. 数据属性:value,writable,configurable,enumerable
  2. 访问器属性:get,set
  3. 注:不能同时设置valuewritable,这两对属性是互斥的
  4. 复制代码

4.拦截对象的两种情况:

  1. let obj = {name:'',age:'',sex:'' },
  2. defaultName = ["这是姓名默认值1","这是年龄默认值1","这是性别默认值1"];
  3. Object.keys(obj).forEach(key => {
  4. Object.defineProperty(obj, key, {
  5. get() {
  6. return defaultName;
  7. },
  8. set(value) {
  9. defaultName = value;
  10. }
  11. });
  12. });
  13. console.log(obj.name);
  14. console.log(obj.age);
  15. console.log(obj.sex);
  16. obj.name = "这是改变值1";
  17. console.log(obj.name);
  18. console.log(obj.age);
  19. console.log(obj.sex);
  20. let objOne={},defaultNameOne="这是默认值2";
  21. Object.defineProperty(obj, 'name', {
  22. get() {
  23. return defaultNameOne;
  24. },
  25. set(value) {
  26. defaultNameOne = value;
  27. }
  28. });
  29. console.log(objOne.name);
  30. objOne.name = "这是改变值2";
  31. console.log(objOne.name);
  32. 复制代码

5.拦截数组变化的情况

  1. let a={};
  2. bValue=1;
  3. Object.defineProperty(a,"b",{
  4. set:function(value){
  5. bValue=value;
  6. console.log("setted");
  7. },
  8. get:function(){
  9. return bValue;
  10. }
  11. });
  12. a.b;//1
  13. a.b=[];//setted
  14. a.b=[1,2,3];//setted
  15. a.b[1]=10;//无输出
  16. a.b.push(4);//无输出
  17. a.b.length=5;//无输出
  18. a.b;//[1,10,3,4,undefined];
  19. 复制代码

结论:defineProperty无法检测数组索引赋值,改变数组长度的变化; 但是通过数组方法来操作可以检测到
多级嵌套对象监听

  1. let info = {};
  2. function observe(obj) {
  3. if (!obj || typeof obj !== "object") {
  4. return;
  5. }
  6. for (var i in obj) {
  7. definePro(obj, i, obj[i]);
  8. }
  9. }
  10. function definePro(obj, key, value) {
  11. observe(value);
  12. Object.defineProperty(obj, key, {
  13. get: function() {
  14. return value;
  15. },
  16. set: function(newval) {
  17. console.log("检测变化", newval);
  18. value = newval;
  19. }
  20. });
  21. }
  22. definePro(info, "friends", { name: "张三" });
  23. info.friends.name = "李四";
  24. 复制代码

6.存在的问题

  1. 不能监听数组索引赋值和改变长度的变化
  2. 必须深层遍历嵌套的对象,因为defineProterty只能劫持对象的属性,因此我们需要对每个对象的每个属性进行遍历,如果属性值也是对象那么需要深度遍历,显然能劫持一个完整的对象是更好的选择
  3. 复制代码

2.6.2 proxy

1.ES6出来的方法,实质是对对象做了一个拦截,并提供了13个处理方法
2.两个参数:对象和行为函数

  1. let handler = {
  2. get(target, key, receiver) {
  3. console.log("get", key);
  4. return Reflect.get(target, key, receiver);
  5. },
  6. set(target, key, value, receiver) {
  7. console.log("set", key, value);
  8. return Reflect.set(target, key, value, receiver);
  9. }
  10. };
  11. let proxy = new Proxy(obj, handler);
  12. proxy.name = "李四";
  13. proxy.age = 24;
  14. 复制代码

涉及到多级对象或者多级数组

  1. //传递两个参数,一个是object, 一个是proxy的handler
  2. //如果是不是嵌套的object,直接加上proxy返回,如果是嵌套的object,那么进入addSubProxy进行递归。
  3. function toDeepProxy(object, handler) {
  4. if (!isPureObject(object)) addSubProxy(object, handler);
  5. return new Proxy(object, handler);
  6. //这是一个递归函数,目的是遍历object的所有属性,如果不是pure object,那么就继续遍历object的属性的属性,如果是pure object那么就加上proxy
  7. function addSubProxy(object, handler) {
  8. for (let prop in object) {
  9. if ( typeof object[prop] == 'object') {
  10. if (!isPureObject(object[prop])) addSubProxy(object[prop], handler);
  11. object[prop] = new Proxy(object[prop], handler);
  12. }
  13. }
  14. object = new Proxy(object, handler)
  15. }
  16. //是不是一个pure object,意思就是object里面没有再嵌套object了
  17. function isPureObject(object) {
  18. if (typeof object!== 'object') {
  19. return false;
  20. } else {
  21. for (let prop in object) {
  22. if (typeof object[prop] == 'object') {
  23. return false;
  24. }
  25. }
  26. }
  27. return true;
  28. }
  29. }
  30. let object = {
  31. name: {
  32. first: {
  33. four: 5,
  34. second: {
  35. third: 'ssss'
  36. }
  37. }
  38. },
  39. class: 5,
  40. arr: [1, 2, {arr1:10}],
  41. age: {
  42. age1: 10
  43. }
  44. }
  45. //这是一个嵌套了对象和数组的数组
  46. let objectArr = [{name:{first:'ss'}, arr1:[1,2]}, 2, 3, 4, 5, 6]
  47. //这是proxy的handler
  48. let handler = {
  49. get(target, property) {
  50. console.log('get:' + property)
  51. return Reflect.get(target, property);
  52. },
  53. set(target, property, value) {
  54. console.log('set:' + property + '=' + value);
  55. return Reflect.set(target, property, value);
  56. }
  57. }
  58. //变成监听对象
  59. object = toDeepProxy(object, handler);
  60. objectArr = toDeepProxy(objectArr, handler);
  61. //进行一系列操作
  62. console.time('pro')
  63. objectArr.length
  64. objectArr[3];
  65. objectArr[2]=10
  66. objectArr[0].name.first = 'ss'
  67. objectArr[0].arr1[0]
  68. object.name.first.second.third = 'yyyyy'
  69. object.class = 6;
  70. object.name.first.four
  71. object.arr[2].arr1
  72. object.age.age1 = 20;
  73. console.timeEnd('pro')
  74. 复制代码

3.问题和优点 reflect对象没有构造函数 可以监听数组索引赋值,改变数组长度的变化, 是直接监听对象的变化,不用深层遍历

2.6.3 defineProterty和proxy的对比

1.defineProterty是es5的标准,proxy是es6的标准;
2.proxy可以监听到数组索引赋值,改变数组长度的变化;
3.proxy是监听对象,不用深层遍历,defineProterty是监听属性;
3.利用defineProterty实现双向数据绑定(vue2.x采用的核心) 4.利用proxy实现双向数据绑定(vue3.x会采用)

3.数组

数组基本上考察数组方法多一点,所以这里就单纯介绍常见的场景数组的方法,还有很多场景后续补充;
本文主要从应用来讲数组api的一些骚操作;
如一行代码扁平化n维数组、数组去重、求数组最大值、数组求和、排序、对象和数组的转化等;
上面这些应用场景你可以用一行代码实现?

3.1 扁平化n维数组

1.终极篇

  1. [1,[2,3]].flat(1) //[1,2,3]
  2. [1,[2,3,[4,5]]].flat(2) //[1,2,3,4,5]
  3. [1,[2,3,[4,5]]].toString() //'1,2,3,4,5'
  4. [1[2,3,[4,5[...]].flat(Infinity) //[1,2,3,4...n]
  5. 复制代码

Array.flat(n)是ES10扁平数组的api,n表示维度,n值为Infinity时维度为无限大
2.开始篇

  1. function flatten(arr) {
  2. while(arr.some(item=>Array.isArray(item))) {
  3. arr = [].concat(...arr);
  4. }
  5. return arr;
  6. }
  7. flatten([1,[2,3]]) //[1,2,3]
  8. flatten([1,[2,3,[4,5]]) //[1,2,3,4,5]
  9. 复制代码

实质是利用递归和数组合并方法concat实现扁平

3.2 去重

1.终极篇

  1. Array.from(new Set([1,2,3,3,4,4])) //[1,2,3,4]
  2. [...new Set([1,2,3,3,4,4])] //[1,2,3,4]
  3. 复制代码

set是ES6新出来的一种一种定义不重复数组的数据类型 Array.from是将类数组转化为数组 …是扩展运算符,将set里面的值转化为字符串 2.开始篇

  1. Array.prototype.distinct = function() {
  2. const map = {}
  3. const result = []
  4. for (const n of this) {
  5. if (!(n in map)) {
  6. map[n] = 1
  7. result.push(n)
  8. }
  9. }
  10. return result
  11. }
  12. [1,2,3,3,4,4].distinct(); //[1,2,3,4]
  13. 复制代码

取新数组存值,循环两个数组值相比较

3.3排序

1.终极篇

  1. [1,2,3,4].sort((a, b) => a - b); // [1, 2,3,4],默认是升序
  2. [1,2,3,4].sort((a, b) => b - a); // [4,3,2,1] 降序
  3. 复制代码

sort是js内置的排序方法,参数为一个函数 2.开始篇 冒泡排序:

  1. Array.prototype.bubleSort=function () {
  2. let arr=this,
  3. len = arr.length;
  4. for (let outer = len; outer >= 2; outer--) {
  5. for (let inner = 0; inner <= outer - 1; inner++) {
  6. if (arr[inner] > arr[inner + 1]) {
  7. //升序
  8. [arr[inner], arr[inner + 1]] = [arr[inner + 1], arr[inner]];
  9. console.log([arr[inner], arr[inner + 1]]);
  10. }
  11. }
  12. }
  13. return arr;
  14. }
  15. [1,2,3,4].bubleSort() //[1,2,3,4]
  16. 复制代码

选择排序

  1. Array.prototype.selectSort=function () {
  2. let arr=this,
  3. len = arr.length;
  4. for (let i = 0, len = arr.length; i < len; i++) {
  5. for (let j = i, len = arr.length; j < len; j++) {
  6. if (arr[i] > arr[j]) {
  7. [arr[i], arr[j]] = [arr[j], arr[i]];
  8. }
  9. }
  10. }
  11. return arr;
  12. }
  13. [1,2,3,4].selectSort() //[1,2,3,4]
  14. 复制代码

3.4最大值

1.终极篇

  1. Math.max(...[1,2,3,4]) //4
  2. Math.max.apply(this,[1,2,3,4]) //4
  3. [1,2,3,4].reduce( (prev, cur,curIndex,arr)=> {
  4. return Math.max(prev,cur);
  5. },0) //4
  6. 复制代码

Math.max()是Math对象内置的方法,参数是字符串; reduce是ES5的数组api,参数有函数和默认初始值; 函数有四个参数,pre(上一次的返回值),cur(当前值),curIndex(当前值索引),arr(当前数组)
2.开始篇 先排序再取值

3.5求和

1.终极篇

  1. [1,2,3,4].reduce(function (prev, cur) {
  2. return prev + cur;
  3. },0) //10
  4. 复制代码

2.开始篇

  1. function sum(arr) {
  2. var len = arr.length;
  3. if(len == 0){
  4. return 0;
  5. } else if (len == 1){
  6. return arr[0];
  7. } else {
  8. return arr[0] + sum(arr.slice(1));
  9. }
  10. }
  11. sum([1,2,3,4]) //10
  12. 复制代码

利用slice截取改变数组,再利用递归求和

3.6合并

1.终极篇

  1. [1,2,3,4].concat([5,6]) //[1,2,3,4,5,6]
  2. [...[1,2,3,4],...[4,5]] //[1,2,3,4,5,6]
  3. let arrA = [1, 2], arrB = [3, 4]
  4. Array.prototype.push.apply(arrA, arrB))//arrA值为[1,2,3,4]
  5. 复制代码

2.开始篇

  1. let arr=[1,2,3,4];
  2. [5,6].map(item=>{
  3. arr.push(item)
  4. })
  5. //arr值为[1,2,3,4,5,6],注意不能直接return出来,return后只会返回[5,6]
  6. 复制代码

3.7判断是否包含值

1.终极篇

  1. [1,2,3].includes(4) //false
  2. [1,2,3].indexOf(4) //-1 如果存在换回索引
  3. [1, 2, 3].find((item)=>item===3)) //3 如果数组中无值返回undefined
  4. [1, 2, 3].findIndex((item)=>item===3)) //2 如果数组中无值返回-1
  5. 复制代码

includes(),find(),findIndex()是ES6的api
2.开始篇

  1. [1,2,3].some(item=>{
  2. return item===3
  3. }) //true 如果不包含返回false
  4. 复制代码

3.8类数组转化

1.终极篇

  1. Array.prototype.slice.call(arguments) //arguments是类数组(伪数组)
  2. Array.prototype.slice.apply(arguments)
  3. Array.from(arguments)
  4. [...arguments]
  5. 复制代码

类数组:表示有length属性,但是不具备数组的方法
call,apply:是改变slice里面的this指向arguments,所以arguments也可调用数组的方法
Array.from是将类似数组或可迭代对象创建为数组
…是将类数组扩展为字符串,再定义为数组
2.开始篇

  1. Array.prototype.slice = function(start,end){
  2. var result = new Array();
  3. start = start || 0;
  4. end = end || this.length; //this指向调用的对象,当用了call后,能够改变this的指向,也就是指向传进来的对象,这是关键
  5. for(var i = start; i < end; i++){
  6. result.push(this[i]);
  7. }
  8. return result;
  9. }
  10. 复制代码

3.9每一项设置值

1.终极篇

  1. [1,2,3].fill(false) //[false,false,false]
  2. 复制代码

fill是ES6的方法 2.开始篇

  1. [1,2,3].map(() => 0)
  2. 复制代码

3.10每一项是否满足

  1. [1,2,3].every(item=>{return item>2}) //false
  2. 复制代码

every是ES5的api,每一项满足返回 true

3.11有一项满足

  1. [1,2,3].some(item=>{return item>2}) //true
  2. 复制代码

some是ES5的api,有一项满足返回 true

3.12.过滤数组

  1. [1,2,3].filter(item=>{return item>2}) //[3]
  2. 复制代码

filter是ES5的api,返回满足添加的项的数组

3.13对象和数组转化

  1. Object.keys({name:'张三',age:14}) //['name','age']
  2. Object.values({name:'张三',age:14}) //['张三',14]
  3. Object.entries({name:'张三',age:14}) //[[name,'张三'],[age,14]]
  4. Object.fromEntries([name,'张三'],[age,14]) //ES10的api,Chrome不支持 , firebox输出{name:'张三',age:14}
  5. 复制代码

3.14 对象数组

  1. [{count:1},{count:2},{count:3}].reduce((p, e)=>p+(e.count), 0)
  2. 复制代码

4.数据结构篇

数据结构是计算机存储、组织数据的方式,算法是系统描述解决问题的策略。了解基本的数据结构和算法可以提高代码的性能和质量。 也是程序猿进阶的一个重要技能。 手撸代码实现栈,队列,链表,字典,二叉树,动态规划和贪心算法

4.1 栈

栈的特点:先进后出

  1. class Stack {
  2. constructor() {
  3. this.items = [];
  4. }
  5. // 入栈
  6. push(element) {
  7. this.items.push(element);
  8. }
  9. // 出栈
  10. pop() {
  11. return this.items.pop();
  12. }
  13. // 末位
  14. get peek() {
  15. return this.items[this.items.length - 1];
  16. }
  17. // 是否为空栈
  18. get isEmpty() {
  19. return !this.items.length;
  20. }
  21. // 长度
  22. get size() {
  23. return this.items.length;
  24. }
  25. // 清空栈
  26. clear() {
  27. this.items = [];
  28. }
  29. }
  30. // 实例化一个栈
  31. const stack = new Stack();
  32. console.log(stack.isEmpty); // true
  33. // 添加元素
  34. stack.push(5);
  35. stack.push(8);
  36. // 读取属性再添加
  37. console.log(stack.peek); // 8
  38. stack.push(11);
  39. console.log(stack.size); // 3
  40. console.log(stack.isEmpty); // false
  41. 复制代码

4.2 队列

队列:先进先出 class Queue { constructor(items) { this.items = items || []; }

  1. enqueue(element) {
  2. this.items.push(element);
  3. }
  4. dequeue() {
  5. return this.items.shift();
  6. }
  7. front() {
  8. return this.items[0];
  9. }
  10. clear() {
  11. this.items = [];
  12. }
  13. get size() {
  14. return this.items.length;
  15. }
  16. get isEmpty() {
  17. return !this.items.length;
  18. }
  19. print() {
  20. console.log(this.items.toString());
  21. }
  22. }
  23. const queue = new Queue();
  24. console.log(queue.isEmpty); // true
  25. queue.enqueue("John");
  26. queue.enqueue("Jack");
  27. queue.enqueue("Camila");
  28. console.log(queue.size); // 3
  29. console.log(queue.isEmpty); // false
  30. queue.dequeue();
  31. queue.dequeue();
  32. 复制代码

4.3 链表

链表:
存贮有序元素的集合;
但是不同于数组,每个元素是一个存贮元素本身的节点和指向下一个元素引用组成
要想访问链表中间的元素,需要从起点开始遍历找到所需元素

  1. class Node {
  2. constructor(element) {
  3. this.element = element;
  4. this.next = null;
  5. }
  6. }
  7. // 链表
  8. class LinkedList {
  9. constructor() {
  10. this.head = null;
  11. this.length = 0;
  12. }
  13. // 追加元素
  14. append(element) {
  15. const node = new Node(element);
  16. let current = null;
  17. if (this.head === null) {
  18. this.head = node;
  19. } else {
  20. current = this.head;
  21. while (current.next) {
  22. current = current.next;
  23. }
  24. current.next = node;
  25. }
  26. this.length++;
  27. }
  28. // 任意位置插入元素
  29. insert(position, element) {
  30. if (position >= 0 && position <= this.length) {
  31. const node = new Node(element);
  32. let current = this.head;
  33. let previous = null;
  34. let index = 0;
  35. if (position === 0) {
  36. this.head = node;
  37. node.next = current;
  38. } else {
  39. while (index++ < position) {
  40. previous = current;
  41. current = current.next;
  42. }
  43. node.next = current;
  44. previous.next = node;
  45. }
  46. this.length++;
  47. return true;
  48. }
  49. return false;
  50. }
  51. // 移除指定位置元素
  52. removeAt(position) {
  53. // 检查越界值
  54. if (position > -1 && position < length) {
  55. let current = this.head;
  56. let previous = null;
  57. let index = 0;
  58. if (position === 0) {
  59. this.head = current.next;
  60. } else {
  61. while (index++ < position) {
  62. previous = current;
  63. current = current.next;
  64. }
  65. previous.next = current.next;
  66. }
  67. this.length--;
  68. return current.element;
  69. }
  70. return null;
  71. }
  72. // 寻找元素下标
  73. findIndex(element) {
  74. let current = this.head;
  75. let index = -1;
  76. while (current) {
  77. if (element === current.element) {
  78. return index + 1;
  79. }
  80. index++;
  81. current = current.next;
  82. }
  83. return -1;
  84. }
  85. // 删除指定文档
  86. remove(element) {
  87. const index = this.findIndex(element);
  88. return this.removeAt(index);
  89. }
  90. isEmpty() {
  91. return !this.length;
  92. }
  93. size() {
  94. return this.length;
  95. }
  96. // 转为字符串
  97. toString() {
  98. let current = this.head;
  99. let string = "";
  100. while (current) {
  101. string += ` ${current.element}`;
  102. current = current.next;
  103. }
  104. return string;
  105. }
  106. }
  107. const linkedList = new LinkedList();
  108. console.log(linkedList);
  109. linkedList.append(2);
  110. linkedList.append(6);
  111. linkedList.append(24);
  112. linkedList.append(152);
  113. linkedList.insert(3, 18);
  114. console.log(linkedList);
  115. console.log(linkedList.findIndex(24));
  116. 复制代码

4.4 字典

字典:类似对象,以key,value存贮值 class Dictionary { constructor() { this.items = {}; }

  1. set(key, value) {
  2. this.items[key] = value;
  3. }
  4. get(key) {
  5. return this.items[key];
  6. }
  7. remove(key) {
  8. delete this.items[key];
  9. }
  10. get keys() {
  11. return Object.keys(this.items);
  12. }
  13. get values() {
  14. /*
  15. 也可以使用ES7中的values方法
  16. return Object.values(this.items)
  17. */
  18. // 在这里我们通过循环生成一个数组并输出
  19. return Object.keys(this.items).reduce((r, c, i) => {
  20. r.push(this.items[c]);
  21. return r;
  22. }, []);
  23. }
  24. }
  25. const dictionary = new Dictionary();
  26. dictionary.set("Gandalf", "gandalf@email.com");
  27. dictionary.set("John", "johnsnow@email.com");
  28. dictionary.set("Tyrion", "tyrion@email.com");
  29. console.log(dictionary);
  30. console.log(dictionary.keys);
  31. console.log(dictionary.values);
  32. console.log(dictionary.items);
  33. 复制代码

4.5 二叉树

特点:每个节点最多有两个子树的树结构 class NodeTree { constructor(key) { this.key = key; this.left = null; this.right = null; } }

  1. class BinarySearchTree {
  2. constructor() {
  3. this.root = null;
  4. }
  5. insert(key) {
  6. const newNode = new NodeTree(key);
  7. const insertNode = (node, newNode) => {
  8. if (newNode.key < node.key) {
  9. if (node.left === null) {
  10. node.left = newNode;
  11. } else {
  12. insertNode(node.left, newNode);
  13. }
  14. } else {
  15. if (node.right === null) {
  16. node.right = newNode;
  17. } else {
  18. insertNode(node.right, newNode);
  19. }
  20. }
  21. };
  22. if (!this.root) {
  23. this.root = newNode;
  24. } else {
  25. insertNode(this.root, newNode);
  26. }
  27. }
  28. //访问树节点的三种方式:中序,先序,后序
  29. inOrderTraverse(callback) {
  30. const inOrderTraverseNode = (node, callback) => {
  31. if (node !== null) {
  32. inOrderTraverseNode(node.left, callback);
  33. callback(node.key);
  34. inOrderTraverseNode(node.right, callback);
  35. }
  36. };
  37. inOrderTraverseNode(this.root, callback);
  38. }
  39. min(node) {
  40. const minNode = node => {
  41. return node ? (node.left ? minNode(node.left) : node) : null;
  42. };
  43. return minNode(node || this.root);
  44. }
  45. max(node) {
  46. const maxNode = node => {
  47. return node ? (node.right ? maxNode(node.right) : node) : null;
  48. };
  49. return maxNode(node || this.root);
  50. }
  51. }
  52. const tree = new BinarySearchTree();
  53. tree.insert(11);
  54. tree.insert(7);
  55. tree.insert(5);
  56. tree.insert(3);
  57. tree.insert(9);
  58. tree.insert(8);
  59. tree.insert(10);
  60. tree.insert(13);
  61. tree.insert(12);
  62. tree.insert(14);
  63. tree.inOrderTraverse(value => {
  64. console.log(value);
  65. });
  66. console.log(tree.min());
  67. console.log(tree.max());
  68. 复制代码

5.算法篇

5.1 冒泡算法

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

5.2 斐波那契

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

  1. function fibonacci(num) {
  2. if (num === 1 || num === 2) {
  3. return 1
  4. }
  5. return fibonacci(num - 1) + fibonacci(num - 2)
  6. }
  7. 复制代码

5.3 动态规划

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

  1. class MinCoinChange {
  2. constructor(coins) {
  3. this.coins = coins
  4. this.cache = {}
  5. }
  6. makeChange(amount) {
  7. if (!amount) return []
  8. if (this.cache[amount]) return this.cache[amount]
  9. let min = [], newMin, newAmount
  10. this.coins.forEach(coin => {
  11. newAmount = amount - coin
  12. if (newAmount >= 0) {
  13. newMin = this.makeChange(newAmount)
  14. }
  15. if (newAmount >= 0 &&
  16. (newMin.length < min.length - 1 || !min.length) &&
  17. (newMin.length || !newAmount)) {
  18. min = [coin].concat(newMin)
  19. }
  20. })
  21. return (this.cache[amount] = min)
  22. }
  23. }
  24. const rninCoinChange = new MinCoinChange([1, 5, 10, 25])
  25. console.log(rninCoinChange.makeChange(36))
  26. // [1, 10, 25]
  27. const minCoinChange2 = new MinCoinChange([1, 3, 4])
  28. console.log(minCoinChange2.makeChange(6))
  29. // [3, 3]
  30. 复制代码

5.4 贪心算法

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

  1. function MinCoinChange(coins) {
  2. var coins = coins;
  3. var cache = {};
  4. this.makeChange = function(amount) {
  5. var change = [],
  6. total = 0;
  7. for (var i = coins.length; i >= 0; i--) {
  8. var coin = coins[i];
  9. while (total + coin <= amount) {
  10. change.push(coin);
  11. total += coin;
  12. }
  13. }
  14. return change;
  15. };
  16. 复制代码

}
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.代码:

  1. let UserFactory = function (role) {
  2. function User(opt) {
  3. this.name = opt.name;
  4. this.viewPage = opt.viewPage;
  5. }
  6. switch (role) {
  7. case 'superAdmin':
  8. return new User(superAdmin);
  9. break;
  10. case 'admin':
  11. return new User(admin);
  12. break;
  13. case 'user':
  14. return new User(user);
  15. break;
  16. default:
  17. throw new Error('参数错误, 可选参数:superAdmin、admin、user')
  18. }
  19. }
  20. //调用
  21. let superAdmin = UserFactory('superAdmin');
  22. let admin = UserFactory('admin')
  23. let normalUser = UserFactory('user')
  24. //最后得到角色,可以调用
  25. 复制代码

6.2工厂方法模式

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

  1. var Factory=function(type,content){
  2. if(this instanceof Factory){
  3. var s=new this[type](content);
  4. return s;
  5. }else{
  6. return new Factory(type,content);
  7. }
  8. }
  9. //工厂原型中设置创建类型数据对象的属性
  10. Factory.prototype={
  11. Java:function(content){
  12. console.log('Java值为',content);
  13. },
  14. PHP:function(content){
  15. console.log('PHP值为',content);
  16. },
  17. Python:function(content){
  18. console.log('Python值为',content);
  19. },
  20. }
  21. //测试用例
  22. Factory('Python','我是Python');
  23. 复制代码

6.3原型模式

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

  1. function Animal (name) {
  2. // 属性
  3. this.name = name || 'Animal';
  4. // 实例方法
  5. this.sleep = function(){
  6. console.log(this.name + '正在睡觉!');
  7. }
  8. }
  9. // 原型方法
  10. Animal.prototype.eat = function(food) {
  11. console.log(this.name + '正在吃:' + food);
  12. };
  13. function Cat(){
  14. }
  15. Cat.prototype = new Animal();
  16. Cat.prototype.name = 'cat';
  17. //&emsp;Test Code
  18. var cat = new Cat();
  19. console.log(cat.name);//cat
  20. console.log(cat.eat('fish'));//cat正在吃:fish undefined
  21. console.log(cat.sleep());//cat正在睡觉! undefined
  22. console.log(cat instanceof Animal); //true
  23. console.log(cat instanceof Cat); //true
  24. 复制代码

6.4单例模式

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

  1. let singleCase = function(name){
  2. this.name = name;
  3. };
  4. singleCase.prototype.getName = function(){
  5. return this.name;
  6. }
  7. // 获取实例对象
  8. let getInstance = (function() {
  9. var instance = null;
  10. return function(name) {
  11. if(!instance) {//相当于一个一次性阀门,只能实例化一次
  12. instance = new singleCase(name);
  13. }
  14. return instance;
  15. }
  16. })();
  17. // 测试单体模式的实例,所以one===two
  18. let one = getInstance("one");
  19. let two = getInstance("two");
  20. 复制代码

6.5外观模式

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

6.6适配器模式

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

6.7装饰者模式

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

  1. let decorator=function(input,fn){
  2. //获取事件源
  3. let input=document.getElementById(input);
  4. //若事件源已经绑定事件
  5. if(typeof input.onclick=='function'){
  6. //缓存事件源原有的回调函数
  7. let oldClickFn=input.onclick;
  8. //为事件源定义新事件
  9. input.onclick=function(){
  10. //事件源原有回调函数
  11. oldClickFn();
  12. //执行事件源新增回调函数
  13. fn();
  14. }
  15. }else{
  16. //未绑定绑定
  17. input.onclick=fn;
  18. }
  19. }
  20. //测试用例
  21. decorator('textInp',function(){
  22. console.log('文本框执行啦');
  23. })
  24. decorator('btn',function(){
  25. console.log('按钮执行啦');
  26. })
  27. 复制代码

6.8桥接模式

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

6.9模块方法模式

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

6.10.观察者模式

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

  1. let Observer=
  2. (function(){
  3. let _message={};
  4. return {
  5. //注册接口,
  6. //1.作用:将订阅者注册的消息推入到消息队列
  7. //2.参数:所以要传两个参数,消息类型和处理动作,
  8. //3.消息不存在重新创建,存在将消息推入到执行方法
  9. regist:function(type,fn){
  10. //如果消息不存在,创建
  11. if(typeof _message[type]==='undefined'){
  12. _message[type]=[fn];
  13. }else{
  14. //将消息推入到消息的执行动作
  15. _message[type].push(fn);
  16. }
  17. },
  18. //发布信息接口
  19. //1.作用:观察这发布消息将所有订阅的消息一次执行
  20. //2.参数:消息类型和动作执行传递参数
  21. //3.消息类型参数必须校验
  22. fire:function(type,args){
  23. //如果消息没有注册,则返回
  24. if(!_message[type]) return;
  25. //定义消息信息
  26. var events={
  27. type:type, //消息类型
  28. args:args||{} //消息携带数据
  29. },
  30. i=0,
  31. len=_message[type].length;
  32. //遍历消息
  33. for(;i<len;i++){
  34. //依次执行注册消息
  35. _message[type][i].call(this,events);
  36. }
  37. },
  38. //移除信息接口
  39. //1.作用:将订阅者注销消息从消息队列清除
  40. //2.参数:消息类型和执行的动作
  41. //3.消息参数校验
  42. remove:function(type,fn){
  43. //如果消息动作队列存在
  44. if(_message[type] instanceof Array){
  45. //从最后一个消息动作序遍历
  46. var i=_message[type].length-1;
  47. for(;i>=0;i--){
  48. //如果存在该动作在消息队列中移除
  49. _message[type][i]===fn&&_message[type].splice(i,1);
  50. }
  51. }
  52. }
  53. }
  54. })()
  55. //测试用例
  56. //1.订阅消息
  57. Observer.regist('test',function(e){
  58. console.log(e.type,e.args.msg);
  59. })
  60. //2.发布消息
  61. Observer.fire('test',{msg:'传递参数1'});
  62. Observer.fire('test',{msg:'传递参数2'});
  63. Observer.fire('test',{msg:'传递参数3'});
  64. 复制代码

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)
掘金1.5W字 - 图4在这里插入图片描述

  1. 四次挥手过(图片来源 CSDN)掘金1.5W字 - 图5在这里插入图片描述

    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 浏览器请求分析

掘金1.5W字 - 图6

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 原生从初级到高级的梳理;
原创码字不易,欢迎 star!

https://juejin.im/post/5daeefc8e51d4524f007fb15