javaScript手写专题——实现instanceof/call/apply/bind/new的过程/继承方式

目录

原型链相关

手写instanceof

实现一个_instance方法，判断对象obj是否是target的实例

 测试

 手写new的过程

实现一个myNew方法，接收一个构造函数以及构造函数的参数，返回构造函数创建的实例对象

测试myNew方法

手写类的继承

ES6：class+extends实现继承

组合继承：调用两次父类构造函数

Object.create原型式继承

寄生组合式继承：调用一次父类构造函数+通过object()复制原型

手写call/apply/bind方法

手写call方法

普通版call方法

 使用Symbol标识属性

处理非object类型绑定

测试call方法

手写apply方法

手写bind方法

 bind使用场景

普通版bind方法

用作构造函数boundFn处理

考虑构造函数继承

 测试bind方法

原型链相关

原型链（prototype chain）是 JavaScript 中面向对象编程的一个重要概念，用于实现对象的继承和共享属性。每个函数（构造函数）都有一个 prototype 属性，指向一个对象，这个对象称为原型对象。这个原型对象包含了所有实例共享的属性和方法。

当我们使用构造函数创建一个新对象时，新对象会有一个隐式的原型属性（__proto__），指向构造函数的原型对象。这样，新对象就可以通过原型链访问到构造函数原型对象上的属性和方法。

如果我们继续查找 __proto__ 属性，可以找到一个叫做 Object.prototype 的对象，它是所有对象的原型。如果继续查找 __proto__ 属性，会找到 null，表示原型链的结束。

这就形成了一个原型链的连接，从新对象的 __proto__ 属性可以一直向上查找到 Object.prototype，然后再查找到 null。这种连接方式让所有对象都可以继承 Object.prototype 的属性和方法，并且可以通过原型链实现对象的继承和共享属性。

手写instanceof

实现一个_instance方法，判断对象obj是否是target的实例

思路：instanceof的原理是基于原型链的概念，通过遍历对象的原型链，检查原型链中的某个原型是否等于目标构造函数的 prototype 属性。如果找到匹配，则返回 true，否则返回 false。

instanceof使用场景：我们通常用typeof判断基本类型、symbol、function。对于对象的具体类型，通常用instanceof来判断，比如判断Map、Set、Array、Date类型。 

function _instanceof(obj, target) {
  //instanceof只检测对象
  if (typeof obj != "object" || obj == null) {
    return false;
  }
  let proto = Object.getPrototypeOf(obj); //拿到对象的原型
  //   let proto = obj.__proto__;
  while (proto) {
    if (proto == target.prototype) {
      //原型上找到了target
      return true;
    }
    proto = Object.getPrototypeOf(proto);
    // proto = proto.__proto__;
  }
  return false;
}

 可以通Object.getPrototypeOf()方法拿到对象/构造函数原型的原型

也可以使用__proto__两个下划线proto拿到原型

 测试

对Array、Set、Map类型进行测试

console.log(_instanceof(null, Array));
console.log(_instanceof([], Array)); //判断数组
console.log(_instanceof({}, Array));
console.log(_instanceof({}, Object)); //普通对象
const set = new Set();
console.log(_instanceof(set, Set)); //判断Set
const map = new Map();
console.log(_instanceof(map, Map)); //判断Map
const date = new Date();
console.log(_instanceof(date, Date)); //判断Date

 手写new的过程

实现一个myNew方法，接收一个构造函数以及构造函数的参数，返回构造函数创建的实例对象

思路：

  1. 创建一个对象obj，使用 constructor.prototype 作为其原型。
  2. 使用 apply 方法改变构造函数 constructor 的 this 指向为新对象 obj，并将 args 传递给 constructor。
  3. 如果 constructor 返回一个对象，则返回 constructor 返回的对象；否则返回 newObj。
//第一个参数构造函数，第二个通过...拿到的args参数
function myNew(constructor, ...args) {
  const obj = Object.create(constructor.prototype);
  let res = constructor.apply(obj, args); //使用apply绑定this,传args类数组对象，执行constructor构造函数方法
  //   let res = constructor.call(obj, ...args);
  return typeof res === "object" ? res : obj; //构造函数如果没有返回值，返回obj;如果有返回值，返回res
}

