Guía de Vala

Versión 0.1

Autor

Varun Madiath

Agosto 8, 2010

Traductor

Juan Matías Olmos

Agosto, 2011

Licencia del documento original

Copyright ©2010 Varun Madiath

Permission is granted to copy, distribute, and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with Invariant Sections being “Preface”, with no Front-Cover Texts, and with no Back-Cover Texts.

Licencia de la traducción

Esta obra está bajo una licencia Creative Commons Atribución 2.5 Argentina

Usted es libre de:

Compartir – copiar, distribuir, ejecutar y comunicar públicamente la obra

hacer obras derivadas

hacer un uso comercial de esta obra

Bajo las condiciones siguientes:

Atribución – Debe reconocer los créditos de la obra de manera especificada por el autor o el licenciante (pero no de una manera que sugiera que tiene su apoyo o que apoyaron el uso que hace de su obra).

[…]

Aviso – Al reutilizar o distribuir la obra, tiene que dejar en claro los términos de la licencia de esta obra. La mejor forma de hacerlo es enlazar a la siguiente página (donde puede acceder a la versión completa de la licencia):

http://creativecommons.org/licenses/by/2.5/ar/

Contenido

Capítulo 1...............................................................................................4

Introducción..............................................................................................................4

Capítulo 2...............................................................................................6

Lo básico de Vala......................................................................................................6

Compilar el código...............................................................................................6

Comprender el código..........................................................................................7

Programando con Variables.................................................................................8

Un recorrido por la gramática básica de Vala....................................................11

Espacios en blanco.............................................................................................12

Comentarios.......................................................................................................12

Identificadores...................................................................................................12

Palabras clave....................................................................................................13

Literales.............................................................................................................13

Separadores.......................................................................................................14

Capítulo 1

Introducción

C es un lenguaje de programación de bajo nivel que puede ser ejecutado en una variedad de plataformas. Un lenguaje de bajo nivel es el que expone al programador al hardware donde se ejecutará el código. C viene con las librerías C estándar, las que en teoría permite a los programadores escribir código que puede ser compilado en diferentes sistemas operativos, y diferentes arquitecturas de procesador, para crear un archivo ejecutable que pueda ejecutarse en el sistema. Sin embargo, en la práctica, la librería estándar de C no es realmente portable a los diferentes sistemas operativos, y para solucionar esto se desarrolló la librería GLib.

GLib es una librería escrita en C diseñada para ser multiplataforma, y se usa como alternativa a la librería estándar. Además de proveer funcionalidades como imprimir texto en la pantalla y lectura de archivos, también provee un tipo de sistema que permite la implementación de clases, interfaces y objetos en C.

Vala es un lenguaje de programación diseñado para los desarrolladores GLib. El uso de Vala provee un montón de características presentes en otros lenguajes de programación de alto nivel pero de una forma que es simple y fácil de entender. Esto lo hace sin incorporar ninguna máquina virtual de ningún tipo, y por ello el código escrito puede ser compilado muy eficientemente.

Este lenguaje funciona convirtiendo el código Vala en código fuente C y archivos cabecera. Vala usa el sistema de tipos GObject de GLib para obtener las características de orientación a objetos. La sintaxis de Vala es similar a C# o Java, pero modificada para trabajar con el sistema de tipos GObject.

Algunas de las características que soporta Vala son:

• Interfaces

• Propiedades

• Señales

• Bucle foreach

• Expresiones Lambda

• Inferencia de tipo para variables locales

• Genéricos

• Tipo Non-null (no nulos)

• Gestor de memoria asistido

• Control de excepciones

Vala no incluye ninguna característica que no se puede realizar usando C con GLib, sin embargo hace el uso de estas mismas características de forma más simple. Una de las criticas más comunes de GLib es que resulta muy verboso y tiene un código desprolijo. Usando Vala, los programadores pueden evitarse escribir todo ese código verboso que requiere GLib.

Este lenguaje está diseñado para permitir el uso de librerías C fácilmente, en especial las librerías basadas en GObject. Todo lo que se necesita para usar una librería escrita en C es un archivo describiendo la API, estos archivos suelen usar extensión .vapi. Ésta es una diferencia con respecto a otros lenguajes que usan librerías en C, los cuales requieren un código especial, llamado binding, que une la funcionalidad del lenguaje con la librería en C. El problema con eso es que si una librería cambia, el binding tendría que ser reescrito antes de seguir siendo usado con la librería, dando como resultado que el binding esté un poco detrás de la implementación oficial.

