#Esto es un comentario
def saludar(nombre)
puts "Hola #{nombre}"
End
También soporta muchas formas de hacer lo mismo:
saludar "Alex"
saludar("Jeison")
saludar("Pipe")
Ruby es un lenguaje de programación dinámico y de código abierto enfocado en la simplicidad y productividad. Su elegante sintaxis se siente natural al leerla y fácil al escribirla. - Página oficial de Ruby
\curl -sSL https://get.rvm.io | bash -s stable --ruby
identificador_var = 20 #Creación y asignación de la variable identificador_var = 20 * 2 #Modificación de la variable #Nótese que no hay ningún tipo lo que permite identificador_var = "Ya soy un string" #Antes era un número ############################################################### #################Tipos de datos básicos######################## soy_bool = true #Falso o verdadero, en este caso verdadero soy_bool = false #Ya no eres bool, eres falso # soy_entero = 1 soy_real = 2.34 # soy_string = "Hola" #Nótese que no hay caracteres pero se pueden simular # no_existo = nil #Valores vacíosOperaciones Las operaciones en Ruby dependen de los tipos de datos, pero son bastante intuitivas ya que se espera que hagan lo que representan los operadores.
soy_entero = 1 # => 1
soy_entero = 1 + 2 # => 3
soy_entero = soy_entero - 2 # => 2
soy_entero = soy_entero * 5 # => 10
soy_entero = soy_entero / 3 # => 3, arroja 3 porque los operandos son enteros
#####
soy_bool = true
ya_no_soy_bool = (!soy_bool) # La negación equivale al !
trabajo = true
duermo = false
trabajo_o_duermo = (trabajo or duermo) # true el "o" es una conjunción de matemática, es true si por lo menos uno de los involucrados es true caso contrario sería false
trabajo_y_duermo = (trabajo and duermo) # false el "y" es una disyunción de matemática, es true si los involucrados son verdaderos true caso contrario sería false
trabajo_o_exclusivo_duermo = (trabajo ^ duermo) # true el "o exclusivo".
duermo = true
trabajo_o_exclusivo_duermo = (trabajo ^ duermo) #false
##########
_1_mayor_que_2 = (1 > 2) #false
_2_mayor_que_1 = (2 > 1) #true
_1_menor_que_2 = (2 > 1) #true
_1_mayor_igual_2 = (1 >= 2) #false
_1_menor_igual_2 = (1 <= 2) #true _1_igual_a_2 = (1 == 2) #false _2_igual_a_2 = (2 == 2) #true
#Estas operaciones de comparación también aplican para Strings
string = "Hola" string = string + " mundo" # => Hola Mundo
string = "Soy Alex y tengo #{20 + 2} años" #Interpolación de Strings
Condicionales
Los condicionales son preguntas que se hacen con los datos que se tienen en el programa para cambiar el flujo del mismo, por ejemplo si pasa esto y esto, haga esto. Los condicionales en Ruby son bloques de código, es decir comienzan por una definición y terminan en un end.
a = 2 b = 3 if a > b #Se puede hacer cualquier pregunta siempre y cuando retorne un bool o se puede evaluar a bool puts "A es mayor" end #También hay forma de tener en cuenta muchos más casos if a > b puts "A es mayor" elsif a < b #Sino si b mayor que a puts "B es mayor" else puts "A y B son iguales" endCiclosComo la mayoría de lenguajes, Ruby tiene dos ciclos básicos como el for y el while. El for ejecuta todas las instrucciones programadas en el bloque teniendo un fin "asegurado". En cambio el while es un ciclo que puede o no terminar, dependiendo de las condiciones que el programador indique.
#FOR for i in 1..20 puts i # 1 2 3 4 ... 19,20 end #WHILE i = 1 while i <= 20 puts i # 1 2, 3 , 4 ... 20 i += 1 # i = i + 1 end #UNTIL == While not i = 1 until i > 20 puts i # 1 2, 3 , 4 ... 20 i += 1 endFunciones Las funciones son bloques de código que se pueden reutilizar, comunmente estas reciben parametros y ejecutan operaciones sobre estos devolviendo un resultado. Ruby siempre retorna un valor aunque sea nil. Para retornar un valor en Ruby simplemente se ejecuta la operación return o se especifica el valor en la última línea de código que se ejecuta.
def nombre_funcion(parametro_1, parametro_2) # Retorna vacio(nil)
puts "#{parametro_1} #{parametro_2}"
end
def suma(a,b)
return a + b
end
def resta(a,b)
a - b #No es necesario el return
end
array = [1, 2, 3, 4, 5] array.each do |num| puts num # 1 ,2 , 3, 4, 5 end puts array[1] # => 2 acceso directo por indices comenzados desde 0 array[1] = 20 puts array[1] # => 20Hash Los Hash son estructuras de datos "parecidos a los vectores"; estos relacionan un parejas de datos, es decir un valor A me entrega un Valor B. Los valores A pueden ser de cualquier tipo, ya que estos son convertidos a números por el algoritmo hash.
hash = {}
hash[1] = 20
hash[20] = 2000
puts hash[1] #20
puts hash[2] #nil
puts hash[20] #2000
hash = {1 => 3, 2 => 5, 3 => 7, 4 => 11, 5 => 13}
hash.each do |key, value|
puts "#{key} => #{value}" #1 => 3, 2 => 4 ....
end
Lambda
Los lambda son bloques de código parecidos a las funciones, sin embargo estas son tipos de datos que pueden ser pasados a las funciones como parametros.
l = lambda do |string|
if string == "try"
return "There's no such thing"
else
return "Do or do not."
end
end
puts l.call("try")
[maxbutton id="3" url="https://platzi.com/cursos/ruby-on-rails/?utm_source=blog&utm_medium=cta_curso&utm_campaign=blog-ruby"]
