Ruby：将super传递给另一种方法以有条件地执行

Question

I have some code that looks like this:

 if args
   eval("super(#{args.join(',')})")
 else
   super
 end

twice in a method. I'd like to move it so that my code looks more like:

def special_method
  if a
    some_block do
      call_super(args, super_method)
    end
  else
    call_super(args, super_method)
  end
end

def call_super(args, super_method)
  if args
    eval("super(#{args.join(',')})")
  else
    super
   end
 end

I need to have a reference to the super I want to call (super special_method ), since if I just create a method call_super and call super , it calls call_super on the superclass instead.

Does any of this make sense? x_x

Answer 1

It makes sense except for why you would ever need it. super already passes any parameters that the current method receives. super() passes no params. super(*args) passes any params in args , or no params if args is [] or nil .

If you actually want to do what your code currently does (pass args if they are non- nil , but current method's params if not) and not what I think you wanted, you can write args ? super(*args) : super args ? super(*args) : super as a short alternative (you can't put this in another method since it wouldn't know what the current parameters are).

(Also, you will find that in 99% of cases you think eval is the answer, there is a better answer.)

EDIT in response to the comment:

if args is ['testing', 1] , then super(args) will pass one parameter that is an array; super(*args) passes two parameters (a string and an integer):

# a module
module Foo
  def special_method
    # multiple arguments in `args`
    args = ['testing', 1]
    super(*args)
  end
end

class Bar
  # fixed number of arguments (without splats):
  def special_method(first, second)
    puts "First parameter:  #{first}"
    puts "Second parameter: #{second}"
  end
end

# subclass that includes the module
class Baz < Bar
  include Foo
end

Baz.new.special_method
# First parameter:  testing
# Second parameter: 1

(Note that "multiple arguments in *args " does not make sense, as *args is not a variable, args is).

I think one of the reasons for the confusion is the fact that splat has two different but related roles. In method definitions, they collect arguments into an array. Everywhere else, they distribute an array to an argument list.

require 'pp'

def foo(*args)
  pp args
end
foo([1, 2])  # all the parameters (namely, the one) collected into `args`
# [[1, 2]]
foo(1, 2)    # all the parameters (the two) collected into `args`
# [1, 2]
foo(*[1, 2]) # distribute `[1, 2]` to two parameters; collect both into `args`
# [1, 2]

def foo(args)
  pp args
end
foo([1, 2])  # all the parameters (the one that exists) passed as-is
# [1, 2]
foo(1, 2)    # all the parameters (the two) passed as-is, but method expects one
# ArgumentError: wrong number of arguments (2 for 1)
foo(*[1, 2]) # distribute `[1, 2]` to two parameters, but method expects one
# ArgumentError: wrong number of arguments (2 for 1)