miércoles, 18 de febrero de 2009

Eliminar Objetos no Utilizados en Java



Muchos otros lenguajes orientados a objetos necesitan que se siga
la pista de los objetos que se han ceado y luego se destruyan
cuando no se necesiten. Escribir código para manejar la memoria de
esta es forma es aburrido y propenso a errores. Java permite
ahorrarse esto, permitiéndo crear tantos objetos como se quiera
(sólo limitados por los que el sistema pueda manejar) pero nunca
tienen que ser destruidos. El entorno de ejecución Java borra los
objetos cuando determina que no se van autilizar más. Este proceso
es conocido como recolección de basura.

Un objeto es elegible para la recolección de basura cuando no existen
más referencias a ese objeto. Las referencias que se mantienen en una
variable desaparecen de forma natural cuando la variable sale de su
ámbito. O cuando se borra explicitamente un objeto referencia mediante
la selección de un valor cuyo tipo de dato es una referencia a null.

Recolector de Basura

El entorno de ejecución de Java tiene un recolector de basura que
periódicamente libera la memoria ocupada por los objetos que no se van
a necesitar más. El recolector de basura de Java es un barredor de
marcas que escanea dinamicamente la memoria de Java buscando
objetos, marcando aquellos que han sido referenciados. Después de
investigar todos los posibles paths de los objetos, los que no están
marcados (esto es, no han sido referenciados) se les conoce como
basura y son eliminados.

El colector de basura funciona en un thread (hilo) de baja prioridad y
funciona tanto síncrona como asíncronamente dependiendo de la situación
y del sistema en el que se esté ejecutando el entorno Java.

El recolector de basura se ejecuta síncronamente cuando el sistema
funciona fuera de memoria o en respuesta a una petición de un
programa Java. Un programa Java le puede pedir al recolector de basura
que se ejecute en cualquier momento mediane una llamada a System.gc().

Nota: Pedir que se ejecute el recolector de basura no
garantiza que los objetos sean recolectados.

En sistemas que permiten que el entorno de ejecución Java note cuando
un thread a empezado a interrumpir a otro thread (como Windows
95/NT), el recolector de basura de Java funciona asíncromamente
cuando el sistema está ocupado. Tan pronto como otro thread se vuelva
activo, se pedira al recolector de basura que obtenga un estado
consistente y termine.

Finalización

Antes de que un objeto sea recolectado, el recolector de basura le da
una oportunidad para limpiarse él mismo mediante la llamada al método
finalize() del propio objeto. Este proceso es conocido como finalización.
Durante la finalización un objeto se podrían liberar los recursos del
sistema como son los ficheros, etc y liberar referencias en otros objetos
para hacerse elegible por la recolección de basura.

El método finalize() es un miembro de la clase java.lang.Object. Una
clase debe sobreescribir el método finalize() para realizar cualquier
finalización necesaria para los objetos de ese tipo.

Arrays y Cadenas en Java



Al igual que otros lenguajes de programación, Java permite juntar y manejar múltiples
valores a través de un objeto array (matriz). También se pueden manejar datos
compuestos de múltiples caracteres utilizando el objeto String (cadena).

Arrays

Esta sección te enseñará todo lo que necesitas para crear y utilizar arrays en
tus programas Java.

Como otras variables, antes de poder utilizar un array primero se debe
declarar. De nuevo, al igual que otras variables, la declaración de un array
tiene dos componentes primarios: el tipo del array y su nombre. Un tipo de
array incluye el tipo de dato de los elementos que va contener el array. Por
ejemplo, el tipo de dato para un array que sólo va a contener elementos
enteros es un array de enteros. No puede existir un array de tipo de datos
genérico en el que el tipo de sus elementos esté indefinido cuando se declara
el array. Aquí tienes la declaración de un array de enteros:

int[] arrayDeEnteros;

