blocks|key|2988835|text|你可以像这样从另一个javascript对象继承属性，这很简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2988836|var+a+=+function+()+{}
a.prototype.sayHello+=+function+()+{+alert('hello')+}

var+b+=+function+()+{}
b.prototype+=+new+a();

var+c+=+new+b();
c.sayHello();+//+Alerts+"hello"|code-block|syntax|javascript|2988837|jQuery的John+Resig有一个关于继承http://ejohn.org/apps/learn/#76的出色指南|offset|length|2988838|基于Roberts注释的编辑更新的代码。|style|BOLD|2988839|entityMap|0|LINK|mutability|MUTABLE|url|http://ejohn.org/apps/learn/#76^0|0|0|O|V|0|0|C|2|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@$I|Z|J|10|1|11]]|A|$]]|$1|K|3|L|5|6|7|12|8|@$I|13|J|14|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

It's as simple that you can inherit properties from another javascript object like so:

<pre><code>var a = function () {}
a.prototype.sayHello = function () { alert('hello') }

var b = function () {}
b.prototype = new a();

var c = new b();
c.sayHello(); // Alerts "hello"
</code></pre>

John Resig of jQuery has an exellent guide about it <a href="http://ejohn.org/apps/learn/" rel="nofollow">http://ejohn.org/apps/learn/</a>
about inheritance <a href="http://ejohn.org/apps/learn/#76" rel="nofollow">http://ejohn.org/apps/learn/#76</a>

EDIT Updated code based on Roberts comment.

blocks|key|2988853|text|JavaScript中继承的含义与任何面向对象语言中的含义没有什么不同。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2988854|继承的子代继承父代的行为(说明可能性和功能)。这些子类当然可以添加额外的行为或覆盖现有的行为。在这一点上，JavaScript中的继承肯定与其他继承没有什么不同。|2988855|这就是用尽可能简单的单词表达的意思。但是，您并没有问继承是如何在JavaScript中实现的，因为这将是一个完全不同的故事(和问题)。在这种情况下，我们应该解释类和原型(在JavaScript中使用)之间的区别。|2988856|entityMap^0|B|P|0|0|29|0|0|2Y|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|K|$]]

The meaning of inheritance in JavaScript is no different than in any object oriented language.

Inherited children inherit their parent's behaviour (state possibilities and functionality). These children can of course add additional behaviour or override existing. In this regard inheritance in JavaScript is definitely no different than any other.

That's about the meaning in as simple words as possible. However you didn't ask how inheritance is implemented in JavaScript because that'd be a completely different story (and question). In that case we should explain differences between classes and prototypes (which are used in JavaScript).

blocks|key|2988877|text|Robert说得对，“继承”在JS中没有任何不同之处，但它的实现方式与许多其他语言不同。可以说，一个对象或类继承自另一个对象或类，这意味着成员(属性、行为)可以在父对象上定义，但可以通过子对象访问。在你问“成员”是什么意思之前，对象是aggregate+types+(也就是composite+types)，成员是组件。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2988878|JS最初是用prototype+based+inheritance设计的，其中父对象是对象，但基于类的继承(某种)可以通过各种方式硬塞进去。类(以及类继承)可能会与ActionScript等其他语言一起添加到后来的ECMAScript标准中，后者是定义JS的标准。ActionScript已经支持类。|2988879|与“继承”密切相关的是“扩展”，子级通过添加或覆盖成员来扩展父级。|2988880|entityMap|0|LINK|mutability|MUTABLE|url|http://foldoc.org/aggregate|1|http://en.wikipedia.org/wiki/Composite_data_type|2|http://en.wikipedia.org/wiki/Prototype-based_programming|3|http://www.ecma-international.org/publications/standards/Ecma-262.htm^0|39|F|0|3T|F|1|0|6|R|2|2Z|A|3|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]|$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]|$A|16|B|17|1|18]]|C|$]]|$1|F|3|G|5|6|7|19|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]|R|$5|K|L|M|C|$N|S]]|T|$5|K|L|M|C|$N|U]]]]

Robert is right that "inheritance" doesn't mean anything different in JS, but it is implemented differently than in many other languages. To say that an object or class inherits from another means that members (attributes, behavior) can be defined on the parent but accessed through the child. Before you ask what "members" means, objects are <a href="http://foldoc.org/aggregate" rel="nofollow">aggregate types</a> (aka <a href="http://en.wikipedia.org/wiki/Composite_data_type" rel="nofollow">composite types</a>), and members are the components. 

JS was originally designed with <a href="http://en.wikipedia.org/wiki/Prototype-based_programming" rel="nofollow">prototype based inheritance</a>, where parents are objects, but class based inheritance (of a sort) can be shoehorned in by various means. Classes (and thus class inheritance) may be added to later <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm" rel="nofollow">ECMAScript</a> standards, which is the standard that defines JS, along with other languages such as ActionScript. ActionScript already supports classes.

