原生JavaScript 如何实现继承?什么是构造函数?

【JS继承】JS继承之构造函数继承 一、构造函数js中定义一个function,当使用new关键字调用这个function的时候,这个function成为一个构造函数。如下所示: 二、new关键字当使用new关键字调用构造函数生成一个对象实例时,js做出的关键处理如下: 1.创建一个新的对象,将构造函数内this指针指向新建对象。 2.将新建对象的__proto__属性设置成构造函数的prototype属性,确保新建对象是构造函数实例。 3.运行一遍构造函数,如果构造函数本身需要返回一个object或者array对象,则舍去新创建对象 阅读详情

JavaScript 中的继承

最近在读 《JavaScript 高级程序设计》,看到了继承这里,学到了很多,根据书中的内容和自己学到的内容进行总结输出了这样的一篇文章

构造函数

提问:如何在 JavaScript 中创建一个对象呢?

答:

const obj1 = {};
const obj2 = Object.create(); 

提问:如何在 JavaScript 创建对象的时候,共用一些属性呢?

答:用工厂模式,如下,调用 createPerson 函数生成的对象都具有 name 属性

function createPerson(name) {const o = Object.create();o.name = name;return o;
}

const person1 = createPerson('小明');
person1; // {name:"小明"}
const person2 = createPerson('小红');
person2; // {name:"小红"} 

提问:还有没有什么方式能在创建对象的时候共用属性吗?

答:构造函数。

什么是构造函数

构造函数其实就是一个函数,只不过在使用构造函数的时候需要使用 new 关键字。

或者说,使用 new 关键字调用的函数就是构造函数。

上面工厂函数可以写成下面这样的构造函数。

function Person(name) {this.name = name;
}

const person1 = new Person('小明');
person1; // {name:"小明"}
const person2 = new Person('小红');
person2; // {name:"小红"} 

按照惯例,构造函数名称的首字母都是要大写的,非构造函数则以小写字母开头。通常我们用一个函数首字符是否大写来判断这个函数是构造函数还是普通函数。

构造函数的作用

ECMAScript 的构造函数就是能创建对象的函数。

要创建构造函数的实例,应使用 new 操作符。使用 new 关键字调用构造函数会执行如下操作。

1.在内存中创建一个新对象。
2.这个新对象的原型([[Prototype]]特性)赋值为构造函数的 prototype 属性。
3.构造函数内部的 this 被赋值为这个新对象 (即 this 指向新对象)。
4.执行构造函数内部的代码 (给新对象添加属性)。
5.如果构造函数返回非空对象,则返回该对象; 否则,返回刚创建的新对象。

判断构造函数实例

用下面两种方法可以判断一个实例是不是由构造函数创建的。

// 方法1
console.log(person1.constructor == Person); // true
console.log(person2.constructor == Person); // true

// 方法2
console.log(person1 instanceof Object); // true
console.log(person1 instanceof Person); // true
console.log(person2 instanceof Object); // true
console.log(person2 instanceof Person); // true 

构造函数也是函数

不使用 new 关键字调用的时候,构造函数中的 this就会一层一层向上找,最终找到window结束。

function Person(name) {this.name = name;
}

const person1 = new Person('小明');
person1; // {name:"小明"}

const person2 = Person('小红'); // 没有使用 new 函数内部的this就会一层一层向上找
window.name; // 小红 

构造函数的问题

  • 构造函数中的共用,并不是完美的。

如下例子

function Person(name) {this.name = name;this.sayName = function () {console.log(this.name);};
} 

我们新加了一个 sayName 方法,用来打印 name 属性,这个是一个很通用的方法,但是每一次在创建实例的时候都会重新创建一次 sayName 方法。

function Person(name) {this.name = name;this.sayName = new Function('console.log(this.name)'); // 逻辑等价
}

const person1 = new Person('小明');
const person2 = Person('小红');

person1.sayName === person2.sayName; // false 

sayName 方法是一个很通用的方法,每创建一个实例就要创建一次方法,这就体现了不完美的共用了。

这样也有解决方法。

  • 解决方法 1,可以把函数定义转移到构造函数外部
function sayName() {console.log(this.name);
}
function Person(name) {this.name = name;this.sayName = sayName;
} 

