blocks|key|390466|text|你发布的最后一个例子具有误导性。我不同意这种行为与以前的行为相似的观点。最后一个示例将参数哈希作为第一个可选参数传入，这是另一回事！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|390467|如果不希望具有默认值，则可以使用nil。|offset|length|style|CODE|390468|如果你想读一篇好的文章，请看"Ruby+2关键字参数“。|390469|entityMap|0|LINK|mutability|MUTABLE|url|https://robots.thoughtbot.com/ruby-2-keyword-arguments^0|0|G|3|0|F|B|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|J|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

The last example you posted is misleading. I disagree that the behavior is similar to the one before. The last example passes the argument hash in as the first optional parameter, which is a different thing!
If you do not want to have a default value, you can use <code>nil</code>.
If you want to read a good writeup, see &quot;<a href="https://robots.thoughtbot.com/ruby-2-keyword-arguments" rel="nofollow noreferrer">Ruby 2 Keyword Arguments</a>&quot;.

blocks|key|390506|text|根据"Ruby2.0.0示例“，您必须有默认值：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|390507|在Ruby2.0.0中，关键字参数必须有默认值，否则必须在末尾被**附加捕获。|blockquote|390508|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.marc-andre.ca/2013/02/23/ruby-2-by-example/^0|3|B|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@$A|P|B|Q|1|R]]|C|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|C|$]]|$1|G|3|-4|5|6|7|T|8|@]|9|@]|C|$]]]|H|$I|$5|J|K|L|C|$M|N]]]]

According to "<a href="http://blog.marc-andre.ca/2013/02/23/ruby-2-by-example/" rel="nofollow">Ruby 2.0.0 by Example</a>" you must have defaults: 

<blockquote>
 In Ruby 2.0.0, keyword arguments must have defaults, or else must be captured by **extra at the end. 
</blockquote>

blocks|key|2499262|text|您可以定义命名参数，如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2499263|def+test(var1:+var1,+var2:+var2,+var3:+var3)
++puts+"#{var1}+#{var2}+#{var3}"
end|code-block|syntax|javascript|2499264|如果您不传递其中一个参数，那么Ruby就会抱怨undefined+local+variable+or+method。|offset|length|style|CODE|2499265|entityMap^0|0|0|N|Y|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can define named parameters like

<pre><code>def test(var1: var1, var2: var2, var3: var3)
 puts "#{var1} #{var2} #{var3}"
end
</code></pre>

If you don't pass one of the parameters, then Ruby will complain about an <code>undefined local variable or method</code>.

blocks|key|2499282|text|def+test(a+=+1,+b:+2,+c:+3)
++p+[a,b,c]
end

test+#=>+[1,2,3]
test+10+#=>+[10,2,3]
test+c:30+#=>+[1,2,30]+<-+this+is+where+named+parameters+become+handy.+|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2499283|您可以定义参数的默认值和名称，然后以调用方法的方式调用该方法，如果您有基于散列的“命名”参数，但不需要在方法中定义默认值。|unstyled|2499284|如果使用哈希，则每个“命名参数”在您的方法中都需要这样做。|2499285|b+=+options_hash[:b]+%7C%7C+2|2499286|如：|2499287|++def+test(a+=+1,+options_hash)
++++b+=+options_hash[:b]+%7C%7C+2
++++c+=+options_hash[:c]+%7C%7C+3
++++p+[a,b,c]
++end|2499288|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$B|C]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$B|C]]|$1|O|3|-4|5|F|7|W|8|@]|9|@]|A|$]]]|P|$]]

<pre><code>def test(a = 1, b: 2, c: 3)
 p [a,b,c]
end

test #=&gt; [1,2,3]
test 10 #=&gt; [10,2,3]
test c:30 #=&gt; [1,2,30] &lt;- this is where named parameters become handy. 
</code></pre>

You can define the default value and the name of the parameter and then call the method the way you would call it if you had hash-based "named" parameters but without the need to define defaults in your method.

You would need this in your method for each "named parameter" if you were using a hash.

