Programa - Nuevo pograma

# Este programa es un analizador de lo que se mete por teclado
# Arroja dos ficheros sentidos.txt y decisiones.txt
# En realidad es un interface entre la entrada y el paso analizador
=begin
Esta parte del programa es lo que capta por el teclado
Sería el sentido teclado
=end

puts 'Hola, ¿Cómo te llamas?'
STDOUT.flush
@p=gets.strip.to_s

$otro_origen = nil
#puts "esto es $otro_origen=#{$otro_origen}"
@ma=[]
@captado = []
@evaluados = []
@sentidos  = "sentidos.txt"
@evaluado = "evaluado.txt"
@nueva = []
@ahora = Time.now
@hora = @ahora.strftime("%H")
@minuto = @ahora.strftime("%M")
@segundo = @ahora.strftime("%S")
@dia = @ahora.strftime("%d")
@mes = @ahora.strftime("%m")
@year = @ahora.strftime("%Y")

def xf
if File.exist?(@sentidos)
puts
#puts "El fichero necesario #{@sentidos} existe"
else
puts "No existia el archivo y ha sido creado sin contenido"
f=File.new @sentidos,"a+"
#puts "El fichero necesario #{@sentidos} ya existe"
f.close
end

if File.exist?(@evaluado)
#puts "El fichero necesario #{@decisiones} existe"
else
puts "No existia el archivo y ha sido creado sin contenido"
f=File.new @evaluado,"a+"
puts "El fichero necesario #{@evaluado} ya existe"
f.close
end
end
xf

=begin
Esta parte del programa busca lo que capta por el teclado
en un fichero sentidos.txt
y si lo tiene nos informa y continúa
si no lo tiene procederá a guardarlo en el siguiente paso
=end
def primero
fab=File.open("sentidos.txt", "a+")
@l=0
fab.each do |a|
#puts "Esto es a = #{a} de la clase #{a.class} con longitud de #{a.size}"
@ma=a.split(" ")
#puts "Esto es @ma = #{@ma} de la clase #{@ma.class} con longitud de #{@ma.size}"
#puts "Esto es @ma[0] = "+@ma[0]+" de la clase #{@ma[0].class} con longitud de #{@ma[0].size}"
s=@ma[0].to_s
#puts "Esto es s = #{s} con longitud de #{s.size}"
#limpiamos el array @ma porque tiene comillas, coma y [
menos = s.size-2
@quiero = s[2...menos] #ahora sólo se queda con lo que interesa
#puts "esto es @quiero = #{@quiero} y ésto es @p = #{@p} de la clase #{@quiero.class}"
#puts "@l = #{@l}"
if @p === @quiero
#puts "HAY COINCIDENCIA y no grabaré el nombre"
@l=1
end
end
fab.close
#puts "                         @l = #{@l}"


case @l
when 0
puts "Esto es bueno o malo (escribe bueno o malo)"
STDOUT.flush
@primeraimpresion = gets.chomp.upcase.to_s
puts "has esxrito #{@primeraimpresion}"
if @primeraimpresion != "BUENO" || @primeraimpresion != "MALO"
puts 'lo tomaré como bueno'
@primeraimpresion = "BUENO"
end
@evaluados<<@primeraimpresion
@evaluados<<@p
@evaluados<<@hora
@evaluados<<@minuto
@evaluados<<@dia
@evaluados<<@mes
@evaluados<<@year



@captado<<@p
@captado<<@hora
@captado<<@minuto
@captado<<@segundo
@captado<<@dia
@captado<<@mes
@captado<<@year

puts 'Como no ha habido ninguna coincidencias lo grabo en sentidos.txt'
faa=File.open("sentidos.txt", "a+")
faa.print @captado
faa.puts
faa.close

puts 'Como no ha habido ninguna coincidencias lo grabo en sentidos.txt'
faaa =File.open("evaluado.txt", "a+")
faaa.print @evaluados
faaa.puts
faaa.close
when 1
puts "HAY alguna COINCIDENCIA y no grabaré nada en sentidos.txt"
@ll=1
end
end

