Ruby'；操作员的工作？

我最近遇到了一个方法调用，该调用由格式

对象组成。（arg1，arg2）

，但没有看到对其工作原理的良好解释。请参见此示例代码：

class TestServiceObject
  def call
    'method'
  end
end

TestServiceObject.new.()
# => 'method'

---

这种速记的术语是什么？

obj.（args）

只是通过解析器提供的一种功能。从技术上讲，它不是别名，但它的作用与在定义

call

方法的对象上调用

obj.call（args）

的作用相同。

点括号表示法是在Ruby对象上向隐式方法传递参数的一种简捷方法：

foo = lambda {|bar| puts bar}

foo.call('baz')
#=> baz
foo.('baz')

foo.call('baz') === foo.('baz')
#=> true

---

还请注意，以下符号也是

调用

方法的有效（和等效）调用：

foo['baz']
#=> baz
foo::('baz')
#=> baz

在您的示例中，您显式重写了

TestServiceObject

类上的

call

方法，以便调用时返回字符串

'method'

。因此，您可以显式重写

调用

方法以接受参数：

class TestServiceObject
  def call(foo=nil)
    foo || 'method'
  end
end

TestServiceObject.new.()
#=> method
TestServicesObject.new.('bar')
#=> bar

更新：

正如评论者适时指出的那样，速记操作员似乎在处理任何响应

呼叫的内容，这一点在一定程度上通过以下示例得到验证：

m = 12.method("+")

m.call(3)
#=> 15
m.(3)
#=> 15

更新2：

正如评论员还指出的那样：

prc。（）使用给定的参数调用prc.call（）。隐藏“呼叫”是一种语法糖分

被解释为

foo.call(bar, baz)

foo.+(bar)

foo.[]=(bar, baz, quux)

就像

foo + bar

被解释为

foo.call(bar, baz)

foo.+(bar)

foo.[]=(bar, baz, quux)

或

被解释为

foo.call(bar, baz)

foo.+(bar)

foo.[]=(bar, baz, quux)

其目的是使类似于调用函数的对象看起来类似于调用方法：

foo.(bar, baz) # function
foo(bar, baz)  # method

尽管在这个问题的其他答案中有声明，但它与“隐式
调用
方法”（Ruby甚至没有隐式方法，只有Scala有）或索引操作符无关

索引运算符被转换为不同的方法调用（
[]
），而不是对
调用的调用：

o = Object.new

def o.call(*args); "`call` called with #{args.join(', ')}" end

o.(42)
# => "`call` called with 42"

o[42]
# NoMethodError: undefined method `[]' for #<Object:0xdeadbeefc0ffee>

def o.[](*args);   "`[]` called with #{args.join(', ')}"   end

o[42]
# => "`[]` called with 42"

o=Object.new
def o.call（*参数）；“`call`用#{args.join（'，'）}结尾调用”
o、 （42）
#=>“`call`用42呼叫”
o[42]
#NoMethodError:的未定义方法“[]”#
def o.[]（*args）；“`[]`用#{args.join（'，'）}结尾调用”
o[42]
#=>“`[]`用42调用”
看起来像你要找的东西。作为将来的参考，它对于查找语言语法非常方便…太棒了！感谢您提供的提示。From：“请注意，prc。（）使用给定的参数调用prc.call（）。隐藏“call”是一种语法糖。为了完整起见，您还可以使用方括号
m[3]
和范围解析操作符
m:（3）
“点括号表示法是将参数传递给Ruby对象上的隐式
调用
方法的一种简写方式”——这是错误的。没有“隐式
调用
方法”这样的东西。Ruby没有隐式方法。你可能会想到Scala，据我所知，它是唯一具有隐式属性的语言。”还请注意，以下符号也是对
调用
方法的有效（和等效）调用：
foo['baz']
”–这是错误的：索引运算符转换为对
[]
方法的调用，而不是对
调用
方法的调用。
foo['baz']
等同于
foo.[]（'baz'））
，而不是
foo.call（'baz'）
a_-proc[arg]
被转换为
a_-proc.[]（arg）
，而不是
a_-proc.call（arg）
。
[
索引操作符的转换不会根据对象而神奇地改变，它总是转换为对
[]的调用
方法，并且永远不要调用
方法，不管对象是
数组
、
散列
、
过程
还是
foobarfrobnigatorhingamajingy
。ruby…真是一团糟：）