Definición y Uso de Métodos

Introducción

En esta lección aprenderemos sobre la importancia de los métodos en la programación, cómo definir y utilizar métodos en Ruby, y cómo utilizar bloques, Procs, y Lambdas.

Definición de Métodos

Un método es un bloque de código que realiza una tarea específica. Los métodos son una parte fundamental de la programación orientada a objetos, ya que permiten reutilizar código y mantenerlo organizado.

En Ruby, los métodos se definen utilizando la palabra clave def, seguida del nombre del método y los parámetros que recibe. El cuerpo del método se define con un bloque de código que se ejecuta cuando se llama al método.

Uso de Métodos

Para llamar a un método en Ruby, simplemente escribimos su nombre seguido de paréntesis que contienen los argumentos que se le pasan al método. Por ejemplo:

def saludar(nombre)
  puts "Hola, #{nombre}!"
end

saludar("Juan") # Hola, Juan!

En este ejemplo, el método saludar recibe un argumento nombre y lo imprime en la consola. Al llamar al método saludar con el argumento “Juan”, se imprimirá “Hola, Juan!”.

Valores de Retorno

Los métodos en Ruby pueden devolver un valor utilizando la palabra clave return. Por ejemplo:

def suma(a, b)
  return a + b
end

resultado = suma(3, 5)
puts resultado # 8

En este ejemplo, el método suma recibe dos argumentos a y b, y devuelve la suma de los dos valores. Al llamar al método suma con los argumentos 3 y 5, se asigna el resultado a la variable resultado y se imprime en la consola.

Bloques, Procs, y Lambdas

En Ruby, los bloques, Procs, y Lambdas son formas de encapsular código y pasarlo como argumento a un método. Aunque tienen similitudes, también tienen diferencias importantes en su comportamiento y uso.

Bloques

Un bloque es un fragmento de código que se puede pasar a un método y ejecutar dentro de ese método. Los bloques se definen entre llaves {} o con la palabra clave do y end. Por ejemplo:

def ejecutar
  yield
end

ejecutar { puts "Hola, mundo!" } # Hola, mundo!

En este ejemplo, el método ejecutar recibe un bloque y lo ejecuta utilizando la palabra clave yield. Al llamar al método ejecutar con un bloque que imprime “Hola, mundo!”, se ejecutará el bloque dentro del método.

Procs

Un Proc es un objeto que encapsula un bloque de código y se puede almacenar en una variable para ser reutilizado. Los Procs se crean utilizando la clase Proc y el método proc o lambda. Por ejemplo:

saludar = Proc.new { |nombre| puts "Hola, #{nombre}!" }
saludar.call("Juan") # Hola, Juan!

En este ejemplo, se crea un Proc saludar que recibe un argumento nombre y lo imprime en la consola. Al llamar al Proc saludar con el argumento “Juan”, se ejecutará el bloque del Proc.

Lambdas

Un Lambda es similar a un Proc, pero con algunas diferencias en su comportamiento. Los Lambdas se crean utilizando la clase Proc y el método lambda. Por ejemplo:

saludar = lambda { |nombre| puts "Hola, #{nombre}!" }
saludar.call("Juan") # Hola, Juan!

En este ejemplo, se crea un Lambda saludar que recibe un argumento nombre y lo imprime en la consola. Al llamar al Lambda saludar con el argumento “Juan”, se ejecutará el bloque del Lambda.

Diferencias entre Procs y Lambdas

Las diferencias más importantes entre Procs y Lambdas son:

Los Lambdas comprueban el número de argumentos que se les pasan, mientras que los Procs no.
Los Lambdas devuelven el valor de la última expresión evaluada, mientras que los Procs devuelven el valor de la última expresión evaluada en el método que los contiene.

Ejemplo:

def ejemplo
  proc { return "Proc" }.call
  lambda { return "Lambda" }.call
  return "Método"
end

puts ejemplo # Proc

En este ejemplo, el método ejemplo contiene un Proc y un Lambda que devuelven un valor. Al llamar al método ejemplo, se imprimirá “Proc” porque el Proc devuelve el valor de la última expresión evaluada en el método que lo contiene.

Creación y Uso de Métodos

Para crear un método en Ruby, utilizamos la palabra clave def, seguida del nombre del método y los parámetros que recibe. El cuerpo del método se define con un bloque de código que se ejecuta cuando se llama al método. Por ejemplo:

def saludar(nombre)
    puts "Hola, #{nombre}!"
end

saludar("Juan") # Hola, Juan!

Métodos de Ruby

Ruby proporciona una serie de métodos integrados que se pueden utilizar para realizar tareas comunes. Algunos de los métodos más utilizados en Ruby son:

