Ejercicios

1. ¿Que resultados dan las siguientes operaciones?

   >> x = { :a => 1, :b => 2 }
   => {:b=>2, :a=>1}
   >> x.keys
   => 
   >> x.values
   => 
   >> x[:c] = 3
   => 3
   >> x
   => 
   >> x.delete('a')
   => nil
   >> x
   => 
   >> x.delete(:a)
   => 1
   >> x
   => 
   >> x = { :a => 1, :b => 2, :c => 4 }
   => {:b=>2, :c=>4, :a=>1}
   >> x.delete_if { |k,v| v % 2 == 0 }
   => 
   >> x
   => 
   >> z = { :a => [1, { :b => { :c => 2 }}], :e => lambda { |x| x*x } }
   => {:e=>#<Proc:0x00000001012c5108@(irb):18>, :a=>[1, {:b=>{:c=>2}}]}
   >> z[:a][1][:b][:c]
   => 
   >> z[:e]
   => #<Proc:0x00000001012c5108@(irb):18>
   >> z[:e].class
   => Proc
   >> Proc.instance_methods(false)
   => ["dup", "[]", "==", "to_s", "binding", "clone", "arity", "to_proc", "call"]
   >> z[:e].call(4)
   => 
   >> z[:e][9]
   => 
   >> z[:e][4]
   =>
   

2. ¿Que resultado da la siguiente expresión?

   >> f = lambda { |x,y| x * y }
   => #<Proc:0x000000010128a4b8@(irb):17>
   >> f.arity
   =>
   

3. ¿Que retorna la función mult?

   ~/rubytesting$ cat -n closure.rb 
        1  def mult(n)
        2    lambda { |v| v.map { |x| x * n } }
        3  end
        4  
        5  doubler = mult(2)
        6  puts doubler[[1,2,3]]
   

   ¿Cuál es la salida?
4. ¿Cual es la salida de este programa?

   ~/rubytesting$ cat -n sharedvarandclosure.rb 
        1  def accessor_pair(initialValue = nil)
        2    value = initialValue
        3  
        4    getter = lambda { value }
        5    setter = lambda { |x| value = x }
        6    return getter, setter
        7  end
        8  
        9  
       10  getX, setX = accessor_pair(9)
       11  puts getX[]
       12  
       13  setX[-1]
       14  puts getX[]
   

   ¿Que retorna accessor_pair? Cómo es que la variable value no es destruída por el garbage collector de Ruby cuando se termina el ámbito de accessor_pair?
5. ¿Qué resultados se dan?

   >> a = (1..5).to_a
   => 
   >> a = a.collect { |x| x*x }
   => 
   >> b = a.select { |y| (4..16).include? y }
   =>
   

6. ¿Que queda en c?

   >> a = (1..5).to_a
   => 
   >> c = a.inject(1) { |x,y| x *= y }
   =>
   

7. ¿Cual es el resultado?

   >> "%d %s" % [3, "rubies"]
   =>
   

8. ¿Cuales son los resultados?

   >> x, y = 4, 5
   => 
   >> z = x > y ? x : y
   => 
   >> x,y,z = [1,2,3]
   =>
   

9. ¿Cuales son los resultados?

   >> z = %x{ls}.split(/\s+/).select { |w| w =~ /ruby/i }
   => 
   >> /ruby/i === "Ruby"
   =>
   

10. Escriba una expresión regular que describa los números en punto flotante (1.5, -2.3, -4.7e-1, etc.)
11. Explique el resultado:

    >> str = "Hello 'name'"
    => "Hello 'name'"
    >> name = "John"
    => "John"
    >> str.gsub(/'([^']*)'/) { eval($1) }
    => "Hello John"
    

12. Explique los resultados:

    >> "hello".index /e/
    => 1
    >> "hello".index /h/
    => 0
    >> "hello".index /n/
    => nil
    >> "hello".index /o/
    => 4
    

13. ¿Que hace attr_accessor? ¿ Que argumentos lleva?
14. ¿Que hace attr_reader? ¿ Que argumentos lleva?
15. ¿Que hace attr_writer? ¿ Que argumentos lleva?

16. ¿Cómo hago que los objetos de una clase puedan sumarse? ¿Como hago para que puedan ser indexados como si fueran arrays?

17. ¿Cómo se llama la función que hay que definir para el menos unario (opuesto)?

18. ¿Que hace yield 4, 5?

19. ¿Cómo se define una constante en Ruby?

20. ¿Como se denota una variable que guarda un atributo de clase en Ruby?

21. ¿Puede un método privado de una clase ser llamado desde una subclase?

22. ¿Puede un método privado p de una clase ser llamado x.p() desde un objeto x de una subclase?

23. ¿Puede un método protected p de una clase ser llamado x.p() desde un objeto x de una subclase?