puts "Hola #{@p}, son las #{@ahora.strftime("%H:%M:%S")} de la fecha #{@ahora.strftime("%d-%m-%Y")}"

primero

Teoría - Los bloques

Los bloques

http://rubytutorial.wikidot.com/bloques

Un bloque es una porción de código encerrada entre paréntesis {} o entre do…end. Es una forma de agrupar instrucciones, y solo puede aparecer después de usar un método: el bloque empieza en la misma línea que usa el método. El código dentro del bloque no es ejectuado en el instante que el intérprete de Ruby lo encuentra: Ruby recordará del bloque (variables locales, …) y después entra en el método, ejecutando el bloque cuando es preciso.

Supongamos que existen dos métodos llamados greet1 y greet2:

#greet1, no necesita argumentos
greet1 {puts 'Hola'}
 
#greet2, necesita un argumento
greet2 ("argumento_cualquiera") {puts 'Hola'}

Lo usual es usar las llaves para bloques de una línea y el do…end para más de una línea.

yield

Un método puede usar el bloque mediante la palabra yield:

def metodo
  puts 'Comienzo del metodo'
  yield
  yield
  puts 'Final del metodo'
end
 
metodo{puts 'Dentro del bloque'}

La salida es:

'Comienzo del metodo'
'Dentro del bloque'     # primer yield
'Dentro del bloque'     # segundo yield
'Final del metodo'

Lo que sucede es que en el momento que el intérprete llega al yield, se ejecuta el código dentro del bloque, y luego se retorna al método.

Argumentos en los bloques

En los bloques se pueden usar argumentos especificándolos dentro de dos barras verticales | |. Y si se usan, en el yield no podemos olvidar darles valor:

def metodo
  yield('hola', 99)
end
 
metodo{|str,num| puts str + ' ' + num.to_s}  #hola 99

Un bloque de código devuelve un valor: el valor de la última expresión evaluada. Y este valor devuelto por yield, 

Teoría - Los proc en Ruby

Los proc en Ruby

http://rubytutorial.wikidot.com/bloques

Los bloques no son objetos, pero pueden convertirse en ellos gracias a la clase Proc. Los objetos tipo proc son bloques que se han unido a un conjuto de variables locales. Esto se hace gracias al método lambda del módulo Kernel.

prc = lambda{ "hola" }

Un bloque creado con lambda actúa como un método: si no especificas el número correcto de argumentos, no puedes llamar al bloque. La clase Proc tiene un método para llamar al bloque: el método call

prc = lambda {puts 'Hola'}
prc.call #llamamos al bloque
 
#otro ejemplo
toast = lambda do
  puts 'Gracias'
end
toast.call

La salida es:

Hola
Gracias

Para usar argumentos con lambda:

aBlock = lambda { |x| puts x }  
aBlock.call 'Hola Mundo!'

La salida es:

Hola Mundo!

Los procs son muy útiles por que:

• No puedes pasar métodos dentro de otros métodos (usarlos como argumentos); pero si puedes usar procs como argumentos.

• Los métodos no pueden devolver otros métodos; pero sí pueden devolver un procs.

#uso de procs como argumentos
 
def metod1 proc1
  puts 'Principio del metodo'
  proc1.call
  puts 'Final del metodo'
end
 
hola = lambda do
  puts 'Hola'
end
 
metod1 hola

la salida es:

Principio del metodo
Hola
Final del metodo

Teoría - Operadores en Ruby

http://www.marcossarmiento.com/2015/09/15/operadores-en-ruby/

Operadores en Ruby

MARCOS SARMIENTO  15/09/2015 LEAVE A COMMENT

Los operadores en Ruby son elementos que relacionan de forma diferente, los valores de una o mas variables y/o constantes para manipular valores. Los operadores son de tres tipos: Aritméticos, Relacionales y Lógicos.

Operadores Aritméticos

