Joshi - Bitácora de aprendizajes

El diario público de una persona que le gusta aprender

Programita para valorar seguridad de contraseña | POO

Sigamos sufriendo con POO. La idea que se me ocurrió hacer esta vez es un programa que le pida al usuario su contraseña, y le responda que el nivel de seguridad de esta. Mis criterios de evaluación serán muy básicos.

Planeemos nuestro programa:

  1. Defino clase como HowSecurePass
  2. ¿Que variables de instancia crearé para el constructor? Se me ocurren las siguientes:
    • un array vacío para guardar la contraseña del usuario (cada elemento del array será un elemento de la contraseña)
    • @esLetra para almacenar el número de elementos de la contraseña que sean letras.
    • @esNumero para almacenar el número de elementos de la contraseña que sean números.
    • @esSimbolo para almacenar el número de elementos de la contraseña que sean símbolos
    • @calificacion Donde guardaré la ponderación de puntos que evalúan que tan segura es la contraseña
  3. Método para pedirle la contraseña al usuario, y guardarla en la variable userPass
  4. Método para evaluar la seguridad de la contraseña del usuario:
    1. Primero de pasar el string de la contraseña que metió al usuario al array
    2. Después, como primer rasgo, evaluaremos la longitud de la contraseña.
    3. inmediatamente procederemos a evaluar los elementos de la contraseña convertida en array:
      • Si el elemento es una letra, @esLetra aumenta 1
      • Si el elemento es un número, @esNumero aumenta 1
      • Si el elemento es un símbolo, @esSimbolo aumenta 1
  5. Imprimimos calificación y definimos un mensaje de acuerdo a la calificación obtenida:
    • Si el puntaje es 5, Tu contraseña es completamente segura
    • Si el puntaje está entre 2 y 4, Debes mejorar la seguridad de tu contraseña
    • Si es menor a 2, ¡Cambia esa contraseña!

Desarrollemos nuestro programa:

class HowSecurePass
	# Creando mi constructor con las siguientes variables
	def initialize
		@evaluatePass=[]
		@esLetra = 0
		@esNumero = 0
		@esSimbolo = 0
		@calificacion = 0
	end
	
	# Defino un método para recibir la contraseña del usuario
	def userPass
		print "Dame tu contraseña "
		gets.chomp
	end
	
	
	#Método para evaluar seguridad de la contraseña
	def evaluator(userPass)
		# Pasar el string de la contraseña al array @evaluatePass
		@evaluatePass = userPass.chars # El método chars se encarga de hacer el trabajito de la conversión ^^'
		puts @evaluatePass
		
		=begin
		 Para no hacerme bolas, la variable contarCaracteres guarda la contraseña
		 en string para poder contar el número de elementos, ahorita
		  que lo pienso, pude simplemente contar los elementos del array... Duuuuh!!
		=end
		contarCaracteres = userPass
		
		# Evaluamos la longitud de la contraseña
		case contarCaracteres.length
		when 9..Float::INFINITY
			puts "Longitud adecuada"
			@calificacion += 2
		when 5..7
			puts "Podrías hacerla mas larga"
			@calificacion += 1
		else
			puts "LONGITUD INADECUADA"
		end
		
		# Que cosa tan hermosa es el case, ni yo me lo creo, es muy simple de entender y trabajar.
		
		#Evaluamos los elementos que componen la contraseña
		# NOTA MENTAL: APRENDER REGEX
		# Para hacerlo usaremos each do, un ciclo iterativo para ir recorriendo cada elemento de nuestro array
		@evaluatePass.each do |elemento|
		if elemento.match?(/[a-zA-Z]/) # Verifica si el elemento es una letra 
			@esLetra += 1
		elsif elemento.match?(/\d/) # Verifica si el elemento es un dígito
			@esNumero += 1
		else # Si no es una letra ni un número, se considera un símbolo
			@esSimbolo += 1
		end
		
		end
		
		# Trabajamos con los puntajes y hacemos los comentarios correspondientes
		
		puts "Tu contraseña tiene letras" if @esLetra > 0; @calificacion += 1 if @esLetra > 0
		puts "Tu contraseña tiene numeros" if @esNumero > 0; @calificacion += 1 if @esNumero > 0
		puts "Tu contraseña tiene simbolos" if @esSimbolo > 0; @calificacion += 1 if @esSimbolo > 0