La parte int[] de la declaración indica que arrayDeEnteros es un array de
enteros. La declaración no asigna ninguna memoria para contener los
elementos del array.

Si se intenta asignar un valor o acceder a cualquier elemento de
arrayDeEnteros antes de haber asignado la memoria para él, el compilador
dará un error como este y no compilará el programa:

testing.java:64: Variable arraydeenteros may not have been initialized.

Para asignar memoria a los elementos de un array, primero se debe
ejemplarizar el array. Se puede hacer esto utilizando el operador new de Java.
(Realmente, los pasos que se deben seguir para crear un array son similares a
los se deben seguir para crear un objeto de una clase: declaración,
ejemplarización e inicialización.

Strings

Una secuencia de datos del tipo carácter se llama un string (cadena) y en el
entorno Java está implementada por la clase String (un miembro del paquete
java.lang).

String[] args;

Este código declara explícitamente un array, llamado args, que contiene
objetos del tipo String. Los corchetes vacios indican que la longitud del array
no se conoce en el momento de la compilación, porque el array se pasa en el
momento de la ejecución.

El segundo uso de String es el uso de cadenas literales (una cadena de
caracteres entre comillas " y "):

"Hola mundo!"

El compilador asigna implicitamente espacio para un objeto String cuando
encuentra una cadena literal.

Los objetos String son inmutables - es decir, no se pueden modificar una vez
que han sido creados. El paquete java.lang proporciona una clase diferente,
StringBuffer, que se podrá utilizar para crear y manipular caracteres al vuelo.

Concatenación de Cadenas

Java permite concatenar cadenas facilmente utilizando el operador
+. El siguiente fragmento de código concatena tres cadenas para
producir su salida:

"La entrada tiene " + contador + " caracteres."

Dos de las cadenas concatenadas son cadenas literales: "La
entrada tiene " y " caracteres.". La tercera cadena - la del medioes
realmente un entero que primero se convierte a cadena y luego
se concatena con las otras.

Expresiones en Java



Las expresiones realizan el trabajo de un programa Java. Entre otras cosas, las
expresiones se utilizan para calcular y asignar valores a las variables y para
controlar el flujo de un programa Java. El trabajo de una expresión se divide en
dos partes: realizar los cálculos indicados por los elementos de la expresión y
devolver algún valor.

Definición: Una expresión es una serie de variables, operadores y llamadas a métodos (construida de acuerdo a la sintaxis del lenguaje) que evalúa a un valor sencillo.

El tipo del dato devuelto por una expresión depende de los elementos utilizados en
la expresión. La expresión count++ devuelve un entero porque ++ devuelve un
valor del mismo tipo que su operando y count es un entero. Otras expresiones
devuelven valores booleanos, cadenas, etc...

Una expresión de llamada a un método devuelve el valor del método; así el tipo de
dato de una expresión de llamada a un método es el mismo tipo de dato que el
valor de retorno del método. El método System.in.read() se ha declarado como
un entero, por lo tanto, la expresión System.in.read() devuelve un entero.

La segunda expresión contenida en la sentencia System.in.read() != -1 utiliza el
operador !=. Recuerda que este operador comprueba si los dos operandos son
distintos. En esta sentencia los operandos son System.in.read() y -1.
System.in.read() es un operando válido para != porque devuelve un entero. Así
System.in.read() != -1 compara dos enteros, el valor devuelto por
System.in.read() y -1. El valor devuelto por != es true o false dependiendo de
la salida de la comparación.

Operadores en Java



Los operadores realizan algunas funciones en uno o dos operandos. Los operadores
que requieren un operador se llaman operadores unarios. Por ejemplo, ++ es un
operador unario que incrementa el valor su operando en uno.

Los operadores que requieren dos operandos se llaman operadores binarios. El
operador = es un operador binario que asigna un valor del operando derecho al
operando izquierdo.

Los operadores unarios en Java pueden utilizar la notación de prefijo o de sufijo. La
notación de prefijo significa que el operador aparece antes de su operando:
operador operando

La notación de sufijo significa que el operador aparece después de su operando:

operando operador

Todos los operadores binarios de Java tienen la misma notación, es decir
aparencen entre los dos operandos:

op1 operator op2

Además de realizar una operación también devuelve un valor. El valor y su tipo
dependen del tipo del operador y del tipo de sus operandos. Por ejemplo, los
operadores aritméticos (realizan las operaciones de aritmética básica como la suma
o la resta) devuelven números, el resultado típico de las operaciones aritmétcias.
El tipo de datos devuelto por los operadores aritméticos depende del tipo de sus
operandos: si sumas dos enteros, obtendrás un entero. Se dice que una operación
evalúa su resultado.

Es muy útil dividir los operadores Java en las siguientes categorías: aritméticos,
relacionales y condicionales. lógicos y de desplazamiento y de asignación.

Operadores Aritméticos

El lenguaje Java soporta varios operadores aritéticos - incluyendo +
(suma), - (resta), * (multiplicación), / (división), y % (módulo)-- en
todos los números enteros y de coma flotante. Por ejemplo, puedes
utilizar este código Java para sumar dos números:

sumaEsto + aEsto

O este código para calcular el resto de una división:

divideEsto % porEsto

Esta tabla sumariza todas las operaciones aritméticas binarias en Java:

Operador Uso Descripción
+ op1 + op2 Suma op1 y op2
- op1 - op2 Resta op2 de op1
* op1 * op2 Multiplica op1 y op2
/ op1 / op2 Divide op1 por op2
% op1 % op2 Obtiene el resto de dividir op1 por op2

Nota: El lenguaje Java extiende la definición del operador + para incluir la concatenación de cadenas.

Los operadores + y - tienen versiones unarias que seleccionan el signo
del operando:

Operador Uso Descripción
+ + op Indica un valor positivo
- - op Niega el operando

Además, existen dos operadores de atajos aritméticos, ++ que
incrementa en uno su operando, y -- que decrementa en uno el valor de su operando.

Operador Uso Descripción
++ op ++ Incrementa op en 1; evalúa el valor antes de incrementar
++ ++ op Incrementa op en 1; evalúa el valor después de
incrementar
-- op -- Decrementa op en 1; evalúa el valor antes de decrementar
-- -- op Decrementa op en 1; evalúa el valor después de
decrementar

Operadores Relacionales y Condicionales

Los valores relacionales comparan dos valores y determinan la relación
entre ellos. Por ejemplo, != devuelve true si los dos operandos son
distintos.

Esta tabla sumariza los operadores relacionales de Java:

Operador Uso Devuelve true si
> op1 > op2 op1 es mayor que op2
>= op1 >= op2 op1 es mayor o igual que op2
< op1 < op2 op1 es menor que op2
<= op1 <= op2 op1 es menor o igual que op2
== op1 == op2 op1 y op2 son iguales
!= op1 != op2 op1 y op2 son distintos

Frecuentemente los operadores relacionales se utilizan con otro juego de
operadores, los operadores condicionales, para construir expresiones de
decisión más complejas. Uno de estos operadores es && que realiza la
operación Y booleana . Por ejemplo puedes utilizar dos operadores
relacionales diferentes junto con && para determinar si ambas relaciones
son ciertas. La siguiente línea de código utiliza esta técnica para
determinar si un indice de un array está entre dos límites- esto es, para
determinar si el indice es mayor que 0 o menor que NUM_ENTRIES (que
se ha definido préviamente como un valor constante):

0 < index && index < NUM_ENTRIES

Observa que en algunas situaciones, el segundo operando de un
operador relacional no será evaluado. Consideremos esta sentencia:

((count > NUM_ENTRIES) && (System.in.read() != -1))

Si count es menor que NUM_ENTRIES, la parte izquierda del operando de
&& evalúa a false. El operador && sólo devuelve true si los dos
operandos son verdaderos. Por eso, en esta situación se puede
deteminar el valor de && sin evaluar el operador de la derecha. En un
caso como este, Java no evalúa el operando de la derecha. Así no se
llamará a System.in.read() y no se leerá un carácter de la entrada
estandard.

Aquí tienes tres operadores condicionales:

Operador Uso Devuelve true si
&& op1 && op2 op1 y op2 son verdaderos
|| op1 || op2 uno de los dos es verdadero
! ! op op es falso

El operador & se puede utilizar como un sinónimo de && si ambos
operadores son booleanos. Similarmente, | es un sinonimo de || si
ambos operandos son booleanos.

Operadores de Desplazamiento

Los operadores de desplazamiento permiten realizar una manipualción
de los bits de los datos. Esta tabla sumariza los operadores lógicos y de
desplazamiento disponibles en el lenguaje Java:

Operador Uso Descripción
>> op1 >> op2 desplaza a la derecha op2 bits de op1
<< op1 << op2 desplaza a la izquierda op2 bits de op1
>>> op1 >>> op2 desplaza a la derecha op2 bits de op1(sin
signo)
& op1 & op2 bitwise and
| op1 | op2 bitwise or
^ op1 ^ op2 bitwise xor
~ ~ op bitwise complemento

Los tres operadores de desplazamiento simplemente desplazan los bits
del operando de la izquierda el número de posiciones indicadas por el
operador de la derecha. Los desplazamientos ocurren en la dirección
indicada por el propio operador. Por ejemplo:

13 >> 1;

desplaza los bits del entero 13 una posición a la derecha. La
representación binaria del número 13 es 1101. El resultado de la
operación de desplazamiento es 110 o el 6 decimal. Observe que el bit
situado más a la derecha desaparece. Un desplazamiento a la derecha de
un bit es equivalente, pero más eficiente que, dividir el operando de la
izquierda por dos. Un desplazamiento a la izquierda es equivalente a
multiplicar por dos.

Los otros operadores realizan las funciones lógicas para cada uno de los
pares de bits de cada operando. La función "y" activa el bit resultante si
los dos operandos son 1.

op1 op2 resultado
0 0 0
0 1 0
1 0 0
1 1 1

Supon que quieres evaluar los valores 12 "and" 13:

12 & 13

El resultado de esta operación es 12. ¿Por qué? Bien, la representación
binaria de 12 es 1100 y la de 13 es 1101. La función "and" activa los bits
resultantes cuando los bits de los dos operandos son 1, de otra forma el
resultado es 0. Entonces si colocas en línea los dos operandos y realizas
la función "and", puedes ver que los dos bits de mayor peso (los dos bits
situados más a la izquierda de cada número) son 1 así el bit resultante
de cada uno es 1. Los dos bits de menor peso se evalúan a 0 poque al
menos uno de los dos operandos es 0:

1101
& 1100
------
1100

El operador | realiza la operación O inclusiva y el operador ^ realiza la
operación O exclusiva. O inclusiva significa que si uno de los dos
operandos es 1 el resultado es 1.

op1 op2 resultado
0 0 0
0 1 1
1 0 1
1 1 1

O exclusiva significa que si los dos operandos son diferentes el resultado
es 1, de otra forma el resultado es 0:

op1 op2 resultado
0 0 0
0 1 1
1 0 1
1 1 0

Y finalmente el operador complemento invierte el valor de cada uno de
los bites del operando: si el bit del operando es 1 el resultado es 0 y si el
bit del operando es 0 el resultado es 1.

Operadores de Asignación

Puedes utilizar el operador de asignación =, para asignar un valor a otro.
Además del operador de asignación básico, Java proporciona varios
operadores de asignación que permiten realizar operaciones aritmétcias,
lógicas o de bits y una operación de asignación al mismo tiempo.
Especificamente, supon que quieres añadir un número a una variable y
asignar el resultado dentro de la misma variable, como esto:

i = i + 2;

Puedes ordenar esta sentencia utilizando el operador +=.

i += 2;

Las dos líneas de código anteriores son equivalentes.
Esta tabla lista los operadores de asignación y sus equivalentes:

Operador Uso Equivale a
+= op1 += op2 op1 = op1 + op2
-= op1 -= op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/= op1 /= op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 % op2
&= op1 &= op2 op1 = op1 & op2
|= op1 |= op2 op1 = op1 | op2
^= op1 ^= op2 op1 = op1 ^ op2
<<= op1 <<= op2 op1 = op1 << op2
>>= op1 >>= op2 op1 = op1 >> op2
>>>= op1 >>>= op2 op1 = op1 >>> op2

Variables y Tipos de Datos en Java



Las variables son las partes importantes de un lenguaje de programación: ellas son
las entidades (valores, datos) que actúan y sobre las que se actúa.
Una declaración de variable siempre contiene dos componentes, el tipo de la
variable y su nombre:

tipoVariable nombre;

Tipos de Variables

Todas las variables en el lenguaje Java deben tener un tipo de dato. El
tipo de la variable determina los valores que la variable puede contener y
las operaciones que se pueden realizar con ella.

Existen dos categorias de datos principales en el lenguaje Java: los tipos
primitivos y los tipos referenciados.

Los tipos primitivos contienen un sólo valor e incluyen los tipos como los
enteros, coma flotante, los caracteres, etc... La tabla siguiente muestra
todos los tipos primitivos soportados por el lenguaje Java, su formato, su
tamaño y una breve descripción de cada uno:

Tipo Tamaño/Formato Descripción
(Números enteros)
byte 8-bit complemento a 2 Entero de un Byte
short 16-bit complemento a 2 Entero corto
int 32-bit complemento a 2 Entero
long 64-bit complemento a 2 Entero largo
(Números reales)
float 32-bit IEEE 754 Coma flotante de precisión simple
double 64-bit IEEE 754 Coma flotante de precisión doble
(otros tipos)
char 16-bit Caracter Un sólo carácter
boolean true o false Un valor booleano (verdadero o falso)

Los tipos referenciados se llaman así porque el valor de una variable de
referencia es una referencia (un puntero) hacia el valor real. En Java
tenemos los arrays, las clases y los interfaces como tipos de datos
referenciados.

Nombres de Variables

Un programa se refiere al valor de una variable por su nombre. Por
convención, en Java, los nombres de las variables empiezan con una
letra minúscula (los nombres de las clases empiezan con una letra
mayúscula).

Un nombre de variable Java:

debe ser un identificador legal de Java comprendido en una serie de
caracteres Unicode. Unicode es un sistema de codificación que
soporta texto escrito en distintos lenguajes humanos.Unicode
perminte la codificación de 34.168 caracteres. Esto le permite
utilizar en sus programas Java varios alfabetos como el Japonés, el
Griego, el Ruso o el Hebreo. Esto es importante para que los
programadores pueden escribir código en su lenguaje nativo.

1. no puede ser el mismo que una palabra clave o el nombre de un
valor booleano (true or false)
2. no deben tener el mismo nombre que otras variables cuyas
declaraciones aparezcan en el mismo ámbito.
3. La regla número 3 implica que podría existir el mismo nombre en otra
variable que aparezca en un ámbito diferente.

Por convención, los nombres de variables empiezan por un letra
minúscula. Si una variable está compuesta de más de una palabra, como
'nombreDato' las palabras se ponen juntas y cada palabra después de la
primera empieza con una letra mayúscula.

domingo, 15 de febrero de 2009

Leer datos de un archivo utilizando Line Input con Visual Basic 6.0


Para leer datos de un archivo se utiliza la sentencia Input.
pero para leer los datos del archivo y poder utilizarlos en nuestro programa se utilizan 2 sentencias o instrucciones: Line Input e Input.

Ejemplo:

Dim mivariable As String

Open "c:\nombres.txt" For Input As #1

While Not EOF(1)

Line Input #1, mivariable

Wend

Close #1


En el ejemplo anterior aparece una función nueva llamada EOF. Esta función significa End Of File o fin de archivo.

Cuando abrimos un archivo para leer información con Input, debemos saber en que momento llegamos al final del archivo, por que de lo contrario la sentencia Line Input o Input seguiría leyendo líneas donde no existen datos después del fin del archivo, y por lo tanto se produciría un error en tiempo de ejecución por querer leer un dato que no existe.

Mediante la condición Not Eof(1) leeremos los datos hasta que llegue al final del archivo, y en cada pasada del bucle While se almacenará en la variable mivariable, línea por línea los datos del mismo. Es evidente que como está planteado el ejemplo habría que manipular los datos leídos y agregar otras instrucciones, por que en este ejemplo la variable mivariable solo almacenaría los datos de la línea que está leyendo y borrando los datos de las líneas que almacenó anteriormente. Mas adelante veremos como solucionar esto.

conclusión : para leer datos de un archivo se utiliza la sentencia Line Input y luego de la coma debemos poner una variable nuestra para almacenar los datos que se van leyendo de la línea actual

Line Input #1, nuestravariable

Tipos de acceso de un archivo en Visual Basic 6.0


Append: esta sentencia se utiliza para agregar información a un archivo de texto.

Ejemplo :

Open "c:\miarchivo.txt" For Append As #1


Si el archivo ya contiene datos, se le agregarán al mismo al final del archivo, si no contenía datos los agrega igual. Si el archivo no existe, lo crea y le agrega los datos.

Input: la sentencia Input se utiliza para leer datos de un archivo de texto, ejemplo:

Open "c:\miarchivo.txt" For Input As #2


Este ejemplo abre un archivo para leer los datos del mismo. En las próximas líneas veremos ejemplos de como leer los datos , escribir y guardar.

Una cosa importante con respecto a leer datos de un archivo con Input es que, si el archivo que queremos abrir, no existe, se producirá un error en tiempo de ejecución al intentar abrir un archivo que no existe, por eso debemos verificar la ruta del mismo siempre que esté bien escrita en la sentencia Open y evitarnos dolores de cabeza, y simpre añadir algún manejador de error para este caso

Output: esta sentencia se utiliaza para crear un archivo de texto y grabar datos. Esta es igual que Append salvo por un gran detalle:

Output crea el archivo y le agrega información, pero si el archivo existía y contenía información previa, sobre escribe todos los datos del archivo por los datos nuevos, perdiendo los anteriores datos.

Si accedemos con Output a un archivo que no existe, no se produce un error, si no que se crea dicho archivo.

Conclusión : si vamos a añadir datos a un archivo existente (para actualizarlo por ejemplo) hay que utilizar la sentencia Append. si vamos a crear un archivo vacío y nuevo para grabar nuevos datos, hay que utilizar la sentencia Output. si vamos a abrir un archivo para leer datos utilizamos la sentencia Input.

Manejo de archivos secuenciales en Visual Basic 6.0


Los archivos secuenciales se denominan de esta manera por que la forma de escribir y leer los datos en un archivo es, desde el principio hasta el fin del archivo, es decir, si yo quisiera acceder a un determinado dato del archivo y este dato se encuentra en la mitad del archivo, para llegar a ese dato necesito pasar por todos los demás datos, de forma secuencial.

Por lo general se suelen utilizar los archivos secuenciales, para trabajar con archivos que contengan una estructura de datos no muy compleja. por que por ejemplo, si utilizáramos un archivo para almacenar 50000 nombres con sus respectivos datos (apellido, teléfono, dirección etc...) , este mecanismo resultaría ineficiente, ya que si quisiera recuperar por ejemplo el registro n° 3650, para leer este dato tendría que pasar previamente por los 3649 registros anteriores a este, haciendo mas lento el acceso y por lo tanto desperdiciando recursos del sistema.

Sentencia Open en Visual Basic 6.0


Esta sentencia es la encargada de abrir o crear un archivo, ya sea para leer datos del mismo, sobre escribirlos y/o para agregarle datos.

Esta sentencia tiene una serie de parámetros que varían de acuerdo a lo que queramos hacer.

Por ejemplo :



Open "c:\prueba.txt" For Input As #1


Este ejemplo abre un archivo para poder acceder a los datos que contenga en su interior. cuando decimos abrir, estamos diciendo que se encuentra actualmente abierto y alojado en la memoria ram para poder manipularlo.

En el primer parámetro indicamos el path del archivo en el que queremos trabajar.

Luego la palabra "As #1" indica el número de archivo que estamos utilizando. Este número lo asignamos nosotros y va desde el rango 1 al 511. El "número de archivo" se utiliza para poder diferenciar al archivo en el código. Cada archivo que se encuentra abierto no se puede asignar un número de archivo igual, ya que nos daría un error en tiempo de ejecución.

Por ejemplo no podríamos hacer esto:



Open "archivo1.txt" For Input As #1
Open "otroarchivo1.txt" For Input As #1


Una vez que terminamos de trabajar con un archivo que se encuentra abierto y que no lo vamos a utilizar mas, debemos cerrarlo. para ello se utiliza la sentencia Close seguido del número de archivo que lo identifica.

Por ejemplo:

Close #2


Esto cerrará al archivo abierto que anteriormente le asignamos el número de archivo 2. También si tengo 3 archivos abiertos podría hacer lo siguiente:

Close #1, #2, #3


Si utilizamos la sentencia Close sin ningún parámetro, o mejor dicho ningún número de archivo, se cerrarán todos los archivos cargados en memoria por nuestra aplicación (los que nosotros abrimos con Open).

Por lo general, si trabajamos con varios archivos abiertos simultáneamente, es aconsejable utilizar la sentencia Close sin ningún parámetro, de este modo cuando termine de ejecutarse el procedimiento se cerrarán todos los archivos abiertos.

Hay una función en Visual basic llamada FreeFile. Esta función lo que hace es darnos un número de archivo que esté libre y que se pueda usar, para que de este modo no intentamos abrir uno esté siendo utilizado, y evitar un error en tiempo de ejecución. Para usar la función es muy fácil, por ejemplo:

Dim NumeroArchivo As Integer

NumeroArchivo = FreeFile

Open "La ruta de un archivo" For Input As #NumeroArchivo

¿como pasar un arreglo o vector de controles como parámetro a una Sub o function en visual basic 6.0?



Una tarea habitual es la de poder pasar un arreglo o vector de controles como parámetro a una Sub o function.

Por ejemplo supongamos que tenemos un programa que tiene muchos formularios. y varios de esos formularios tienen una función que se encarga de limpiar todas los textBox y eliminar el contenido de los mismos

Para solucionar esto, y no tener que repetir código, podríamos crear en un módulo de código, una SubRutina para que la puedan utilizar y acceder desde todos los formularios.

Para poder pasar un vector como parámetro a una rutina, la variable o argumento en la Subrutina, debe estar declarada como de tipo Object

Ejemplo

Colocar en un formulario un arreglo de textBox, por ejemplo TextBox1(0), TextBox1(1) y TextBox1(2)

Colocar un CommandButton para limpiar el contenido de las cajas de texto

Código fuente en el formulario

Option Explicit

Private Sub Command1_Click()
Call Limpiar_TextBox(Text1)
End Sub


' Recibe el vector como parámetro
Sub Limpiar_TextBox(El_TextBox As Object)

Dim i As Integer

For i = 0 To El_TextBox.Count - 1
El_TextBox(i).Text = vbNullString
Next

End Sub