Est-il possible d'avoir une portée avec des arguments facultatifs?

Est-il possible d'écrire une portée avec des arguments optionnels, de sorte que je peux appeler le champ d'application avec et sans arguments?

Quelque chose comme:

scope :with_optional_args,  lambda { |arg|
  where("table.name = ?", arg)
}

Model.with_optional_args('foo')
Model.with_optional_args

Je peux vérifier dans le lambda bloc si un argument est donné (comme décrit par Unixmonkey), mais sur l'appel de la portée sans argument, j'ai eu une ArgumentError: wrong number of arguments (0 for 1)

OriginalL'auteur tonymarschall | 2012-04-26

  1. 19

    Oui. Il suffit d'utiliser un * comme vous le feriez dans une méthode.

    scope :print_args, lambda {|*args|
    puts args
}

    OriginalL'auteur z5h

  2. 21

    Ruby 1.9 étendue des blocs d'avoir les mêmes caractéristiques que les méthodes (les valeurs par défaut sont parmi eux):

    scope :cheap, lambda{|max_price=20.0| where("price < ?", max_price)}

    Appel:

    Model.cheap
Model.cheap(15)

    OriginalL'auteur jdoe

  3. 9

    J'ai utilisé scope :name, ->(arg1, arg2 = value) { ... } il y a quelques semaines, il a travaillé bon, si la mémoire est correcte. À utiliser avec ruby 1.9+

    OriginalL'auteur ksol

  4. 7

    Vous pouvez modifier conditionnellement à votre portée basée sur un argument donné.

    scope :random, ->(num = nil){ num ? order('RANDOM()').limit(num) : order('RANDOM()') }

    Utilisation:

    Advertisement.random # => returns all records randomized
Advertisement.random(1) # => returns 1 random record

    Ou, vous pouvez fournir une valeur par défaut.

    scope :random, ->(num = 1000){ order('RANDOM()').limit(num) }

    Utilisation:

    Product.random # => returns 1,000 random products
Product.random(5) # => returns 5 random products

    REMARQUE: La syntaxe indiquée pour RANDOM() est spécifique à Postgres. La syntaxe est montré Rails 4.

    OriginalL'auteur scarver2

  5. 3

    Voulais juste vous faire savoir que, selon la guide, la méthode recommandée pour le passage d'arguments aux étendues est d'utiliser une méthode de classe, comme ceci:

    class Post < ActiveRecord::Base
  def self.1_week_before(time)
    where("created_at < ?", time)
  end
end

    Ce qui peut donner un plus propre approche.

    OriginalL'auteur Lasse Bunk

  6. 0

    Certainement.

    scope :with_optional_args,  Proc.new { |arg|
  if arg.present?
    where("table.name = ?", arg)
  end
}
    Ne voudriez-vous pas inclure une solution de secours pour quand pas les arguments sont passés?
    J'ai eu une erreur si je ne passe pas un argument: ArgumentError: mauvais nombre d'arguments (0 1)
    Vous pouvez utiliser Proc.de nouveau au lieu de lambda pour éviter l'argument de l'erreur. Voir cette vieille discussion sur ce ici

    OriginalL'auteur Unixmonkey

  7. 0

    Utiliser l' *

    scope :with_optional_args,  -> { |*arg| where("table.name = ?", arg) }

    OriginalL'auteur edymerchk