blocks|key|3130580|text|当然，可以添加一种处理它们的机制，但它与静态类型是什么是不一致的:编译时确定程序没有类型错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3130581|附录|offset|length|style|BOLD|3130582|Scala+2.9引入了一个实验性的选项，支持以静态类型检查失败的方式动态处理对类型的访问。它在2.10中进行了优化，并成为非实验性的，尽管它仍然由默认禁用功能标志控制。您可以在SIP+17文档中了解它。有关Scala2.10的“模块化”和特性标志的解释，请参阅SIP+18。|3130583|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.scala-lang.org/sips/pending/type-dynamic.html|1|http://docs.scala-lang.org/sips/pending/modularizing-language-features.html^0|0|0|2|0|2H|6|0|3N|6|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]|$D|11|E|12|1|13]]|A|$]]|$1|J|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]]]

Certainly a mechanism for handling them could be added, but it is at odds with what static typing is: Compile-time determination that your program is free of type errors.

Addendum

Scala 2.9 introduced an experimental option enabling this sort of dynamic handling of accesses to types in ways that would otherwise fail static type checking. It was refined and made non-experimental in 2.10, though it is still controlled by a default-disable feature flag. You can read about it in the <a href="http://docs.scala-lang.org/sips/pending/type-dynamic.html" rel="nofollow">SIP 17</a> document. See <a href="http://docs.scala-lang.org/sips/pending/modularizing-language-features.html" rel="nofollow">SIP 18</a> for an explanation of Scala 2.10's "modularization" and feature flags.

blocks|key|3130618|text|在静态类型语言中，成员函数是直接调用的。如果编译器不能确定要调用哪个成员函数，程序将不会编译。从这个意义上讲，方法调用是静态的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3130619|在动态类型语言中，成员函数不是直接调用的。相反，调用代码会向对象发送一条消息，然后语言运行库会确定如何处理该消息。例如，运行库将扫描对象以查找同名的方法，然后扫描对象以查找名为method_missing的方法。从这个意义上讲，方法调用是动态的。|offset|length|style|CODE|3130620|C#+4结合了静态类型和动态类型。变量的编译时类型可以是dynamic。对此变量的任何方法调用都将像在动态类型语言中一样进行处理。对具有静态类型的变量的任何方法调用都将像在静态类型语言中一样处理。|3130621|#+static+invocation,+bound+at+compile+time+by+the+compiler
var+s+=+6;
s.ToString();

#+dynamic+invocation,+handled+at+runtime+by+the+CLR
dynamic+d+=+6;
d.ToString();|code-block|syntax|javascript|3130622|entityMap^0|0|2G|E|0|S|7|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|U|8|@$D|V|E|W|F|G]]|9|@]|A|$]]|$1|J|3|K|5|L|7|X|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

In statically typed languages, member functions are invoked directly. If the compiler cannot figure out which member function to invoke, the program will not compile. Method invocation is, in this sense, static.

In dynamically typed languages, member functions are not invoked directly. Rather, calling code sends a message to an object, and then the language runtime figures out what to do with that message. For example, the runtime will scan the object for a method with the same name, and then will scan the object for a method with the name <code>method_missing</code>. Method invocation is, in this sense, dynamic.

C# 4 combines static typing with dynamic typing. An variable may have a compile-time type of <code>dynamic</code>. Any method invocations on this variable will be handled as in dynamically typed languages. Any method invocations on variables with static types will be handled as in statically typed languages.

<pre><code># static invocation, bound at compile time by the compiler
var s = 6;
s.ToString();

# dynamic invocation, handled at runtime by the CLR
dynamic d = 6;
d.ToString();
</code></pre>

blocks|key|4540928|text|只是为了进一步Randall的帖子，这是可能的，但它与静态范式背道而驰的原因是它超越了“动态分派”。动态分派可以让您轻松地分派到动态绑定到已知的静态代码段的函数。即，从编译器的角度来看，编译器建立在运行时确定性地执行的分派。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4540929|method_missing调用所做的实质上是进行“全部捕获”，您可以使用Switch语句或类似的语句根据方法名决定要做什么(我相信您知道这一点)。因此，编译器不知道这里会发生什么。让我们假设编译器做了一些类似的事情：|offset|length|style|CODE|4540930|if+(function+is+known+at+compile+time)
{
++provide+static+call+or+dynamic+call+to+"some"+derivation
}
else
{
++bind+the+function+call+to+obj.method_missing(...)+and+pass+in+the+"details"
}|code-block|syntax|javascript|4540931|然后，您必须像这样提供method_missing：|4540932|def+method_missing(intendedFunctionName,+arguments)
{
++if+(intendedFunctionName+is+"X")
++{
++++X+may+not+need+arguments,+so+just+do+something
++}
++else+if+(intendedFunctionName+is+"Y")
++{
++++Y+expects+5+arguments+of+varying+types
++++Throw+exception+if+there+isn't+the+right+number+or+types
++}
++...+etc+...
}|4540933|要求编译器向您发送任意类型的“任意”(即在编译时未知的)参数，并带有您可能没有考虑到的intendedFunctionName+...嗯，它不是很安全，Scala的目的是成为一种静态安全的语言。|4540934|是的，这是可行的，但不是静态语言的精神。如果您真的想要这种类型的灵活性，多语言编程可能是您的好朋友。|4540935|注意:+Objective-C不是严格静态类型的。有一个运行时引擎，代码在其上执行，动态类型系统不允许像C/C%2B%2B那样剥离或内联代码。|4540936|entityMap^0|0|0|E|0|0|B|E|0|0|17|K|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|17|8|@$D|18|E|19|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|X|$]]

