blocks|key|838520|text|解决此问题的典型方法是使用具有默认值的散列。如果散列是方法的最后一个参数，Ruby有一个很好的语法来传递散列值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|838521|class+Fruit
++attr_accessor+:color,+:type

++def+initialize(params+=+{})
++++@color+=+params.fetch(:color,+'green')
++++@type+=+params.fetch(:type,+'pear')
++end

++def+to_s
++++"#{color}+#{type}"
++end
end

puts(Fruit.new)++++++++++++++++++++++++++++++++++++#+prints:+green+pear
puts(Fruit.new(:color+=>+'red',+:type+=>+'grape'))+#+prints:+red+grape
puts(Fruit.new(:type+=>+'pomegranate'))+#+prints:+green+pomegranate|code-block|syntax|javascript|838522|这里有一个很好的概述：http://deepfall.blogspot.com/2008/08/named-parameters-in-ruby.html|offset|length|838523|entityMap|0|LINK|mutability|MUTABLE|url|http://deepfall.blogspot.com/2008/08/named-parameters-in-ruby.html^0|0|0|B|1U|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

The typical way to solve this problem is with a hash that has a default value. Ruby has a nice syntax for passing hash values, if the hash is the last parameter to a method.

<pre><code>class Fruit
 attr_accessor :color, :type

 def initialize(params = {})
 @color = params.fetch(:color, 'green')
 @type = params.fetch(:type, 'pear')
 end

 def to_s
 "#{color} #{type}"
 end
end

puts(Fruit.new) # prints: green pear
puts(Fruit.new(:color =&gt; 'red', :type =&gt; 'grape')) # prints: red grape
puts(Fruit.new(:type =&gt; 'pomegranate')) # prints: green pomegranate
</code></pre>

A good overview is here: <a href="http://deepfall.blogspot.com/2008/08/named-parameters-in-ruby.html" rel="noreferrer">http://deepfall.blogspot.com/2008/08/named-parameters-in-ruby.html</a>

blocks|key|1053238|text|我会这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1053239|class+Fruit
++attr_accessor+:color,+:type

++def+initialize(args={})
++++options+=+{:color+=>+'green',+:type+=>+'pear'}.merge(args)

++++self.color+=+options[:color]
++++self.type++=+options[:type]
++end
end

apple+=+Fruit.new(:color+=>+'red',+:type+=>+'apple')|code-block|syntax|javascript|1053240|这样，您就不必担心缺少参数--或者它们的顺序--并且您将始终保留您的默认值。当然，如果默认值存在，.merge将覆盖默认值。|offset|length|style|CODE|1053241|entityMap^0|0|0|1D|6|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|$]]

I'd do it like this:

<pre><code>class Fruit
 attr_accessor :color, :type

 def initialize(args={})
 options = {:color =&gt; 'green', :type =&gt; 'pear'}.merge(args)

 self.color = options[:color]
 self.type = options[:type]
 end
end

apple = Fruit.new(:color =&gt; 'red', :type =&gt; 'apple')
</code></pre>

This way, you never have to worry about missing arguments--or their order--and you'll always have your default values right there. <code>.merge</code> will of course overwrite the default values if they're present.

blocks|key|838599|text|更简单的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|838600|class+Fruit
++attr_accessor+:color,+:type
++def+initialize(color+=+'green',+type+=+'pear')
++++@color+=+color
++++@type+=+type
++end
++def+to_s
++++"#{color}+#{type}"
++end
end


puts+Fruit.new+#+prints:+green+pear
puts+Fruit.new('red','apple')+#+prints:+red+apple
puts+Fruit.new(nil,'pomegranate')+#+prints:+green+pomegranate|code-block|syntax|javascript|838601|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

More simple way:

<pre><code>class Fruit
 attr_accessor :color, :type
 def initialize(color = 'green', type = 'pear')
 @color = color
 @type = type
 end
 def to_s
 "#{color} #{type}"
 end
end


puts Fruit.new # prints: green pear
puts Fruit.new('red','apple') # prints: red apple
puts Fruit.new(nil,'pomegranate') # prints: green pomegranate
</code></pre>

blocks|key|838657|text|Brian的回答很好，但我想建议一些修改，使其主要是meta：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|838658|class+Fruit

++#+Now+this+is+the+only+thing+you+have+to+touch+when+adding+defaults+or+properties
++def+set_defaults
++++@color+%7C%7C=+'green'
++++@type++%7C%7C=+'pear'
++end

++def+initialize(params+=+{})
++++params.each+{+%7Ckey,value%7C+instance_variable_set("@#{key}",+value)+}
++++set_defaults
++++instance_variables.each+{%7Cvar%7C+self.class.send(:attr_accessor,+var.to_s.delete('@'))}
++end

++def+to_s
++++instance_variables.inject("")+{%7Cvars,+var%7C+vars+%2B=+"#{var}:+#{instance_variable_get(var)};+"}
++end

end

