blocks|key|2834905|text|构造函数中的代码不能由类型记录检查以确定类是否正确地实现了接口。打字本不可能检查代码中的所有赋值，以确保类型是正确的，因此需要静态声明类型。interface和implements的目的不是减少您必须编写的代码量，而是声明代码中的对象类型，以便类型记录可以静态地检查代码是否与类型相一致。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2834906|通过说类实现了接口，您就可以有效地要求类型记录保持诚实，并检查类型是否确实一致。如果类型抄本仅仅相信您会在构造函数中做正确的事情，那么它就不会非常有效！请注意，构造函数可能包含条件逻辑、循环和其他代码，这意味着，即使在原则上，类型记录也不可能分析构造函数代码以确定是否保留了与implements的约定。|2834907|entityMap^0|1Y|9|28|A|0|3U|A|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$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|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

Code in a constructor is not something that Typescript can check to determine if your class correctly implements the interface. It would be impossible for Typescript to check all the assignments in your code to ensure the types are correct, so you need to declare the types statically. The point of <code>interface</code> and <code>implements</code> is not to reduce the amount of code you have to write, it's to declare the type of objects in your code, so that Typescript can statically check that your code is self-consistent with regard to types.
By saying the class implements the interface, you are effectively asking Typescript to keep you honest and check that the types are indeed consistent. If Typescript merely trusted that you'd do the right thing in your constructor, it would not be very effective! Note that constructors may contain conditional logic, loops and other code that mean it is not possible even in principle for Typescript to analyse the constructor code to determine if you are keeping the contract you commit to with <code>implements</code>.

blocks|key|251001|text|低调你需要学习面向对象的编程。你的问题是oop的核心原则。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|251002|当您找到一份新工作时，您将签署一份合同，合同将指定您的角色、职责、行为等等；因此，您需要遵循该合同，因此，如果您实现了一个接口，您的类需要遵循您的接口结构。|251003|例如，如果您发现这是多余的，而不是创建一个类，则使用纯对象。|251004|const+obj:Obj+={
name:+“eneto”
};|code-block|syntax|javascript|251005|此外还有您的语句“但是如果我在构造函数之前将x:+number添加到Test中，它就能工作。因此，如果您想检查构造函数中初始化的属性的类型，那么必须在类本身上指定它。那么实现和接口是什么呢？“没有意义，因为类型记录在编译时检查代码，但是一旦代码编译，它就变成JavaScript，它没有静态类型|251006|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Low key You need to learn Object Oriented Programming. Your question is a core principle of oop.
When you find a new job, you sign a contract, the contract specifies your role, duties, behavior and more; so you need to follow the contract so if you implement an interface your class need to follow the structure of your interface.
If for instance you find that redundant instead of creating a class use pure objects
<pre><code>const obj:Obj ={
name: “eneto”
};
</code></pre>
Plus also your statement “But if I add x: number to Test before constructor, it works. So I am guessing if you wanted to check the type of a property initialized in the constructor, you have to specify that on the class itself. Then what is implement and the interface for?” doesn’t have sense, because typescript checks your code at compilation fase, but once your code compiles it becomes JavaScript which doesn’t have static types

blocks|key|2834969|text|因此，我猜如果您想检查构造函数中初始化的属性的类型，就必须在类本身上指定它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2834970|2834971|你说得很对！|2834972|2834973|，那么实现和接口是什么呢？|blockquote|2834974|2834975|2834976|接口意在成为“合同”。下面是一个简单的例子：|2834977|interface+Connectable+{
++connect:+()+=>+Promise<void>
}

const+robustConnect+=+async+(connection:+Connectable)+=>+{
++try+{
++++await+connection.connect();
++}+catch+(error)+{
++++console.warn(`there+was+an+error,+let's+try+once+more`);
++++await+connection.connect();
++}
}|code-block|syntax|javascript|2834978|在本例中，我们输入了函数robustConnect，以便它只接收任何具有connect方法的对象。这是接口最有用的用法：给一个类型命名，这样它就可以更容易读懂。|offset|length|style|CODE|BOLD|2834979|在其他面向对象语言中，接口将是声明类似类型的唯一方法，必须通过扩展接口来使用robustConnect。否则，编译步骤将失败。由于javascript本身并不是一种面向对象的语言，而且是动态类型的，所以不存在这种限制。这样，implements关键字就会觉得毫无用处。充其量，您可以在编写类时使用它来帮助自己:只需使用implements关键字并让TypeScript编译器告诉您所缺少的内容。但仅此而已。|2834980|希望这能有所帮助。|2834981|entityMap^0|0|0|0|0|0|0|0|0|0|C|D|10|7|1O|J|0|R|4|12|D|34|A|4F|A|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|C|3|D|5|6|7|16|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|18|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1B|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|1C|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|1D|8|@$T|1E|U|1F|V|W]|$T|1G|U|1H|V|W]|$T|1I|U|1J|V|X]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1K|8|@$T|1L|U|1M|V|X]|$T|1N|U|1O|V|W]|$T|1P|U|1Q|V|W]|$T|1R|U|1S|V|W]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1T|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|13|$]]

<blockquote>
So I am guessing if you wanted to check the type of a property initialized in the constructor, you have to specify that on the class itself.
</blockquote>
You are exactly right!
<blockquote>
Then what is implement and the interface for?
</blockquote>
An interface is intended to be a &quot;contract&quot;. Here's a simple example:
<pre><code>interface Connectable {
 connect: () =&gt; Promise&lt;void&gt;
}

const robustConnect = async (connection: Connectable) =&gt; {
 try {
 await connection.connect();
 } catch (error) {
 console.warn(`there was an error, let's try once more`);
 await connection.connect();
 }
}
</code></pre>
In this example, we've typed the function <code>robustConnect</code> so that it can receive just any object that has a <code>connect</code> method. This is the most useful usage of an interface: giving a name to a type so that it is more legible.
In other OO languages, an interface would be the only way to declare a type like that, and you would have to extend the interface to use <code>robustConnect</code>. Otherwise, the compilation step would fail. Since javascript isn't inherently an object-oriented language and is dynamically typed, that restriction isn't there. So the <code>implements</code> keyword can feel useless. At best, you could use it to help yourself when writing classes: just use the <code>implements</code> keyword and let the TypeScript compiler tell you what you are missing. But that's about it.
Hope this helps.

I am new to Typescript and ran into the following question when trying to implement a interface in a class:
<pre><code>interface TestInterface {
 x: number
}

class Test implements TestInterface {
 constructor() {
 this.x = 0
 }
}

// Class 'Test' incorrectly implements interface 'TestInterface'.
// Property 'x' is missing in type 'Test' but required in type 'TestInterface'.
</code></pre>
But if I add <code>x: number</code> to <code>Test</code> before <code>constructor</code>, it works. So I am guessing if you wanted to check the type of a property initialized in the <code>constructor</code>, you have to specify that on the class itself. Then what is <code>implement</code> and the <code>interface</code> for? And if I want to use the interface to check the type of its instances, wouldn't it be repetitive since I have to write it in two places?

Typescript Implements

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我对类型记录很陌生，在尝试实现类中的接口时遇到了以下问题：interface TestInterface {  x: number}class Test implements TestInterface {  constructor() {    this.x = 0  }}// Class 'Test' incorr...

问打字本工具
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问打字本工具EN