Comment puis-je autoriser un argument dans une fonction rubis d'être un certain type?

Vous ne pouvez pas faire fonction DEF (Array arg) code> Comme dans d'autres langues, mais vous pouvez remplacer quatre lignes de votre deuxième extrait de votre deuxième extrait par un seul:

def function(arg)
  raise TypeError unless arg.is_a? Array
  # code...
end

Ruby ne prend pas en charge la vérification du type - au moins, pas dans le sens de la possibilité de déclarer des types d'arguments dans le cadre de la signature de la méthode. En règle générale, l'appelant est responsable du passage des objets corrects, ou les objets transmises sont responsables de la conversion. Cependant, vous pouvez certainement faire vos propres coercitions. En fait, About.com a un exemple d'utiliser la déclaration de cas pour faire juste ce type de vérification de type.

Voici quelques exemples supplémentaires: P>

# Ask your object to convert itself to an array.
def foo my_object
  my_object.to_a
end

# Give your object a #to_a method if it doesn't already have one.
def foo my_object
  unless my_object.respond_to? :to_a
    def my_object.to_a
      # perform your type conversion
    end
  end
end

# Do your own type conversions.
def foo my_object
  case my_object
  when Array
    p my_object
  when String
    my_object.scan /\d+/
  end
end

D'autres ont souligné comment vous pouvez techniquement appliquer un type d'argument, mais vous combattez une bataille fondamentale avec la façon de penser de rubis. Google autour de "dactylographie de canard".

Dans le monde de rubis, nous ne nous inquiétons généralement pas du type d'argument, mais plutôt de savoir si cela répond à l'interface de ce que nous voulons faire avec elle. En d'autres termes, cela compare-t-il comme un canard? Assez bon! P>

Permet de supposer que vous essayez d'utiliser un tableau pour quelque chose: p> xxx pré>

si vous appelez cela comme: Fonction (1) code>, vous obtenez nométhoderror: méthode non définie 'chacun' code> p>

Utilisez votre idée de le forcer à être un tableau. P>

function([1,2,3,4])
function("foo")
function("foo".chars)

Au lieu de soulever une erreur, vous pouvez vous assurer que vous convertissez l'argument en une matrice, mais vous devez plutôt travailler à la routine fournissant le paramètre afin qu'il vous donne une matrice en premier lieu.

def function(*arg)
  a = arg.flatten
  p a
end

function("ab")
function(1,2)
function([1,2])

#=>
#["ab"]
#[1, 2]
#[1, 2]

Si le récepteur dans votre exemple est trivial et que cela est défini comme une fonction plutôt qu'une méthode, vous voudrez peut-être tourner l'argument dans un récepteur.

class Array
  def function
    # do stuff
  end
end