puts+Fruit.new
puts+Fruit.new+:color+=>+'red',+:type+=>+'grape'++
puts+Fruit.new+:type+=>+'pomegranate'
puts+Fruit.new+:cost+=>+20.21
puts+Fruit.new+:foo+=>+"bar"


f+=+Fruit.new+:potato+=>+"salad"
puts+"f.cost.nil?+#{f.cost.nil?}"|code-block|syntax|javascript|838659|以下哪项输出：|838660|@color:+green;+@type:+pear;+
@color:+red;+@type:+grape;+
@color:+green;+@type:+pomegranate;+
@color:+green;+@type:+pear;+@cost:+20.21;+
@color:+green;+@type:+pear;+@foo:+bar;+
f.cost.nil?+true|838661|当然，这并不是万能的完美解决方案，但它为您提供了一些使代码更具动态性的想法。|838662|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|$]]

Brian's answer is excellent but I would like to suggest some modifications to make it mostly meta:

<pre><code>class Fruit

 # Now this is the only thing you have to touch when adding defaults or properties
 def set_defaults
 @color ||= 'green'
 @type ||= 'pear'
 end

 def initialize(params = {})
 params.each { |key,value| instance_variable_set("@#{key}", value) }
 set_defaults
 instance_variables.each {|var| self.class.send(:attr_accessor, var.to_s.delete('@'))}
 end

 def to_s
 instance_variables.inject("") {|vars, var| vars += "#{var}: #{instance_variable_get(var)}; "}
 end

end

puts Fruit.new
puts Fruit.new :color =&gt; 'red', :type =&gt; 'grape' 
puts Fruit.new :type =&gt; 'pomegranate'
puts Fruit.new :cost =&gt; 20.21
puts Fruit.new :foo =&gt; "bar"


f = Fruit.new :potato =&gt; "salad"
puts "f.cost.nil? #{f.cost.nil?}"
</code></pre>

Which outputs:

<pre><code>@color: green; @type: pear; 
@color: red; @type: grape; 
@color: green; @type: pomegranate; 
@color: green; @type: pear; @cost: 20.21; 
@color: green; @type: pear; @foo: bar; 
f.cost.nil? true
</code></pre>

Of course this wouldn't be a perfect solution for everything but it gives you some ideas on making your code more dynamic.

blocks|key|1053423|text|我喜欢vonconrad的答案，但有一个单独的defaults方法。也许它在代码行数方面效率不高，但它更能揭示意图，涉及更少的认知开销，更少的认知开销意味着更有效的开发。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1053424|class+Fruit
++attr_accessor+:color,+:type

++def+initialize(args={})
++++options+=+defaults.merge(args)

++++@color+=+options.fetch(:color)
++++@type++=+options.fetch(:type)
++end

++def+defaults
++++{
++++++color:+'green',
++++++type:++'pear'
++++}
++end
end

apple+=+Fruit.new(:color+=>+'red',+:type+=>+'apple')|code-block|syntax|javascript|1053425|entityMap^0|N|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I like vonconrad's answer but would have a separate <code>defaults</code> method. Maybe it's not efficient in terms of lines of code, but it's more intention-revealing and involves less cognitive overhead, and less cognitive overhead means more efficient dev onboarding.

<pre><code>class Fruit
 attr_accessor :color, :type

 def initialize(args={})
 options = defaults.merge(args)

 @color = options.fetch(:color)
 @type = options.fetch(:type)
 end

 def defaults
 {
 color: 'green',
 type: 'pear'
 }
 end
end

apple = Fruit.new(:color =&gt; 'red', :type =&gt; 'apple')
</code></pre>

blocks|key|1053588|text|更美味的语法糖：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1053589|class+Fruit
++attr_accessor+:color,+:type
++def+initialize+*args
++++@color,+@type+=+args+
++end
end

pear+=+Fruit.new+'green',+:pear|code-block|syntax|javascript|1053590|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<h3>Even more tasty syntactic sugar:</h3>

<pre><code>class Fruit
 attr_accessor :color, :type
 def initialize *args
 @color, @type = args 
 end
end

pear = Fruit.new 'green', :pear
</code></pre>

I would like to have a class and some attributes which you can either set during initialization or use its default value.

<pre><code>class Fruit
 attr_accessor :color, :type
 def initialize(color, type)
 @color=color ||= 'green'
 @type=type ||='pear'
 end
end

apple=Fruit.new(red, apple)
</code></pre>

What is the most efficient way to initialize a Class in Ruby with different parameters and default values?

我希望有一个类和一些属性，您可以在初始化期间设置它们，也可以使用它的默认值。class Fruit  attr_accessor :color, :type  def initialize(color, type)    @color=color ||= 'green'    @type=type ||='pear' ...

问在Ruby中用不同的参数和默认值初始化Class最有效的方法是什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中用不同的参数和默认值初始化Class最有效的方法是什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中用不同的参数和默认值初始化Class最有效的方法是什么？
EN