# ¡Pero que hermosa forma de hacer los IF's! Ruby permite  poner primero la expresión y luego el if, como si fuera una oración hablada "Escribe esto si pasa esto" eso es genial, el ";" permite hacer un salto de line invisible para escribir la siguiente linea de código en la linea actual. 



		# Damos calificación
		print "Tienes #{@calificacion} de calificación, por lo tanto creemos que "
		
		case @calificacion
		when 5 then puts "TU CONTRASEÑA ES COMPLETAMENTE SEGURA"
		when 2..4 then puts "DEBES MEJORAR LA SEGURIDAD DE TU CONTRASEÑA"
		else puts "CAMBIA ESA CONTRASEÑA YA!!"
		end
end


end

#Ya creamos nuestro molde, ahora creemos el objeto particular

nuevaContra= HowSecurePass.new
evaluar = nuevaContra.userPass
nuevaContra.evaluator(evaluar)

Me siento satisfecho, no sé aún que tan bien he aplicado la POO en este ejercicio pero siento que he progresado.

NOTA MENTAL: Procuraré entrenar mas arduamente para mejorar mis habilidades de programación ^^'

Sufriendo con POO

El paradigma de POO (Programación Orientada a Objetos) siempre ha sido un problema para mí, debido la instrucción desordenada que recibí y que yo he continuado en programación. En la escuela aprendí a moverme con soltura en PHP pero siempre desde el paradigma procedimental, declarando y guardando variables... pero el POO solo lo vi de manera abstracta (mejor dicho conceptual; exposiciones de clase) lo que siempre ha sido para mi un reto, porque en programación se aprende practicando.

En internet también encontrar material para ejercitarse como el que yo requería es difícil. Los ejemplos siempre son muy ¿Simples? ¿No aplicables? Soy un cabeza dura, lo reconozco, aprendo a base de equivocarme una y otra vez. Así que se me ocurrió que ya que estoy aprendiendo Ruby, resolver los problemas clásicos de programación pero siguiendo en la medida que pueda los lineamientos de POO.

¿Que haremos hoy?

Sistemita que devuelve cambio

Un usuario ingresa una cantidad en el prompt y el programa se encarga de devolverle esa cantidad en billetes y monedas de distintas denominaciones

Le tengo cariño a este ejercicio porque fue el primer ejercicio donde en verdad me entretuve mentalmente en la escuela y no en mi casa con libros de la biblioteca.

Planteomoslo en paradigma POO

NOTA No tengo formación académica que me respalde, todo lo que hago es lo que creo que es y luego a base de golpes y metidas de pata me voy corrigiendo, así que no duda de mi, lector anónimo.

En POO debemos pensar primero en crear un molde genérico del programa, del que después iremos creando objetos específicos.

*Ese molde se llama CLASE*

class DarEfectivo
	# Aquí todo el código del molde 

end

En Ruby, siempre que se crea un objeto nuevo, busca un método llamado initialize y lo ejecuta.

initialize vendría siendo lo que en otros lenguajes conocen como constructor citando a Wikipedia:

En Programación Orientada a Objetos (POO), un constructor es una subrutina cuya misión es inicializar un objeto de una clase. En el constructor se asignan los valores iniciales del nuevo objeto.

Entonces, hagamos nuestro constructor, en este caso las variables que inicializaré serán dos arrays donde estarán almacenados las denominaciones de billetes y monedas.

Repito, fue la forma en que yo resolví el ejercicio y la forma en la que, de momento, he entendido el concepto.

Quedaría de esta forma:

class DarEfectivo

	def initialize
		@billetes =[1000,500,200,100,50,20]
		@monedas = [10,5,2,1]
	end

end

¡Ya tenemos nuestro molde! Pero aun está incompleto. debemos darle métodos.

Yo lo entendí de esta forma:

Un objeto tiene atributos y métodos. los atributos son como sus características, los métodos, en cambio, son las acciones que el objeto puede realizar.