缺点:sayName定义到了构造函数外,污染了全局作用域。

  • 解决方法 2,使用原型模式

原型模式

每个函数都会有一个 prototype 属性,它是一个对象类型,这个对象就叫原型。在通过new 调用构造函数创建内部对象的时候,创建的这个内部对象是从原型拷贝来的。

也就是说,原型上有的属性,构造函数创建的实例也就会拥有

function Person(name) {this.name = name;
}
Person.prototype.sayName = function () {console.log(this.name);
};
const person1 = new Person('小明');
person1.sayName(); // 小明
const person2 = new Person('小红');
person2.sayName(); // 小红

person1.sayName === person2.sayName; // true 

理解原型

上面我们说原型是一个对象类型。

首先他继承自 Object,也就是说Object有的属性和方法,原型都有,这很好理解。

其次,原型有一个自己特殊的属性 constructor,这个属性的值是构造函数本身。

Person.prototype.constructor === Person; // true 

使用构造函数创建实例的时候,实例的[[Prototype]] 特性就是构造函数的原型,不过我们不能直接访问这个特性,所以在不同的浏览器上,浏览器给实例上暴露了__proto__属性用来访问构造函数的原型。

function Person(name) {}
const person1 = new Person();

person1.__proto__ === Person.prototype; // true 
小总结一下
  • 构造函数都有一个 prototype属性,是一个对象类型,我们叫它原型对象。
  • 用构造函数创建实例的时候,创建的实例是基于 原型对象来的。
  • 原型对象有一个 constructor 属性指向构造函数,原型对象上的其他属性继承于Object对象。
  • 实例对象上有一个 __proto__属性,指向构造函数的原型。

小扩展,正常的原型链都会终止于 Object 的原型对象。

于是下面的判断就成立了。

console.log(Person.prototype.__proto__ === Object.prototype); // true
console.log(Person.prototype.__proto__.constructor === Object); // true
console.log(Person.prototype.__proto__.__proto__ === null); // true 

原型层级、搜索机制

通过对象访问属性的时候,会先在实例上找,找到了值就返回,没找到会去找原型对象。 原型对象也是一个对象,在原型对象上没有找到,就会去找原型对象的原型对象,直到找到原型对象的终点,null。

原型的问题

动态性

因为从原型上搜索值的过程是动态的,所以即使实例在修改原型之前已经存在,任何时候对原型对象所做的修改也会在实例上反映出来。

function Person() {}

// 先创建实例
const person1 = new Person();

// 在创建原型后 给原型定义方法
Person.prototype.sayHi = function () {console.log('hi');
};

// 实例拥有 创建实例后 修改原型的方法
person1.sayHi(); // "hi" 
共享特性

原型上的所有属性是在实例间共享的,这对函数来说比较合适。

另外包含原始值的属性也还好,可以通过在实例上添加同名属性来简单地遮蔽原型上的属性。

真正的问题来自包含引用值的属性。

举个 例子:

function Person() {}

Person.prototype.friends = [];

let person1 = new Person();
let person2 = new Person();

person1.friends.push('小明');
console.log(person1.friends); // ['小明']
console.log(person2.friends); // ['小明']
console.log(person1.friends === person2.friends); // true 

由于这个 friends 属性是一个引用类型,存在于 Person.prototype 而非 person1 上。

person1.friends.push('小明');新加的这个字符串也会在(指向同一个数组的)person2.friends 上反映出来。如果这是有意在多个实例间共享数组,那没什么问题。但一般来说,不同的实例应该有属于自己的属性副本。

继承

继承能够让代码复用变得更加容易,提高程序的可维护性,提高开发效率和开发质量。

1. 原型链继承

重温一下构造函数、原型和实例的关系: 每个构造函数都有一个原型对象,原型有一个属性指回构造函数,而实例有一个内部指针指向原型。

如果原型是另外一个类型的实例,那么这个原型本身有一个内部指针指向另一个原型,相应地另一个原型也有一个指针指向另一个构造函数。这样就在实例和原型之间构造了一条原型链。

原型链代码示例:

function Dog() {this.name = '狗';
}
Dog.prototype.run = function () {console.log('我能跑');
};

function SmallDog() {this.name = '小狗';
}