Closely related to "inheritance" is "extension", where a child extends a parent by adding or overriding members.

blocks|key|2988909|text|简单地说，继承是一个事物获得另一个事物的属性或行为的概念。说A继承了B的，就是说A是+B的一种。鸟继承了动物的，因为鸟是动物的一种--它可以做同样的事情，但有一点不同！|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2988910|在JavaScript中，指定这种关系有点复杂，但要遵守语法。必须使用名为prototype的特殊对象，该对象将属性分配给类型的。只有function有一个prototype，这就是为什么你必须先创建一个函数：|CODE|2988911|function+Animal()+{};+//+This+is+the+Animal+*Type*
Animal.prototype.eat+=+function+()+{
++++alert("All+animals+can+eat!");
};|code-block|syntax|javascript|2988912|现在，要创建一个继承自Animal的类型，您还需要使用prototype对象，但这次是属于另一个类型的对象，例如：|2988913|function+Bird()+{};+//+Declaring+a+Bird+*Type*
Bird.prototype+=+new+Animal();+//+Birds+inherit+from+Animal
Bird.prototype.fly+=+function()+{
++++alert("Birds+are+special,+they+can+fly!");
};|2988914|这样做的效果是，您创建的任何鸟(称为鸟的实例)都具有动物的属性，但它们也具有额外的.fly()|2988915|var+aBird+=+new+Bird();+//+Create+an+instance+of+the+Bird+Type
aBird.eat();+//+It+should+alert,+so+the+inheritance+worked
aBird.fly();+//+Important+part+of+inheritance,+Bird+is+also+different+to+Animal

var+anAnimal+=+new+Animal();+//+Let's+check+an+instance+of+Animal+now
anAnimal.eat();+//+Alerts,+no+problem+here
anAnimal.fly();+//+Error+will+occur,+since+only+Birds+have+fly()+in+its+prototype|2988916|entityMap^0|V|5|15|1|1D|6|1N|1|0|11|9|1V|8|26|9|1P|3|0|0|I|2|1C|2|R|9|0|0|15|6|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|H]|$9|19|A|1A|B|H]|$9|1B|A|1C|B|H]|$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|I|3|J|5|K|7|1F|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|H]]|D|@]|E|$]]|$1|P|3|Q|5|K|7|1N|8|@]|D|@]|E|$L|M]]|$1|R|3|S|5|6|7|1O|8|@$9|1P|A|1Q|B|H]]|D|@]|E|$]]|$1|T|3|U|5|K|7|1R|8|@]|D|@]|E|$L|M]]|$1|V|3|-4|5|6|7|1S|8|@]|D|@]|E|$]]]|W|$]]

In simple terms, inheritance is the concept of one thing gaining the properties or behaviours of something else. To say A inherits from B, is saying that A is a type of B. A Bird inherits from Animal because a Bird is a type of Animal - it can do the same things, but a little more (or differently)!

In JavaScript, this relationship is a little complicated to specify, but bear with the syntax. You must use a special object called <code>prototype</code> which assigns properties to a type such as Animal. Only <code>function</code>s have a <code>prototype</code>, which is why you must create a function first:

<pre><code>function Animal() {}; // This is the Animal *Type*
Animal.prototype.eat = function () {
 alert("All animals can eat!");
};
</code></pre>

Now to create a type that inherits from Animal, you also use the <code>prototype</code> object, but this time the one belonging to the other type, e.g. Bird:

<pre><code>function Bird() {}; // Declaring a Bird *Type*
Bird.prototype = new Animal(); // Birds inherit from Animal
Bird.prototype.fly = function() {
 alert("Birds are special, they can fly!");
};
</code></pre>

The effect of this is that any Birds you create (called an instance of Bird) all have the properties of Animals, but they also have the additional <code>.fly()</code>:

<pre><code>var aBird = new Bird(); // Create an instance of the Bird Type
aBird.eat(); // It should alert, so the inheritance worked
aBird.fly(); // Important part of inheritance, Bird is also different to Animal

var anAnimal = new Animal(); // Let's check an instance of Animal now
anAnimal.eat(); // Alerts, no problem here
anAnimal.fly(); // Error will occur, since only Birds have fly() in its prototype
</code></pre>

