Bienvenidos nuevamente a otra entrega sobre el lenguaje Small Basic, en esta ocasión hablaremos sobre la librería Stack, cuya misión es ofrecernos la opción de manejar pilas en nuestros programas. Una pila, para el que no lo sepa, es una estructura de datos similar a una lista de valores, la diferencia radica en que solo podemos meter nuevos elementos por el final de esta y al sacarlos solo podemos sacar el último. Al principio uno puede no ver la utilidad de las pilas, pero con el paso del tiempo al final se hacen indispensables y es de agradecer que estén implementadas en Small Basic. Introducido el concepto, pasemos a indicar cuales son las operaciones que soporta la librería Stack:

• GetCount(nombre): Devuelve el número de elementos almacenados en una pila.
• PopValue(nombre): Saca y devuelve un elemento de una pila.
• PushValue(nombre, valor): Introduce un elemento en una pila.

Nuevamente como ya indicamos en los arrays, hay que tener en cuenta que el nombre que identifica a la pila será convertido a una cadena, con lo que ello implica. Para verlo mejor aquí tenemos un ejemplo de lo que acabo de decir.

Stack.PushValue(0, "42")
aux = Stack.PopValue("0")
TextWindow.WriteLine(aux)

En este otro ejemplo se puede ver el funcionamiento de todas las operaciones de la librería. Lo que hacemos es calcular las potencias de dos con la librería Math, de la que hablaremos próximamente, y mostramos los números a medida que los vamos sacando para ver como parece que vamos hacia atrás.

'----------------------------------------------------
' Prueba con pilas y las potencias de 2
'----------------------------------------------------
TextWindow.Title = "Prueba con pilas"

endl = Text.GetCharacter(13)        '\n
endl = endl + Text.GetCharacter(10) '\r

TextWindow.Write("Los metemos: ")
For i = 0 To 10
  valor = Math.Power(2, i)
  Stack.PushValue("PotenciasDeDos", valor)
  TextWindow.Write(valor + " ")
EndFor
TextWindow.WriteLine(endl)

aux = "Hay " + Stack.GetCount("PotenciasDeDos")
aux = aux + " valores en la pila." + endl
TextWindow.WriteLine(aux)

TextWindow.Write("Y los sacamos: ")
For i = 0 To 10
  valor = Stack.PopValue("PotenciasDeDos")
  TextWindow.Write(valor + " ")
EndFor

TextWindow.WriteLine(endl)

Y por último el golpe maestro y definitivo para el lenguaje Small Basic, que a pesar de sus múltiples limitaciones ello no nos impide para que podamos realizar algoritmos recursivos (subrutinas que se llaman a si mismas sin que ello implique un bucle infinito). Para ello vamos a poner de ejemplo la función factorial:

'----------------------------------------------------
' Prueba del cálculo del factorial con pilas
'----------------------------------------------------
TextWindow.Title = "Cálculo del factorial con pilas"
For i = 0 To 28
  Array.SetValue("MostrarFactorial", "n", i)
  MostrarFactorial()
EndFor

'----------------------------------------------------
' MostrarFactorial(n)
Sub MostrarFactorial
  ' Obtenemos el parametro "n".
  n = Array.GetValue("MostrarFactorial", "n")
  ' Salvamos el parametro antes de la llamada.
  Stack.PushValue("MostrarFactorial", n)
  ' Pasamos el parametro a la función.
  Array.SetValue("Factorial", "n", n)
  ' Invocamos a la función.
  Factorial()
  ' Recuperamos el parametro tras la llamada.
  n = Stack.PopValue("MostrarFactorial")
  ' Mostramos el resultado por pantalla.
  aux = "Factorial(" + n + ") = " + r
  TextWindow.WriteLine(aux)
EndSub

'----------------------------------------------------
' Factorial(n) = x * Factorial(n - 1)
Sub Factorial
  ' Obtenemos el parametro "n".
  n = Array.GetValue("Factorial", "n")
  ' Comprobamos que "n" esté en unos límites.
  If n > 27 Then ' Error por desbordamiento.
    r = 0 ' Devolvemos 0.
  ElseIf n > 1 Then ' Caso recursivo.
    ' Salvamos el parametro "n".
    Stack.PushValue("Factorial", n)
    ' Pasamos el parametro a la función.
    Array.SetValue("Factorial", "n", n - 1)
    ' Invocamos a la función.
    Factorial()
    ' Recuperamos el parametro "n".
    n = Stack.PopValue("Factorial")
    ' Calculamos el resultado a devolver.
    r = r * n
  Else ' Caso base.
    r = 1 ' Devolvemos 1.
  EndIf