Just to further Randall's post, it is possible, but the reason it goes against the static paradigm is that it's beyond "dynamic dispatch". Dynamic dispatch happily lets you dispatch to a function that is dynamically bound to a known static piece of code. i.e. the compiler sets up the dispatch that is deterministically executed at runtime, from its perspective.

What the <code>method_missing</code> call does, is essentially make a "catch all" where you decide what to do based on the method name using a switch statement, or something equivalent (which I'm sure you know). Thus, the compiler has no idea what's going to happen here. Let's say the compiler did something like:

<pre><code>if (function is known at compile time)
{
 provide static call or dynamic call to "some" derivation
}
else
{
 bind the function call to obj.method_missing(...) and pass in the "details"
}
</code></pre>

Then you have to provide <code>method_missing</code> like this:

<pre><code>def method_missing(intendedFunctionName, arguments)
{
 if (intendedFunctionName is "X")
 {
 X may not need arguments, so just do something
 }
 else if (intendedFunctionName is "Y")
 {
 Y expects 5 arguments of varying types
 Throw exception if there isn't the right number or types
 }
 ... etc ...
}
</code></pre>

Asking the compiler to send you "arbitrary" (i.e. not known at compile time) arguments of arbitrary types, with an <code>intendedFunctionName</code> that you may not be accounting for... well, it's not very safe, and Scala is intended to be a statically safe language.

Yes, it's doable but not in the spirit of a static language. If you really want that type of flexibility, polyglot programming is probably your friend.

Note: Objective-C is not strictly statically typed. There is a runtime engine on which the code executes and the dynamic typing system does not allow code to be stripped or inlined like C/C++.

blocks|key|1831299|text|Objective-C有"method_missing“(具体地说，是forwardInvocation和methodSignatureForSelector)，而且它可以说是静态类型的。这是可行的，因为它将静态类型错误视为警告，而不是编译时的错误，因为方法分派在运行时发生的程度比C%2B%2B中的虚方法要大得多(这就是为什么您可以使用"method_missing")。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1831300|entityMap|0|LINK|mutability|MUTABLE|url|http://developer.apple.com/library/mac/documentation/cocoa/reference/foundation/Classes/NSProxy_Class/Reference/Reference.html#//apple_ref/occ/instm/NSProxy/methodSignatureForSelector%253a|1|http://developer.apple.com/library/mac/documentation/cocoa/reference/foundation/Classes/NSProxy_Class/Reference/Reference.html#//apple_ref/occ/instm/NSProxy/methodSignatureForSelector%253a^0|Z|H|0|1H|Q|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

Objective-C has "method_missing" (specifically, <a href="http://developer.apple.com/library/mac/documentation/cocoa/reference/foundation/Classes/NSProxy_Class/Reference/Reference.html#//apple_ref/occ/instm/NSProxy/methodSignatureForSelector%3a" rel="nofollow">forwardInvocation</a> and <a href="http://developer.apple.com/library/mac/documentation/cocoa/reference/foundation/Classes/NSProxy_Class/Reference/Reference.html#//apple_ref/occ/instm/NSProxy/methodSignatureForSelector%3a" rel="nofollow">methodSignatureForSelector</a>) and it is arguably statically typed. This works because it will treat static type errors as warnings rather than errors at compile time, since method dispatch occurs at runtime to a much greater extent than something like virtual methods in C++ (and this is why you can have "method_missing").

blocks|key|4541022|text|Scala2.9版通过Dynamic特征(scaladoc)引入了这一功能。扩展Dynamic的类得到了神奇的方法applyDynamic(methodName,+args)，它类似于Ruby的method_missing。从Scala2.9开始，必须启用-Xexperimental选项才能使用Dynamic。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4541023|entityMap|0|LINK|mutability|MUTABLE|url|http://www.scala-lang.org/archives/downloads/distrib/files/nightly/docs/library/scala/Dynamic.html^0|B|7|14|7|1L|U|2P|E|3K|E|44|7|L|8|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@$9|10|A|11|1|12]]|E|$]]|$1|F|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Scala version 2.9 introduces this functionality through the <code>Dynamic</code> trait (<a href="http://www.scala-lang.org/archives/downloads/distrib/files/nightly/docs/library/scala/Dynamic.html" rel="nofollow">scaladoc</a>). Classes that extend <code>Dynamic</code> get the magical method <code>applyDynamic(methodName, args)</code>, which is analogous to Ruby's <code>method_missing</code>. As of Scala 2.9, the <code>-Xexperimental</code> option must be enabled to use <code>Dynamic</code>.

I don't have much experience with statically typed languages (currently learning Scala and loving it!) but one thing I've noticed is that they don't ever seem to have anything like Ruby's method_missing or ColdFusion's onMissingMethod. Is there some inherent limitation in statically typed languages that prevent or make this difficult?

What prevents a statically typed language from having something like Ruby's method_missing?

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我没有太多使用静态类型语言的经验(目前正在学习Scala，并且非常喜欢它！)但我注意到的一件事是，它们似乎从来没有像Ruby的method_missing或ColdFusion的onMissingMethod那样的东西。静态类型语言中是否存在一些固有的限制，从而阻止或使这一点变得困难？

问是什么阻止了静态类型语言拥有像Ruby的method_missing这样的东西？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是什么阻止了静态类型语言拥有像Ruby的method_missing这样的东西？EN