使用对象组合的多态性-JavaScript_Javascript

使用对象组合的多态性-JavaScript

javascript

使用对象组合的多态性-JavaScript,javascript,Javascript,多态性是否仅适用于JavaScript中的OOP概念？我试图在JavaScript中使用对象组合与原型/类继承。如果这个概念适用，那么对象组合中多态性的实现是什么下面是一个实现多态性的原型继承示例（在子对象上重写、重新实现rendermethod）函数HtmlElement（）{ this.click=function（）{ console.log（'clicked'）； } } HtmlElement.prototype.focus=函数（）{ console.log（'focused'）

多态性是否仅适用于JavaScript中的OOP概念？我试图在JavaScript中使用对象组合与原型/类继承。如果这个概念适用，那么对象组合中多态性的实现是什么

下面是一个实现多态性的原型继承示例（在子对象上重写、重新实现

render

method）

函数HtmlElement（）{
this.click=function（）{
console.log（'clicked'）；
}
}
HtmlElement.prototype.focus=函数（）{
console.log（'focused'）；
}
函数HtmlSelectElement（项=[]）{
这个项目=项目；
this.addItem=函数（项）{
此.items.push（item）；
}
this.removietem=函数（项）{
此.items.拼接（此.items.indexOf（item），1）；
}
this.render=函数（）{
返回`
${this.items.map（item=>`
${item}`）。加入（“”）}
`;
}  
}
HtmlSelectElement.prototype=新的HtmlElement（）；
HtmlSelectElement.prototype.constructor=HtmlSelectElement；
函数HtmlImageElement（src）{
this.src=src；
this.render=函数（）{
返回``
}
}
HtmlImageElement.prototype=新的HtmlElement（）；
HtmlImageElement.prototype.constructor=HtmlImageElement；
常量元素=[
新的HtmlSelect元素（[1,2,3]），
新的HtmlImageElement（'http://'）
];
for（让元素中的元素）
log（element.render（））；

实际上很难在JavaScript中谈论多态性，因为

多态性[…]是为不同类型的实体提供单一接口[1]，或使用单一符号表示多种不同类型。[2]

因为只有基本类型和“对象”，所以很难谈论这些对象的类型。可以说还有其他类型，因为原型链和

instanceof

操作符，也可以说javascript得到了duck类型。以以下为例：

 class User {
   constructor() { this.name = "test"; }
 }

value             |  type      |    instanceof User  | "name" in 
-----------------------------------------------------------------------------------
new User()        |  object    |     true            | true
{ name: "test" }  |  object    |     false           | true
{}                |  object    |     false           | false

现在哪一个是用户类型？是否存在用户类型？没有对错，只有意见。以下是我的看法：

多态性是否仅适用于JavaScript中的OOP概念

我会说不。范式是“写某些东西的风格”，多态性是描述对象关系的一种方式，你可以在所有范式中使用对象

如果这个概念适用，那么对象组合中多态性的实现是什么

如果我们有两个工厂，比如说

user

和

reader

，它们可能看起来像：

 function createUser() {
   return { name: "test" };
 }

 function createReader() {
   return { books: ["a book"] };
 }

 const user = createUser(), reader = createReader();

现在，我们可以通过多种方式获得多态性：

1）行多态性

1a）我们可以通过添加书籍将用户变成读者：

 user.books = ["another book"];

现在用户是一个读者，因为它有书（这就是

1b）我们可以将用户和阅读器结合起来：

const readingUser = Object.assign(createUser(), createReader());

2）亚型

如果我们将构造函数更改为：

 function createReader() {
   return { ...createUser(), books: ["a book"] };
 }

现在每个读者都是用户，我们得到了继承（但没有经典继承）

3）特殊多态性

我们可以为用户或读者声明不同行为的函数：

 function doSomething(obj) {
   if(obj.name) {
     console.log("a user");
   }
   if(obj.books) {
    console.log("a reader");
  }
}

doSomething(user); // a user
doSomething(reader) // a reader
doSomething(readingUser); // a user, a reader

4）参数多态性

读者和用户都是对象，因此我们可以“作为对象”使用它们：