SmallDog.prototype = new Dog(); // 继承Dog
let smallDog = new SmallDog();
console.log(smallDog.name); // 小狗
console.log(smallDog.run()); // 我能跑 

SmallDog 通过创建 Dog 实例并赋值给自己的原型实现了对 Dog 的继承。

这样一来,SmallDog 的实例不仅能从 Dog 的实例中继承属性和方法,而且还与 Dog 的原型挂上了钩。

原型链扩展了前面描述的原型搜索机制。

默认原型

默认情况下,所有引用类型都继承自 Object,这也是通过原型链实现的。

也是为什么自定义类型能够继承包括 toString()、valueOf()在内的所有默认方法的原因。

原型与继承关系

第一种方式是使用 instanceof 操作符,如果一个实例的原型链中出现过相应的构造函数,则 instanceof 返回 true。

console.log(smallDog instanceof Object); // true
console.log(smallDog instanceof Dog); // true
console.log(smallDog instanceof SmallDog); // true 

确定这种关系的第二种方式是使用 isPrototypeOf()方法。原型链中的每个原型都可以调用这个 方法,如下例所示,只要原型链中包含这个原型,这个方法就返回 true。

console.log(Object.prototype.isPrototypeOf(smallDog)); // true
console.log(Dog.prototype.isPrototypeOf(smallDog)); // true
console.log(SmallDog.prototype.isPrototypeOf(smallDog)); // true 
原型链的问题
  • 问题一:主要问题出现在原型中包含引用值的时候。

原型中包含的引用值会在所有实例间共享,这也是为什么属性通常会在构造函数中定义而不会定义在原型上的原因。

在使用原型链实现继承时,原型实际上变成了另一个类型的实例。这意味着原先的实例属性摇身一变成为了原型属性。

function Dog() {this.colors = ['red', 'blue', 'green'];
}
function SmallDog() {}
SmallDog.prototype = new Dog(); // 继承Dog

let smallDog1 = new SmallDog();
smallDog1.colors.push('black');
console.log(smallDog1.colors); // "red,blue,green,black"

let smallDog2 = new SmallDog();
console.log(smallDog2.colors); // "red,blue,green,black" 

SmallDog.prototype 变成了 Dog 的一个实例,因而也获得了自己的 colors 属性。这类似于创建了 SmallDog.prototype.colors 属性。

最终结果是,SmallDog 的所有实例都会 共享这个 colors 属性。这一点通过 smallDog1.colors 上的修改也能反映到 smallDog1.colors 上就可以看出来。

  • 问题二:子类型在实例化时不能给父类型的构造函数传参。

事实上,我们无法在不影响所有对象实例的情况下把参数传进父类的构造函数。再加上之前提到的原型中包含引用值的问题, 就导致原型链基本不会被单独使用。

2. 盗用构造函数继承

为了解决原型包含引用值导致的继承问题,一种叫作“盗用构造函数”(constructor stealing)的技 术在开发社区流行起来(这种技术有时也称作“对象伪装”或“经典继承”)。

基本思路很简单:在子类构造函数中调用父类构造函数。

因为毕竟函数就是在特定上下文中执行代码的简单对象,所以可以使用 apply()和 call()方法以新创建的对象为上下文执行构造函数。

引用值问题解决
function Dog() {this.colors = ['red', 'blue', 'green'];
}

function SmallDog() {// 继承 DogDog.call(this);
}

let smallDog1 = new SmallDog();
smallDog1.colors.push('black');
console.log(smallDog1.colors); // "red,blue,green,black"

let smallDog2 = new SmallDog();
console.log(smallDog2.colors); // "red,blue,green" 

Dog 构造函数在为 SmallDog 的实例创建的新对象的上下文中执行了。这相当于新的 SmallDog 对象上运行了 Dog()函数中的所有初始化代码。结果就是每个实例都会有自己的 colors 属性。

子类向父类传参问题解决

相比于使用原型链,盗用构造函数的一个优点就是可以在子类构造函数中向父类构造函数传参。

function Dog(name) {this.name = name;
}

function SmallDog() {// 继承 Dog 并传参Dog.call(this, '狗');// 实例属性rhis.age = 10;
}
let smallDog1 = new SmallDog();
smallDog1.name; // "狗";
smallDog1.age; // 10 

