sintaxis

[Ruby] – Sintaxis Básica y semántica

Ya hemos comentado que Ruby es un lenguaje interprete, orientado a Objetos, ágil (es “maleable”, fácil de refactorizar) y de muy alto nivel (VHLL), el principio que subyace al desarrollo con este lenguaje es, que la computadora debería trabajar para el programador, esto significa que operaciones complejas y sofisticadas pueden ser realizadas con relativa facilidad en comparación con lenguajes de más bajo nivel.
Vamos a conocer la sintaxis y semántica básica de este lenguaje, aprenderemos las palabras reservadas, identificadores, comentarios, precedencia de operadores, estructuras de control, condicionales, ciclos, etc.


Keywords e Identificadores

Las palabras reservadas en Ruby no pueden utilizarse para otros propósitos que los definidos en el lenguajes estos son:
Ruby_keywords
Las variables y otros identificadores normalmente comienzan con alguna letra del afabeto o algún modificador especial, pero siempre debe seguir estas reglas:
  • Variables locales (pseudovariables como self o nil) deben comenzar con una letra minúscula o el caracter underscore (_).
  • Variables globales deben comenzar con el signo dólar ($).
  • Variables de instancia (las que están dentro de un objeto) deben comenzar con el signo arroba (@).
  • Variables de clase (dentro de una clase) deben comenzar con 2 signos arroba (@@).
  • Constantes deben comenzar con la primera letra en mayúscula.
  • Cuando se quiera formar identificadores, el underscore (_) puede ser utilizado como letra minúscula.
  • Variables especiales comienzan con el signo dólar ($) como por ejemplo $1 o $/.

1
2
3
4
5
6
7
8
9
10
11
12
#variables locales
alpha, _ident, some_var
#Pseudovariables
self, nil, __FILE__
#Constantes
K6chip, longitud, LONGITUD
# Variables de Instancia
@foobar, @thx1138, @NO_CONST
#Variable de Clase
@@pi, @@mi_var, @@NO_CONST
# Variables globales
$beta, $B12vitamina, $NO_CONST

Comentarios y documentación embebida

