Gambas/Scripting con Gambas
Gambas recientemente obtuvo soporte para convertirse en un lenguaje para scripting. Los scripts es una forma de programa que es interpretado en vez de compilado. Los scripts son de hecho archivos de texto plano que son interpretados una linea a la vez. El scripting te permite desarrollo rapido y comunicar facilmente con programas, incluso si estos no han sido escritos en Gambas.
Porque usar scripts El uso de scripts te permite combinar secuencias largas y repetitivas de comandos en un único y simple comando. También puedes generalizar secuencias de operaciones sobre un grupo de datos, en un procedimiento que pueda ser aplicado posteriormente a un grupo de datos similar. Incluso, puedes crear nuevos comandos usando una combinación de comandos, utilerías y programas en maneras que ni sus autores originales se hubieran imaginado. Scripting es muy comun en Linux, si tu eres nuevo en Linux, piensa en los scripts como primos de los archivos de procesamiento por lotes (batch) de MSDOS o Windows.
Desde la version 2.9, Gambas también te ofrece otro tipo de scripts, los tipo CGI. Que te permiten crear paginas web con funcionalidad tipo ASP.
Gsb2 - En la consola de Linux
[editar]- Hola Mundo con Scripting en Gambas
Esta característica es provista por la utilería gbs2, que es un pequeño ejecutable de Gambas que permite vaciar cualquier código de Gambas en un archivo de texto. Antes que nada debes asegurarte que el scripter gbs2 esta instalado en alguna parte de tu sistema. Teclea en la linea de comandos o consola de tu distribución de Linux:
user@PC:~$ which gbs2 /usr/bin/gbs2 user@PC:~$
Despues abre el Editor de Codigo de Gamabs y tu editor de texto favorito. Crea un archivo llamado holamundo.gbs en el directior home. Inserta las siguientes lineas a tu archivo:
#!/usr/bin/env gbs2 DIM text AS String = "Hola Mundo con Scripting en Gambas" PRINT text
Cada script de Gambas inicia con la linea
#!/usr/bin/env gbs2
Ahora ejecuta el script en la consola de Linux tecleando el nombre del script.
user@PC:~$ holamundo.gbs Hola Mundo con Scripting en Gambas user@PC:~$
- Ejecutar comandos y aplicaciones
Una de las tareas mas comunes de los scripts es ejecutar otras aplicaciones y comandos del sistema. El siguiente script muestra el contenido del directorio actual pero ignorando los owners y los archivos de respaldo. Llama a este archivo ls.gbs.
#!/usr/bin/env gbs2
DIM command AS NEW String[]
command.Add("ls")
command.Add("-B")
command.Add("-g")
PRINT "------ USING EXEC ------"
EXEC command
PRINT "------ USING SHELL ------"
SHELL "ls -B -g"
De hecho, si teclearas directamente en la consola el comando ls -g -B obtendrías el mismo resultado que ejecutando tu script. Ejecuta tu script para que lo constates.
Como de seguro ya notaste, puedes declarar todo tipo de variables, incluso arrays; pero no esta limitado a esto, también puedes hacer uso de procedimientos, funciones y casi todos los recursos disponibles en el lenguaje Gambas.
- Leer entradas por el usuario
Cuando un script esta siendo ejecutado, frecuentemente es necesario que reciba cierta retroalimentación del usuario para iniciar alguna tarea o para tomar alguna decision o cualquier otra cosa que deba hacer. Escribe el siguiente código en un archivo llamado preguntanombre.gbs.
#!/usr/bin/env gbs2 DIM userInput AS String PRINT "Por favor, introduce tu nombre:" INPUT userInput PRINT "Hey " & userInput &"! Recibí tu respuesta. Yupi!"
Ejecuta el script y veras que pregunta por tu nombre y después que presiones [Enter] aparece un mensaje usando la cadena de caracteres que tecleaste.
user@PC:~$ preguntanombre.gbs Por favor, introduce tu nombre: Sergio Hey Sergio! Recibí tu respuesta. Yupi! user@PC:~$
- Pasar argumentos al script
Algunas otras veces, desearas recibir la información del usuario desde un inicio como argumentos del script. Esto lo consigues haciendo uso del array Args[] de la clase Application. Escribe el siguiente código en un archivo llamado argumentos.gbs.
#!/usr/bin/env gbs2
PUBLIC SUB Main()
DIM i AS Integer
DIM arg AS String
'Using a FOR-NEXT loop
FOR i = 0 TO Application.Args.Count
PRINT Application.Args[i]
NEXT
'Using a FOR-EACH loop
FOR EACH arg IN Application.Args
Print arg
NEXT
'Using a FOR-NEXT loop
PRINT “\nThis loop starts from 1 not from 0”
FOR i = 0 TO Application.Args.Count
PRINT Application.Args[i]
NEXT
END
Hasta el momento, los scripts que habias escrito empezabas sin ninguna declaración del método Main(), pero ahora, para poder acceder a la clase Application necesitas declarar un metodo de inicio. De hecho, es una buena practica siempre hacer uso del metodo Main() incluso en scripts pequenos. Ejecuta el script.
user@PC:~$ arguments.gbs Estos son argumentos “Este es un solo argumento”
/tmp/gambas.1.../script-cache/5......
Estos son argumentos Este es un solo argumento /tmp/gambas.1...script-cache/5...... Estos son argumentos Este es un solo argumento This loop starts from 1 not from 0 Estos son argumentos Este es un solo argumento user@PC:~$
La primer linea de los argumentos, es decir el elemento 0 del array, no es un argumento pasado por el usuario, sino una referencia al cache del script. Toma en cuenta esto cuando estés escribiendo tus propios scripts.
- Usando componentes de Gambas
Para darle mas poder a tus scripts, puedes hacer uso de los componentes incluidos en Gambas. En este caso usaremos el componente gb.xml. En un script llamado escribexml.gbs agrega los siguiente:
#!/usr/bin/env gbs2
USE "gb.xml"
PUBLIC SUB Main()
DIM writer AS XmlWriter
writer = NEW XmlWriter
writer.Open(User.Home & "/Heroes.xml", TRUE)
writer.Comment("Heroes Characters")
writer.StartElement("characters")
writer.Attribute("series", "Heroes")
writer.StartElement("heroe")
writer.Attribute("id", "1")
writer.Attribute("name", "Claire Bennet")
writer.StartElement("name")
writer.Text("Claire Bennet")
writer.EndElement 'name
writer.StartElement("played_by")
writer.Text("Hayden Panettiere")
writer.EndElement 'played_by
writer.StartElement("ability")
writer.Text("Rapid cellular regeneration")
writer.EndElement 'ability
writer.EndElement 'heroe
writer.StartElement("heroe", ["id", "2", "name", "Hiro Nakamura"])
writer.Element("name", "Hiro Nakamura")
writer.Element("played_by", "Masi Oka")
writer.Element("ability", "Space-time manipulation: teleportation & time travel")
writer.EndElement 'heroe
writer.StartElement("villain", ["id", "3", "name", "Gabriel Sylar"])
writer.Element("name", "Gabriel Sylar")
writer.Element("played_by", "Zachary Quinto")
writer.Element("ability", "Understand how things work and multiple other abilities acquired")
writer.EndElement 'villain
writer.EndElement 'character
PRINT writer.EndDocument()
END
Ejecutalo y debiera crearte un archivo XML llamado Heroes.xml con el siguiente contenido:
<?xml version="1.0"?> <characters series="Heroes"> <heroe id="1" name="Claire Bennet"> <name>Claire Bennet</name> <played_by>Hayden Panettiere</played_by> <ability>Rapid cellular regeneration</ability> </heroe> <heroe id="2" name="Hiro Nakamura"> <name>Hiro Nakamura</name> <played_by>Masi Oka</played_by> <ability>Space-time manipulation: teleportation & time travel</ability> </heroe> <villain id="3" name="Gabriel Sylar"> <name>Gabriel Sylar</name> <played_by>Zachary Quinto</played_by> <ability>Understand how things work and multiple other abilities acquired</ability> </villain> </characters>
Gsw - En CGI Web
[editar]La funcionalidad es provista por gbw2, que en realidad es un link simbolico a gbs2. Cuando gbs2 detecta que es ejecutado desde gbw2, sabe que tienen que procesar una pagina de servidor y no un script. Después, gbs2 transforma la pagina de servidor aun script normal y luego lo ejecuta.
#!/usr/bin/env gbw2
<%
DIM sEnv AS String
%>
<html>
< h2 >CGI script environmental variables< /h2 >
< table border="1" cellspacing="0" cellpadding="2" >
< tr >
< th align="left">Name< /th >
< th align="left">Value< /th >
< /tr >
<% FOR EACH sEnv IN Application.Env %>
< tr valign="top" >
< td ><%= sEnv %>< /td >
< td ><%= Application.Env[sEnv] %> < /td >
< /tr >
<% NEXT %>
< /table >
</html>
Ejemplo tomado de http://gambasdoc.org/help/doc/serverpage