在myNew方法中调用constructor方法，需要显示通过call或apply改变this。让方法找调用的对象obj。

测试myNew方法

测试myNew方法，打印person实例，调用person方法

// 测试
function Person(name, age) {
  this.name = name;
  this.age = age;
}
Person.prototype.say = function () {
  console.log(this.age);
};
let person = myNew(Person, "三月的一天", 18);
console.log(person);
person.say();

手写类的继承

在过去，JavaScript 中实现类的继承有多种方式，包括原型链继承、构造函数继承、组合继承、原型式继承等。这些方式各有优缺点，需要开发人员根据具体情况进行选择和使用。

但是，随着 ES6 的普及和使用，开发人员可以更多地关注使用 class 和 extends 实现继承，而不必过多地关注其他继承方式的优缺点。这也是为什么说类的继承在 ES6 普及后越来越不重要的原因之一。

ES6：class+extends实现继承

class Parent {
  constructor(name) {
    this.name = name;
  }
  sayName() {
    console.log("parent", this.name);
  }
}
class Child extends Parent {
  constructor(name, age) {
    super(name); //继承父类构造函数
    this.age = age;
  }
  sayAge() {
    console.log("Child", this.age);
  }
}
const child = new Child("三月的一天", 18);
child.sayName(); //继承父类的fangfa
child.sayAge(); //自己的方法

 手写继承就是不用Class和extends通过原型+构造函数实现继承。在红宝书里写到，虽然ES6类表面实现了面向对象编程，但是背包使用的仍然是原型和构造函数的概念。

组合继承：调用两次父类构造函数

组合继承：原型链+盗用父类构造函数

即通过call方法，将父类的构造函数在子类中执行一遍，使得子类也获取同样属性。将子类的prototype指向父类构造函数的实例，实现子类和父类的原型链继承。

 组合继承有两点注意：一是在子类的构造函数里，通过call方法，手动让父类的构造函数在子类里执行一遍。其次，必须先将子类的prototype更改为Parent的实例，在去给子类添加方法。否则子类的方法会被Parent覆盖掉。

function Parent(name) {
  this.name = name;
}
Parent.prototype.sayName = function () {
  console.log("parent", this.name);
};
function Child(name, age) {
  Parent.call(this, name); //通过call方法，手动让父类构造函数执行一遍
  this.age = age; //子类自己的属性
}
//先改变Child的原型
Child.prototype = new Parent(); //必须先将Child原型改成Parent，否则Child的方法会被Parent覆盖
//定义Child自己的原型方法
Child.prototype.sayAge = function () {
  console.log("Child", this.age);
};
const child = new Child("三月的一天", 18);
child.sayName();
child.sayAge();

Object.create原型式继承

Object.create() 是 JavaScript 中用于创建一个新对象，使用现有的对象来作为新创建对象的原型（prototype）。Object.create() 方法接受一个对象，然后以此对象为原型，返回一个新的对象。Object.create() 的第二个参数是一个可选的属性描述对象，用于定制创建的对象。这个参数与 Object.defineProperties() 方法的第二个参数格式相同。

使用Object.create方法继承适合不需要单独创建构造函数，但仍然需要再对象之间共享信息的场合。但是属性中包含的引用类型的值始终会在对象间共享，跟使用原型模式是一样的。Object.create方法的实现了下面的过程

function object(o){
    function F(){}
    F.prototype =o;
    return new F();
}
let person = {
  name: "三月的一天",
  age: 18,
};
let anotherPerson = Object.create(person);

console.log(anotherPerson.name);//输出'三月的一天'
console.log(anotherPerson.age);

通过Objec.create实现继承。通过Object的第二个参数 修改name，增加sex属性。

let person = {
  name: "三月的一天",
  age: 18,
};
let anotherPerson = Object.create(person, {
  name: {
    value: "新的名字",
  },
  sex: {
    value: "female",
  },
});

console.log(anotherPerson.name);//输出'新的名字'
console.log(anotherPerson.age);//18
console.log(anotherPerson.sex);//female

寄生组合式继承：调用一次父类构造函数+通过object()复制原型

在红宝书中描述了，最好的方式是寄生组合式继承。因为组合式继承调用了父类两次构造函数，子类的实例和子类的原型上都实例化了两次属性。为了解决这个问题，在原型链构建上，不通过父类构造函数给子类原型赋值，而是复制一份父类原型的副本。