EndSub

Como podemos ver Small Basic a pesar de sus limitaciones aparentes, nos permite cierta flexibilidad como realizar subrutinas recursivas. El problema es que nos podemos volver un poco locos a la hora de asignar valores a las variables, porque un solo descuido y el programa se pone a hacer cosas muy raras. Pero ahí está la opción para poder usarla. Como veis las pilas pueden ser bastante útiles si uno se lo propone.

Y con esto ya hemos terminado la sección de la API de Small Basic dedicada a las estructuras de datos. En el próximo artículo posiblemente explique un poco más el tema de cuando una cadena es convertida a número, que yo creo que es un tema bastante peliagudo y confuso. Luego seguiré hablando de las librerías del sistema que faltan (Math, File y Sound), antes de ponerme a hablar de las librerías que utilizan la ventana de windows normal. Mientras tanto ánimo y que paséis un buen puente.

Y ahora algo muy interesante, los arrays, que están dentro de la librería Array, quién lo hubiera sospechado, ¿eh? Como ya hemos visto las variables en Small Basic solo almacenan números y cadenas (y estas últimas al almacenarlas con la asignación en las variables o al usar el operador +, se comprueba primero si se pueden convertir a un número), pero en una aplicación, o mismamente en un juego, vamos a necesitar muchas veces formas de almacenar datos en tablas para tenerlos organizados de alguna forma. Para ello existe la librería Array, que contiene las siguientes operaciones:

• ContainsIndex(nombre, índice): Comprueba si existe un índice en un array, algo que puede ser útil para determinar si hemos inicializado o no una zona del array con un valor o no. Si el índice tiene asignado un valor devolverá “True”, sino ha sido inicializado o ha sido borrado, devolverá “False”.
• ContainsValue(nombre, valor): Comprueba si existe un determinado valor en alguno de los índices de un array. Si existe el valor en el array devolverá “True”, sino devolverá “False”.
• GetItemCount(nombre): Devuelve el número de elementos almacenados en un array.
• GetValue(nombre, índice): Devuelve un valor almacenado en un índice de un array. Si no existe el índice lo que devuelve es una cadena vacía.
• RemoveValue(nombre, índice): Borra un índice de un array.
• SetValue(nombre, índice, valor): Inicializa o cambia el valor almacenado en un índice de un array.

Hay que tener una cosa muy presente a la hora de manejar arrays y que es muy importante. Tanto el nombre, como el índice que le pasemos a estas operaciones, serán convertidos a cadenas internamente en caso de pasarle un número. Es decir que yo puedo hacer lo siguiente:

Array.SetValue(0, 0, 101)
aux = Array.GetValue("0", "0")
TextWindow.WriteLine(aux)

Ahí lo que hacemos es crear un array cuyo nombre es el número cero y en la posición cero asignar el valor 101. Sin embargo internamente coge los valores numéricos que le hayamos pasado para el nombre y el índice, y los transforma en cadenas, por lo que en realidad hemos creado un array cuyo nombre es la cadena “0″ y hemos asignado el valor 101 en el índice “0″. Puede resultar un poco lioso al principio, pero todo es acostumbrarse, como con los punteros en C/C++.

El caso es que lo mejor para descubrir como funciona algo es realizar toda clase de experimentos con ello y probar todas las posibles combinaciones que se nos ocurran para ver qué es lo que funciona y que no funciona. Pero antes de ponerse a lo loco, aquí tenéis un ejemplo ilustrativo de como utilizar los arrays:

'----------------------------------------------------
' Prueba con arrays
'----------------------------------------------------
TextWindow.Title = "Prueba con arrays"

endl = Text.GetCharacter(13)        '\n
endl = endl + Text.GetCharacter(10) '\r

'----------------------------------------------------
' Meter valores en un array
TextWindow.WriteLine("1) Metemos valores:")
TextWindow.Write(endl)

Array.SetValue("Teléfonos", "Pepe", "555-1234")
Array.SetValue("Teléfonos", "Juan", "555-1243")
Array.SetValue("Teléfonos", "Jose", "555-1423")

Array.SetValue("Edad", "Pepe", 37)
Array.SetValue("Edad", "Juan", 42)
Array.SetValue("Edad", "Jose", 101)

Array.SetValue("Números", "0", "Zero")
Array.SetValue("Números", "1", "Ichi")
Array.SetValue("Números", "2", "Ni")
Array.SetValue("Números", "3", "San")
Array.SetValue("Números", "4", "Shi")
Array.SetValue("Números", "5", "Go")
Array.SetValue("Números", "6", "Roku")
Array.SetValue("Números", "7", "Nana")
Array.SetValue("Números", "8", "Shichi")
Array.SetValue("Números", "9", "Kyu")
Array.SetValue("Números", "10", "Jû")

