Apuntes sobre Ruby

Primeras notas que he tomado aprendiendo Ruby con el fantástico libro Programming Ruby.

Ejecutando código ruby.

Podemos escribir código interactivamente desde la consola de comandos o escribirlo en un fichero y luego ejecutarlo (programa), que es lo más apropiado para código complejo o que queramos guardar.

• Interactivamente:
  • En la consola escribir ruby -> expresión -> ^D (control+D).
    % ruby
    puts "Hello, world!"
    ^D

    Hello, world!

    Apropiado para ejecutar expresiones sencillas.

  • En la consola escribir irb -> expresiones
    
    % irb
    irb(main):001:0> def sum(n1, n2)
    irb(main):002:1> n1 + n2
    irb(main):003:1> end
    => nil
    irb(main):004:0> sum(3, 4)
    => 7
    irb(main):005:0> sum("cat", "dog")
    => "catdog"
    
    Irb (interactive ruby) contiene algunas características avanzadas para trabajar interactivamente, por ej va mostrando los resultados de los comandos. Para salir poner exit
• Programas:
  Suelen tener la extensión .rb. En la primera linea se le puede poner la ruta a Ruby y así los sistemas *nix lo pueden ejecutar directamente (acordarse de hacer el fichero ejecutable). Es en la manera que yo suelo trabajar, aunque sólo sea para hacer pruebas. #!/usr/local/bin/ruby w puts "Hello, world!"

  Documentación:

  Tiene un sistema llamado RDoc. Puede ser exportado a HTML facilmente. http://www.ruby-doc.org contiene toda la documentación Rdoc de Ruby. Para acceder a ésta documentación interactivamente se usa el comando ri ClassNameOrMethod

  Nociones básicas de Ruby

  En Ruby todo es un objeto: "gin joint".length # 9 "Rick".index("c") # 2 // find the index of letter c -45.abs # 45 // en java Math.abs(-45)

  Escribir por pantalla:
  En lineas diferentes: puts 'one', 'thwo'

  one
  thwo

  En la misma linea: print 'one', 'thwo'

  onethwo
  Con formato: printf("Number: %5.2f,\nString: %s\n", 1.234, "hello")

  Number: 1.23
  String: hello

  Leer por pantalla: line = gets print line.capitalize

  Variables y constantes

  Convención para distinguir el uso de las variables:

  • Local variables, method parameters, and method names:
    mi_variable
    _mi_variable
  • Global variables:
    $mi_variable
  • Instance variables:
    @mi_variable
  • Class variables:
    @@mi_variable
  • Class names, module names:
    MyClassOrModule
  • Constants:
    CONSTANT_PI

  Acceso:

  Para acceder a una variable o metodo dentro de una clase: clase.var_o_met
  Para acceder a una constante dentro de una clase: clase::CONSTANTE

  Con dobles comillas busca substituciones: puts "And good night,\nGrandma"

  And good night,
  Grandma

  ‘Good night, ‘ + name es lo mismo que “Good night, #{name}”
  Si es variable global, de instancia, o de clase no hacen falta los corchetes: $greeting = "Hello" # $greeting is a global variable @name = "Prudence" # @name is an instance variable puts "#$greeting, #@name"

  Tambien podemos meter código: puts "now is #{ def the(a) 'the ' + a end the('time') } for all good coders..."

  Las variables contienen referencias a objetos, no objetos: person1 = "Tim" person2 = person1 person1[0] = 'J' person1 # "Jim" person2 # "Jim"

  Si queremos evitar estos alias: person1 = "Tim" person2 = person1.dup person1[0] = "J" person1 # "Jim" person2 # "Tim"

  Para evitar modificaciones a un objeto: person1.freeze

  comprobar si una variable está definida: defined?(c) != nil

  Símbolos
  Los símbolos son una manera interna de Ruby de manejar strings, también accesible al programador. Se definen con dos puntos delante:
  :a
  :book
  :”Here’s how to make a symbol with spaces in it.”

  Consumen menos recursos que un string, pero son inmutables (no podemos añadir, borrar o modificarlos).

  Cuando creamos una variable x, Ruby automáticamente crea el símbolo :x name = 'Pepe' print 'The value of ', :name, ' is ', name

  Son apropiados como argumentos para métodos y especialmente como hash keys. También si vamos a utilizar una palabra muchas veces en el código sin ser modificada mejor que sea un símbolo.

  Arrays:

  a = [ 1, 3, 5, 7, 9 ] a.length # 5 a[1] # 3 a[-1] # 9 a[99] # nil #puedes indexar arrays con [start,count] a[1, 3] # [3, 5, 7] a[3, 1] # [7] a[-3, 2] # [5, 7] #puedes indexar arrays con [start..end], o [start...end](no incluye el último) a[1..3] # [3, 5, 7] a[1...3] # [3, 5] a[3..3] # [7] a[3..1] # [5, 7, 9] #y también funciona con strings prof = ' We tore the universe a new space-hole, alright! ' puts prof[12, 8] puts prof[12..20] #para crear un array a partir de varios valores txt = 'a b c' a = txt.split # a=['a', 'b', 'c'] a = [ 'ant', 'bee', 'cat', 'dog', 'elk' ] #equivalente a = %w{ ant bee cat dog elk } a = %w( One\tThwo wilma great\ gazoo ) # sin sustituciones puts a

  One\tThwo
  wilma
  great gazoo

  a = %W( One\tThwo wilma great\ gazoo ) # hace sustituciones puts a

  One Thwo
  wilma
  great gazoo

  Hashes:

  histogram = {'key1'=>1, 'key2'=>2} puts histogram['key3'] # nil // default value histogram = Hash.new(0) # change the default value histogram = {'key1'=>1, 'key2'=>2} puts histogram['key3'] # 0

  Estructuras de control:

  if: if radiation > 3000 puts "Danger, Will Robinson" end #equivalente puts "Danger, Will Robinson" if radiation > 3000 if song.artist == "Gillespie" then handle = "Dizzy" elsif song.artist == "Parker" then handle = "Bird" else handle = "unknown" end #equivalente if song.artist == "Gillespie": handle = "Dizzy" elsif song.artist == "Parker": handle = "Bird" else handle = "unknown" end #equivalente handle = if song.artist == "Gillespie" then "Dizzy" elsif song.artist == "Parker" then "Bird" else "unknown" end if song.duration > 180 cost = 0.35 else cost = 0.25 end #equivalente cost = song.duration > 180 ? 0.35 : 0.25 #equivalente unless song.duration > 180 cost = 0.25 else cost = 0.35 end

  case: kind = case year when 1850..1889 then "Blues" when 1890..1909 then "Ragtime" else "Jazz" end

  while / begin: square = 2 while square < 1000 square = square*square end #equivalente square = 2 square = square*square while square < 1000 #equivalente square = 2 until square > 1000 square = square*square end file = File.open("ordinal") while line = file.gets puts(line) if line =~ /third/ .. line =~ /fifth/ end #equivalente file = File.open("ordinal") while file.gets print if ~/third/ .. ~/fifth/ end # esto se puede hacer poque gets asigna la última línea leida a la variable global $_, y print sin argumentos imprime $_ begin print "#{ list[i]} " i += 1 end while i < list.size

  loop: i=0 loop do i +=1 break if i == 5 puts i end

  1
  2
  3
  4

  for/Do: for i in 0..5 do print 'hola', i, "\n" end num = 1 6.times do puts num num *= num end a = %w{ ant bee cat dog elk } for x in a do puts x end #equivalente ( escepto porque las variables del bloque son locales ) a = %w{ ant bee cat dog elk } a.each do |x| puts x end

  Alteradores de flujo:
  retry: vuelve a empezar desde el primer elemento de la condición
  redo: vuelve a empezar desde el elemento que estaba
  next: salta al siguiente elemento
  break: cancela la iteración

  Bloques:
  Son trozos de código que pueden ser definidos entre do y end o entre llaves.

  Do puts 'hola' end # equivalente {puts 'hola'}

  Se puede utilizar para hacer callbacks, pasar trozos de código, o implementar iteraciones.

  def my_sequence for i in 1..5 do yield 'hola' # yield es para mandar valores a los bloques end end my_sequence { |x| print x, "\n" } # equivalente my_sequence do |x| print x, "\n" end

  hola
  hola
  hola
  hola
  hola

  Ejemplos de bloques:

  Muchos de los métodos de las librerías de Ruby que devuelven sucesivos elementos (iteradores) utilizan estos bloques. Ej: [ 'cat', 'dog', 'horse' ].each {|name| print name, " " } # devuelve cada elemento de un array 5.times { print "*" } 3.upto(6) {|i| print i } ('a'..'e').each {|char| print char }

  cat dog horse *****3456abcde

  collect crea un array a partir de otro: x = %w[alpha bravo charlie delta echo foxtrot] # Get the string lengths b = x.collect { |w| w.length} # [5, 5, 7, 5, 4, 7] x.collect! { |w| w.upcase} # x is now %w[ALPHA BRAVO CHARLIE DELTA ECHO FOXTROT] # map is just an alias x.map! { |w| w.reverse} # x is now %w[AHPLA OVARB EILRAHC ATLED OHCE TORTXOF] c = x.map { |w| w.length} # [5, 5, 7, 5, 4, 7]

  inject acumula valores a traves de los elementos de un array a=[2,3,5,7] b = a.inject(1) {|var1, var2| var1*var2} # (((1*2)*3)*5)*7 = 210 #Primero <em>var1</em> guarda el valor del parametro dado y <em>var2</em> el primer elemento del array, y realiza la operación. Luego <em>var1</em> guarda el valor de la operación y <em>var2</em> recoje el segundo elemento del array, y realiza la operación. Y así sucesivamente. a=[2,3,5,7] b = a.inject {|var1, var2| var1*var2} # ((2*3)*5)*7 = 210 # Si no se le indica parámetro comienza guardando en var1 el primer elemento del array y var2 el segundo.

  Procs

  Son una manera de guardar trozos de código (blocks) en variables, o pasarlas a métodos. toast = Proc.new do puts ' Cheers! ' end toast.call toast.call toast.call

  Cheers!
  Cheers!
  Cheers!

  Los blocks, como ya hemos visto, pueden recibir variables do_you_like = Proc.new do |good_stuff| puts ' I *really* like ' +good_stuff+ ' ! ' end do_you_like.call ' chocolate ' do_you_like.call ' Ruby '

  I *really* like chocolate!
  I *really* like Ruby!

  De ésta manera podemos hacer cosas que los métodos no nos permiten, como escribir una función que haga ‘algo’ dos veces, sin saber de antemano qué es ese ‘algo’.

  def twice_do some_proc some_proc.call some_proc.call end wink = Proc.new do puts ' <wink> ' end glance = Proc.new do puts ' <glance> ' end twice_do wink twice_do glance

  <wink>
  <wink>
  <glance>
  <glance>
  

  Podemos enviar acciones y bloques como parámetros a las funciones. Se indica poniendo un & a la variable (las convierte automáticamente a procs).

  acciones:

  songlist = SongList.new class JukeboxButton < Button def initialize(label, &action) super(label) @action = action end def button_pressed @action.call(self) end end start_button = JukeboxButton.new("Start") { songlist.start } pause_button = JukeboxButton.new("Pause") { songlist.pause }

  bloques: class Array def each_even(&was_a_block__now_a_proc) # We start with "true" because # arrays start with 0, which is even. is_even = true self.each do |object| if is_even was_a_block__now_a_proc.call object end # Toggle from even to odd, or odd to even. is_even = !is_even end end end fruits = [ ' apple ' , ' bad apple ' , ' cherry ' , ' durian ' ] fruits.each_even do |fruit| puts ' Yum! I just love ' +fruit+ ' pies, don\ ' t you? ' end # Remember, we are getting the even-numbered *elements* # of the array, which in this case are all odd numbers, # because I live only to irritate you. [1, 2, 3, 4, 5].each_even do |odd_ball| puts odd_ball.to_s+ ' is NOT an even number! ' end

  Yum! I just love apple pies, don ' t you?
  Yum! I just love cherry pies, don ' t you?
  1 is NOT an even number!
  3 is NOT an even number!
  5 is NOT an even number!

  Podemos hacer de varias formas: def do_it_twice(&block) block.call 'a' block.call 'b' end do_it_twice do |x| puts ' murditivent flavitemphan siresent litics '+x end #equivalente def do_it_twice yield 'a' yield 'b' end do_it_twice do |x| puts ' buritiate mustripe lablic acticise '+x end

  Expresiones Regulares:

  if line =~ /Perl|Python/ #match Perl or Python puts "Scripting language mentioned: #{line}" end line.sub(/Perl/, 'Ruby') # replace first 'Perl' with 'Ruby' line.gsub(/Python/, 'Ruby') # replace every 'Python' with 'Ruby' def show_regexp(a, re) if a =~ re "#{$`}<<#{$&}>>#{$'}" else "no match" end end show_regexp('very interesting', /t/) # very in<<t>>eresting show_regexp('Fats Waller', /a/) # F<<a>>ts Waller show_regexp('Fats Waller', /ll/) # Fats Wa<<ll>>er show_regexp('Fats Waller', /z/) # no match

  Metodos:

  def say_goodnight(name) result = 'Good night, ' + name return result end # Time for bed... puts say_goodnight("JohnBoy") puts (say_goodnight("MaryEllen")) # equivalente a la anterior sentencia

  Si no se indica un return devuelve el valor de la última sentencia: def say_goodnight(name) 'Good night, ' + name end puts say_goodnight("JohnBoy")

  Convención: en minusculas y palabras separadas por _. Normalmente si un método actua como una pregunta se le suele poner un ? (is_instance_of?). Si puede ser peligrosa o modifica al que la llama se le pone un ! (collect!). Si puede asignar un valor se le pone un = (duration=)

  En el caso de querer pasar parametros entre funciones sin saber cuales son esos parámetros, basta con poner un * a la variable. class File def File.open_and_process(*args) f = File.open(*args) yield f f.close() end end File.open_and_process("testfile", "r") do |file| while line = file.gets puts line end end #otro ej def varargs(a, *b) [ a, b ] end varargs 1 # [1, []] varargs 1, 2 # [1, [2]] varargs 1, 2, 3 # [1, [2, 3]]

  Aliasing

  Define un nuevo nombre para referirse a un metodo, operador, variable o expresión regular. Si luego el original cambia el aliased conserva el original.

  def meth "original method" end alias original meth def meth "new and improved" end meth # "new and improved" original # "original method"

  Clases

  class Song def initialize(name, artist, duration) #llamada cuando se crea un nuevo objeto @name = name @artist = artist @duration = duration end end song = Song.new("Bicylops", "Fleck", 260) puts 'song.inspect: ' + song.inspect # formats the object id and instance variables // song.inspect: #<Song:0x1c7ca8 @name="Bicylops",@duration=260,@artist="Fleck"> puts 'song.to_s: ' + song.to_s # song.to_s: #<Song:0x1c7ec4> class Song # podemos redefinir metodos def to_s "Song: #@name, #@artist (#@duration)" end end song = Song.new("Bicylops", "Fleck", 260) puts 'song.to_s redefined: ' + song.to_s # song.to_s redefined: Song: Bicylops, Fleck (260)

  Métodos de clase

  Un método no tiene poque ir siempre asociado a un objeto, puede ir asociado a la clase en sí. Por ejemplo el método new (se llama para crear una nueva instancia, por lo cual la instancia no puede existir). Otro ejemplo: para crear nuevas canciones, podemos detectar si existe el hardware necesario, de otra manera no tendría sentido crear el nuevo objeto: class Song MAX_SAMPLE = 192 def Song.detectHardware # ... end def play # ... end end if Song.detectHardware Song.new('mysong') # otras formas de declarar métodos de clase: class Demo def Demo.meth1 # ... end def self.meth2 # ... end class <<self def meth3 # ... end end end

  Lectura y escritura de atributos: class Song def initialize(artist, duration) @artist = artist @duration = duration end # equivalente def artist @artist end def duration @duration end #equivalente attr_reader :artist, :duration attr_writer :duration #equivalent def duration=(new_duration) @duration = new_duration end song = Song.new("Bicylops", "Fleck", 260) puts song.duration song.duration = 257 # set attribute with updated value puts song.duration

  Herencia class KaraokeSong < Song # KaraokeSong hereda propiedades y métodos de Song def initialize(name, artist, duration, lyrics) super(name, artist, duration) # envía las variables a la clase superior @lyrics = lyrics end def to_s 'Karaoke ' + super + " [#@lyrics]" # en este caso super recoge el valor devuelto por to_s en la clase superior end end song = KaraokeSong.new("My Way", "Sinatra", 225, "And now, the...") puts 'song.to_s (karaoke): ' + song.to_s # song.to_s (karaoke): Karaoke Song: Bicylops, Fleck (260) [And now, the...]

  Control de acceso

  Métodos Públicos: Puede ser llamado por cualquiera. Es el acceso por defecto, escepto initialize que es siempre privado.

  Métodos Privados: Sólo pueden ser llamados por la propia clase o subclase, y quien recibe su valor es siempre self (la instancia que llama al método).

  Métodos Protegidos: Sólo pueden ser llamados por la propia clase o subclase, pero su valor puede ser recivido por otro que no sea self, como otras instancias de la clase. class MyClass def method1 # default is 'public' #... end protected # subsequent methods will be 'protected' def method2 # will be 'protected' #... end private # subsequent methods will be 'private' def method3 # will be 'private' #... end public # subsequent methods will be 'public' def method4 # and this will be 'public' #... end end # equivalente class MyClass def method1 #... end # ... and so on public :method1, :method4 protected :method2 private :method3 end

  Errores y escepciones

  Éste sería el código original.

  op_file = File.open(opfile_name, "w") while data = socket.read(512) op_file.write(data) end

  Para manejar escepciones y errores meteremos el código en una clausula begin, y manejaremos el error con la clausula rescue. Rescue puede manejar distintos tipos de errores, pertenecientes a la clase Esception. En éste caso nos interesa error de sistema. Cuando un error ocurre, rescue guarda en la variable global $! una referencia a ese error. Al terminar llamamos a raise para lanzar la escepción (detiene la ejecución). op_file = File.open(opfile_name, "w") begin # Exceptions raised by this code will # be caught by the following rescue clause while data = socket.read(512) op_file.write(data) end rescue SystemCallError $stderr.print "IO failed: " + $! op_file.close File.delete(opfile_name) raise end

  Otras formas de utilizar raise: raise raise "Missing name" if name.nil? if i >= names.size raise IndexError, "#{i} >= size (#{names.size})" end raise ArgumentError, "Name too big", caller

  Podemos manejar distintos tipos de errores y guardar sus referencias en variables de ésta forma: begin eval string rescue SyntaxError, NameError => boom print "String doesn't compile: " + boom rescue StandardError => bang print "Error running script: " + bang end

  Si no se encuentran errores podemos realizar alguna acción con else. Con ensure realizamos acciones hubiera o no errores. f = File.open("testfile") begin # .. process rescue # .. handle error else puts "Congratulations! no errors!" ensure f.close unless f.nil? end

  En el manejo de escepción modemos realizar algun cambio y volver a intertarlo con retry. begin # First try an extended login. If it fails because the # server doesn't support it, fall back to a normal login if @esmtp then @command.ehlo(helodom) else @command.helo(helodom) end rescue ProtocolError if @esmtp then @esmtp = false retry else raise end end

  Otro tipo de bloque es catch, que es ejecutado hasta que encuentra un trow, que puede estar o no dentro del catch. def prompt_and_get(prompt) print prompt res = readline.chomp throw :quit_requested if res == "!" res end catch :quit_requested do name = prompt_and_get("Name: ") age = prompt_and_get("Age: ") sex = prompt_and_get("Sex: ") # .. # process information end

  Organizando código. Archivos externos y modules

  Son una manera de agrupar métodos, clases y constantes, sin tener que formar otra clase. Su nombre sigue la misma convención que para las clases.

  Una forma sería guardar esas cosas en varios .rb, pero no funcionaría si tienen funciones con el mismo nombre. Los ficheros externos se cargan con load o require (sólo lo carga una vez).

  trig.rb module Trig PI = 3.141592654 def Trig.sin(x) # .. end def Trig.cos(x) # .. end end

  moral.rb module Moral VERY_BAD = 0 BAD = 1 def Moral.sin(badness) # ... end end

  cargando.rb require 'trig' # o trig.rb require 'moral' # o moral.rb y = Trig.sin(Trig::PI/4) wrongdoing = Moral.sin(Moral::VERY_BAD)

  También podemos cargar módulos con include. module Debug def who_am_i? "#{self.class.name} (\##{self.id}): #{self.to_s}" end end class Phonograph include Debug # ... end class EightTrack include Debug # ... end ph = Phonograph.new("West End Blues") et = EightTrack.new("Surrealistic Pillow") ph.who_am_i? ! "Phonograph (#935520): West End Blues" et.who_am_i? ! "EightTrack (#935500): Surrealistic Pillow"

  Para acceder a clases anidadas y modulos se usa el operador :: module NameSpace class Example CONST = 123 end end obj = NameSpace::Example.new a = NameSpace::Example::CONST

  Puedes agregar un modulo a un objeto con extend: module Humor def tickle "hee, hee!" end end a = "Grouchy" a.extend Humor puts a.tickle puts a

  hee, hee!
  Grouchy

  Trabajando con archivos

  Una buena forma de abrir archivos por medio de File.open que soporta bloques, de ésta manera el archivo se cierra automáticamente. El primer parámetro es el nombre del fichero y el segundo el modo de abrirlo, los más importantes son r (lectura), w (escritura), r+ (lectura-escritura), a (agregar). File.open("testfile", "r") do |file| # ... process the file end

  Lectura: File.open("testfile") do |file| while line = file.gets puts line end end # También con la clase IO # read into an array arr = IO.readlines("testfile") puts arr.length # 4 puts arr[0] // "This is line one\n"

  Escritura File.open("testfile","w") do |file| file.puts "Line 1" file.puts "Line 2" file.puts "Third and final line" end

  Agregar
  Si no utilizamos bloques tendremos que cerrar el archivo manualmente: file = File.open("testfile", "a") # Add a line at the end, then close. file.puts "New line..." file.close

  Lectura escritura con YAML

  Lo visto hasta ahora está bien para guardar cadenas sencillas, pero para guardar datos más complejos como arrays lo más ágil y versátil es utilizar YAML, que es una forma de representar datos, igual que XML, pero mucho más sencillo. require ' yaml ' # First we define these fancy methods... def yaml_save object, filename File.open filename, ' w ' do |f| f.write(object.to_yaml) end end def yaml_load filename yaml_string = File.read filename YAML::load yaml_string end # ...and now we use these fancy methods. test_array = [ ' Slick Shoes ' , ' Bully Blinders ' , ' Pinchers of Peril ' ] # Hey, time for some "me" trivia: # In Portland once, I met the guy who # played Troy ' s dad. True story. filename = ' DatasGadgets.txt ' # We save it... yaml_save test_array, filename # We load it... read_array = yaml_load filename # We weep for the po ' foo ' s that ain ' t got it... puts(read_array == test_array) #-> true

  Otra documentación

  Try Ruby: Explorarás online las características básicas de Ruby.
  Poignant Guide: Buena guía, pero quizá distrae con tanto chiste y parafernalia.

  Una lista muy buena de documentación disponible online está en la web de Ruby.