function Parent(name) {
  this.name = name;
}
Parent.prototype.sayName = function () {
  console.log(this.name);
};
function Child(name, age) {
  Parent.call(this, name);
  this.age = age;
}

// Child.prototype = new Parent(); //组合继承
Child.prototype = Object.create(Parent.prototype);//寄生组合式继承
Child.prototype.constructor = Child;//手动修复Child.prototype的constructor

Child.prototype.sayAge = function () {
  console.log("Child", this.age);
};
const child = new Child("三月的一天", 18);
child.sayName(); //继承父类的fangfa
child.sayAge(); //自己的方法
console.log(child.__proto__ == Child.prototype);
console.log(Child.prototype.__proto__ == Parent.prototype);

原型链断裂通常是由于重写原型对象而导致的。在JavaScript中，每个函数都有一个prototype属性，用于指向原型对象，而原型对象中又有一个constructor属性，指向该函数本身。

当我们重写一个函数的prototype时，实际上是创建了一个新的对象，这个新对象的constructor属性会指向新对象的构造函数，而不再指向原来的函数。

 上面通过Child.prototype = Object.create(Parent.prototype);这行代码，实际上是将Child.prototype指向了一个新的对象prototype，而这个新对象的constructor属性指向的是Parent构造函数，而不是Child构造函数。这就导致了原型链的断裂，因为Child.prototype.constructor不再指向Child构造函数。

为了避免原型链断裂，我们可以手动修复constructor属性，确保它指向正确的构造函数，如您之前提到的Child.prototype.constructor = Child;这行代码所做的操作。

手写call/apply/bind方法

通常，在调用函数时，函数内部的 this 值是访问该函数的对象。使用函数原型上的 call方法/apply方法/bind方法，你可以在调用现有函数时将任意值分配给 this，而无需首先将函数附加到对象上作为属性。这样可以将一个对象的方法用作通用的实用函数。

使用场景：说人话就是，当你自己本身没有某个方法，想要借用别的对象上的方法时，可以使用call或apply来改变this的指向，使得方法似乎是当前对象自己的方法。这种感觉就像是方法去找对象。所有call/apply/bind的左侧使用方是函数，函数.call(谁调用我，参数拿来)。

具体使用哪个方法，取决于你的具体需求： 

  • 使用call：当你知道函数的参数是哪些，并且想要按顺序传递它们时。
  • 使用apply：当你知道函数的参数是一个数组，并且想要以数组的形式传递这些参数时。
  • 使用bind：当你需要一个新函数，新函数的this指向和参数已经确定时，或者当你需要动态地传递参数时。

手写思路：

将函数（this）设为对象的属性；执行函数，处理入参；删除这个属性；

原生call、apply传入的this如果是值类型，会被new Object（如fn.call('abc')）

手写call方法

 举一个使用call方法的例子：

var foo = {
    value: 1
};

function bar() {
    console.log(this.value);
}

bar.call(foo); // 1

 可以看call 改变了 this 的指向，指向到 foo；然后bar 函数执行了。

一般来说，带有this的是构造函数，需要通过new构造函数，拿到构造函数的实例对象，然后通过对象访问方法。但是这里好像在执行foo.bar方法。可是foo又不是构造函数的实例，怎么foo.bar进行方法调用？换个思路，将bar当成是对象的某个属性呢？

那么模拟call的过程，是不是可以假设将bar函数当成是foo的一个属性，foo.属性，对象访问属性

var foo = {
  value: 1,
  fn: function bar() {
    console.log(this.value);
  },
};

foo.fn();

首先call方法思路：将函数设为对象的属性；通过对象.属性执行函数；删除函数，不能真正改变原对象的属性； 如果不传入参数时，设置默认指向window

普通版call方法

Function.prototype.myCall = function (context = window, ...args) {
  context.fn = this;
  let result = context.fn(...args);
  delete context.fn;
  return result;
};

这样我们得到了一个简单的myCall方法。通过给对象context添加一个fn属性，fn的值为函数。然后立刻执行函数。之后将context.fn删除，但是有个问题，如果context对象本身就有fn。这样不就破坏了原始对象的属性了吗？怎么给新增的属性起一个不冲突的名字呢？是不是可以用Symbol啊。