在 SmallDog 构造函数中调用 Dog 构造函数时传入这个参数,实际上会在 SmallDog 的实例上定义 name 属性。

为确保 Dog 构造函数不会覆盖 SmallDog 定义的属性,可以在调用父类构造函数之后再给子类实例添加额外的属性。

盗用构造函数的问题

盗用构造函数实际上是把父类的构造函数内容在子类中执行了,没有使用到原型链相关的内容。

那么构造函数有的问题,盗用构造函数继承的方式也会拥有。

比如:

  • 构造函数中定义的函数不是一个完美的基础。每个子类都会创建一遍这个函数。
  • 子类只能获得父类构造函数

3. 组合继承

组合继承(有时候也叫伪经典继承)综合了原型链和盗用构造函数,将两者的优点集中了起来。

基本的思路是使用原型链继承原型上的属性和方法,而通过盗用构造函数继承实例属性。

function Dog(name) {this.name = name;this.colors = ['red', 'blue', 'green'];
}
Dog.prototype.sayName = function () {console.log(this.name);
};

function SmallDog(name, age) {Dog.call(this, name); // 通过盗用构造函数的方式 继承属性this.age = age;
}
SmallDog.prototype = new Dog(); // 通过原型链方式 继承方法
SmallDog.prototype.sayAge = function () {console.log(this.age);
};

let instance1 = new SmallDog('Nicholas', 29);
instance1.colors.push('black');
console.log(instance1.colors); // "red,blue,green,black"
instance1.sayName(); // "Nicholas";
instance1.sayAge(); // 29

let instance2 = new SmallDog('Greg', 27);
console.log(instance2.colors); // "red,blue,green"
instance2.sayName(); // "Greg";
instance2.sayAge(); // 27 

组合继承弥补了原型链和盗用构造函数的不足,是 JavaScript 中使用最多的继承模式。而且组合继 承也保留了 instanceof 操作符和 isPrototypeOf()方法识别合成对象的能力。

4. 原型式继承

2006 年,Douglas Crockford 写了一篇文章:《JavaScript 中的原型式继承》(“Prototypal Inheritance in JavaScript”)。

这篇文章介绍了一种,不涉及严格意义上构造函数的继承方法。

他的出发点是即使不自定义类型也可以通过原型实现对象之间的信息共享。

文章最终给出了一个函数:

function object(o) {function F() {}F.prototype = o;return new F();
} 

这个 object()函数会创建一个临时构造函数,将传入的对象赋值给这个构造函数的原型,然后返回这个临时类型的一个实例。

本质上,object()是对传入的对象执行了一次浅复制。

let person = {name: 'Nicholas',friends: ['Shelby', 'Court', 'Van'],
};

let anotherPerson = object(person);
anotherPerson.name = 'Greg';
anotherPerson.friends.push('Rob');

let yetAnotherPerson = object(person);
yetAnotherPerson.name = 'Linda';
yetAnotherPerson.friends.push('Barbie');
console.log(person.friends); // "Shelby,Court,Van,Rob,Barbie" 

Crockford 推荐的原型式继承适用于这种情况: 你有一个对象,想在它的基础上再创建一个新对象。 你需要把这个对象先传给 object(),然后再对返回的对象进行适当修改。

person 对象定义了另一个对象也应该共享的信息,把它传给 object()之后会返回一个新对象。这个新对象的原型 是 person,意味着它的原型上既有原始值属性又有引用值属性。这也意味着 person.friends 不仅是 person 的属性,也会跟 anotherPerson 和 yetAnotherPerson 共享。

ECMAScript 5 通过增加 Object.create()方法将原型式继承的概念规范化了。

这个方法接收两个参数: 作为新对象原型的对象,以及给新对象定义额外属性的对象(第二个可选)。在只有一个参数时, Object.create()与这里的 object()方法效果相同:

let person = {name: 'Nicholas',friends: ['Shelby', 'Court', 'Van'],
};

let anotherPerson = Object.create(person);
anotherPerson.name = 'Greg';
anotherPerson.friends.push('Rob');