Los operadores aritméticos permiten realizar operaciones matemáticas, entre dos variables y/o constantes. Todas las expresiones entre paréntesis se evalúan primero. Las expresiones con paréntesis anidados se evalúan de adentro hacia afuera, el paréntesis más interno se evalúa primero. Dentro de una misma expresión los operadores se evalúan en el siguiente orden:

Operador	Descripción
**	Exponencial
*, /, %	Multiplicación, división, modulo
+, –	Suma y resta

Ejemplo:

Exponencial

5 ** 2 (el resultado sera 25)
5 ** 3 (el resultado sera 125)

División

5 / 3 = 1 (la operación nos da como resultado 1, que seria el cociente de una división)

Modulo

5 % 3 = 2 ( la operación nos da como resultado 2, que es el resto o residuo de una división)

Los operadores en una misma expresión con igual nivel de prioridad se evalúan de izquierda a derecha.

Ejemplo:

5 * 5 / 6 = 4 (Primero se opera 5 * 5 que seria 25 y después se divide por 6 y nos daría 4)
6 / 5 * 5 = 5 (Primero se opera 6 / 5 que seria 1 y después se multiplica por 5 y nos daría 5)

En los dos ejemplos mostrados como los dos operadores tienen el mismo nivel de prioridad se evalúan de izquierda a derecha dándonos diferente resultado en dos operaciones aparentemente iguales.

Operadores Relacionales

Los operadores relacionales comparan valores entre sí, el resultado es verdadero o false (uno o cero).

Operador	Descripción
==	igual que
!=	diferente de
<	menor que
>	mayor que
<=	menor o igual que
>=	mayor o igual que

El operador == (igual que) es solo para realizar comparaciones, si deseamos asignar un valor a una variable debemos utilizar el operador = (igual)

Ejemplo:

a = 16
b = 61

a == b (el resultado sera falso, porque, 16 no es igual que 61)
a = b (el resultado de la variable a, ahora es 61, porque, se le ha asignado el valor de b)

Operadores Lógicos

Los operadores lógicos se utilizan para comparar dos expresiones y devolver un resultado booleano (verdadero o falso). Estos operadores unen estas expresiones devolviendo también verdadero o falso.

Operador	Descripción
&&, and	Y
||, or	O
!	No

Las expresiones conectadas con operadores && y || se evalúan de izquierda a derecha y la evaluación se detiene tan pronto como el resultado verdadero o falso es conocido.

Ejemplo:

Utilizamos el operador “and” para evaluar dos condiciones, solo si las dos son verdaderas obtendremos el mensaje “Mujer mayor de edad”.

En este ejemplo utilizamos el operador “or” para evaluar dos condiciones, si una de ellas es verdadera(se evalúan de izquierda a derecha) obtendremos el mensaje “Mujer mayor de edad”.

Como la primera condición es verdadera devuelve el mensaje “Mujer mayor de edad” a pesar que la segunda condición es falsa, porque se evalúa de izquierda a derecha y la evaluación se detiene tan pronto como el resultado es verdadero o falso.

Estos tres tipos de operadores se utilizan para el desarrollo de todo tipo de aplicaciones, elaboración de trabajos excel avanzado, operaciones matemáticas y la solución de todo tipo de problemas, es importante conocer a fondo este tema.

Teoría - Saber ruta en Ruby

@ruta=Dir.pwd

Teoría - GTK2

GTK2

require gtk2                                                                              0.- Requerir la gema gtk2

variable = Gtk::Window.new                                             1.- Crear la ventana

Contorno y/o interior                                                          2.- Definir ventana (como mínimo ésto)

variable.signal_connect("delete_event") do

    Gtk.main_quit

    false

end

window.border_width = 20                                                       

window.show  ó winsow.show_all                                  3.- llamar a la ventana.

Gtk.mail                                                                                     4.- Activar la ventana para que se muestre con Gtk.main

Teoría - / ó \ en las rutas????

/ ó \ en las rutas????

En windows es \ En Linux es /