Qbasic Olor a pestañas quemadas
Una vez que ya hemos hecho nuestro primer programita, y vemos que funciona, entonces profundizaremos un poco mas en el conocimiento teorico, que nos servirá para todos los idiomas de programación.
La antigua manera de programar, se llamaba programación serial o secuencial, en este tipo de programación, el código se armaba línea tras línea a medida que se iba ejecutando, y si había que seleccionar, se hacían saltos de línea, medianotes ordenes como GO TO (Nro de línea) o etiqueta
SI vemos algunos códigos, todavía se estila usar Nros de línea en algunos códigos, pero solo para tener una referencia visual al mencionar una parte del mismo
La programación modular, divide el código en partes que hacen un determinado trabajo, o función. Reciben el nombre de funciones, o procedimientos según el caso.
http://es.wikipedia.org/wiki/Programación_modular
Las funciones, casi siempre reciben valores como parámetros, y devuelven también algún valor como resultado, en cambio los procedimientos por lo general, usan las variables del entorno con sus valores, y ejecutan alguna tarea especifica (imprimir, mostrar etc.) Estos conceptos estan bastante discutidos, pero en general son aplicables a todos los idiomas de programacion, las funciones y los procedimientos, pertenecen al grupo de las rutinas o subrutinas. (el programa deja de ejecutarse siguiendo su secuencia para hacer una determinada subrutina).
Otro concepto es el de las macros, que son partes de código que se incorporan al código principal al ser invocadas
http://es.wikipedia.org/wiki/Subrutina
En el idioma que estamos usando, el QuickBasic, podemos usar estas rutinas, para lo cual nos vamos a edicion nueva sub y le ponemos un nombre, esta subrutina tendrá su propio codigo y podemos llamarla desde el codigo principal cuando querramos y cuantas veces lo querramos. Nos aparecera como Sub (nombre) y al finalizar su código End Sub
Tambien podemos uar funciones mediante la orden FUNCTION (nombre) lista de parámetros que termina con el END FUNCTION; para devolver un valor ponemos el (nombre) = a lo que devolverá; una linea antes de terminar la función
La POO que es el nombre que recibe la Programacion Orientada a Objetos, usa estos elementos, ademas de otros que permiten cumplir sus requisitos, asi que haremos uso de estos elementos para irnos acostumbrando cuando avancemos con otros idiomas que trabajan con objetos.
Ahora dare un breve concepto del tema para los que no quieren quedarse con las duda. Un Objeto, es una instancia de una Clase
Una Clase, es una declaración de un conjunto de datos, sus funciones, sus rutinas que tiene capacidad para hacer determinadas cosas y responde a ciertas otras, lo que recibe el nombre de propiedades, de atributos, y métodos
http://es.wikipedia.org/wiki/Clase_(informática)
Las propiedades se refieren a las características que puede asumir (Ej., en el caso de una ventana de datos, alto, ancho, color, tipo de letra, imagen de fondo etc.), mientras que los atributos son los como parámetros que puede recibir para hacer determinadas tareas que se llaman métodos.
Si Dios quiere, cuando entremos al Visual Basic, estos conceptos quedarán más claros, al relacionarlo con los objetos visuales de ese idioma, que es una “evolución” del Qbasic
Después de esta dosis de teoría, que les abrá costado a mas de uno que se le quemen las pestañas, seguimos con los códigos de Quick Basic
Abriremos MULTITAB.BAS (esta entre los codigos de ejemplo que bajarás cuando bajes el compilador)
DIM i%, j%, k%, f%
CLS
k% = 1
f% = 1
FOR i% = 1 TO 10
FOR j% = 1 TO 10
LOCATE f%, k%
PRINT USING "## * ## = ###"; i%; j%; i% * j%
f% = f% + 1
IF f% = 11 THEN f% = f% + 1
IF f% > 21 THEN
f% = 1
k% = k% + 15
END IF
NEXT j%
NEXT i%
Acá tenemos como diferencia, el uso del formato, que en Qbasic se pone como PRINT USING (” formato “); variables y formato es una cadena de caracteres que podemos seleccionar usando la referencia de: Ayuda, Índice, Print Using, <especificadores de formato>
Caracteres que dan formato a una expresión numérica
# Posición de dígito. ║ - Después del dígito, imprime
. Posición de punto decimal. ║ el signo para los números
, A la izquierda del punto decimal, ║ negativos.
imprime una coma cada 3 dígitos. ║ $$ Imprime $ adelante.
+ Posición del signo de número. ║ ** Llena espacios adelante con *
^^^^ Imprime con formato exponencial. ║ **$ Combina ** y $$.
Caracteres que dan formato a una expresión de cadena
& Imprime la cadena completa. ║ Imprime los primeros n
! Imprime sólo el primer carácter ║ caracteres, donde n es el
de la cadena. ║ número de espacios entre
║ barras + 2.
Caracteres utilizados para imprimir caracteres literales
_ Imprime el carácter de formato ║ Cualquier carácter que no
siguiente como literal. ║ esté en la tabla será
║ impreso como literal.
Esto es muy útil para presentar ordenadamente datos que pueden tener variaciones en su tamaño, y lo mismo a la hora de imprimir
Esto seria para el detalle de una factura
PRINT "║ Cant.│ Detalle del Artículo │ Precio │ Subtotal ║"
PRINT "║______│__________________________________│________│__________║"
PRINT USING "║ ### │ │ ###.## │ #####.##║ “;C1!; Det1$; Prec1!; Stot1!
PRINT "║------│----------------------------------│--------│----------║"
PRINT USING "║ ### │ │ ###.## │ #####.## ║"; C2!; Det2$; Prec2!; Stot2!
PRINT "║------│----------------------------------│--------│----------║"
PRINT USING "║ ### │ │ ###.## │ #####.## ║"; C3!; Det3$; Prec3!; Stot3!
PRINT "║------│----------------------------------│--------│----------║"
PRINT USING "║ ### │ │ ###.## │ #####.## ║"; C4!; Det4$; Prec4!; Stot4!
PRINT "║------│----------------------------------│--------│----------║"
PRINT USING "║ ### │ │ ###.## │ #####.## ║"; C5!; Det5$; Prec5!; Stot5!
PRINT "║------│----------------------------------│--------│----------║"
PRINT USING "║ ### │ │ ###.## │ #####.## ║"; C6!; Det6$; Prec6!; Stot6!
PRINT "║------│----------------------------------│--------│----------║"
PRINT "║ ╔═════════════════╗║"
PRINT "║ TOTAL :■■>"; USING " ║ #####.## ║║"; Stot1! + Stot2! + Stot3! + Stot4! + Stot5! + Stot6!
PRINT "║ ╚═════════════════╝║"
GOSUB PRINTPIE ‘//en esta linea llamo a un procedimiento que muestra el pie de la factura
PRINTPIE:
PRINT "║cuit:20-11782071-9 Ingr.Bru: ║"
PRINT "║Confeccionada por computadora; sin valor fiscal ║"
PRINT "╚═════════════════════════════════════════════════════════════╝"
PRINT ""
PRINT ""
RETURN
'=============================================================================
Vemos el uso del RETURN que sirve en este caso, para seguir el programa a partir de donde el procedimiento fue llamado
Ahora el manejo de archivos, para eso abrimos BASEDAT.BAS donde tenemos el siguiente código
Vemos el uso del DO (hacer) que termínan en LOOP WHILE (condición) algo así como: Repetir Mientras la condición se cumpla
Mas abajo vemos DO WHILE NOT EOF(1) Hacer mientras no sea fin del archivo 1 que termina en LOOP
CLS
OPEN "LISTA" FOR OUTPUT AS #1
DO
INPUT " NOMBRE: ", Nombre$ 'Lee datos desde el teclado.
INPUT " EDAD: ", Edad%
INPUT " PESO: ", Pesok#
WRITE #1, Nombre$, Edad%, Pesok#
INPUT "¿Desea ingresar otros datos"; R$
LOOP WHILE UCASE$(R$) = "S"
CLOSE #1
'Mostrar el archivo en la pantalla.
OPEN "LISTA" FOR INPUT AS #1
CLS
PRINT "Datos en el archivo:": PRINT
DO WHILE NOT EOF(1)
INPUT #1, name$, year%, peso# 'Leer datos del archivo.
PRINT name$, year%, peso# 'Imprimir los datos en la pantalla
LOOP
CLOSE #1
KILL "LISTA" ‘// Esta orden podemos eliminarla para que nos quede el archivo en el disco, y poder verlo
De esta manera, podemos hacer una sucesion de registros similares, y para saber en que posicion esta, solo basta agregar un contador en la presentacion
Cont%=0
DO WHILE NOT EOF(1)
INPUT #1, name$, year%, peso# 'Leer datos del archivo.
PRINT cont%, name$, year%, peso# 'Imprimir los datos en la pantalla
Cont%=Cont% +1
LOOP
Otra forma, seria al grabar el registro, agregarle un numero de índice, pero debemos asegurarnos, que cuando cerramos y volvemos a abrir el programa, el Nro de índice continué al ultimo, para lo cual hay que hacer primero una lectura buscando ese índice, y luego abrir el archivo para escribirlo
Cuando se requiere más precisión en el manejo de datos, se usa un tipo de dato personal, que no es más que un conjunto de datos definidos como un dato complejo, (asemejándose a una clase y a objetos). Para esto usamos TYPE
Define un tipo de datos que contiene uno o más elementos.
TYPE tipousuario
elemento AS tipo
[elemento AS tipo]
END TYPE
■ tipousuario El nombre del tipo de datos que será definido. El
nombre puede tener hasta 40 caracteres y debe comenzar
con una letra. Los caracteres válidos son A-Z, 0-9 y el
punto (.). No se pueden usar letras acentuadas ni la ñ.
■ elemento Un elemento del tipo de datos definido por el usuario.
■ tipo El tipo de datos del elemento (INTEGER, LONG, SINGLE,
DOUBLE, STRING o un tipo de datos definido por el
usuario).
Ejemplo:
TYPE Cartas
Palo AS STRING * 9
Valor AS INTEGER
END TYPE
DIM Juego(1 TO 52) AS Carta
Juego(1).Palo = "Bastos"
Juego(1).Valor = 2
PRINT Juego(1).Palo, Juego(1).Valor
La ventaja es que al definir un tipo de dato de usuario. Nos aseguramos que el contenido del mismo, no se mezclara con otros datos y que podemos crear un vector de esos datos y usar el indice del vector para localizar un registro en forma individual, sin tener que andar pasando por todos
Un vector, es un arreglo de datos del mismo tipo, diferenciados por un indice,
Cuando el arreglo tiene una sola dimension, tiene un solo indice y se llama comunmente vector o matriz de una dimension
Cuando el arreglo tiene mas de una dimensión, se llama comunmente matriz y tiene tantos indices como dimensiones
Luego el procedimiento quedaria asi
1) crear tipo de dato de usuario (semejante a la clase )
2) crear un vector de esos datos (semejante a crear un grupo de instancias u objetos)
3) Amacenar en el dico duro y trabajar en el programa con ese vector
Use el formularo de contacto para que podamos ver como intercambiar la documentación-
_ Gracias.-