PDF de programación - Taller 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 d