Los comentarios en Ruby comienzan con el signo (#) , el interprete considera como comentario todo lo que viene después de este signo hasta el final de línea. Claro los comentarios no deben estar declarados entre otras sentencias de Ruby, por que no serían considerados como tal, sino como parte de la sentencia. Por ejemplo:
1
2
3
x = y + 5  # Esto es un comentario.
# Otro comentario.
print "# Pero esto no lo es."
La documentación embebida tiene como finalidad ser procesada por alguna herramienta de procesamiento externo, Para el interprete, son comentarios adicionales que no analizará. Esta documentación se encierra entre las lineas =begin y =end, todo lo que se encuentre entre estas lineas (inclusive) es ignorado por Ruby, no les debe preceder espacios en blanco. Por ejemplo
1
2
3
4
=begin
Este Párrafo es de comentarios
y se toma como tal.
=end

Operadores y su Precedencia

En ruby los operadores y su precedencia son:
ruby_scope
Algunos operadores se utilizan para más de un propósito, por ejemplo, el operador << realiza desplazamiento de bits a la izquierda, pero también funciona para añadir en elementos como arrays, strings,etc.

Estructuras de control


Sentencias condicionales

En Ruby las sentencias condicionales se pueden expresar de 2 formas, La forma “if” y la forma “unless”. La diferencia entre estas es simple, mientras una sentencia con “if” se ejecuta si se cumple la evaluación, una sentencia con “unless” se  ejecutará si la evaluación no se cumple.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# If
if x < 5 then
sentencia1
end

#unless
unless x >= 5 then
sentencia1
end

#If /else
if x < 5 then
sentencia1
else
sentencia2
end

# unless / else
unless x < 5 then
sentencia2
else
sentencia1
end
La sentencia “case” es más poderosa que en muchos lenguajes, permitiendo probar otras  condiciones aparte de la igualdad, por ejemplo expresiones regulares.
1
2
3
4
5
6
7
8
9
10
11
case "Esto es un string."

when "algun valor"
puts "Rama 1"
when "otro valor"
puts "rama 2"
when /char/
puts "Rama 3"
else
puts "Rama 4"
end

Ciclos

Ruby  aparte de los tradicionales “for”, “while” y “until”, existen otras maneras de iterar.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
# (while)
i=0
while i < list.size
do
print "#{list[i]} "
i += 1
end

#(until)
i=0
until i == list.size
do
print "#{list[i]} "
i += 1
end

#(for)
for x in list
do
print "#{x} "
end

# ('each')
list.each
do |x|
print "#{x} "
end

# ( método 'loop')
i=0
n=list.size-1
loop do
print "#{list[i]} "
i += 1
break  if i > n
end

# (Otro método 'loop')
i=0
n=list.size-1
loop do
print "#{list[i]} "
i += 1
break unless i

#('times')
n=list.size
n.times do |i|
print "#{list[i]} "
end

#('upto')
n=list.size-1
0.upto(n) do |i|
print "#{list[i]} "
end

#(for)
n=list.size-1
for
i in 0..n do
print "#{list[i]} "
end

#('each_index')
list.each_index do |xt
print "#{list[x]} "
en-ld

Excepciones

Ruby también soporta excepciones, son utilizadas para manejar errores , la sentencia Raise captura las excepciones que se generan al ejecutar métodos que puedan generar error, nota que Raise no es una palabra reservada, pero es un método del Kernel. Los siguientes son ejemplos de captura de errores en Ruby.
1
2
3
4
5
6
raise
raise "Un mensaje de error"
raise ArgumentError
raise ArgumentError, "Informacion equivocada"
raise ArgumentError.new("Informacion equivocada")
raise ArgumentError, "Informacion equivocada", caller[0]
En el código anterior vemos diferentes tipos de captura, el primer ejemplo se re-captura la última excepción generada, el segundo ejemplo se genera un error de Runtime (Error por defecto) utilizando un mensaje.
El ejemplo 3 se genera un error de tipo ArgumentError, en el ejemplo 4 el mismo error es generado con un mensaje asociado a el, el ejemplo 5 es similar al anterior y por útlimo el ejemplo 6 agrega información del array llamado “caller” el cual contiene información de la línea, archivo y método.
Para manejar las excepciones, las incluimos dentro de bloques begin-end, su sintaxis es de la forma:
1
2
3
4
begin
# algo que hacer.
# ...
end
Las excepciones no contienen valores que se puedan capturar, podemos definir tantas clausulas rescuecomo deseemos que en el momento de producirse un determinado error, Ruby se encargará de pasar el control al rescue apropiado.
1
2
3
4
5
6
7
begin
x = Math.sqrt(y/z) # ...
rescue ArgumentError
puts "Error calculando la raiz  cuadrada."
rescue ZeroDivisionError
puts "Se ha intentado dividir por cero."
end
Podemos modificar ligeramente el código anterior para imprimir que tipo de error nos genera.
1
2
3
4
5
begin
x = Math.sqrt(y/z)
rescue => err
puts err
end
Aquí la variable err se utiliza para guardar el valor de la excepción, si imprimimos esta variable, el contenido se traduce en una cadena que suministre alguna información útil.  Podemos utilizar la sentencia else, para denotar la captura de todas las demás excepciones que no incluyamos en el bloque begin-end.
1
2
3
4
5
6
7
8
9
begin
# metodo que puede generar el error
rescue Tipo1
# ...
rescue Tipo2
# ...
else
# Otras excepciones...
end
Muchas veces cuando se generan excepciones, deseamos re-intentar nuevamente la operación que ha fallado(esto es importante cuando ocurren problemas de conexión a bases de datos por caída de la conexión por ejemplo), para esto utilizamos la sentencia retry dentro del bloquerescue, permitiéndonos volver a ejecutar desde el principio del bloque begin.
1
2
3
4
5
6
begin
# metodo que puede generar el error...
rescue
# Intentamos recuperar...
retry
end
Por último, algunas veces es necesario escribir código que realice la limpieza después del bloque begin-end. Para asegurarnos de que esta “limpieza” se realice utilizamos la sentencia ensure, bien se genere la excepción o no, ensure  siempre se ejecutará.
1
2
3
4
5
6
7
begin
# metodo que puede generar el error...
rescue
# error
ensure
# codigo que se ejecuta siempre
end
Este pequeño resumen de la sintaxis y semántica de Ruby, nos da una idea del potencial que tiene este lenguaje de scripting. En sucesivas entregas profundizaremos en cada uno de estos aspectos para dominarlo totalmente.

0 comentarios:

Publicar un comentario