在JavaScript中，Symbol是一种新的原始数据类型，它的实例是唯一且不可变的。由于Symbol的值是唯一且不可变的，所以不能通过点语法直接访问一个Symbol属性。这是因为Symbol属性不会出现在对象的属性枚举中（例如使用for...in或Object.keys()），这是符合语言设计的一部分。

为了访问一个Symbol属性，可以使用中括号语法，并将Symbol作为属性名。这是因为Symbol属性不会被覆盖或者更新，因此可以确保在访问时不会发生冲突。

 使用Symbol标识属性

Function.prototype.myCall = function (context = window, ...args) {
  let fn = Symbol(); //将fn属性名称定义为Symbol
  context[fn] = this; //通过[]访问Symbol类型变量，将this当前函数赋给value
  let result = context[fn](...args); //调用方法
  delete context[fn]; //删除属性fn
  return result;
};

这样是不是差不多了。这里假设context是对象，如果context是普通类型，第二行就会报错。而原始call方法是不会报错的。这个时候要对基本类型进行转换。

处理非object类型绑定

//添加函数原型myCall方法
Function.prototype.myCall = function (context = window, ...args) {
  if (typeof context != "object") {
    //非object类型的，手动转object
    context = new Object(context);
  }
  let fn = Symbol(); //将fn属性名称定义为Symbol
  context[fn] = this; //通过[]访问Symbol类型变量，将this当前函数赋给value
  let result = context[fn](...args); //调用方法
  delete context[fn]; //删除属性fn
  return result;
};

测试call方法

手写apply方法

apply和call的差异就是入参的区别

  • call()方法接收的是参数列表，即每个参数都需要单独传递。
  • apply()方法接收的是一个包含多个参数的数组，即所有参数都放在一个数组中传递。

 将call的手写入参改一下就好了

Function.prototype.myApply = function (context = Window, args) {
  //context myApply传入的对象
  //this 调用myApply的函数
  //args this需要的参数
  if (typeof context != "object") {
    context = new Object(context);
  }
  let fn = Symbol();
  context[fn] = this;
  let result = context[fn](...args); //实际函数的入参一定是全展开的
  delete context[fn];
  return result;
};

测试apply方法

传入数组args成功解析

 

手写bind方法

bind()是JavaScript中函数的一个内置方法，用于创建一个新的函数，该函数在调用时，this值会被绑定到传给bind()方法的值上，并可以传入其他参数。

 bind使用场景

函数柯里化，将多参函数转换为单参函数

function add(a, b, c) {
  return a + b + c;
}
const add5 = add.bind(null, 5);
console.log(add5(3, 4)); // 12

 在类的构造函数中使用 bind() 函数来创建一个新的构造函数。

class MyClass {
  constructor(name) {
    this.name = name;
  }
  sayName() {
    console.log(this.name);
  }
}
const obj = {
  name: 'obj'
};
const boundClass = MyClass.bind(obj);
const boundObj = new boundClass('boundObj');
boundObj.sayName(); // 'boundObj'

 将事件监听器函数绑定到某个对象上，并在事件触发时保持对象的上下文。

const obj = {
  name: 'obj',
  handleEvent: function(event) {
    console.log(this.name + ' handled event: ' + event);
  }
};
const button = document.getElementById('myButton');
button.addEventListener('click', obj.handleEvent.bind(obj));

普通版bind方法