En este caso, ¿Que acciones debe realizar nuestra clase para poder ayudarle al usuario con su cambio?

  • recibir datos del usuario.
  • devolver esos datos en billetes y monedas de distinta denominacion.

Por tanto, esos serán los dos métodos que crearemos:

Método 1: recibir datos del usuario


class DarEfectivo

#constructor
	def initialize
		@billetes =[1000,500,200,100,50,20]
		@monedas = [10,5,2,1]
	end

	# recibir datos del usuario
	def cantidad
		print "Dame un cantidad: "
		gets.chomp.to_i
	end

end

Método 2: Devolver el resultado

Esta parte ya es mas familiar para mí ^^' y es que debemos resolver el ejercicio en sí. Le dí un par de vueltas (En la prepa lo resolvimos a bese de puro if y else anidado pues era el tema de la clase) y se me ocurrió usar each do que usamos con los números primos (NOTA MENTAL: convertir el programita de numeros primos a POO)

Lo que vamos a hacer es:

  1. Recorrer el array elemento por elemento (Comenzando con los de mayor denominación)
  2. Si la cantidad que ingresó el usuario es mayor o igual a la denominación del billete (elemento del array):
    1. obtener la cantidad de billetes de esa denominación que pueden acompletar la cantidad (una división entera)
    2. Si el resultado de esa división entera es mayor que uno, se imprimirá el texto “billetes de” (mas de un billete), de lo contrario se imprimirá el texto “billete de” (para ser mas agradable y natural al usuario)
  3. La variable cantidad se actualiza al resultado de la división modular entre el billete con el que se le aplicó la división entera. Es decir, obtener el sobrante, el cual se reutilizará con el siguiente elemento del array.
  4. Si la cantidad no es mayor o igual al elemento del array en el que se encuentre, se pasa al siguiente elemento.
  5. Cuando termine el array de @billetes, nos seguimos con el array de @monedas, que tendrá exactamente el mismo comportamiento que el anterior array.

Quizá en código se entienda mejor mi soliloquio ^^'

class DarEfectivo
# Constructor
def initialize
	@billetes =[1000,500,200,100,50,20]
	@monedas = [10,5,2,1]
end

# Recibir datos del usuario
def cantidad
	print "Dame un cantidad: "
	gets.chomp.to_i
end

# Devolver la cantidad en billetes y monedas de distinta denominación.
def cambio(cantidad)
	
	@billetes.each do |billete|
		if cantidad >= billete 
		print "#{cantidad.div(billete)} " 
		unless cantidad.div(billete) != 1 then puts "billete de #{billete}" else puts "billetes de #{billete}" end
		cantidad=cantidad % billete
		end
	end
	
	@monedas.each do |moneda|
		if cantidad >= moneda 
		print "#{cantidad.div(moneda)} " 
		unless cantidad.div(moneda) != 1 then puts "moneda de #{moneda}" else puts "monedas de #{moneda}" end
		
		end
	end
	
end



end

Podemos notar algo interesante a diferencia del anterior método, y es que en def cantidad no pasamos ningún parámetro, a diferencia de def cambio(cantidad). Esto de pasar parámetros significa que hay métodos que necesitan un parámetro externo para trabajar.

Ahora sí, hemos terminado nuestro molde. Hora de crear un objeto para que nuestro usuario interactué con él.

# Creamos un objeto llamado mi_efectivo, a partir de la clase DarEfectivo.new
mi_efectivo = DarEfectivo.new

# La variable cantidad_ingresada guardará el valor que el usuario escriba en el método cantidad, que mandamos a llamar desde nuestro objeto creado.
cantidad_ingresada = mi_efectivo.cantidad


# ejecutamos el método cambio pasándole el valor de la variable cantidad_ingresada
mi_efectivo.cambio(cantidad_ingresada)	

y ¡voila! nuestro programa funciona.

Programita para identificar números primos.

Se me está haciendo tedioso aprender por temas, empezaré a probar por retos. Es decir, hoy quiero crear un programita que me siga si un número es primo o no. Es obvio que usaré condicionales, A partir de ahí, no sé. Veamos como lo soluciono.