let yetAnotherPerson = Object.create(person);
yetAnotherPerson.name = 'Linda';
yetAnotherPerson.friends.push('Barbie');
console.log(person.friends); // "Shelby,Court,Van,Rob,Barbie" 
使用场景

原型式继承非常适合不需要单独创建构造函数,但仍然需要在对象间共享信息的场合。

但要记住,属性中包含的引用值始终会在相关对象间共享,跟使用原型模式是一样的。

5. 寄生式继承

与原型式继承比较接近的一种继承方式是寄生式继承(parasitic inheritance),也是 Crockford 首倡的一种模式。

寄生式继承背后的思路类似于寄生构造函数和工厂模式: 创建一个实现继承的函数,以某种方式增强对象,然后返回这个对象。

function createAnother(original) {let clone = object(original); // 通过调用函数创建一个新对象, 这里的 object 就是原型式继承中的 object 方法// 以某种方式增强这个对象clone.sayHi = function () {console.log('hi');};return clone; // 返回这个对象
} 

createAnother方法 能够基于 original对象返回一个新的对象 ,并且在这个新的对象上添加 了 sayHi 方法。

寄生式继承同样适合主要关注对象,而不在乎类型和构造函数的场景。

通过寄生式继承给对象添加函数会导致函数难以重用,与构造函数模式类似。

6. 寄生式组合继承

组合继承其实也存在效率问题。最主要的效率问题就是父类构造函数始终会被调用两次:一次在是创建子类原型时调用,另一次是在子类构造函数中调用。

再来看一看之前组合继承的例子:

function Dog(name) {this.name = name;this.colors = ['red', 'blue', 'green'];
}
Dog.prototype.sayName = function () {console.log(this.name);
};

function SmallDog(name, age) {Dog.call(this, name); // 第二次调用 Dog 的构造函数this.age = age;
}
SmallDog.prototype = new Dog(); // 第一次调用 Dog 的构造函数,创建子类的实例对象赋值给子类原型
SmallDog.prototype.sayAge = function () {console.log(this.age);
}; 

本质上,子类原型最终是要包含超类对象的所有实例属性,子类构造函数只要在执行时重写自己的原型就行了。

寄生式组合继承通过盗用构造函数继承属性,但使用原型式继承方法混合原型链。

基本思路是不通过调用父类构造函数给子类原型赋值,而是取得父类原型的一个副本。

说到底就是使用寄生式继承来继承父类原型,然后将返回的新对象赋值给子类原型。

寄生式组合继承的基本模式如下所示:

function inheritPrototype(subType, superType) {let prototype = object(superType.prototype); // 创建对象prototype.constructor = subType; // 增强对象subType.prototype = prototype; // 赋值对象
} 

这个 inheritPrototype()函数实现了寄生式组合继承的核心逻辑。 这个函数接收两个参数: 子类构造函数和父类构造函数。 在这个函数内部,第一步是创建父类原型的一个副本。然后,给返回的 prototype 对象设置 constructor 属性,解决由于重写原型导致默认 constructor 丢失的问题。最后将新创建的对象赋值给子类型的原型。

这样可能不够直观了解,请看下面这个例子:

function Dog(name) {this.name = name;this.colors = ['red', 'blue', 'green'];
}
Dog.prototype.sayName = function () {console.log(this.name);
};

function SmallDog(name, age) {Dog.call(this, name); // 这里调用 Dog 的构造函数 是不可少的,因为只有 盗用构造函数的 方式能给父类的构造函数传参数this.age = age;
}

//这里替代了SmallDog.prototype = new Dog();能够减少一次 父类构造函数的调用,本质是 复制父类的原型 在赋值给子类原型
inheritPrototype(SubType, SuperType); 

SmallDog.prototype.sayAge = function () {console.log(this.age);
}; 

这里只调用了一次 Dog 构造函数,避免了 SmallDog.prototype 上不必要也用不到的属性, 因此可以说这个例子的效率更高。

而且,原型链仍然保持不变,因此 instanceof 操作符和 isPrototypeOf()方法正常有效。

寄生式组合继承可以算是引用类型继承的最佳模式。

总结