<pre><code>b = options_hash[:b] || 2
</code></pre>

as in:

<pre><code> def test(a = 1, options_hash)
 b = options_hash[:b] || 2
 c = options_hash[:c] || 3
 p [a,b,c]
 end
</code></pre>

blocks|key|1710233|text|我认为你最新问题的答案可以用明确的例子来解释。在下面的示例中，您可以以显式顺序获得可选参数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1710234|def+show_name_and_address(name="Someone",+address="Somewhere")
++puts+"#{name},+#{address}"
end

show_name_and_address
#=>+'Someone,+Somewhere'

show_name_and_address('Andy')
#=>+'Andy,+Somewhere'|code-block|syntax|javascript|1710235|命名参数方法是不同的。它仍然允许您提供默认值，但它允许调用方确定要提供哪些参数(如果有的话)：|1710236|def+show_name_and_address(name:+"Someone",+address:+"Somewhere")
++puts+"#{name},+#{address}"
end

show_name_and_address
#=>+'Someone,+Somewhere'

show_name_and_address(name:+'Andy')
#=>+'Andy,+Somewhere'

show_name_and_address(address:+'USA')
#=>+'Someone,+USA'|1710237|虽然这两种方法在没有参数的情况下确实是相似的，但是当用户向方法提供参数时，它们是不同的。使用命名参数，调用方可以指定要提供的参数。具体来说，最后一个示例(仅提供地址)在第一个示例中是不完全可以实现的；您只能通过向方法提供两个参数才能得到类似的结果。这使得命名参数方法更加灵活。|1710238|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I think that the answer to your updated question can be explained with explicit examples. In the example below you have optional parameters in an explicit order:

<pre><code>def show_name_and_address(name="Someone", address="Somewhere")
 puts "#{name}, #{address}"
end

show_name_and_address
#=&gt; 'Someone, Somewhere'

show_name_and_address('Andy')
#=&gt; 'Andy, Somewhere'
</code></pre>

The named parameter approach is different. It still allows you to provide defaults but it allows the caller to determine which, if any, of the parameters to provide:

<pre><code>def show_name_and_address(name: "Someone", address: "Somewhere")
 puts "#{name}, #{address}"
end

show_name_and_address
#=&gt; 'Someone, Somewhere'

show_name_and_address(name: 'Andy')
#=&gt; 'Andy, Somewhere'

show_name_and_address(address: 'USA')
#=&gt; 'Someone, USA'
</code></pre>

While it's true that the two approaches are similar when provided with no parameters, they differ when the user provides parameters to the method. With named parameters the caller can specify which parameter is being provided. Specifically, the last example (providing only the address) is not quite achievable in the first example; you can get similar results ONLY by supplying BOTH parameters to the method. This makes the named parameters approach much more flexible.

blocks|key|2499342|text|我同意您的观点，将默认值作为使用命名参数的代价是很奇怪的，显然Ruby维护人员也同意我们的观点！Ruby2.1将删除2.1.0-预览1中的默认值要求。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2499343|entityMap|0|LINK|mutability|MUTABLE|url|http://rkh.im/ruby-2.1^0|1K|I|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I agree with you that it's weird to require default values as the price for using named parameters, and evidently the Ruby maintainers agree with us! Ruby 2.1 will <a href="http://rkh.im/ruby-2.1" rel="noreferrer">drop the default value requirement as of 2.1.0-preview1</a>.

blocks|key|1710310|text|从Ruby2.1.0开始，您不再需要为指定的参数设置默认值。如果省略参数的默认值，则将要求调用方提供该参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1710311|def+concatenate(val1:+'default',+val2:)
++"#{val1}+#{val2}"
end

concatenate(val2:+'argument')
#=>+"default+argument"

concatenate(val1:+'change')
#=>+ArgumentError:+missing+keyword:+val2|code-block|syntax|javascript|1710312|给予：|1710313|def+test1(var1="default+value123")
++var1
end