blocks|key|2988943|text|罗伯特对Javascript+here中继承的精彩解释|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2988944|继承在JavaScript中的工作方式是它是prototype，而不是class-based。|style|CODE|2988945|例如，用于|2988946|function+Being+()+{
++++this.living+=+true;
}
Being.prototype.breathes+=+function+()+{
++++return+true;++|code-block|syntax|javascript|2988947|继承存在的对象|2988948|Robert.prototype+=+new+Being;
function+Robert+()+{
++++this.blogs+=+true;
}
Robert.prototype.getsBored+=+function+()+{
++++return+"You+betcha";
};++|2988949|因此，基本上，如果我们创建Robert对象的一个新实例并调用它的一些方法，结果将是：|2988950|//+Create+an+instance+of+the+Robert+object
var+me+=+new+Robert();

/*
++++Returns+"You+betcha"+as+it's+a+method
++++belonging+to+the+Robert+object
*/
me.getsBored();

/*
++++Returns+true.+Since+the+Robert+object
++++doesn't+have+a+breathes+method+of
++++its+own,+it+goes+back+in+the
++++prototype+chain+to+its+parent
++++object,+Being,+and+finds+the
++++method+there
*/
me.breathes();++|2988951|还有一个很好的JavaScript继承的读物：JavaScript+Inheritance|2988952|entityMap|0|LINK|mutability|MUTABLE|url|http://robertnyman.com/2008/10/06/javascript-inheritance-how-and-why/|1|http://books.google.com/books?id=2weL0iAfrEMC&pg=PA167&dq=prototype%2Binheritance%2Bin%2Bjavascript&sig=ACfU3U1S1YegUWWwIFPqlEWCgMvQv3kSgQ#v=onepage&q=prototype%2520inheritance%2520in%2520javascript&f=false^0|F|4|0|0|M|9|Z|B|0|0|0|0|0|0|0|N|M|1|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|D|3|E|5|6|7|1C|8|@$A|1D|B|1E|F|G]|$A|1F|B|1G|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|1H|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|1I|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1J|8|@]|9|@]|C|$]]|$1|Q|3|R|5|L|7|1K|8|@]|9|@]|C|$M|N]]|$1|S|3|T|5|6|7|1L|8|@]|9|@]|C|$]]|$1|U|3|V|5|L|7|1M|8|@]|9|@]|C|$M|N]]|$1|W|3|X|5|6|7|1N|8|@]|9|@$A|1O|B|1P|1|1Q]]|C|$]]|$1|Y|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]|16|$5|11|12|13|C|$14|17]]]]

A nice explanation by Robert on Inheritance in Javascript <a href="http://robertnyman.com/2008/10/06/javascript-inheritance-how-and-why/" rel="noreferrer">here</a>

The way inheritance works in JavaScript is that it is <code>prototype</code>, instead of <code>class-based</code>. 

For e.g 

<pre><code>function Being () {
 this.living = true;
}
Being.prototype.breathes = function () {
 return true; 
</code></pre>

An object which inherits Being 

<pre><code>Robert.prototype = new Being;
function Robert () {
 this.blogs = true;
}
Robert.prototype.getsBored = function () {
 return "You betcha";
}; 
</code></pre>

So, basically, if we create a new instance of the Robert object and call some of its methods, the result would be: 

<pre><code>// Create an instance of the Robert object
var me = new Robert();

/*
 Returns "You betcha" as it's a method
 belonging to the Robert object
*/
me.getsBored();

/*
 Returns true. Since the Robert object
 doesn't have a breathes method of
 its own, it goes back in the
 prototype chain to its parent
 object, Being, and finds the
 method there
*/
me.breathes(); 
</code></pre>

Also a good read of JavaScript inheritance : <a href="http://books.google.com/books?id=2weL0iAfrEMC&amp;pg=PA167&amp;dq=prototype+inheritance+in+javascript&amp;sig=ACfU3U1S1YegUWWwIFPqlEWCgMvQv3kSgQ#v=onepage&amp;q=prototype%20inheritance%20in%20javascript&amp;f=false" rel="noreferrer">JavaScript Inheritance</a>

blocks|key|277683|text|它很简单，继承的意思是:通过原型“对象/类继承自其他对象/类”|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|277684|为例：|277685|function+Person(first,+last,+age,+eyecolor)+{
++++this.firstName+=+first;
++++this.lastName+=+last;
++++this.age+=+age;
++++this.eyeColor+=+eyecolor;
}
Person.prototype.nationality+=+"English";|code-block|syntax|javascript|277686|entityMap^0|G|F|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Its simple, the inheritance means: "objects/classes inherit from other objects/classes" through prototypes

for example:

<pre><code>function Person(first, last, age, eyecolor) {
 this.firstName = first;
 this.lastName = last;
 this.age = age;
 this.eyeColor = eyecolor;
}
Person.prototype.nationality = "English";
</code></pre>

Can anyone explain to me with simple words the meaning of "inheritance" in JavaScript?

What is "inheritance" in Javascript?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有没有人能用简单的话给我解释一下JavaScript中"inheritance“的意思？

问Javascript中的“继承”是什么？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Javascript中的“继承”是什么？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Javascript中的“继承”是什么？
EN