1.原型链继承是使用 创建父类实例给子类原型实现的继承。但是有 引用值的问题和不能给父类构造函数传参的问题。
2.盗用构造函数是 在子类构造函数中调用父类的构造函数实现的继承。解决了上面的两个问题,但是有构造函数的常见问题,子类构造函数中的方法没有完美的继承。
3.组合继承是结合 盗用构造函数继承和原型链继承,使用盗用构造函数继承方式继承属性和给父类传参,使用原型链继承的方式继承方法。
4.原型式继承是方便我们不定义一个新的类型(不创建构造函数),来实现在对象之间共享一些属性的方式。从此还诞生了 Object.create()方法。
5.寄生式继承是在 原型式继承的基础上,使用工厂模式对 要继承的对象额外做一些扩展。
6.寄生式组合继承是解决了组合继承调用两次父类构造函数的效率问题。核心思想是给子类原型赋值父类原型的clone对象,而不是创建父类的实例。

最后

整理了一套《前端大厂面试宝典》,包含了HTML、CSS、JavaScript、HTTP、TCP协议、浏览器、VUE、React、数据结构和算法,一共201道面试题,并对每个问题作出了回答和解析。

有需要的小伙伴,可以点击文末卡片领取这份文档,无偿分享

部分文档展示:



文章篇幅有限,后面的内容就不一一展示了

有需要的小伙伴,可以点下方卡片免费领取

超详细Tokenizer——文本训练数据预处理 Tokenizer是Keras库中的一个文本处理工具,它用于将文本分词并构建词汇表,同时将文本映射到整数序列。这对于自然语言处理任务非常有用,例如文本分类、情感分析、机器翻译等。 阅读详情

相关推荐

告别虚拟机!用ZYNQ7000和PYNQ 2.6.0打造一个能实时识别人脸的“智能摄像头”

本文详细介绍了如何利用Xilinx ZYNQ7000开发板和PYNQ 2.6.0框架构建实时人脸识别系统。通过硬件加速和嵌入式开发技术,该系统实现了低延迟、低功耗的独立运行能力,适用于边缘计算和物联网应用。文章包含从环境搭建到核心功能实现的完整指南,并提供了性能优化和问题排查的实用技巧。

weixin_42543046的博客 393

js常见的继承

提示:本文对js常见的继承做了个小结,分为原型链继承,构造函数继承,组合继承,extends继承 js常见的继承一、原型链继承(prototype)二、构造函数继承(call)三、组合继承(prototype+call)四、extends继承 提示:以下是本篇文章正文内容,下面案例可供参考 一、原型链继承(prototype) 特点:将父类的实例作为子类的原型,即Son.prototype = new Father() 优点:(1)(不但继承父类构造函数中的属性和方法)可以继承父类原型上的方法或属性.

weixin_47417033的博客 445

瑞萨RH850/U2A8以太网模块mcal说明

如下所有功能的支持需要在达芬奇中开启EthGlobalTimeSupport。秒[32bit], 纳秒[32bit], 纳秒小数[20bit]每一帧发送数据的相关结构缓冲区都放在变量。每一帧接收数据的相关结构缓冲区都放在变量。

至道无难,唯嫌拣择。 1865

原生js实现继承的几种方式(call(), 原型继承,构造函数继承)

     要实现继承,基本的面向对象知识和原型链知识是必不可少的.今天简单聊一下,以后有时间详细说一下.      1.继承的目的: 就是共享属性和方法.      2.继承的实现方法: 原型链是实现继承的主要方式.改变作用域也算一种,也就是call()或者apply().      3.构造函数式继承: (继承的是属性)将父类的构造函数在子类的函数体中执行,并且通过call改变this指向...

青蛙背蝎子过河的博客 1175

【推荐100个unity插件】unity实现交互式火焰 —— Ignis

Ignis是一款Unity互动式消防系统插件,可轻松将物体转换为可燃物。支持固体、植被、蒙皮网格和地形树木等多种对象类型,提供火焰蔓延、熄灭等效果。安装需通过Unity Package Manager添加Visual Effects Graph,并按照指引转换目标物体材质。使用盒型碰撞体或网格计算燃烧区域,可自定义火焰参数和视觉效果。内置多种转换选项,如Flammable Vegetation、Flammable Skinned Mesh等,适用于不同场景需求。注意使用前需备份材质和地形数据,并提供性能优化

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 2243