Los programas escritos en C también pueden usar librerías de Vala sin ningún esfuerzo extra. El compilador de vala genera automáticamente los archivos cabecera requeridos, lo cual necesitan los programas en C para usar la librería. También es posible escribir bindings para Vala desde otros lenguajes como Python y Mono.

Se encuentra más información sobre Vala en:

http://live.gnome.org/Vala/

Capítulo 2

Lo básico de Vala

Comencemos a escribir programas usando Vala. El siguiente es un programa simple que muestra en pantalla las palabras Hola Mundo. Ingresa este código en tu editor de texto favorito y guárdalo en un archivo llamado holamundo.vala. Vala es un lenguaje que distingue mayúsculas de minúsculas, así que asegúrate de ingresar el código correctamente.

/* * holamundo.vala * * Este es un programa en Vala simple. * Se muestra en pantalla las palabras Hola Mundo */void main(string[] args) {    // La siguiente linea muestra en pantalla las palabras “Hola Mundo”.    stdout.printf(“Hola Mundo\n”);}

Compilar el código

Para compilar este programa, abre una terminal, ingresa al directorio donde guardaste tu archivo y escribe valac seguido del código fuente, como se muestra aquí.

$ valac holamundo.vala

Si no hubieron errores parecerá que no ocurrió nada. Sin embargo el compilador habrá creado un nuevo archivo ejecutable llamado holamundo. Puedes ejecutar este programa escribiendo su nombre precedido por ./ como se muestra abajo.

$ ./holamundo

Verás la siguiente salida.

Hola Mundo

Comprender el código

A pesar de su longitud, el programa «hola mundo» introduce varias de las características y conceptos usados en Vala. El programa inicia con las siguientes líneas:

/* * holamundo.vala * * Este es un programa en Vala simple. * Se muestra en pantalla las palabras Hola Mundo */

Esto es un comentario, un texto encontrado en el código fuente pero que el compilador ignora. Generalmente, un comentario se usa para describir la operación del programa, la razón detrás de algún código o una explicación del funcionamiento de una sección del mismo.

Este lenguaje usa dos tipos de comentarios. El comentario visto arriba se llama comentario multilínea. Se llama de esa forma porque ocupa varias líneas del código fuente. Este tipo de comentario inicia con los caracteres /* y finaliza con */, con todo lo que haya entre estos caracteres componen el comentario.

void main(string[] args) {

Esta línea define el método main(), el mismo contiene el código que se ejecuta cuando inicia el programa. Se entiende como un punto de partida para la ejecución del programa. Todas las aplicaciones en Vala (así como C, C++ y C# entre otros) inician ejecutando este método.

Cuando un programa es ejecutado por el sistema operativo, el mismo corre el código del método principal, y cuando el programa a terminado, puede devolver o no un número al sistema operativo. Este número puede ser usado para informar al sistema operativo si el programa termino sin problemas o si hubo alguno durante la ejecución. La palabra clave void de esta línea simplemente le dice al compilador que main() no retornará ningún valor. Todos los métodos pueden retornar un valor, como se verá más adelante.

Vala es un lenguaje que distingue mayúsculas de minúsculas, por lo que void no puede ser escrito como VOID o Void. El método main() debe ser escrito exactamente como es, cualquier cambio en la capitalización producirá un archivo que no se ejecutará. Esto es porque el compilador no vería un método llamado main(), y por ello el compilador asumirá que el código será usado en otro programa.

El último carácter de esta línea es la llave {. Esto señala el inicio del cuerpo de main(). Todo el código que comprenda un método estará entre una llave abierta y una llave cerrada.

Otro punto: main() simplemente es un punto de partida del programa. Un programa complejo tendrá docenas de clases, solo una de las cuales tendrá que ser el método principal main() para que las cosas puedan arrancar.

    // La siguiente linea muestra en pantalla las palabras “Hola Mundo”.

Esta línea es un comentario de línea simple, el otro tipo de comentario soportado en Vala. Un comentario de una sola línea comienza con los caracteres // y termina al final de la línea. Generalmente se usan para agregar explicaciones cortas en una línea de código en particular, mientras que los comentarios de múltiples líneas son usados para explicaciones más largas.

    stdout.printf(“Hola Mundo\n”);

Esta línea muestra en pantalla la cadena de caracteres “Hola Mundo”, seguida del carácter de salto de línea, que mueve la salida a la línea siguiente. El método printf() mostrado aquí es parte de GLib, una librería de la que Vala depende ampliamente. Este método mostrará en pantalla todo el texto que está entre paréntesis. La secuencia de caracteres especial \n representa el salto de línea.

Observa que la sentencia printf() termina con un punto y coma. Todas las sentencias en Vala terminan de esta forma. En este programa, la única sentencia es printf(), las otras líneas son comentarios, declaración de métodos, o líneas con solo caracteres como { o } llamados también descriptores de alcance.

Programando con Variables

Aunque el programa escrito arriba instruye a la computadora, no es muy útil ya que todo el programa es estático. El programa produciría la misma salida cada ejecución, y no hacía ningún cálculo. El concepto de variable es fundamental para hacer programas dinámicos. Una variable es solo el nombre de una cierta dirección de memoria, puede pensarse como una caja donde guardas datos. El dato dentro de una variable puede ser modificado durante la ejecución del programa, lo que le permite volverse dinámico.

El siguiente programa introduce algunos tipos básicos de variables que están disponibles en Vala.

/* * ejemplo_variable.vala * * Este programa muestra como usar variables, introduce algunos tipos de * ellas que están disponibles en Vala. */void main(string[] args) {    // Declaracion de variables    bool verdadero = false;    unichar letra = ‘v’;    int num = 10;    double punto_decimal = 15.33;    string nombre = “Alejandro Magno”;

    // Imprimiendo los valores de las variables    stdout.printf(verdadero.to_string() + “\n”);    stdout.printf(letra.to_estring() + “\n”);    stdout.printf(num.to_string() + “\n”);    stdout.printf(punto_decimal.to_string() + “\n”);    stdout.printf(nombre + “\n”);

    //Modificando una variable    num = num * 2;

    // Imprimiendo la variable modificada    stdout.printf(num.to_string() + “\n”);}

Puedes compilar y ejecutar el programa escribiendo.

$ valac ejemplo_variable.vala

$ ./ejemplo_variable

La salida se verá como la siguiente.

falsev1015.33Alejandro Magno20

Vamos a disecar este código para comprender como se generó esta salida.

    bool verdadero = false;    unichar letra = ‘v’;    int num = 10;    double punto_decimal = 15.33;    string nombre = “Alejandro Magno”;

Estas líneas crean variables y les asigna valores. Se crearon diferentes tipos de variables aquí. La variable bool representa un booleano, una variable que puede tener uno de dos posibles valores, true o false (serían verdadero o falso en español). La variable unichar representa un carácter de texto, por lo que casi cualquier carácter puede ser guardado en esta variable (si, esto incluye caracteres de escrituras Japonesas e Índicas). El carácter es encerrado con comillas simples para indicar que es un carácter y no un comando para la computadora. La variable int representa un entero (un número que no tiene punto decimal). La variable double representa un número de punto flotante (una variable que puede o no tener punto decimal) y finalmente una variable string que representa una serie (o cadena) de caracteres. Una cadena es encerrada con comillas dobles para indicar que el texto es una cadena.

Las variables de asignan con el operador =, con el nombre y tipo del operador del lado izquierdo y el valor del lado derecho. La forma general de una declaración de variable puede ser escrita como (el texto encerrado por corchetes es opcional).

type name [= value]

    stdout.printf(verdadero.to_string() + “\n”);    stdout.printf(letra.to_estring() + “\n”);    stdout.printf(num.to_string() + “\n”);    stdout.printf(punto_decimal.to_string() + “\n”);    stdout.printf(nombre + “\n”);

Estas líneas imprimen los valores de las variables en la pantalla. La impresión en la pantalla se hace usando el mismo método printf() que fue usado en el primer ejemplo. Notarás que en este caso, a la mayoría de las variables se le añade .to_string(). Esto se debe a que el método printf() debe dar una cadena para imprimir en pantalla. Por la misma razón, la variable string no lleva .to_string().

num = num * 2;

Esta línea modifica el valor de num asignándole un valor nuevo. El valor nuevo es dado por la expresión num * 2. Es importante no ver esto como una expresión algebraica, que no tendría sentido, sino como una asignación. Hay otro operador para igualdad, como veremos luego. Aquí, el valor de num es multiplicado por dos, y el resultado es almacenado en num.

stdout.printf(num.to_string() + “\n”);

Esta línea imprime el valor de num, como puedes ver en la salida, el valor a cambiado desde de la asignación de arriba.

Un recorrido por la gramática básica de Vala

Ahora hemos escrito dos programas pequeños en Vala, pero antes de seguir sería bueno mirar los elementos que componen el programa. Los diferentes elementos que componen un programa en Vala son:

• Espacios en blanco

• Comentarios

• Identificadores

• Palabras Clave

• Literales

• Operadores

• Separadores

Espacios en blanco

Vala es un lenguaje de formato libre. Eso significa que el código no necesita ser formateado de alguna manera en particular. Los programas que hemos escrito hasta aquí podrían ser condensados en una simple línea (con la excepción del comentario de línea simple). El único requisito es que cada símbolo esté separado por al menos un carácter de espacio, salvo que ya esté separado por algún separador u operador. Los separadores y operadores se verán más adelante también.

Comentarios

Ya hemos introducido los dos tipos de comentarios que soporta Vala, el comentario de una línea y el de múltiples líneas.

Es importante observar que la secuencia de caracteres */ no puede aparecer en tu comentario, ya que el compilador entenderá que se trata del final del comentario. Esto implica que un comentario en línea no puede ser colocado dentro de otro. En cuanto comiences a escribir programas más largos y complicados, desearás comentar secciones del código para tratar de seguir los rastros de posibles errores. En tales casos utiliza comentarios de líneas múltiples, esto no se recomienda si ya tienes comentarios de múltiples líneas en esa sección de código. Se recomienda usar un editor para anteponer // en cada línea de ese bloque para evitar cualquier problema. La mayoría de los editores traen una característica para realizar esto.

Identificadores

Los identificadores se usan para nombrar variables y métodos. En los programas que hemos escrito hasta ahora siempre escribimos el métodos main(), en este caso, el identificador es main. Todos los nombres de las variables del segundo ejemplo son identificadores. Otros identificadores menos obvios son stdout y printf, separados por un separador (el punto). Los identificadores de Vala solo pueden contener los caracteres A-Z, a-z, 0-9 o el guión bajo, además el primer carácter no puede ser un número.

Palabras clave

Vala tiene un conjunto de palabras que no pueden ser usadas como identificadores. Estas palabras son reservadas para expresar información sobre el programa al compilador.

La lista de palabras reservadas se muestra en la siguiente tabla:

if else switch case default do while

for foreach in break continue return try

catch finally throw lock class interface struct

enum delegate errordomain const weak unowned dynamic

abstract virtual override signal extern static async

inline new public prívate protected internal out

ref throws requires ensures namespace using as

is in owned delete sizeof typeof this

base null true false get set construct

default value construct void var yield global

Literales

Los literales son construcciones que representan valores en el programa. Un ejemplo de una constante sería el valor true, para un booleano, o Varun para una cadena. Aquí tenemos algunos ejemplos más:

• 1824

• 1858.58

• true

• false

• null

• “Alejandro Magno”

Los primeros literales representan un entero y un valor de punto flotante, el tercero y cuarto son constantes booleanas, el quinto es una constante nula y el último representa una cadena. Un literal puede ser sustituido por una variable en cualquier lugar donde una variable de ese tipo sea permitida. Si lees la lista completa de las

palabras reservadas, verás que los literales true, false y null también son palabras reservadas.

Separadores

Símbolo Nombre Objetivo

() Paréntesis Se usan para contener la lista de parámetros en la definición de un método y su invocación. También se usan para definir la prioridad en expresiones que los contenga. Finalmente, se usan para contener tipos de dato realizando lo que se llama casting de tipo estático.

{} Llaves Usadas para contener los valores de los arreglos inicializados automáticamente. También se usan para definir un bloque de código, para clases, métodos y alcances locales.

[] Corchetes Uso para declarar tipo de arreglos. También se usan para referenciar valores en arreglos.

; Punto y coma Termina una sentencia.

, Coma Separa identificadores consecutivos en una declaración de variables. También se usa para juntar las expresiones dentro de una sentencia for.

. Punto Usado para separar los nombres de paquetes y los nombres de subpaquetes y clases. También usado para separar una variable o método de variable de referencia.

Fuente de la traducción:

The Vala Guide, Varun Madiath, Version 0.1, August 8, 2010.