Nuestra herramienta: GAMBAS

Introducción
Este míni-manual esta pensado y orientado para los asistentes al taller de Gambas. Dado que, a
priori, esperamos la asistencia de gente sin conocimientos previos de programación este texto va a
ser escueto y muy elemental.
Además de dar una formación teórica básica tiene el propósito de servir como chuleta para poder
consultar las sintaxis más elementales como por ejemplo de las condicionales, bucles, etc.
Nuestra herramienta: GAMBAS
Vamos a usar Gambas, un lenguaje de programación visual similar al Visual Basic de Microsoft.
Gambas dispone de su propio IDE. Un IDE, por sus siglas en inglés, es un entorno de desarrollo
integrado. Gambas es lo que se conoce como un lenguaje de programación interpretado y como
ocurre con GNU que es un acrónimo recurrente (Gnu No es Unix) Gambas significa Gambas
Almost Means BASic, que traducido al castellano es Gambas Casi es BASic.
Los IDE's son unos programas que aglutinan todo lo que necesitamos para programar. Tenemos un
editor para picar (vamos a ir introduciéndonos en la jerga del programador) código, con resaltado
por colores, autocompletado para ayudarnos en la edición, señalización de errores, etc. Un
depurador para poder controlar la ejecución del programa y evaluar su comportamiento con sus
inspectores de variables, objetos, etc. Un compilador para generar los binarios, bytecodes,
ejecutables, etc. Un empaquetador para crear los instaladores. Además disponen de otras
herramientas como gestores de servicios SVC para el control de versiones como GIT o similares.
Editores de conexión a bases de datos, etc.
Lo primero que vemos al ejecutar Gambas la ventana de bienvenida y nos da varias opciones, abrir
un proyecto existente, crear uno nuevo o abrir recientes. Seleccionamos la que necesitemos. Si
elegimos crear uno nuevo debemos completar algunos datos. Lo primero el tipo de proyecto, en
nuestro caso “Aplicación gráfica”. Después nos pide donde queremos guardar el proyecto, elegimos
la ubicación que más nos guste. Y por último un nombre para el proyecto y un título, el primero
debe ser una palabra sin espacios, el segundo podemos poner lo consideremos.
Pues ya está, ya tenemos nuestro proyecto. Pero y ¿que es todo esto? Pues vamos a poner una foto
con el nombre de cada cosa.
Empecemos a diseñar nuestra ventana, y esto es tan fácil como arrastrar los controles desde la
ventana de herramientas hasta el área de trabajo. ¿Fácil no?
Consideraciones, hay muchos controles, ordenados por categorías, pero para empezar solo algunos:
Los señalados en rojo son los más elementales. La “A”, es el control “Label” o etiqueta y con ellos
se hacen las típicas descripciones que encontramos al lado, por ejemplo de un cuadro de texto o
“TextBox” que es el cuadrado con la “abc”. Las etiquetas no son editables por el usuario, se pueden
cambiar sus propiedades únicamente en tiempo de edición o en tiempo de ejecución mediante
código. En cambio en los Textbox podemos escribir durante la ejecución, y se usan para la
introducción de datos al programa. El botón, el del “OK” se usa típicamente confirmar o iniciar la
ejecución de código.
En azul encontramos otros controles muy útiles pero en menos medida. El circulo se conoce como
“RadioButton” y se usa en casos donde necesitamos que el usuario elija entre varias opciones
excluyentes entre ellas, por ejemplo subir o bajar, no podemos hacer las dos a la vez. El cuadrado es
conocido como “CheckBox” y sirve para que el usuario elija opciones, podemos seleccionar más de
una, por ejemplo comer arroz y beber agua, podemos elegir las 2.
Bien, una vez tenemos los controles en nuestro formulario podemos cambiarles las propiedades,
incluido el propio formulario, desde la ventana de propiedades. Esto lo hacemos, primero para que
al iniciar tengamos una serie de cosas ya hechas, por ejemplo, muchos controles disponen de la
propiedad “text” donde podemos definir el texto que se mostrara de inicio en pantalla. Y segundo,
hay una propiedad que los primerizos no suelen tener en cuenta, la propiedad “name” nos permite
identificar los controles. Cuando los añadimos se numeran, con lo que al final si no cambias los
nombres seguirle la pista a “Label1”, “Label2”, “Label3”, ….., “Label50” es complicado saber cual
es cual. Podemos darle el nombre que queramos, pero es bueno tener un sistema, por ejemplo yo
uso 3 consonantes del control en minúsculas y un nombre descriptivo empezando en mayúscula,
para un “Textbox” donde queremos que el usuario introduzca un nombre usaría
“txtNombreUsuario”, y la etiqueta correspondiente sería “lblNombreUsuario”
A nivel de edición esto es lo más básico para empezar a usar el IDE, ahora vamos a empezar con la
chuleta de código.
Empezando con el código
Aquí está la madre del cordero, la parte de diseño es necesaria, pero sin el código no hacemos nada.
Así que vamos a ponernos al lío.
Lo primero que tenemos que saber es que hay una serie de palabras reservadas que no podemos usar
como identificadores. La ventaja es que los lenguajes de programación se orientan al inglés, con lo
que las palabras reservadas no nos afectarán mucho. Esencialmente se trata de las expresiones
reservadas para las instrucciones, como por ejemplo if, then, do, while, etc... o tipos de dato como
string, integer, long, etc.
Lo primero debemos saber que cada control tiene una serie de eventos. Los eventos son una especie
de “disparadores” de código. Los eventos se enmarcan en un bloque definido por las instrucciones
Public Sub y End. Estos bloques se conocen como métodos o subrutinas, de ahí lo de sub.
Cada control tiene un evento principal, para los botones es click o para las cajas de texto es keypress
(pulsación de tecla). Si en la ventana de edición hacemos doble click sobre un control nos moverá
automáticamente al código asociado al evento principal de ese control.
Si queremos cambiar el evento, solo tenemos que borrar hasta el “_”, el autocompletar desplegará
una lista con todos los eventos disponibles para ese control.
En la imagen anterior ya se puede apreciar otra característica, si queremos cambiar una propiedad
determinada de un control podemos acceder a ella mediante el “.”, con Label1.Text podemos
cambiar el texto que se mostrará en pantalla.
Para manejar datos necesitamos conocerlos. Los principales son Integer, para los enteros sin
decimales. Float, números con decimales. String para las cadenas de texto. Boolean para verdadero
o falso. Hay más, como por ejemplo Short para enteros cortos (hasta +/- 32.767) o Date para
almacenar fechas. En la documentación de Gambas podemos encontrar todos lo tipos disponibles.
Para usar los tipos de datos hemos de definir lo que se conoce como variables. Se usa un
identificador, de forma similar a los controles. Y se definen con las palabras reservadas Dim y as de
la siguiente manera Dim nombreVariable As Integer. Aunque no es obligatorio, ya que por defecto
se les asigna un valor, podemos inicializarla, esto es útil si el valor de base es diferente del que
viene por defecto y además lo conocemos. Esto nos ahorra una linea de código y se hace así Dim
nombreVariable As Integer = 23. Siempre tenemos que definirlas al principio del método donde
queramos usarlas.
Podemos cambiar el valor de las variables tantas veces como sea necesario, pero no podemos
cambiar el tipo de dato, esto es muy importante. Si asignamos un tipo de dato entero es entero y no
podemos cambiarlo. La división de 5 / 2 nos daría 2'5, pero la variable solo guardará el 2, la parte
entera de la división.
Podemos usarlas de forma circular, es decir podemos realizar la siguiente suma de un entero
“variable=variable + 3” y esto se puede hacer por que no realizamos la operación sobre la variable
sino que se asigna el valor tras la operación. Lo que realmente le estamos diciendo al programa es
coge el valor de variable y súmale 3, cuando acabes lo guardas en variable.
Existe otra figura, los arrays o matrices, y son colecciones de datos bajo un mismo identificador.
Los arrays pueden tener varias dimensiones y se definen casi igual que las variables, Dim variable
as Integer[] o Dim variable as Integer[3]. La diferencia entre ambas es que la primera tiene un
tamaño dinámico y la otra esta limitado a 3. Esto significa que bajo el identificador “variable”
podemos guardar hasta 3 valores enteros. Las dimensiones se definen con el número de [].
Las constantes son variables fijas. Sirven para definir datos fijos que conocemos de antemano, que
estamos seguros no van a cambiar y que vamos a usar de forma recurrente. Por ejemplo, el número
pi. Normalmente se declaran al principio del módulo o clase y con las palabras reservadas “Private”
o “Public” dependiendo del ámbito.
Los programas pueden ser realmente extensos y complejos. Los métodos pueden contener cientos
de líneas de código que llaman a a otros métodos y funciones, operaciones matemáticas, muchas
variables, etc. Por eso es importante comentar el código. Esto permite añadir líneas en código que
serán ignoradas por el compilador/interprete y ayudarán a leer el código posteriormente para futuras
actualizaciones o ediciones, por nosotros o por otras personas. En gambas, igual que en visual basic,
se utiliza el apostrofe sencillo “ ' ” para indicar un comentario.
Los número se ponen tal cual, no hay problemas. Pero para el uso de texto siempre tenemos que
entrecomillarlo. Igual que en la imagen anterior.
Manejando el flujo
El código se ejecuta de arriba hacia abajo, siguiendo escrupulosamente el orden de la lineas. Pero
eso no significa que no podamos manejarlo.
Para eso tenemos varias herramientas, la primera es el tipo de programación, bien modular o bien la
programación orientada a objetos. Tienen diferencias sustanciales entre una y otra, pero
esencialmente las dos dividen los fragmentos de código en bloques independientes y que se ejecutan
bajo demanda.
Después tenemos las estructuras de control de flujo que sirven esencialmente para dirigir la
ejecución hacia unos determinados fragmentos de código.
Respecto a la programación modular, solo decir que va implícita en gambas. Al hacer doble click en
un botón accedemos a la porción de código que se ejecutara única y exclusivamente si hacemos
click sobre ese botón en tiempo de ejecución. También podemos crearnos bibliotecas de métodos y
funciones para ser llamadas por el programa. La diferencia fundamental entre un método y una
función es que la segunda devuelve un resultado y la primera no.
La sentencia if then else, para mi es la instrucción más elemental. Conocida como instrucción
condicional evalúa una expresión, por ejemplo el resultado de una suma y si la condición se cumple
ejecuta el código, si no lo ignora.
If (2+2=4) then
ejecuta código
end if
Podemos, si queremos, asignarle un valor por defecto, por si la condición no se cumple.
If (2+2=4) then
ejecuta código 1
else
ejecuta código 2
end if
Podemos anidar diferentes instrucciones, unas dentro de otras.
If (2+2=5) then
ejecuta código 1
else If (2+2=4) then
ejecuta código 2
else
ejecuta código 3
end if
También podemos hacer evaluaciones complejas donde se evalúan varias condiciones como por
ejemplo.
If (2+2=4 AND 3-1=2 OR 10-10=0) then
ejecuta código 1
else
ejecuta código 2
end if
Incluso hacer que funcione con el resultado inverso.
If ( NOT 2+2=4 AND 3-1=2 OR 10-10=0) then
ejecuta código 1
else
ejecuta código 2
end if
Con esta simple instrucción podremos dominar el flujo del programa. Pero podemos encontrarnos
con algunos problemas de uso, o de eficiencia de uso. A veces una variable pueda adoptar muchos
valores. Por ejemplo los meses del año. Programar 12 condicionales anidadas puede ser dramático.
Para eso existen los selectores con la instrucción Select Case. Es una especie de lista de valores para
una expresión.
Dim mes as Integer
mes = obtiene el número del mes actual
Select mes
Case 1
Enero
Case 2
Febrero
Case 3
Marzo
…..
Case 12
Diciembre
End Select
En este caso también podemos asignarle un valor por defecto, igual que con el if.
Select mes
Case 1
Enero
Case 2
Febrero
Case 3
Marzo
…..
Case 12
Diciembre
Case else
No se el mes
End Select
En estos casos conocemos los posibles valores de las variables, pero puede que no sepamos el valor
que pueden tomar, por ejemplo las horas del día y si es mañana, tarde o noche. Para eso se pueden
usar los intervalos.
Case 7 to 12
Mañana
Podemos evaluar texto, no tiene por que ser un número. Se hace entrecomillando el “texto”.
Case “texto”
Es un texto
Con estas herramientas controlamos el flujo dentro del programa, método o función para que
ejecute un determinado código, pero podemos necesitar ejecutar un código varias veces por la razón
que sea. Por ejemplo para un contador o para que el programa compruebe que se cumple una
determinada condición sin la cual no se puede seguir. O por que necesitamos recorrer un texto
buscando algo. Existen varios hay que destacar for de entre los otros, ya que este se ejecuta para un
determinado número de repeticiones conocido de antemano.
FOR contador = 1 TO 20 STEP 3
ejecuta código
NEXT
En este caso el bucle contara de 1 a 20 a intervalos de 3, cuando contador pase de 20 dejara de
repetirse.
Después tenemos los bucles infinitos, estos se ejecutan mientras una determinada condición es
cierta. Ojo con estos bucles, nos metemos en infinito por menos de nada. Básicamente todos hacen
lo mismo, la diferencia entre ellos es el momento de evaluar la condición. While y Do While
evalúan la condición al inicio del bucle, lo que significa que si la condición es falsa no se ejecutara
nunca. La sintaxis de ambos es similar.
[Do While / While] contador <=10 ' La condición se evalúa aquí
ejecuta código
INC contador 'esto es igual que poner contador = contador +1
[Loop / Wend]
En este caso el bucle se repite mientras el contador es menor o igual que 10.
Podemos usar el bucle Do Until, en este caso la evaluación se realiza al final, lo que significa que el
código se ejecutara por lo menos una vez. Eso significa que debemos tener en cuenta las iteraciones
ya que para el mismo resultado que con la estructura anterior la condición a evaluar es distinta.
Do
ejecuta código
INC contador 'esto es igual que poner contador = contador +1
Loop Until contador= 11 ' La condición se evalúa aquí
En este caso el bucle se repite mientras el contador no sea igual 11, mientras sea menor se repetirá
por eso si ponemos <=10 como en el anterior solo se repetiría 1 vez, la condición se cumple en la
primera iteración (1 es menor que 10) y si ponemos = 10 solo lo haría 9 veces.
Glosario
En está última página tenéis un pequeño glosario para algunos conceptos que hay aquí.
Picar código: escribir código, programar.
Tiempo de desarrollo: Es el momento en el cual picamos código y podemos editar sus propiedades
de forma manual. Los errores en esta fase suelen ser de tipo sintáctico o tipográficos y
generalmente fáciles de corregir y localizar.
Tiempo de ejecución: Es cuando el programa se ejecuta de forma autónoma. Los errores en esta
fase suelen venir asociados a errores de programación, por ejemplo un uso incorrecto de datos y
generalmente difíciles de resolver, ya que no se ven fácilmente. Por ejemplo intentamos hacer una
división entre 0.
Depurador: Es una de las herramientas más útiles de IDE. Nos permite parar o reanudar la
ejecución del código. Evaluar las variables y los valores que contiene. Ejecutar paso a paso, etc.
Módulo: Es un archivo de código fuente, sin interfaz gráfica, donde programamos métodos y
funciones que vamos a usar de forma recurrente a lo largo de todo el programa. Tiene varias
ventajas, la primera es que de esta forma si hay que cambiar algo solo tendremos que modificar en
un sitio y no andar buscando por todo el código. Y la segunda es que como suelen ser funciones
genéricas podremos reciclarlas para otros proyectos.
Expresión: Son operaciones matemáticas, de concatenación, asignación de valores, etc.
Instrucción: Orden que se le da al programa para que haga algo.
Sentencia: El conjunto de una instrucción más una expresión.
Servicio SVC: Los servicios de control de versiones sirven para ayudar a los desarrolladores a
mantener un código limpio y estable. Estos servicios guardan los cambios producidos en el código
a lo largo del tiempo de forma que podemos recuperar cualquier estado previo. Son especialmente
útiles en grandes proyectos donde hay varios desarrolladores implicados.
Controles: Funcionalidades que el IDE nos facilita para poder hacer nuestro programa. Son
controles los botones, cajas de texto, la propia ventana, las etiquetas, etc.