Array.SetValue("Binario", "00", "000")
Array.SetValue("Binario", "01", "001")
Array.SetValue("Binario", "02", "010")
Array.SetValue("Binario", "03", "011")
Array.SetValue("Binario", "04", "100")
Array.SetValue("Binario", "05", "101")

'----------------------------------------------------
' Obtener valores de un array
TextWindow.WriteLine("2) Mostramos los valores:")
TextWindow.Write(endl)

Sub MostrarPersona
  aux = nombre + ": "
  aux = aux + Array.GetValue("Edad", nombre)
  aux = aux + ", "
  aux = aux + Array.GetValue("Teléfonos", nombre)
  TextWindow.WriteLine(aux)
EndSub

TextWindow.WriteLine("Listado de datos:")

nombre = "Pepe"
MostrarPersona()

nombre = "Juan"
MostrarPersona()

nombre = "Jose"
MostrarPersona()

TextWindow.Write(endl)

TextWindow.WriteLine("Los números en japonés:")
For i = 0 To 10
  aux = Array.GetValue("Números", i)
  TextWindow.Write(aux + " ")
EndFor
TextWindow.Write(endl)

PauseAndClear()

'----------------------------------------------------
' Problemas al obtener valores de un array
TextWindow.WriteLine("3) Problemas al mostrar:")

TextWindow.WriteLine("Los números en binario:")
For i = 0 To 5
  aux = Array.GetValue("Binario", i)
  TextWindow.Write(aux + " ")
EndFor
TextWindow.Write(endl)
TextWindow.Write("Pero no ha salido nada, snif... ")
TextWindow.Write("porque los índices no son los ")
TextWindow.WriteLine("correctos." + endl)

TextWindow.WriteLine("Los números en binario:")
For i = 0 To 5
  i = Text.Append("0", i)
  aux = Array.GetValue("binario", i)
  TextWindow.Write(aux + " ")
EndFor
TextWindow.Write(endl)
TextWindow.Write("Pero no ha salido nada, snif... ")
TextWindow.Write("porque el nombre del array es ")
TextWindow.WriteLine("incorrecto." + endl)

TextWindow.WriteLine("Los números en binario:")
For i = 0 To 5
  i = Text.Append("0", i)
  aux = Array.GetValue("Binario", i)
  TextWindow.Write(aux + " ")
EndFor
TextWindow.Write(endl)
TextWindow.WriteLine("Ahora sí sale todo bien ^_^")

PauseAndClear()

'----------------------------------------------------
' Obtener información de un array
TextWindow.WriteLine("4) Informaciones varias:")
TextWindow.Write(endl)

Sub ExisteÍndice
  existe = Array.ContainsIndex(nombre, índice)
  aux = "¿Existe en " + nombre + " el índice "
  aux = aux + índice + "? "
  TextWindow.Write(aux)
  MostrarExiste()
  TextWindow.Write(endl)
EndSub

nombre = "Números"
índice = 5
ExisteÍndice()

nombre = "Números"
índice = "8"
ExisteÍndice()

nombre = "Números"
índice = 14
ExisteÍndice()

TextWindow.Write(endl)

Sub ContieneValor
  existe = Array.ContainsValue(nombre, valor)
  aux = "¿Existe en " + nombre + " el valor "
  aux = aux + valor + "? "
  TextWindow.Write(aux)
  MostrarExiste()
  TextWindow.Write(endl)
EndSub

nombre = "Edad"
valor = 42
ContieneValor()

nombre = "Edad"
valor = 64
ContieneValor()

nombre = "Edad"
valor = "101"
ContieneValor()

TextWindow.Write(endl)

Sub MostrarTamaño
  tamaño = Array.GetItemCount(nombre)
  aux = "El array " + nombre + " tiene "
  aux = aux + tamaño + " elementos."
  TextWindow.WriteLine(aux)
EndSub

nombre = "Teléfonos"
MostrarTamaño()

nombre = "Números"
MostrarTamaño()

nombre = "Pájaros"
MostrarTamaño()

PauseAndClear()

'----------------------------------------------------
' Borrar valores en un array
TextWindow.WriteLine("5) Borramos valores:")

Sub MostrarTrasBorrar
  aux = "Borrando el índice " + índice
  TextWindow.WriteLine(aux)
  Array.RemoveValue(nombre, índice)
  MostrarTamaño()
EndSub

nombre = "Números"
MostrarTamaño()