Condicional 1

Crear programa donde de acuerdo al número que nos escriba el usuario, el programa nos diga is este número es menor, igual o mayor a 10

print "Ingresa un número: "
num = gets.chomp.to_i  #Ruby lee el número, le quitamos los caracteres ocultos y lo convertimos a entero.

if num < 10 # Si num es menor que diez..
	puts "El numero es menor a 10" # imprimes esto
elsif num == 10 # De lo contrario, si num es identico a 10
	puts "El número es igual a 10" # imprimes esto
else # De lo contrario
	puts "el número es mayor a 10" # Haces esto
end

Muy simple ¿No?

Intentemos hacer los siguiente:

EJERCICIO Identificando números primos con lo aprendido.

Recuerdo la criba de Eratostónes como una forma de identificar números primos. Lo que quiero hacer es un programa donde yo inserte un número y me diga si es primo o no, para deducirlo iré dividiendo el número entre los primeros 10 números primos, si no es divisible entre ninguno de ellos, daremos por hecho que es primo (Solo para practicar)

Intento de Solución 1
# EJERCICIO-3-Condicionales-2.rb
# IDENTIFICANDO NÚMEROS PRIMOS

print "Dame un número: "
num = gets.chomp.to_i

#Haremos uso de la divisińn modular.

if num.modulo(2) != 0 && num.modulo(3) != 0 && num.modulo(5) != 0 && num.modulo(7) != 0 && num.modulo(11) != 0 && num.modulo(13) != 0 && num.modulo(17) != 0 && num.modulo(19) != 0 && num.modulo(23) != 0 && num.modulo(29) != 0 && num.modulo(31) != 0
puts "El número #{num} es primo." 
else
puts "El número #{num} NO es primo." 
# Hasta aqui todo bien, sin embargo, en caso de que no sea primo, quiero que me diga entre que números es divisible.

unless num.modulo(2) != 0 then puts "Porque es divisible entre 2" end
unless num.modulo(3) != 0 then puts "Porque es divisible entre 3" end
unless num.modulo(5) != 0 then puts "Porque es divisible entre 5" end
unless num.modulo(7) != 0 then puts "Porque es divisible entre 7" end
unless num.modulo(11) != 0 then puts "Porque es divisible entre 11" end
unless num.modulo(13) != 0 then puts "Porque es divisible entre 13" end
unless num.modulo(17) != 0 then puts "Porque es divisible entre 17" end
unless num.modulo(19) != 0 then puts "Porque es divisible entre 19" end
unless num.modulo(23) != 0 then puts "Porque es divisible entre 23" end
unless num.modulo(29) != 0 then puts "Porque es divisible entre 29" end
unless num.modulo(31) != 0 then puts "Porque es divisible entre 31" end



end

Funciona genial!!!! Pero no me gustan las ultimas lineas es repetitivo y aburrido, siento que debe haber otra forma “Mas elegante de resolverlo”. Se me ocurre hacerlo con arrays.

*Un arreglo o array es una lista ordenada de elementos de cualquier tipo.*

Se me ocurre guardar todos los elementos a dividir en un arreglo y después que solo se opere con todos sus elementos internos.

el arreglo tendría la siguiente forma:

divisores = [2,3,5,7,11,13,17,19,23,29,31]

Intento de Solución 2

# IDENTIFICANDO NÚMEROS PRIMOS

print "Dame un número: "
num = gets.chomp.to_i

#Haremos uso de la divisińn modular.

if num.modulo(2) != 0 && num.modulo(3) != 0 && num.modulo(5) != 0 && num.modulo(7) != 0 && num.modulo(11) != 0 && num.modulo(13) != 0 && num.modulo(17) != 0 && num.modulo(19) != 0 && num.modulo(23) != 0 && num.modulo(29) != 0 && num.modulo(31) != 0
puts "El número #{num} es primo." 
else
puts "El número #{num} NO es primo." 
# Hasta aqui todo bien, sin embargo, en caso de que no sea primo, quiero que me diga entre que números es divisible.

# Haré un array para hacer el recorrido de divisiones
divisores = [2,3,5,7,11,13,17,19,23,29,31]

