Leesbare boolean parameters

Geplaatst door Michiel de Mare do, 30 okt 2008 14:34:00 GMT

Soms heb je methodes met een flink aantal parameters, waarvan een aantal booleans zijn. Je aanroep ziet er dan bijvoorbeeld als volgt uit:


button(name, url, false, true, false)

Wat de boolean options betekenen is een volslagen raadsel, zonder er de source bij te pakken, zelfs als je al bekend bent met de methode. Dat is waarom ruby programmeur vaak option hashes gebruiken.

Maar wat dacht je van de volgende notatie:


button(name, url, !:use_form, :icon_only, !:default)

:icon_only evalueert tot true en !:use_form tot false.

Zo wordt het meteen duidelijk wat de booleans betekenen. Wel moet je de volgorde van de parameters goed hebben (in tegenstelling tot een option hash), maar wie de bovenstaande code leest kan de methode-aanroep veel makkelijker begrijpen.

Geplaatst in  | 3 reacties

Reacties

Laat een reactie achter

  1. Iain Hecker zei ongeveer 4 uur later:

    Je hebt alleen de waarden in de twee voorbeelden omgedraaid. Verder wel een cool idee, dat brengt mij tot het volgende idee:

    button(name, url, :use_form, :default)

    met deze methode:

    def button(name, url, @args)
  options = args.extract_options!
  use_form = args.include?(:use_form)
  icon_only = args.include?(:icon_only)
end

    (apestaartje is eigenlijk een asterisk)

    Die locale variabelen hoef je natuurlijk niet zo te zetten, of misschien is er wel een mooie (meta) oplossing voor te schrijven.

    Aan de andere kant, hoe vaak heb je nou zo’n signature op een method?

    PS. Uit het blote hoofd, wellicht erg onverstandig:

    class Array
  def method_missing(method, @rest)
    self.include?($1.to_sym) if method.to_s =~ /(.*)\?$/
  end
end

    levert:

    args.icon_only?
  2. Michiel zei ongeveer 5 uur later:

    Oeps, heb waardes aangepast.

    Verder interessant idee! Niet erg praktisch, aangezien, zoals je al zegt, methodes met heel veel boolean parameters weinig voorkomen (in ruby-projecten, in java-projecten is het een heel ander verhaal), maar wel erg leuk.

    Het leuke van de !:icon_only notatie is dat het in feite een vorm van documentatie is, omdat het exact hetzelfde betekent als false. Je hoeft dus niets aan de aangeroepen methode te veranderen.

  3. p3t0r zei 1 dag later:

    Waarom zouden methodes met boolean parameters nou weer veel moeten voorkomen in java projecten? Vrijwel iedere methode die een boolean als parameter heeft riekt naar code smells; die methode doet vast meer dan één ding tegelijk. Volgens mij kun je het beter refactoren naar methodes die de intentie van hetgeen je probeert te doen verduidelijken!

    Misschien is een fluent builder wel wat:

    class MyButton
 attr_accessor :show_form, :icon_only, :default, :on_click

 def MyButton::create(&config)
  b = MyButton.new
  b.instance_eval(&config)
  b.render()
 end

 def render
   puts "#{"no " unless @show_form}form, #{"icon only" if @icon_only} using #{@default ? 'default' : 'unspecified'} settings" 
 end
end

MyButton::create{
 @show_form = false 
 @icon_only = true
 @default = false
}

    Maarja, voor deze specifieke situatie is een hash dan eigenlijk net zo handig inderdaad ;)

 (Laat url/e-mail achter »)

   Voorvertoning