índice = "1"
MostrarTrasBorrar()
índice = "3"
MostrarTrasBorrar()
índice = "5"
MostrarTrasBorrar()
índice = "7"
MostrarTrasBorrar()
índice = "9"
MostrarTrasBorrar()
índice = "11"
MostrarTrasBorrar()
índice = "02"
MostrarTrasBorrar()

TextWindow.Write(endl)
TextWindow.WriteLine("Los números pares en japonés:")
For i = 0 To 10 Step 2
  aux = Array.GetValue("Números", i)
  TextWindow.Write(aux + " ")
EndFor
TextWindow.WriteLine(endl)

'----------------------------------------------------
' Subrutinas de apoyo
Sub MostrarExiste
  colorAux = TextWindow.ForegroundColor
  If existe Then
    TextWindow.ForegroundColor = "Green"
    TextWindow.Write("Verdadero")
  Else
    TextWindow.ForegroundColor = "Red"
    TextWindow.Write("Falso")
  EndIf
  TextWindow.ForegroundColor = colorAux
EndSub

Sub PauseAndClear
  TextWindow.Write(endl)
  TextWindow.Pause()
  TextWindow.Clear()
EndSub

En el próximo artículo hablaremos sobre las pilas y su uso en un lenguaje como Small Basic, también es posible que después de hablar de las pilas haga algunas anotaciones sobre el tema de las cadenas y su conversión a número o no, dependiendo de diversos factores.

Y lo prometido es deuda, así que en esta nueva entrega sobre el lenguaje Small Basic voy a hablar sobre las estructuras de datos soportadas en el lenguaje, en particular sobre las cadenas. La librería para manejar las cadenas es Text. y esta tiene las siguientes doce operaciones:

• Append(texto1, texto2): Sirve para concatenar dos variables o valores literales, sean números y/o cadenas. El resultado que devolverá será una cadena concatenada. Es una función bastante útil para evitar dejar al lenguaje que trate a aquellas cadenas que contienen un número representado, que sean convertidas en números, en vez de tratarlas como cadenas.
• ConvertToLowerCase(texto): Devuelve una copia en minúsculas de la cadena que le hemos pasado.
• ConvertToUpperCase(texto): Devuelve una copia en mayúsculas de la cadena que le hemos pasado.
• EndsWith(texto, subtexto): Devuelve “True” cuando la cadena que le hemos pasado en texto termina igual que la segunda cadena que le hemos pasado en subtexto.
• GetCharacter(códigoUnicode): Devuelve para un código unicode dado el caracter que lo representa. Es algo que puede ser útil para obtener cadenas con valores de caracteres que no se pueden escribir dentro de una cadena, por ejemplo el salto de linea, las comillas o la tabulación.
• GetCharacterCode(letra): Hace el paso inverso a la anterior función, toma una letra y devuelve su código unicode.
• GetIndexOf(texto, subtexto): Devuelve la posición de una subcadena que esté dentro de la cadena que le hemos pasado en texto. Si no encontrara ninguna coincidencia con el patrón, devolverá como resultado el 0, porque las cadenas empiezan a numerarse sus posiciones a partir del 1 en adelante.
• GetLength(texto): Devuelve el tamaño en caracteres de una cadena.
• GetSubText(texto, comienzo, longitud): Devuelve una subcadena de la cadena que le hemos pasado en texto. Esta subcadena empieza en la posición indicada en comienzo y termina en la posición comienzo+longitud.
• GetSubTextToEnd(texto, comienzo): Igual que la anterior, pero toma siempre como longitud lo que queda de la cadena a partir de la posición indicada en comienzo.
• IsSubText(texto, subtexto): Devuelve “True” cuando la cadena que le hemos pasado en texto contiene en su interior, en alguna posición, la segunda cadena que le hemos pasado en subtexto.
• StartsWith(texto, subtexto): Devuelve “True” cuando la cadena que le hemos pasado en texto empieza igual que la segunda cadena que le hemos pasado en subtexto.

A parte de conocer esas operaciones hay que tener en cuenta también que hay que ser muy cuidadoso al tratar de concatenar cadenas con cadenas o con números, ya que como he señalado antes Small Basic las tratará como números si en su interior se encuentra representado un número. Por cierto que la cadena vacía o llena de espacios es representada como el número cero, por lo que podría fallar si queremos juntar un montón de números separados por espacios. También hay que saber que los valores booleanos verdadero y falso vienen representados como las cadenas “True” y “False”. Y recordad siempre que las cadenas empiezan en la posición 1 y no en la 0 como es habitual en otros lenguajes de programación.