divisores.each do |divisor|
	if num.modulo(divisor) == 0 then puts "Porque es divisible entre #{divisor}" end
end

Ahora funciona con menos líneas de código ^^'... ¡ Y hemos hecho nuestra primeras iteraciones!

El método each acepta un bloque de código y lo ejecuta por cada elemento de la lista que se ira mandando a llamar con la variable definida entre los || (algunos les dicen pipes, no sé como se llaman realmente estos símbolos)

es decir: Por cada elemento en la lista, divisor va tomando su valor y se ejecuta la expresión > if num.modulo(divisor) == 0 then puts “Porque es divisible entre #{divisor}” end

Me ha entrado la curiosidad ¿Podría usar el array, y el método each para hacer mas elegante el if?

Intento de Solución 3

Conseguí esto:

# IDENTIFICANDO NÚMEROS PRIMOS

print "Dame un número: "
num = gets.chomp.to_i

#Haremos uso de la divisińn modular.

# Haré un array para hacer el recorrido de divisiones
divisores = [2,3,5,7,11,13,17,19,23,29,31]
variableContador = 0
divisores.each do |divisor|
	if num.modulo(divisor) == 0 then puts "Es divisible entre #{divisor}" else variableContador += 1 end
end

if variableContador != divisores.count then puts "Por lo tanto el número #{num} NO es primo" else puts "El número #{num} es primo" end

Estoy seguro que debe haber soluciones mas elegantes, pero como un tipo al que la programación siempre le ha dado quebraderos de cabeza, me siento muy a gusto con el resultado ^^'

Convirtiendo cadenas de texto a números

Todo bien hasta ahora, sin embargo lo único que estamos haciendo es imprimir los valores que recibimos. Aún no operamos con ellos.

Supongamos que queremos crear un programa dónde nosotros le demos el precio neto de un producto, y el programa nos devuelva el precio con IVA (Impuesto de Valor Agregado), sabiendo que el IVA equivale al 16%... ¿Cómo podríamos hacerlo?

EJERCICIO-2-CalculadoradeIVA-v1-rb

print "CALCULADORA DE IVA\n"
IVA = 0.16

print "Dame un precio: "
precio = gets.to_f
# El método to_f es el que se encarga de transformar el string en un número flotante.

#imprimimos el precio neto
puts "PRECIO: $#{precio}"

#calculamos el impuesto
puts "IVA: $#{precio*IVA}"

#calculamos el precio final o precio al público
puts "PRECIO AL PÚBLICO: $#{precio + (precio*IVA)}"

Como podemos ver, gets por defecto lo que recibe del usuario los usa como una cadena, pero si mandamos a llamar to_f (to float. convertir a flotante) hace la conversión correspondiente, obvio, si es un número, si fuera un texto, por ejemplo “oso”, el valor generado de la conversión sería 0.

Dentro de puts o print podemos usar algo así como caracteres no imprimibles, por ejemplo:

  • “\n” que significa Salto de línea
  • “\t” que significa Tabulador

Juguemos con Ruby

Me auto-inventé el siguiente ejercicio:

Le pediremos al usuario algunos datos y con el armaremos un texto, los datos a solicitar son su nombre y su edad para registrarse en sistema “x”

Solución 1

print "REGISTRO DE USUARIOS \n Para poder continuar necesitaremos algunos datos suyos \n"
print "\t ¿Cuál es tu nombre?  "
nombre=gets()
print "\t ¿Cuantos años tienes?  "
edad=gets()
print "\t CARGANDO DATOS... \n "

print "Bienvenido #{nombre} al parecer tienes #{edad} años de edad. \n Ahora estás dado de alta en nuestro sistema \n BIENVENIDO"

Sin embargo, no me sentí a gusto con la salida.

REGISTRO DE USUARIOS 
 Para poder continuar necesitaremos alguno datos suyos 
	 ¿Cuál es tu nombre?  jorge
	 ¿Cuantos años tienes?  24
	 CARGANDO DATOS... 
 Bienvenido jorge  <<<<<<<<<<
 al parecer tienes 24  <<<<<<<<
 años de edad. 
 Ahora estás dado de alta en nuestro sistema 
 BIENVENIDO%    