def+test2(var1:"default+value123")
++var1
end|1710314|当没有通过一个论点时，他们的行为也会是一样的：|1710315|test1
#=>+"default+value123"

test2
#=>+"default+value123"|1710316|但是，当一个参数被传递时，它们的行为会有很大的不同：|1710317|test1("something+else")
#=>+"something+else"

test2("something+else")
#=>+ArgumentError:+wrong+number+of+arguments+(1+for+0)


test1(var1:+"something+else")
#=>+{:var1=>"something+else"}

test2(var1:+"something+else")
#=>+"something+else"|1710318|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/ruby/ruby/blob/ruby_2_1/NEWS#L16-17^0|1|9|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|D|3|E|5|F|7|16|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|17|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|C|$]]|$1|S|3|T|5|F|7|1C|8|@]|9|@]|C|$G|H]]|$1|U|3|-4|5|6|7|1D|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]]]

As of <a href="https://github.com/ruby/ruby/blob/ruby_2_1/NEWS#L16-17" rel="noreferrer">Ruby 2.1.0</a>, you no longer have to set default values for named parameters. If you omit the default value for a parameter, the caller will be required to provide it.

<pre><code>def concatenate(val1: 'default', val2:)
 "#{val1} #{val2}"
end

concatenate(val2: 'argument')
#=&gt; "default argument"

concatenate(val1: 'change')
#=&gt; ArgumentError: missing keyword: val2
</code></pre>

<hr>

Given:

<pre><code>def test1(var1="default value123")
 var1
end

def test2(var1:"default value123")
 var1
end
</code></pre>

They'll behave the same way when not passed an argument:

<pre><code>test1
#=&gt; "default value123"

test2
#=&gt; "default value123"
</code></pre>

But they'll behave much differently when an argument is passed:

<pre><code>test1("something else")
#=&gt; "something else"

test2("something else")
#=&gt; ArgumentError: wrong number of arguments (1 for 0)


test1(var1: "something else")
#=&gt; {:var1=&gt;"something else"}

test2(var1: "something else")
#=&gt; "something else"
</code></pre>

blocks|key|390714|text|这在所有其他答案中都有，但我想提炼出这一本质。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|390715|有四种参数：|390716|+++++++++++++Required+++++Optional
Positional+%7C+def+PR(a)++%7C+def+PO(a=1)+%7C
Keyword++++%7C+def+KR(a:)+%7C+def+KO(a:1)+%7C|code-block|syntax|javascript|390717|在定义函数时，位置参数在关键字参数之前指定，而必需参数在可选参数之前指定。|390718|irb(main):006:0>+def+argtest(a,b=2,c:,d:4)
irb(main):007:1>+p+[a,b,c,d]
irb(main):008:1>+end
=>+:argtest

irb(main):009:0>+argtest(1,c:+3)
=>+[1,+2,+3,+4]

irb(main):010:0>+argtest(1,20,c:+3,d:+40)
=>+[1,+20,+3,+40]|390719|编辑:正如其他人提到的，在Ruby2.1.0中，必需的关键字参数(没有默认值)是新的。|390720|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This is present in all the other answers, but I want to extract this essence.

There are four kinds of parameter:

<pre><code> Required Optional
Positional | def PR(a) | def PO(a=1) |
Keyword | def KR(a:) | def KO(a:1) |
</code></pre>

When defining a function, positional arguments are specified before keyword arguments, and required arguments before optional ones.

<pre><code>irb(main):006:0&gt; def argtest(a,b=2,c:,d:4)
irb(main):007:1&gt; p [a,b,c,d]
irb(main):008:1&gt; end
=&gt; :argtest

irb(main):009:0&gt; argtest(1,c: 3)
=&gt; [1, 2, 3, 4]

irb(main):010:0&gt; argtest(1,20,c: 3,d: 40)
=&gt; [1, 20, 3, 40]
</code></pre>

edit: the required keyword argument (without a default value) is new as of Ruby 2.1.0, as mentioned by others.