根据bind的作用，调用的函数fn.bind(调用对象obj,...部分参数1)生成一个新的函数boundFn。然后对这个新的boundFn函数传参，调用它 boundFn(...剩余参数）。

我们得到下面的bind方法。

将当前this保存给fn。因为当前不执行fn函数，而是在boundFn函数内部执行。

myBind方法返回boundFn函数。boundFn这个函数内部还继续接收入参。将闭包内首次入参args与innerArgs合并，作为fn全部的入参。

//myBind方法的调用形式let boundFn =fn.myBind(obj,...args)
//fn是对象想要使用的函数
//fn是调用方法的对象，args是bind时候传入的函数入参的部分或全部参数
Function.prototype.myBind = function (context = window, ...args) {
  const fn = this; //这里的this是fn
  function boundFn(...innerArgs) {
    //创建一个新函数boundFn
    return fn.apply(context, args.concat(innerArgs)); //执行fn，fn从闭包中的this获取，所以this要提前存给fn；fn的参数要将两次入参拼起来
  }
  return boundFn; //返回新函数 新函数执行boundFn(...innerArgs)
};

定义一个内部函数 boundFn，它接收任意数量的剩余参数 ...innerArgs。在 boundFn 函数内部，使用 fn.apply() 方法调用原函数 fn，并将 fn 函数的执行上下文设置为指定的 context 对象，将原函数 fn 的参数 args 与新传入的参数 innerArgs 合并后作为入参传递给 fn。这样即使调用bind分两次传参，底层还是将两个参数合并了。

返回 boundFn 函数，这个函数可以在调用时传入参数，并在指定的 context 对象上执行原函数 fn

 由于函数还包括了构造函数。如果原始fn是个构造函数，那么新的boundFn也是构造函数，构造函数要通过new得到实例。这时fn实际执行的context就是 new boundFn后的对象，也就是boundFn里的this。

用作构造函数boundFn处理

对boundFn函数内部执行fn方法的context做判断。如果boundFn用作构造函数，那么fn里的context就是this。

myBind里出现了两个this。第一个this是fn函数，实际执行的函数，在闭包中被fn保留下来。

第二个this是bind返回的函数调用方，也就是new后的对象。这两个this是不同的意思。

为什么用this instanceof boundFn？

因为newObj = new boundFn()得到，instanceof可以判断实例是否通过构造函数生成的

//myBind方法的调用形式let boundFn =fn.myBind(obj,...args)
//fn是对象想要使用的函数
//fn是调用方法的对象，args是bind时候传入的函数入参的部分或全部参数
Function.prototype.myBind = function (context = window, ...args) {
  const fn = this; //这里的this是fn
  function boundFn(...innerArgs) {
    //创建一个新函数boundFn
    context = this instanceof boundFn ? this : context;//如果boundFn被当做构造函数，执行fn的对象就是当前的this
    return fn.apply(context, args.concat(innerArgs)); //执行fn，fn从闭包中的this获取，所以this要提前存给fn；fn的参数要将两次入参拼起来
  }
  return boundFn; //返回新函数 新函数执行boundFn(...innerArgs)
};

这里构造函数还没考虑继承，如果fn也是一个构造函数呢？，boundFn是不是还要处理原型链关系。原型继承是不是要用“子类原型=Object.create(父类构造函数原型)’模板继承

考虑构造函数继承

创建新的函数跟new的过程差不多，都要处理继承。将boundFn与fn建立原型链。这样新返回的函数就能跟fn执行一样的方法了。

//myBind方法的调用形式let boundFn =fn.myBind(obj,...args)
//fn是对象想要使用的函数
//fn是调用方法的对象，args是bind时候传入的函数入参的部分或全部参数
Function.prototype.myBind = function (context = window, ...args) {
  const fn = this; //这里的this是fn
  function boundFn(...innerArgs) {
    //创建一个新函数boundFn
    context = this instanceof boundFn ? this : context; //如果boundFn被当做构造函数，执行fn的对象就是当前的this
    return fn.apply(context, args.concat(innerArgs)); //执行fn，fn从闭包中的this获取，所以this要提前存给fn；fn的参数要将两次入参拼起来
  }
  boundFn.prototype = Object.create(fn.prototype); //考虑fn也是构造函数，boundFn要继承
  return boundFn; //返回新函数 新函数执行boundFn(...innerArgs)
};

 测试bind方法

// 测试用例
function Person(age, job, gender) {
  console.log(this.name, age, job, gender);
}
var obj = {
  name: "三月的一天",
};
// let result = Person.myBind(obj, 22, "前端开发")("female");
let bindFn = Person.myBind(obj, 22);
bindFn("前端开发", "female");

 测试结果，bind后参数可以分开给，统一执行Person方法

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/526945.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

人民大学：揭示大语言模型事实召回的关键机制

人民大学：揭示大语言模型事实召回的关键机制

引言：大语言模型事实召回机制探索 该论文深入研究了基于Transformer的语言模型在零射击和少射击场景下的事实记忆任务机制。模型通过任务特定的注意力头部从语境中提取主题实体，并通过多层感知机回忆所需答案。作者提出了一种新的分析方法，可…
阅读更多...
dll文件丢失怎么恢复，教你5种简单有效的方法

dll文件丢失怎么恢复，教你5种简单有效的方法

在计算机系统的运行过程中，动态链接库（DLL）文件扮演着至关重要的角色。它们作为共享函数库，封装了大量的可重用代码，使得多个应用程序能够高效调用并执行特定功能，极大地节省了系统资源，提升了软…
阅读更多...
Arduino开发 esp32cam＋opencv人脸识别距离+语音提醒

Arduino开发 esp32cam＋opencv人脸识别距离+语音提醒

效果 低于20厘米语音提醒字体变红 QQ录屏20240406131651 Arduino代码 可直接复制使用&#xff08;修改自己的WIFI) #include <esp32cam.h> #include <WebServer.h> #include <WiFi.h> // 设置要连接的WiFi名称和密码 const char* WIFI_SSID "gumou&q…
阅读更多...
指针的深入理解（六）

指针的深入理解（六）

指针的深入理解&#xff08;六&#xff09; 个人主页&#xff1a;大白的编程日记 感谢遇见&#xff0c;我们一起学习进步&#xff01; 文章目录 指针的深入理解&#xff08;六&#xff09;前言一. sizeof和strlen1.1sizeof1.2strlen1.3sizeof和strlen对比 二.数组名和指针加减…
阅读更多...
动态代理

动态代理

动态代理 动态代理和静态代理角色一致。 代理类是动态生成的，不是我们直接写好的。 动态代理分为俩大类：基于接口的动态代理、基于类的动态代理 基于接口：JDK动态代理（以下示例就是这个） 基于类：cglib java字节码实现：javasist JDK动态代理 InvocationHandler Proxy …
阅读更多...
C语言从入门到实战————编译和链接

C语言从入门到实战————编译和链接

目录 前言 1. 翻译环境和运行环境 2. 翻译环境 2.1 预处理&#xff08;预编译&#xff09; 2.2 编译 2.2.1 词法分析&#xff1a; 2.2.2 语法分析 2.2.3 语义分析 2.3 汇编 2.4 链接 3. 运行环境 前言 编译和链接是将C语言源代码转换成可执行文件的必经过程&a…
阅读更多...
分公司=-部门--组合模式

分公司=-部门--组合模式

1.1 分公司不就是一部门吗&#xff1f; "我们公司最近接了一个项目&#xff0c;是为一家在全国许多城市都有分销机构的大公司做办公管理系统&#xff0c;总部有人力资源、财务、运营等部门。" "这是很常见的OA系统&#xff0c;需求分析好的话&#xff0…
阅读更多...
Linux 内核移植exfat驱动

Linux 内核移植exfat驱动

简介&#xff1a; Linux系统默认可以自动识别到fat32格式的盘&#xff0c;但fat32支持的文件不能大于4G&#xff0c;所以只能将移动硬盘和U盘格式化为NTFS和exFAT这两种格式的&#xff0c;对于U盘最好格式化为exFAT。 Linux5.4以上的内核原生支持exfat格式&#xff0c;不需要你…
阅读更多...
【LeetCode: 572. 另一棵树的子树 + 二叉树 + dfs】

【LeetCode: 572. 另一棵树的子树 + 二叉树 + dfs】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
UE4_动画基础_ 使用分层动画（Using Layered Animations）

UE4_动画基础_ 使用分层动画（Using Layered Animations）

完成在移动过程中武器发射的角色制作&#xff01; 动画混合仅仅意味着在一个角色或骨架网格体上的两个或多个动画之间进行平滑过渡。在虚幻引擎4中&#xff0c;有多种方法可以应用这种混合&#xff0c;要么通过混合空间&#xff0c;或通过实际组合两个基于加权偏差或alpha值的…
阅读更多...
开源免费的多功能PDF工具箱

开源免费的多功能PDF工具箱

它支持修改PDF、编辑PDF书签、导出PDF书签、导入书签、生成、合并、拆分、提取页面内容、提取图片、OCR 功能介绍: 修改PDF信息&#xff1a;修改文档属性、页码编号、页面链接、页面尺寸&#xff1b;删除自动打开网页等动作&#xff0c;去除复制及打印限制&#xff1b;设置阅读…
阅读更多...
SpringBoot中这样用ObjectMapper，才够优雅！

SpringBoot中这样用ObjectMapper，才够优雅！

目录 背景步骤在SpringBoot项目中要实现对象与Json字符串的互转&#xff0c;每次都需要像如下一样new 一个ObjectMapper对象&#xff1a;这样的代码到处可见&#xff0c;有问题吗&#xff1f;我们要使用jmh测试几种方式的区别&#xff1a;所以在我们真正使用的时候不要在方法中…
阅读更多...
tesseract-ocr一站式安装与使用

tesseract-ocr一站式安装与使用

目录 前言 安装tesseract-ocr 添加环境变量 1、在path中添加 2、在系統變量中添加 3、验证是否添加成功 添加语言包 更多语言包下载 示例程序 前言 如果你遇到了&#xff1a;make sure the TESSDATA_PREFIX Failed loading language \‘chi_sim 那么就是语言包缺少这个&#xf…
阅读更多...
【简单讲解下Fine-tuning BERT】

【简单讲解下Fine-tuning BERT】

&#x1f3a5;博主&#xff1a;程序员不想YY啊 &#x1f4ab;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家 &#x1f917;点赞&#x1f388;收藏⭐再看&#x1f4ab;养成习惯 ✨希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出…
阅读更多...
XAMPP本地开发环境软件的最佳替代品

XAMPP本地开发环境软件的最佳替代品

在开发新网站或应用时&#xff0c;选择合适的本地开发环境是至关重要的。本地开发环境让您可以在自己的电脑上搭建和测试网站或应用&#xff0c;直到它们准备好被迁移到线上服务器。一些工具甚至提供了推送到生产环境的功能&#xff0c;以及设置多个本地站点的能力。 XAMPP是一…
阅读更多...
34-5 CSRF漏洞 - CSRF分类

34-5 CSRF漏洞 - CSRF分类

环境准备：构建完善的安全渗透测试环境：推荐工具、资源和下载链接_渗透测试靶机下载-CSDN博客 1）GET 类型 传参: 参数连接在URL后面 POC构造及执行流程: 构造URL，诱导受害者访问点击利用利用标签进行攻击: 构造虚假URL，在链接上添加payload抓包获取数据包，通过CSRF POC…
阅读更多...
ping命令返回无法访问目标主机和请求超时浅析

ping命令返回无法访问目标主机和请求超时浅析

在日常经常用ping命令测试网络是否通信正常&#xff0c;使用ping命令时也经常会遇到这两种情况&#xff0c;那么表示网络出现了问题。 1、请求超时的原因 可以看到“请求超时”没有收到任何回复。要知道&#xff0c;IP数据报是有生存时间的&#xff0c;当其生存时间为零时就会…
阅读更多...
K8s学习七（服务发现_2）

K8s学习七（服务发现_2）

Ingress Service 主要用于集群内部的通信和负载均衡&#xff0c;而 Ingress 则是用于将服务暴露到集群外部&#xff0c;并提供灵活的 HTTP 路由规则。在实际应用中&#xff0c;它们通常结合使用&#xff0c;Service 提供内部通信和负载均衡&#xff0c;Ingress 提供外部访问和…
阅读更多...
植物糖基转移酶数据库-23年-地表最强系列-文献精读-6

植物糖基转移酶数据库-23年-地表最强系列-文献精读-6

pUGTdb: A comprehensive database of plant UDP-dependent glycosyltransferases pUGTdb&#xff1a;植物UDP依赖糖基转移酶的全面数据库 一篇关于植物糖基转移数据库的综述&#xff0c;地表最强&#xff0c;总结的最全面的版本之一&#xff0c;各位看官有推荐请留言评论区~…
阅读更多...
自定义复选款与单选框，input

自定义复选款与单选框，input

注&#xff1a;字体文字取自bootstrap字体库https://icons.bootcss.com/icons <!DOCTYPE html> <html><head><meta charset"utf-8"><title></title><style>.checkbox-com,.radio-com {position: relative;display: inlin…
阅读更多...
最新文章

Copyright @ 2022~2023