使用pytorch-superpoint与pytorch-superglue项目实现训练自己的数据集

superpoint与superglue的组合可以实现基于深度学习的图像配准,官方发布的superpoint与superglue模型均基于coco数据训练,与业务中的实际数据或许存在差距,为此实现基于开源的pytorch-superpoint与pytorch-superglue项目实现训练自己的数据集。然而,在训练pytorch-superpoint有诸多细节需要优化,特此整理成技术文档。本文档描述了实验pytorch-superpoint与pytorch-superglue项目训练自己的图像配准模型。

a486259的博客 9509

原生继承和ES6中的继承

在原生中的继承,例子如下: function Person(name,age){ this.name = name; this.age = age; } Person.prototype.say = function(){ console.log('我是'+this.name); } 类 构造函数,属性写在构造函数中,方法写在原型下;现有一个Code...

weixin_44021199的博客 247

FGC_grasp复现

FGC_GraspNet复现

qq_39568387的博客 385

如何用 mixwith.js 解决 JavaScript 多重继承的 7 大难题

JavaScript 作为一门灵活的面向对象编程语言,却不原生支持多重继承,这给开发者带来了诸多挑战。**mixwith.js** 作为一款轻量级的 ES6 混入(mixin)库,通过创新的“子类工厂”模式,优雅地解决了传统继承方案的局限性。本文将深入探讨 mixwith.js 如何攻克 JavaScript 多重继承的七大核心难题,帮助你编写更模块化、可复用的代码。 ## 🧩 难题 1:传统

gitblog_01183的博客 389

Cesium教程(十七):淹没分析

淹没分析是根据某片区域的地形及洪水流量速度,动态模拟该地形区域水位逐渐上涨的淹没过程。该功能可适用于山区、丘陵等地形起伏较大区域,模拟洪水涨到安全限定高度的淹没过程,为防洪水救灾提供一定的参考。此外,还可以为河谷地带修建水利工程设计与选址提供参考依据。

WwLK123的博客 3010

手把手教你学Simulink--基于Simulink的机械臂工业装配任务仿真建模

特点高精度要求:装配过程通常需要非常高的位置精度。多步骤操作:一个完整的装配任务可能包含多个连续的子任务,如抓取零件、移动到特定位置、装配等。动态环境:工作环境可能是动态变化的,例如其他机器人或人员在同一空间内工作。挑战复杂性管理:需要处理复杂的运动学和动力学问题,以及可能的碰撞避免。实时性:某些应用场景下需要快速响应以保证生产效率。集成度:需要与其他系统(如传感器、PLC等)无缝集成。首先明确要模拟的装配任务内容。零件的位置和尺寸。装配顺序。

MHD0815的博客 240

JavaScript 中的继承

JavaScript 中的继承 原型链继承 让原型对象等于另一个类型的实例。 function Father(){ this.val=1; } father.prototype.getVal=function(){ return this.val; } function Son(){ this.val=2; } //实现继承 Son.prototype=new Fathe...

jiangyaoyujian的博客 196

[AI] 嵌入模型选择:bge / text-embedding-3 / Jina Embeddings 对比与选型指南

摘要: 本文对比了BGE-M3、OpenAI和Jina三种主流嵌入模型在语言覆盖、性能、延迟、维度和成本等维度的差异。BGE-M3适合中文场景,本地部署成本低;OpenAI API多语能力强但依赖网络;Jina在多语表现突出但需关注商用许可。测试显示BGE-M3本地延迟3-6ms,OpenAI API延迟200-600ms。选型建议:隐私场景选BGE本地部署,多语低维护选OpenAI,高精度选Jina。部署时需注意批处理优化、向量库压缩和商用许可等问题,建议建立评测指标并监控关键指标。

每日出拳老爷子的博客 428

用原生js实现bind

用原生js实现bind 按使用情况来实现 使用bind来实现继承或者绑定数据 示例 function Animal(name, color) { this.name = name; this.color = color; this.type = 'Animal' } Animal.prototype.say = functi...

u010693018的博客 978

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

JS继承的深思问题

JS继承的六种方法

codewhy的博客 250

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

JavaScript深入系列之原型继承