blocks|key|390722|text|把这个留在这里是因为它帮了我很多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|390723|示例|390724|假设您有以下内容：|390725|def+foo(thing,+to_print)
++if+to_print
++++puts+thing
++end
end


#+this+works
foo("hi",+true)
#+hi
#+=>+nil|code-block|syntax|javascript|390726|因此，您可以尝试添加参数名，如下所示：|390727|foo(thing:+"hi",+to_print:+true)
#+foo(thing:+"hi",+to_print:+true)
#+ArgumentError:+wrong+number+of+arguments+(given+1,+expected+2)
#+from+(pry):42:in+`foo'|390728|但不幸的是它是错误的。|390729|解决方案|390730|只需在每个参数的末尾添加一个:：|offset|length|style|CODE|390731|def+foo2(thing:,+to_print:)
++if+to_print
++++puts+thing
++end
end


foo2(thing:+"hi",+to_print:+true)
#+hi
#+=>+nil|390732|而且起作用了！|390733|entityMap^0|0|0|0|0|0|0|0|0|E|1|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|19|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1C|8|@$U|1D|V|1E|W|X]]|9|@]|A|$]]|$1|Y|3|Z|5|H|7|1F|8|@]|9|@]|A|$I|J]]|$1|10|3|11|5|6|7|1G|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|13|$]]

Leaving this here because it helped me a lot.
<h3>Example</h3>
Suppose you have this:
<pre class="lang-rb prettyprint-override"><code>def foo(thing, to_print)
 if to_print
 puts thing
 end
end


# this works
foo(&quot;hi&quot;, true)
# hi
# =&gt; nil
</code></pre>
so you try adding the argument names, like so:
<pre class="lang-rb prettyprint-override"><code>foo(thing: &quot;hi&quot;, to_print: true)
# foo(thing: &quot;hi&quot;, to_print: true)
# ArgumentError: wrong number of arguments (given 1, expected 2)
# from (pry):42:in `foo'
</code></pre>
but unfortunately it errors.
<h3>Solution</h3>
Just add a <code>:</code> to the end of each argument:
<pre class="lang-rb prettyprint-override"><code>def foo2(thing:, to_print:)
 if to_print
 puts thing
 end
end


foo2(thing: &quot;hi&quot;, to_print: true)
# hi
# =&gt; nil
</code></pre>
And it works!

I don't understand completely how named parameters in Ruby 2.0 work. 

<pre><code>def test(var1, var2, var3)
 puts "#{var1} #{var2} #{var3}"
end

test(var3:"var3-new", var1: 1111, var2: 2222) #wrong number of arguments (1 for 3) (ArgumentError)
</code></pre>

it's treated like a hash. And it's very funny because to use named parameters in Ruby 2.0 I must set default values for them:

<pre><code>def test(var1: "var1", var2: "var2", var3: "var3")
 puts "#{var1} #{var2} #{var3}"
end

test(var3:"var3-new", var1: 1111, var2: 2222) # ok =&gt; 1111 2222 var3-new
</code></pre>

which very similar to the behaviour which Ruby had before with default parameters' values:

<pre><code>def test(var1="var1", var2="var2", var3="var3")
 puts "#{var1} #{var2} #{var3}"
end

test(var3:"var3-new", var1: 1111, var2: 2222) # ok but ... {:var3=&gt;"var3-new", :var1=&gt;1111, :var2=&gt;2222} var2 var3
</code></pre>

I know why is that happening and almost how it works. 

But I'm just curious, must I use default values for parameters if I use named parameters? 

And, can anybody tell me what's the difference between these two then?

<pre><code>def test1(var1="default value123")
 #.......
end

def test1(var1:"default value123")
 #.......
end
</code></pre>

Named parameters in Ruby 2

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我不完全理解Ruby2.0中的命名参数是如何工作的。def test(var1, var2, var3)  puts "#{var1} #{var2} #{var3}"endtest(var3:"var3-new", var1: 1111, var2: 2222) #wrong number of arguments ...

问Ruby 2中的命名参数
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby 2中的命名参数EN