ruby-on-rails - lista - largo de un arreglo en ruby

Usar símbolos como argumentos para los métodos de ruby

Question

Estoy aprendiendo rails y volviendo a Ruby para entender cómo funcionan los métodos en los rieles (y el rubí realmente funciona). Cuando veo llamadas de método como:

validates validates :first_name, :presence => true

Estoy confundido. ¿Cómo se escriben los métodos en ruby ​​que aceptan símbolos o hashes? El código fuente para el método validates también es confuso. ¿Podría alguien simplificar este tema de usar símbolos como argumentos en clase ruby ​​y métodos de instancia para mí?

ACTUALIZAR:

Buena @Dave! Pero lo que estaba probando era algo así como:

def full_name (:first_name, :last_name)
@first_name = :first_name
@last_name = :last_name
p "#{@first_name} #{last_name}"
end
full_name("Breta", "Von Sustern")

Lo cual obviamente aumenta los errores. Estoy tratando de entender: ¿por qué pasar símbolos como este como argumentos incorrectos si los símbolos son como cualquier otro valor?

Answer 1

Creo que todas las respuestas han perdido el sentido de la pregunta; y el hecho de que alguien que, supongo, lo pregunta, ¿no tiene claro qué es un símbolo?

Como recién llegado a Ruby tuve confusiones similares y para mí una respuesta como la siguiente tendría más sentido

Métodos Los argumentos son variables locales pobladas por valores pasados.

No puede usar símbolos como Argumentos por sí mismo , ya que no puede cambiar el valor de un símbolo.

Answer 2

En Ruby, si llamas a un método con un grupo de pares name => value al final de la lista de argumentos, estos se envuelven automáticamente en un Hash y se pasan a tu método como último argumento:

def foo(kwargs)
p kwargs
end
>> foo(:abc=>"def", 123=>456)
{:abc=>"def", 123=>456}
>> foo("cabbage")
"cabbage"
>> foo(:fluff)
:fluff

No hay nada "especial" sobre cómo escribir el método, es cómo lo llamas. Sería perfectamente legal pasar un objeto Hash regular como el parámetro kwargs . Este atajo sintáctico se usa para implementar parámetros nombrados en una API.

Un símbolo de Ruby es solo un valor como cualquier otro, así que en su ejemplo :first_name es solo un argumento posicional regular. :presence es un símbolo utilizado como tecla Hash: cualquier tipo se puede utilizar como tecla Hash, pero los símbolos son una opción común porque son valores inmutables.

Answer 3

Los símbolos no están limitados a hash. Son identificadores, sin el espacio de almacenamiento adicional de una cadena. Es solo una manera de decir "esto es ..."

Una posible definición de función para la llamada validada podría ser (para simplificar, no sé lo que es en realidad):

def validates(column, options)
puts column.to_s
if options[:presence]
puts "Found a presence option"
end
end

Observe cómo el primer símbolo es un parámetro propio, y el resto es el hash.

Answer 4

Los símbolos y hash son valores como cualquier otro y se pueden pasar como cualquier otro tipo de valor.

Recuerde que los modelos ActiveRecord aceptan un hash como argumento; termina siendo similar a esto (no es tan simple, pero al final es la misma idea):

class User
attr_accessor :fname, :lname
def initialize(args)
@fname = args[:fname] if args[:fname]
@lname = args[:lname] if args[:lname]
end
end
u = User.new(:fname => ''Joe'', :lname => ''Hacker'')

Esto aprovecha la ventaja de no tener que poner el hash en corchetes {} menos que necesite desambiguar los parámetros (y también hay un problema de análisis de bloques cuando omite los parens).

Similar:

class TestItOut
attr_accessor :field_name, :validations
def initialize(field_name, validations)
@field_name = field_name
@validations = validations
end
def show_validations
puts "Validating field ''#{field_name}'' with:"
validations.each do |type, args|
puts " validator ''#{type}'' with args ''#{args}''"
end
end
end
t = TestItOut.new(:name, presence: true, length: { min: 2, max: 10 })
t.show_validations

Esto produce:

Validating field ''name'' with:
validator ''presence'' with args ''true''
validator ''length'' with args ''{min: 2, max: 10}''

A partir de ahí, puede comenzar a ver cómo funcionan cosas como esta.

Answer 5

Pensé en agregar una actualización para Ruby 2+ ya que este es el primer resultado que encontré para ''símbolos como argumentos''.

Desde Ruby 2.0.0 también puedes usar símbolos al definir un método. Al llamar al método, estos símbolos actuarán casi igual que los parámetros opcionales nombrados en otros idiomas. Vea el siguiente ejemplo:

def variable_symbol_method(arg, arg_two: "two", arg_three: "three")
[arg, arg_two, arg_three]
end
result = variable_symbol_method :custom_symbol, arg_three: "Modified symbol arg"
# result is now equal to:
[:custom_symbol, "two", "Modified symbol arg"]

Como se muestra en el ejemplo, omitimos arg_two: cuando arg_two: al método y en el cuerpo del método, podemos acceder a él como variable arg_two . También tenga en cuenta que la variable arg_three es de hecho alterada por la llamada a la función.