puts: Imprime un mensaje en la consola.

puts "Hola, mundo!" # Hola, mundo!

En este ejemplo, el método puts imprime “Hola, mundo!” en la consola.

gets: Lee una línea de texto de la consola.

puts "Por favor, ingresa tu nombre:"
nombre = gets.chomp
puts "Hola, #{nombre}!" # Hola, Juan!

En este ejemplo, el método gets lee una línea de texto de la consola y la asigna a la variable nombre.

chomp: Elimina el salto de línea al final de una cadena.

puts "Por favor, dime tu nombre:"
nombre = gets.chomp
puts "Hola, #{nombre}!" # Hola, Juan!

En este ejemplo, el método chomp elimina el salto de línea al final de la cadena leída por el método gets.

to_i: Convierte una cadena en un entero.

puts "Por favor, ingrese un número:"
numero = gets.chomp.to_i
puts numero + 1 # 6

En este ejemplo, el método to_i convierte una cadena en un número entero, que se puede utilizar en operaciones matemáticas.

to_f: Convierte una cadena en un número de punto flotante.

puts "Por favor, digite um número: "
numero = gets.chomp.to_f
puts numero + 1.5 # 6.5

En este ejemplo, el método to_f convierte una cadena en un número de punto flotante, que se puede utilizar en operaciones matemáticas con decimales.

to_s: Convierte un número en una cadena.

numero = 5
puts "El número es #{numero}" # El número es 5
puts numero.class # # Interger
numero = numero.to_s # Convertir a string
puts "El número es #{numero}" # El número es 5
puts numero.class # String

En este ejemplo, el método to_s convierte un número en una cadena, que se puede utilizar en la interpolación de cadenas.

length: Devuelve la longitud de una cadena.

cadena = "Hola, mundo!"
puts cadena.length # 12

En este ejemplo, el método length devuelve la longitud de la cadena “Hola, mundo!”.

reverse: Invierte una cadena.

cadena = "Hola, mundo!"
puts cadena.reverse # !odnum ,aloH

En este ejemplo, el método reverse invierte la cadena “Hola, mundo!”.

upcase: Convierte una cadena en mayúsculas.

cadena = "hola, mundo!"
puts cadena.upcase # HOLA, MUNDO!

En este ejemplo, el método upcase convierte la cadena “hola, mundo!” en mayúsculas.

downcase: Convierte una cadena en minúsculas.

cadena = "HOLA, MUNDO!"
puts cadena.downcase # hola, mundo!

En este ejemplo, el método downcase convierte la cadena “HOLA, MUNDO!” en minúsculas.

capitalize: Convierte la primera letra de una cadena en mayúscula.

cadena = "hola, mundo!"
puts cadena.capitalize # Hola, mundo!

En este ejemplo, el método capitalize convierte la primera letra de la cadena “hola, mundo!” en mayúscula.

split: Divide una cadena en un array de subcadenas.

cadena = "Hola, mundo!"
subcadenas = cadena.split(", ")
puts subcadenas # ["Hola", "mundo!"]
puts subcadenas[0] # Hola
puts subcadenas[1] # mundo!

En este ejemplo, el método split divide la cadena “Hola, mundo!” en un array de subcadenas.

join: Une un array de subcadenas en una sola cadena.

subcadenas = ["Hola", "mundo!"]
cadena = subcadenas.join(", ")
puts cadena # Hola, mundo!

En este ejemplo, el método join une el array de subcadenas en una sola cadena.

Ejercicios Prácticos

Crea un método que reciba un número entero y devuelva el cuadrado del número.

Ver respuesta

def cuadrado(numero)
  return numero * numero
end

puts cuadrado(5) # 25

En este ejemplo, el método cuadrado recibe un número entero y devuelve el cuadrado del número.

Crea un método que reciba un número entero y devuelva la suma de los dígitos del número.

Ver respuesta

def suma_digitos(numero)
  suma = 0
  while numero > 0
    suma += numero % 10
    numero /= 10
  end
  return suma
end

puts suma_digitos(123) # 6

En este ejemplo, el método suma_digitos recibe un número entero y devuelve la suma de los dígitos del número.

Crea un método que reciba una cadena y devuelva la cadena invertida.

Ver respuesta

def invertir(cadena)
  return cadena.reverse
end

puts invertir("Hola, mundo!") # !odnum ,aloH

En este ejemplo, el método invertir recibe una cadena y devuelve la cadena invertida.

Crea un método que reciba una cadena y devuelva la cadena en mayúsculas.

Ver respuesta

def mayusculas(cadena)
  return cadena.upcase
