Vala

La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la versión revisada el 23 de octubre de 2018; las comprobaciones requieren 43 ediciones .
Vala
Semántica programación estructural , imperativa , orientada a objetos
clase de idioma lenguaje de programación orientado a objetos
Apareció en 2006
Autor Jürg Billeter, Raffaele Sandrini
extensión de archivo .valao.vapi
Liberar 0.56.3 [1]  (3 de septiembre de 2022 ) ( 2022-09-03 )
sistema de tipos estricto, estático
Implementaciones principales Proyecto de escritorio GNOME
sido influenciado C , C++ , Groovy , Java , C#
Licencia LGPL
Sitio web wiki.gnome.org/proyectos/…
sistema operativo multiplataforma
 Archivos multimedia en Wikimedia Commons

Vala  es un lenguaje de programación diseñado para la programación de aplicaciones y sistemas basado en las bibliotecas GLib Object System ( GObject ) del entorno de escritorio GNOME / GTK+ . El lenguaje fue desarrollado por Jürg Billeter y Raffaele Sandrini.

Características principales

Vala es muy similar en sintaxis a Java e implementa completamente el enfoque orientado a objetos . Admite introspección , inferencia de tipos , recolección de basura de conteo de referencias , funciones lambda , concepto de señales y ranuras similar a Qt , pero implementado a nivel de lenguaje, tipos de cadenas , programación genérica , división de matrices , operador de recolección foreach , delegados , cierres , interfaces , propiedades y excepciones .

Una característica del sistema de desarrollo es que el programa Vala se traduce a un programa C , que, a su vez, se compila en el código ejecutable de la plataforma de destino con bibliotecas C estándar , Glib y se ejecuta a la velocidad de la aplicación C compilada en el destino. código objeto de la plataforma . Para obtener código C traducible, debe especificar la opción -C en el compilador Vala. Si el programa tiene una interfaz gráfica de usuario , la biblioteca GTK+ se usa durante la compilación (opción --pkg gtk+-3.0 del compilador). Gracias a este enfoque, el código Vala compilado es binario compatible con las bibliotecas del sistema escritas en C. Para conectar bibliotecas de terceros a los programas Vala, se utilizan archivos vapi especiales que describen la interfaz de la biblioteca. Para muchas bibliotecas, ya hay archivos vapi incluidos en la entrega estándar del compilador Vala [2] . Además, existen archivos vapi para bibliotecas compatibles con usuarios de terceros, que aún no se incluyen en la distribución estándar [3] .

Hay compilaciones no oficiales del compilador de Windows mantenidas por terceros.

Motivos de creación

El lenguaje Vala fue creado para el desarrollo eficiente de aplicaciones complejas y aplicaciones de sistema en la plataforma GNOME con una interfaz gráfica de usuario basada en la biblioteca estándar GTK+ utilizando herramientas de lenguaje y técnicas de programación modernas.

El lenguaje orientado a objetos de Java proporciona suficiente potencia al programador, pero los programas se ejecutan en máquinas virtuales , lo que hace imposible acceder a ellos directamente desde el código binario C , así como el uso de bibliotecas de bajo nivel del sistema como GObject en dichos programas. Por tanto, este lenguaje, como cualquier otro que ejecuta bytecode en máquinas virtuales, no puede ser aceptado dentro de la plataforma GNOME . Las aplicaciones administradas también tienen limitaciones de rendimiento, lo cual es crítico para el funcionamiento de algunos programas (por ejemplo, de sistema) que deben ejecutarse en código binario ( ABI ). Esta fue la razón del surgimiento del nuevo idioma Vala.

Ejemplos de código

Ejemplo #1

Un sencillo programa " Hola, mundo "

void main () { print ( "Hola, mundo \n " ); }

Ejemplo #2

Programa " Hello, World " que demuestra un enfoque orientado a objetos

clase Muestra { void ejecutar () { stdout . printf ( "Hola mundo \n " ); } static int main ( cadena [] args ) { var muestra = nueva muestra (); muestra _ ejecutar (); devolver 0 ; } }

Ejemplo #3

Este es un ejemplo del uso de GTK+ para crear programas GUI en Vala:

utilizando GTK ; int principal ( cadena [] argumentos ) { Gtk . init ( argumentos de referencia ); varwindow = nueva ventana ( ); ventana _ título = "¡Hola mundo!" ; ventana _ borde_ancho = 10 ; ventana _ posición_ventana = PosiciónVentana . CENTRO ; ventana _ establecer_tamaño_predeterminado ( 350 , 70 ); ventana _ destruir _ conectar ( Gtk . main_quit ); var label = new Label ( "¡Hola, mundo!" ); ventana _ añadir ( etiqueta ); ventana _ mostrar_todo (); gtk . principal (); devolver 0 ; }

Aplicación

