Uso del rendimiento y el rendimiento en Ruby

Question

¿Alguien me puede ayudar a averiguar el uso del rendimiento y el rendimiento en Ruby? Soy un principiante de Ruby, por lo que los ejemplos simples son muy apreciados.

¡Gracias de antemano!

Answer 1

La declaración de devolución funciona de la misma manera que funciona en otros lenguajes de programación similares, simplemente regresa del método en el que se usa. Puede omitir la llamada para devolver, ya que todos los métodos en ruby ​​siempre devuelven la última instrucción. Así que es posible encontrar método como este:

def method 
    "hey there" 
end 

que en realidad es lo mismo que hacer algo como:

def method 
    return "hey there" 
end 

El yield por el contrario, excecutes el bloque dado como un parámetro para el método. Para que pueda tener un método como este:

def method 
    puts "do somthing..." 
    yield 
end 

y luego usarlo como esto:

method do 
    puts "doing something" 
end 

El resultado de eso, se imprime en pantalla los siguientes 2 líneas:

"do somthing..." 
"doing something" 

Espero que lo aclare un poco. Para obtener más información sobre bloques, puede consultar this link.

Answer 2

yield se utiliza para llamar al bloque asociado con el método. Esto se hace colocando el bloque (básicamente sólo código entre llaves) después de que el método y sus parámetros, así:

[1, 2, 3].each {|elem| puts elem} 

return sale del método actual, y utiliza su "argumento" como valor de retorno, de este modo:

def hello 
    return :hello if some_test 
    puts "If it some_test returns false, then this message will be printed." 
end 

pero tenga en cuenta que no tienen utilizar la palabra clave de retorno en cualquiera de los métodos; Ruby devolverá el último enunciado evaluado si no encuentra devoluciones. Por lo tanto estos dos se equivelent:

def explicit_return 
    # ... 
    return true 
end 

def implicit_return 
    # ... 
    true 
end 

---

He aquí un ejemplo para yield:

# A simple iterator that operates on an array 
def each_in(ary) 
    i = 0 
    until i >= ary.size 
    # Calls the block associated with this method and sends the arguments as block parameters. 
    # Automatically raises LocalJumpError if there is no block, so to make it safe, you can use block_given? 
    yield(ary[i]) 
    i += 1 
    end 
end 

# Reverses an array 
result = []  # This block is "tied" to the method 
       #       | | | 
       #       v v v 
each_in([:duck, :duck, :duck, :GOOSE]) {|elem| result.insert(0, elem)} 
result # => [:GOOSE, :duck, :duck, :duck] 

y un ejemplo para return, que voy a utilizar para implementar un método para determinar si un número es happy :

class Numeric 
    # Not the real meat of the program 
    def sum_of_squares 
    (to_s.split("").collect {|s| s.to_i ** 2}).inject(0) {|sum, i| sum + i} 
    end 

    def happy?(cache=[]) 
    # If the number reaches 1, then it is happy. 
    return true if self == 1 
    # Can't be happy because we're starting to loop 
    return false if cache.include?(self) 
    # Ask the next number if it's happy, with self added to the list of seen numbers 
    # You don't actually need the return (it works without it); I just add it for symmetry 
    return sum_of_squares.happy?(cache << self) 
    end 
end 

24.happy? # => false 
19.happy? # => true 
2.happy? # => false 
1.happy? # => true 
# ... and so on ... 

Hope this helps! :)

Answer 3

def cool 
    return yield 
end 

p cool {"yes!"} 

La palabra clave yield ordena a Ruby que ejecute el código en el bloque. En este ejemplo, el bloque devuelve la cadena "yes!". Se utilizó una declaración explícita de devolución en el método cool(), pero esto podría haber estado implícito también.