end

puts mayusculas("Hola, mundo!") # HOLA, MUNDO!

En este ejemplo, el método mayusculas recibe una cadena y devuelve la cadena en mayúsculas.

Crea un método que reciba una cadena y devuelva la cadena en minúsculas.

Ver respuesta

def minusculas(cadena)
  return cadena.downcase
end

puts minusculas("HOLA, MUNDO!") # hola, mundo!

En este ejemplo, el método minusculas recibe una cadena y devuelve la cadena en minúsculas.

Crea un programa en Ruby que contenga los siguientes métodos:
- saludar: Recibe un nombre y un bloque, y ejecuta el bloque pasando el nombre como argumento.
- sumar: Recibe dos números y un bloque, y ejecuta el bloque pasando la suma de los dos números como argumento.
- restar: Recibe dos números y un bloque, y ejecuta el bloque pasando la resta de los dos números como argumento.
- multiplicar: Recibe dos números y un bloque, y ejecuta el bloque pasando el producto de los dos números como argumento.
- dividir: Recibe dos números y un bloque, y ejecuta el bloque pasando la división de los dos números como argumento.

Ver respuesta

def saludar(nombre, &bloque)
  bloque.call(nombre)
end

def sumar(a, b, &bloque)
  bloque.call(a + b)
end

def restar(a, b, &bloque)
  bloque.call(a - b)
end

def multiplicar(a, b, &bloque)
  bloque.call(a * b)
end

def dividir(a, b, &bloque)
  bloque.call(a / b)
end

saludar("Juan") { |nombre| puts "Hola, #{nombre}!" } # Hola, Juan!
sumar(3, 5) { |resultado| puts "La suma es #{resultado}" } # La suma es 8
restar(8, 3) { |resultado| puts "La resta es #{resultado}" } # La resta es 5
multiplicar(4, 6) { |resultado| puts "El producto es #{resultado}" } # El producto es 24
dividir(10, 2) { |resultado| puts "La división es #{resultado}" } # La división es 5

En este ejemplo, se definen los métodos saludar, sumar, restar, multiplicar, y dividir que reciben argumentos y un bloque, y ejecutan el bloque pasando el resultado de la operación como argumento.

Crea un bloque que imprima un mensaje con el nombre recibido como argumento.

Ver respuesta

def saludar(nombre, &bloque)
  bloque.call(nombre)
end

saludar("Juan") { |nombre| puts "Hola, #{nombre}!" } # Hola, Juan!

En este ejemplo, se crea un bloque que imprime un mensaje con el nombre recibido como argumento.

Crea un bloque que imprima la suma de los dos números recibidos como argumento.

Ver respuesta

def sumar(a, b, &bloque)
  bloque.call(a + b)
end

sumar(3, 5) { |resultado| puts "La suma es #{resultado}" } # La suma es 8

En este ejemplo, se crea un bloque que imprime la suma de los dos números recibidos como argumento.

Crea un bloque que imprima la resta de los dos números recibidos como argumento.

Ver respuesta

def restar(a, b, &bloque)
  bloque.call(a - b)
end
restar(8, 3) { |resultado| puts "La resta es #{resultado}" } # La resta es 5

En este ejemplo, se crea un bloque que imprime la resta de los dos números recibidos como argumento.

Crea un bloque que imprima el producto de los dos números recibidos como argumento.

Ver respuesta

def multiplicar(a, b, &bloque)
  bloque.call(a * b)
end

multiplicar(4, 6) { |resultado| puts "El producto es #{resultado}" } # El producto es 24

En este ejemplo, se crea un bloque que imprime el producto de los dos números recibidos como argumento.

Conclusiones

En esta lección hemos aprendido sobre la importancia de los métodos en la programación, cómo definir y utilizar métodos en Ruby, y cómo utilizar bloques, Procs, y Lambdas. Los métodos son una parte fundamental de la programación orientada a objetos, ya que permiten reutilizar código y mantenerlo organizado. Los bloques, Procs, y Lambdas son formas de encapsular código y pasarlo como argumento a un método, y tienen diferencias importantes en su comportamiento y uso. Los bloques se definen entre llaves {} o con la palabra clave do y end, los Procs se crean utilizando la clase Proc y el método proc o lambda, y los Lambdas se crean utilizando la clase Proc y el método lambda. Los Procs y Lambdas se pueden utilizar para encapsular código y pasarlo como argumento a un método, y tienen diferencias en la comprobación de argumentos y el retorno de valores. En resumen, los métodos, bloques, Procs, y Lambdas son herramientas poderosas que nos permiten escribir código más limpio, modular, y reutilizable en Ruby.