El lenguaje Vala se usa activamente para desarrollar aplicaciones para GNOME , en particular, para escribir aplicaciones fundamentalmente nuevas que satisfacen las necesidades de los usuarios de GNU Linux . El uso de Vala se está desarrollando:

  • Elementary OS es una distribución cuyos desarrolladores prestan gran atención al diseño del sistema.
  • Akira es una aplicación nativa de GNU/Linux que pretende ser la herramienta de desarrollo y creación de prototipos de UX para usuarios de software libre.
  • Geary - cliente de correo electrónico
  • Budgie es una GUI basada en GTK+
  • Gee - biblioteca de colecciones
  • Ambition : un marco web basado en el modelo MVC . Un ejemplo de creación de un blog simple.
  • Valum - Framework Web
  • VDA es un contenedor alrededor de la biblioteca GDA escrita en C que proporciona un conjunto único de API conectables definidas lo más genéricas posible para que se pueda acceder a cualquier tipo de fuente de datos ( bases de datos , servidores de información , grupos de correo) a través de ellos. Actualmente soporta SQLite (y SQLCipher), MySQL , PostgreSQL , MSAccess , Berkeley Db (y es una extensión de SQL), Oracle y JDBC (permite el acceso a cualquier base de datos a través del controlador JDBC ), se está trabajando para otros tipos de bases de datos.


Ejemplos de código extendido

Si tiene problemas para compilar el ejemplo, pruebe la última versión de Vala.

Características del lenguaje y ejemplos introductorios

Ejemplos básicos

Simple Hola, mundo:

void main () { print ( "Hola, mundo \n " ); }

Compilando y ejecutando:

$ valac hello.vala

$ ./hello

En el modo de secuencias de comandos:

# !/ usr / bin / vala print ( "hola, mundo \n " );

Ejecutar: haga que el archivo sea ejecutable use el comando vala (entonces la primera línea es opcional)

$ vala hello.vala

Lectura de la entrada del usuario vacío principal () { salida estándar . printf ( "Ingrese su nombre: " ); cadena nombre = stdin . leer_linea (); salida estándar printf ( @"¡Hola, $nombre! \n " ); } Leer y escribir en un archivo

Este es un procesamiento muy simple de archivos de texto. Para E/S avanzada, use las poderosas clases de flujo GIO .