Para ir finalizando aquí teneis un ejemplo sobre el manejo de cadenas, donde podeis ver cosas como el problema con los números, podeis ver como se manejan las busquedas de patrones, de subcadenas y de conversión de caracteres.

'----------------------------------------------------
' Prueba con cadenas
'----------------------------------------------------
TextWindow.Title = "Prueba con cadenas"

'----------------------------------------------------
' Obtenemos caracteres especiales
comillas = Text.GetCharacter(34)                '\"
saltolinea = Text.GetCharacter(13)              '\n
saltolinea = saltolinea + Text.GetCharacter(10) '\r
tabulacion = Text.GetCharacter(9)               '\t

'----------------------------------------------------
' Primero concatenar cadenas
TextWindow.WriteLine("***Concatenemos cadenas***")
aux1 = "¡HoLa "
aux2 = "MuNdO!"
aux3 = Text.Append(aux1, aux2)
TextWindow.WriteLine(aux3)
TextWindow.WriteLine("1000" + "1")
TextWindow.WriteLine(Text.Append(1000, 1))
TextWindow.WriteLine(Text.Append("1000", "1"))
aux = Text.GetLength(aux3)
TextWindow.WriteLine("Tamaño aux3 = " + aux)
TextWindow.Write(saltolinea)

'----------------------------------------------------
' Segundo pasar a minúsculas y mayúsculas
TextWindow.WriteLine("***Conversiones***")
aux = Text.ConvertToLowerCase(aux3)
TextWindow.WriteLine(comillas + aux + comillas)
aux = Text.ConvertToUpperCase(aux3)
TextWindow.WriteLine(comillas + aux + comillas)
TextWindow.Write(saltolinea)

PauseAndClear()

'----------------------------------------------------
' Tercero varias busquedas positivas
TextWindow.WriteLine("***Busquedas positivas***")
aux3 = "¡Hola mundo!"
aux = Text.StartsWith(aux3, "¡Ho")
TextWindow.WriteLine("Busqueda = " + aux)
aux = Text.EndsWith(aux3, "do!")
TextWindow.WriteLine("Busqueda = " + aux)
aux = Text.IsSubText(aux3, "a m")
TextWindow.WriteLine("Busqueda = " + aux)
aux = Text.GetIndexOf(aux3, "a m")
TextWindow.WriteLine("Busqueda = " + aux)
TextWindow.Write(saltolinea)

'----------------------------------------------------
' Tercero varias busquedas negativas
TextWindow.WriteLine("***Busquedas negativas***")
aux = Text.StartsWith(aux3, "H")
TextWindow.WriteLine("Busqueda = " + aux)
aux = Text.EndsWith(aux3, "o")
TextWindow.WriteLine("Busqueda = " + aux)
aux = Text.IsSubText(aux3, ".")
TextWindow.WriteLine("Busqueda = " + aux)
aux = Text.GetIndexOf(aux3, ".")
TextWindow.WriteLine("Busqueda = " + aux)
TextWindow.Write(saltolinea)

PauseAndClear()

'----------------------------------------------------
' Tercero varias busquedas negativas
TextWindow.WriteLine("***Tomando subcadenas***")
aux3 = "Hola Basic."
For i = 1 To Text.GetLength(aux3) - 1
  aux = Text.GetSubText(aux3, 1, i)
  TextWindow.WriteLine(aux)
EndFor
For i = 1 To Text.GetLength(aux3)
  aux = Text.GetSubTextToEnd(aux3, i)
  TextWindow.WriteLine(aux)
EndFor
TextWindow.Write(saltolinea)

PauseAndClear()

'----------------------------------------------------
' Cuarto jugando con caracteres
TextWindow.WriteLine("***Usando caracteres***")
aux3 = "Violence is the last refuge of the incompetent"
For i = 1 To Text.GetLength(aux3)
  aux = Text.GetSubText(aux3, i, 1)
  code = Text.GetCharacterCode(aux)
  aux = Text.Append(code, " ")
  TextWindow.Write(aux)
EndFor
TextWindow.WriteLine(saltolinea)

For i = 0 To 25
  code = Text.GetCharacterCode("a") + i
  aux = Text.GetCharacter(code) + " "
  TextWindow.Write(aux)
EndFor
TextWindow.WriteLine(saltolinea)

'----------------------------------------------------
' Subrutinas de apoyo
Sub PauseAndClear
  TextWindow.Pause()
  TextWindow.Clear()
EndSub

En el próximo artículo, seguramente siga hablando de las estructuras de datos, ya sea para hablar de los arrays o de las pilas. Mientras tanto que lo paseis bien programando.