¡Da un salto de línea, justo después de embeber la variable! ¿Por qué hace tal cosa?

Investigando al respecto aprendí lo siguiente:

  • gets() guarda los datos como string (cadena de texto) y, intentando ser bueno con nosotros Le agrega un \n al final por defecto (Recordemos que \n y \t son caracteres no imprimibles)

  • Esto lo podemos visualizar con p p es un método que nos permite visualizar justamente esos caracteres no imprimibles que puede haber en ciertos lugares

en el ejemplo anterior si agrego lo siguiente:

print "\t ¿Cuál es tu nombre?  "
nombre=gets()
p nombre

y al ejecutarlo escribiera “jorge” nos devolvería:

"jorge/n"

que es lo que en verdad se guardó en la variable nombre.

  • Para guiar los caracteres no imprimibles y hacer que el código se vea como yo quiera, usaremos gets.chomp que se encarga de quitar los caracteres no imprimibles a gets.

El código nos quedará entonces de la siguiente forma:

print "REGISTRO DE USUARIOS \n Para poder continuar necesitaremos alguno datos suyos \n"
print "\t ¿Cuál es tu nombre?  "
nombre=gets.chomp
p nombre
print "\t ¿Cuantos años tienes?  "
edad=gets.chomp
p edad
print "\t CARGANDO DATOS... \n "

print "Bienvenido #{nombre} al parecer tienes #{edad} años de edad. \n Ahora estás dado de alta en nuestro sistema \n BIENVENIDO"

y nuestra salida será la siguiente:

REGISTRO DE USUARIOS 
 Para poder continuar necesitaremos alguno datos suyos 
	 ¿Cuál es tu nombre?  jorge
"jorge"
	 ¿Cuantos años tienes?  12
"12"
	 CARGANDO DATOS... 
 Bienvenido jorge al parecer tienes 12 años de edad. 
 Ahora estás dado de alta en nuestro sistema 
 BIENVENIDO    

Dejé p en el código después de usar gets.chomp para ver como en esta ocasión nuestras variables aparecen sin caracteres no imprimibles.

Lo escribí hace unos meses después de una decepción amorosa. Es también una especie homenaje a Idea Vilariño, por la forma de los versos (cortos y contundentes). La poesía no es mi fuerte, pero eso no me quita las ganas de practicarla.

No será

No será,

No seremos,

la noche marca

una frontera infinita

entre nosotros hoy,

entre nosotros mañana

y siempre.

No será,

No seremos,

y el canto de la golondrina

se apaga.

Tu no estás

Yo no estoy,

Jamas estaremos...

Mi primera historia publicada. La cortedad tiene una excusa; el reto del certamen en el que participé era crear un cuento con exactamente 300 palabras. Felicitado por unos y detestado por más, fue mi primer acercamiento al mundo de la escritura. Este es el resultado. ___________

“Dime que eres tú...” me dice Bertha con sus ojos de mujer ilusionada. Respondo afirmativamente moviendo mi adolorida cabeza con dificultad. Ella sonríe satisfecha. Hemos desaparecido a Víctor sin dejar evidencias. Me pregunto cuántos amantes han logrado el mismo cometido a través de la historia, pero no recuerdo ninguno. Tal vez porque el crimen perfecto jamás se divulga.

La conocí en una feria de tecnología a la que Víctor asistía por motivos de trabajo. Los dos andaban por caminos distintos y Bertha se topó conmigo. “Conectamos”, y me llevó a su casa antes de que el llegara. “Jamás había hecho esto” me decía excitada, mientras la besaba con delicadeza... Curiosamente, le sorprendió más que le preparara un café y se lo llevara a la cama. “¿Dónde estabas hace quince años?” murmuró y me tomó de la mano para llevarme al armario. “No escapes” dijo. Y yo no escapé... Así, cuando su marido no estaba y ella tenía tiempo, escapaba del trabajo y disfrutaba de mí.