文章目录原型继承1、原型继承机制2、原型继承的方式 原型继承 上一篇讲到原型,对原型的概念想必有一定的了解了。原型的核心思想就是给其他对象提供共享属性的对象。那它有什么好处呢? 1、原型继承机制 在面向类的语言中,类可以被复制多次,就像一个模具制作东西一样。但是JavaScript并没有类似的复制机制。在JavaScript中,你不能创建多个实例,只能创建多个对象,它们的 [[prototype]] 关联的是同一个对象,这是认为JavaScript没有类的主要原因。观察下图: cf1,cf2,cf3,c

Susan_Q的博客 311

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

原生JS基础巩固

原生js基础巩固 原型和原型链函数柯里化call/apply实现bind模拟实现最优继承instanceof实现原型和原型链提到js,原型和原型链是规避不过的,这之中存在几个容易混淆的概...

frontend_frank的博客 201

用原生js实现一个new方法

首先写一个父类方法(包含参数name,age): function Person(name,age){ this.name = name; this.age = age; this.action = function(){ return "吃饭饭"; } } new一个Person的实例p1做研究对比: var p1 = new Perso...

qq_29207823的博客 422

原生JS实现bind

在JavaScript中有很多改变this指向的方法,如call、apply,本文说的bind也是方法之一,与前两者不同的是,前两者改变this指向的时候会立即执行,而bind不会。 bind是函数原型Function.prototype上的一个方法,作用是改变this的指向并返回一个函数等待执行。 bind可以传入多个参数,第一个参数作为this的一个对象,后面的参数作为返回函数的形参。第一个参...

weixin_39066827的博客 465

掌握JavaScript继承的精髓:原型继承、构造函数继承以及组合继承的实现技巧

掌握JavaScript继承的精髓:原型继承、构造函数继承以及组合继承的实现技巧

唯见青山不见君 2278

JS实现继承的方式原生版

只能考虑Child.prototype = new Father 这一步,最终需要达到目的:Child.Prototype.__ proto __ = Father.prototype(子类的原型指向父类的原型, 解决父类调用两次的缺陷)----->(也就是一个对象继承另一个对象,上面的寄生式和原型式继承方式),另外最后还是需要将子类实例的constructor指回子类。组合继承既具有原型链继承能够复用函数的特性,又有借用构造函数方式能够保证每个子类实例能够拥有自己的属性以及向超类传参的特性。

cherry__yu的博客 1239

原生js实现继承的三种方式

继承的几种方式 1、构造函数继承 原理:利用call,apply,bind等方法,在构造函数内部去调用别的构造函数,为己所用. 缺点:原型对象的函数无法复用 function Parent (name,age) { this.name = name this.age = age } function Child (name,age,gender){ Parent.call(this,name,age) this.gender = gend

sunlando的博客 1604

【JavaScript】js中的原型继承

js中的原型继承

南栀的博客 3705

js中构造函数的继承

js 构造函数的继承例子学习

进一步,有一步的欢喜。 2711

javascript的继承——构造函数继承

构造函数继承方式: Father.call(this, args); 构造函数继承的几个特点: 父类构造函数中的属性和方法都可以被子类继承; 父类原型上的属性和方法无法被继承; 父类实例上的属性和方法无法被继承; 父类构造函数中的属性和方法在所有子类实例中是不共享的; 创建子类实例时可以向父类构造函数传参; 允许多重继承(同时继承多个不同的父类)。 var Father = function ...

讨厌走开啦 1156

Js中的构造函数继承, 原型继承等继承的学习详解

文章目录JS中继承学习和详解1.0 构造函数继承构造函数继承代码演示构造函数继承的原理构造函数继承的缺点2.0 通过原型链继承原型继承代码演示原型继承的原理原型继承的缺点3.0 组合继承组合继承代码演示**组合继承原理:**组合继承的缺点组合继承的优化4.0 Object.create实现继承Object.create继承代码演示Object.create继承原理Object.create继承优点5.0 class 类继承class类继承代码演示总结: JS中继承学习和详解 1.0 构造函数继承 构造函数继

yangyang_A的博客 1520
上一篇: 用 Mobx 实现 React 应用的状态管理
下一篇: 在Canvas中绘制Geojson数据
梅花十三儿
博客等级 码龄5年 1040粉丝 444原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值