vacío principal () { prueba { // Escribe cadena contenido = "hola mundo" ; FileUtils . set_contents ( datos . txt , contenido ); // Leer lectura de cadena ; FileUtils . get_contents ( nombre de archivo , fuera de lectura ); salida estándar printf ( @"El contenido del archivo '$filename' es: \n $leer \n " ); } captura ( Error de archivo e ) { stderr _ printf ( @"$(e.mensaje) \n " ); } } Procesos de desove void main () { try { // Proceso sin bloqueo . spawn_command_line_async ( "ls" ); // Bloqueo (espera a que termine el proceso) Proceso . spawn_command_line_sync ( "ls" ); // Bloqueo con cadena de salida standard_output , standard_error ; int exit_status ; proceso _ spawn_command_line_sync ( "ls" , out standard_output , out standard_error , out exit_status ); // imprime la salida del proceso exec stdout . printf ( salida_estándar ); } catch ( SpawnError e ) { stderr . printf ( "%s \n " , e . mensaje ); } } Ejemplo avanzado /* clase derivada de GObject */ public class AdvancedSample : Object { /* propiedad automática, el campo de datos está implícito */ public string name { get ; conjunto ; } /* señal */ señal pública void foo (); /* método de creación */ public AdvancedSample ( string name ) { this . nombre = nombre ; } /* método de instancia pública */ public void run () { /* asignando una función anónima como manejador de señales */ this . foo _ connect (( s ) => { stdout . printf ( "Expresión lambda %s! \n " , este . nombre ); }); /* emitiendo la señal */ esto . foo (); } /* punto de entrada de la aplicación */ public static int main ( string [] args ) { foreach ( string arg in args ) { var sample = new AdvancedSample ( arg ); muestra _ ejecutar (); /* "muestra" se libera cuando finaliza el bloque */ } return 0 ; } } Trabajando con cadenas
  • void println ( string str ) { stdout . printf ( "%s \n " , cadena ); } vacío principal () { /* Las cadenas son del tipo de datos 'cadena' y se pueden concatenar con el operador más * dando como resultado una nueva cadena: */ cadena a = "concatenado" ; cadena b = "cadena" ; cadena c = a + b ; imprimir ( c ); /* Si desea tener una cadena mutable, debe usar StringBuilder. * Con su ayuda, puede crear cadenas ad libitum agregando, * agregando, insertando o eliminando partes. Es más rápido que múltiples * concatenaciones. Para obtener el producto final se accede al campo * '.str'. */ var constructor = nuevo StringBuilder (); constructor _ agregar ( "construido" ); constructor _ anteponer ( "Cadena" ); constructor _ agregar ( "StringBuilder" ); constructor _ append_unichar ( '.' ); constructor _ insertar ( 13 , "por" ); println ( constructor . str ); // => "Cadena creada por StringBuilder". /* Puede crear una nueva cadena de acuerdo con una cadena de formato llamando al método * 'printf' en ella. Las cadenas de formato siguen las reglas habituales, conocidas de * C y lenguajes de programación similares. */ cadena formateada = "PI %s es igual a %g". . printf ( "aproximadamente" , Matemáticas . PI ); println ( formateado ); /* Las cadenas con el prefijo '@' son plantillas de cadena. Pueden evaluar * variables incrustadas y expresiones con el prefijo '$'. *Desde Vala 0.7.8. */ cadena nombre = "David" ; println ( @"¡Buenos días, $nombre!" ); println ( @"4 + 3 = $(4 + 3)" ); /* El operador de igualdad compara el contenido de dos cadenas, contrario al * comportamiento de Java, que en este caso verificaría la igualdad referencial. */ a = "fu" ; b = "fu" ; if ( a == b ) { println ( "Cadena == el operador compara el contenido, no la referencia." ); } más { afirmación_no_alcanzada (); } /* Puede comparar cadenas lexicográficamente con los operadores < y >: */ if ( "azul" < "rojo" && "naranja" > "verde" ) { // Eso es correcto } // declaración de cambio cadena pl = "vala" ; cambiar ( pl ) { case "java" : assert_not_reached (); case "vala" : println ( "La instrucción Switch funciona bien con cadenas" ); romper ; caso "rubí" : afirmar_no_alcanzado (); } /* Vala ofrece una característica llamada cadenas textuales. Estas son cadenas en * cuyas secuencias de escape (como \n) no se interpretarán, los saltos de línea * se conservarán y las comillas no tienen que enmascararse. Están * encerrados entre comillas dobles triples. Las posibles sangrías * después de un salto de línea también forman parte de la cadena. Tenga en cuenta que el resaltado de sintaxis * en este Wiki no tiene en cuenta las cadenas textuales. */ string verbatim = """ Esta es la llamada " cadena textual " . Las cadenas textuales no procesan secuencias de escape , como \ n , \ t , \\ , etc. Pueden contener comillas y abarcar varias líneas " . ""; println ( textualmente ); /* Puede aplicar varias operaciones en cadenas. Aquí hay una pequeña selección: */ println ( "de minúsculas a mayúsculas" . up ()); println ( "cadena invertida" .reverse ( )); println ( "...subcadena..." . subcadena ( 3 , 9 )); /* La palabra clave 'in' es azúcar sintáctica para verificar si una cadena contiene * otra cadena. La siguiente expresión es idéntica a * "pez espada".contains("palabra") */ if ( "palabra" en "pez espada" ) { // ... } // expresiones regulares pruebe { var regex = new Regex ( "(jaguar|tigre|leopard)" ); animales de cuerda = "lobo, tigre, águila, jaguar, leopardo, oso" ; println ( regex . replace ( animales , - 1 , 0 , "gatito" )); } catch ( RegexError e ) { advertencia ( "%s" , e . mensaje ); } }
  • Trabajar con símbolos
  • Señales y Tragamonedas
  • Trabajar con propiedades
  • Ejemplo de compilación condicional

Fundamentos: Colecciones, archivos, E/S, redes, IPC

Interfaz de usuario

Multimedia y gráficos

Plataforma GNOME

Usando GLib

Trabajar con bases de datos

Varios

  • Ejemplos en desuso (Ejemplos que utilizan bibliotecas en desuso, como los applets del panel de GNOME 2)

Notas

  1. Vala 0.56.3 .
  2. Estado de los enlaces  . Consultado el 7 de septiembre de 2011. Archivado desde el original el 10 de marzo de 2012.
  3. Enlaces externos  . Consultado el 7 de septiembre de 2011. Archivado desde el original el 10 de marzo de 2012.

Entorno de desarrollo integrado

Editor Resaltado de sintaxis Formato de código Análisis de código estático Finalización automática Saltar a definición Documentación completa Compilación, prueba y depuración integradas
Anjuta
átomo
código de sistema operativo elemental
emacs
geany
gedit
Constructor de GNOME
IDEA IntelliJ
meditación
Texto sublime Básico
compañero de texto Básico
empuje
código de estudio visual Video parcial ("Vala Debug" en YouTube)
Kate

Actualmente hay 4 implementaciones de servidores de idiomas en desarrollo para Vala:

Otros instrumentos

  • Valadoc : genera documentación a partir de VAPI, GIR y otros archivos
  • gcovr : informes de cobertura de código, use el interruptor --debugc valacpara incluir los números de línea del archivo de origen
  • Uncrustify - código fuente de formato automático
  • vala-lint : verifica que el código cumpla con las reglas de codificación de Elementary: pautas de Code-Style

Enlaces

  • Qué es Vala (23 de julio de 2010). Consultado: 31 de julio de 2010.