Cuando nadie estaba, yo exploraba las habitaciones, ordenaba sus pertenencias, y me conectaba a Internet para leer y aprender lo que quisiera... la tranquilidad me lo permitía. También descubrí que Víctor quería a Bertha, pero se había cansado de conquistarla. Siempre le regalaba algún detalle o le dejaba notas en cualquier lugar, diciéndole lo mucho que la amaba y que tuviera un buen día. Pero ella no devolvía el cariño que él le daba. Ella solo quería a alguien a su disposición, como yo. Por eso no me sorprendí cuando me dijo que lo matáramos. Yo le propuse algo completamente distinto, a lo que ella respondió de mala gana que mientras nos deshiciéramos de él, accedería.

Hoy, en la cena, Bertha colocó un sedante en la copa de Víctor. Puedo imaginar lo sucedido porque la conozco a la perfección. Nerviosa por su inexperiencia, tiembla a la hora quitar el cuero cabelludo con ayuda de tijeras y bisturí. Hace gestos a la hora de taladrar el cráneo, mientras algunas gotas de sangre manchan el piso y salpican su rostro y el libro de anatomía que compró para guiarse. Se asquea a la hora de enterrar mi circuito de conciencia en el carnoso cerebro de su esposo….

Ahora suspiramos los dos mientras destrozamos aquella piel de neopreno, esos órganos de polímero, los sensores emotivos y circuitos integrados. Ahora yo soy Víctor y siempre estaré a su servicio. ___________

Comencemos con el pie derecho aprendiendo Ruby, es decir, creando nuestro clásico Hola Mundo

1-HolaMundo.rb

puts 'Hello World'

Esto simplemente nos imprimirá en la consola cuando lo ejecutemos:

>>> ~ ruby HolaMundo.rb
Hello World

Podemos notar que puts nos funciona como un “muestra en pantalla lo siguiente”


Hagamos un programita mas complejo:

2-HelloName.rb

print('Escribe tu nombre: ')
name=gets()
puts("Hola #{name}")

En este caso el programita se encarga de pedirle al usuario su nombre con el método gets() el cual para poderlo usar lo guardamos en la variable name desúues lo imprimimos en pantalla con puts

En consola se vería mas o menos así:

>>> ~ ruby 2-HElloName.rb
Escribe tu nombre: Joshi
Hola Joshi

¿Cuál es la diferencia entre print y puts?

puts hace un salto de línea automático, mientras que print no.

PUTS

ejemplo-ImprimiendoConPuts.rb

puts "Hello World"
puts "How are you?"

Nos devuelve lo siguiente:

>>> ~ ruby ejemplo-ImprimiendoConPuts.rb
Hello World
How are you?

PRINT

ejemplo-ImprimiendoConPrint.rb

print "Hello World"
print "How are you?"

Nos devuelve lo siguiente:

>>> ~ ruby ejemplo-ImprimiendoConPrint.rb
Hello WorldHow are you?

¿Cuál es la gramática correcta?

Me sacó un poco de quicio ver que en el primer ejemplo se usa puts con comillas simples, mientras que mas abajo se uso con comillas dobles, y en otro caso tanto print como puts usaron paréntesis y dentro de ellos comillas dobles. ¿Cual es la forma correcta de escribir?

Investigando un poco descubrí que Ruby es un lenguaje muy permisivo pero tiene sus reglas, no tengo la verdad absoluta, recuerda que estoy aprendiendo pero por ahora podemos inferir lo siguiente:

  • Comillas simples y comillas dobles se pueden usar por igual, siempre y cuando no introduzcamos variables. Si usamos variables, las comillas simples nos imprimirán el texto tal cual sin distinguir la variable insertada, en ese caso lo correcto es usar comillas dobles. Es decir: Usar comillas dobles permite embeber o concatenar variables y quizá algunas otras cosillas interesantes. Las comillas simples, imprimen tal cual lo que hay dentro de ellas.
  • En el caso de los paréntesis no encontré mucho, quizá a futuro encuentre algo más

gets()

Es el método con el cual nosotros hacemos que Ruby reciba datos del usuario


#{name}

Es la forma de embeber o concatenar variables en Ruby, recordemos que para que funcione con puts debe estar dentro de comillas dobles.