Shark ' VR

Función Name para el manejo de archivos y directorios en visual basic 6.0

2009-11-20T19:42:00.001-08:00

Name se utiliza para renombrar archivos y directorios. Esta función no se puede utilizar para renombrar archivos abiertos.

Ejemplo:

Name "path del archivo viejo a renombrar" as "path y nombre nuevo del archivo"

También con esta sentencia podemos mover archivos y directorios a otra ubicación. para ello debemos cambiar en el segundo parámetro la ruta del archivo.

Función FileLen para el manejo de Archivos y directorios en Visual Basic 6.0

2009-11-20T19:41:00.001-08:00

Esta función nos devuelve el tamaño en bytes de un archivo.

Ejemplo:

Dim tamaño As Long

tamaño = FileLen("c:\windows\system32\control.exe")

MsgBox tamaño & " bytes"

FileLen es muy útil para trabajar con archivos aleatorios, ya que si queremos conocer la cantidad de registros que tiene el archivo, debemos dividir el tamaño del archivo por el tamaño de la estructura.

Ejemplo:

Private Type t_personas

nombre As String * 20
apellido As String * 20

End Type

Dim cant_reg As Long

Private Sub Form_Load()

cant_reg = FileLen("c:\miarchivo.dat") / Len(t_personas)

End Sub

Función kill para el manejo de ficheros y directorios en Visual Basic 6.0

2009-11-20T19:39:00.000-08:00

La función kill se utiliza para eliminar archivos. También es muy fácil de utilizar, y el único parámetro que lleva es la ruta del archivo que queremos eliminar. Si queremos eliminar varios archivos de un directorio podemos utilizar el comodín"*", y si queremos excluir ciertos archivos utilizamos el comodín "?".

kill "c:\*.txt"

Función MkDir para el manejo de ficheros y directorios en Visual Basic 6.0

2009-11-20T19:36:00.001-08:00

Esta función se utiliza para crear directorios, pero crea un directorio por vez, es decir que no crea varios niveles al mismo tiempo. La sintaxis es:

MkDir "Ruta directorio"

para poder crear un Directorio que contiene varios subdirectorios, podemos hacer lo siguiente:

El ejemplo despliega un InputBox para ingresar el path a crear:

Private Sub Command1_Click()

Dim i As Integer
Dim Array_Dir As Variant
Dim Sub_Dir As String
Dim El_Path As String

El_Path = InputBox("Escriba la ruta del directorio a crear" & _
"con los subdirectorios", " Crear varios niveles de directorios")

If El_Path = vbNullString Then Exit Sub

'Desglosa el path
Array_Dir = Split(El_Path, "\")

El_Path = vbNullString

'Recorre el array anterior para ir creando uno por uno
For i = LBound(Array_Dir) To UBound(Array_Dir)

Sub_Dir = Array_Dir(i)

If Len(Sub_Dir) > 0 Then
El_Path = El_Path & Sub_Dir & "\"

If Right$(Sub_Dir, 1) <> ":" Then
' Verificamos que no exista
If Dir$(El_Path, vbDirectory) = vbNullString Then
'Crea la carpeta
Call MkDir(El_Path)
End If
End If
End If
Next i

End Sub

Función FileCopy para el manejo de ficheros y directorios en Visual Basic 6.0

2009-11-20T19:34:00.001-08:00

FileCopy nos permite copiar archivos. Esta función es muy fácil de usar. ejemplo:

FileCopy "origen", "destino"

Nota: si el archivo existe la función lo sobre escribe.

Función Dir para el manejo de ficheros y directorios en Visual Basic 6.0

2009-11-20T19:32:00.000-08:00

La función Dir se utiliza o para buscar archivos y devuelve una cadena que representa el nombre de un archivo o directorio de acuerdo a un determinado patrón de búsqueda. La sintaxis de la función es:

Dir (ruta, atributos)

En el parámetro ruta debemos indicar el path de un archivo, directorio o unidad. Si el path no existe, la función Dir devuelve una cadena vacía.

En el parámetro atributos podemos especificar los siguientes:

vbnormal : cualquier atributo de archivo.
vbreadonly : archivos de solo lectura.
vbhidden: archivos ocultos
vbsystem : archivos de sistema
vbvolume : etiqueta de volumen de una unidad
vbdirectory : directorios
Ejemplo:

Si el archivo existe Dir devuelve "autoexec.bat"

Archivoabuscar = Dir("c:\autoexec.bat")

También podemos utilizar los comodines * y ? para filtrar búsquedas.

En este ejemplo devuelve el primer archivo exe que encuentra, si es que existe.

Archivoabuscar = Dir("c:\windows\*.exe")

En este ejemplo la función Dir devuelve directorios además de archivos

Archivoabuscar = Dir("c:\, vbdirectory")

El único inconveniente de esta función es que siempre devuelve el primer archivo que encuentra. Para que continúe buscando los demás archivos debemos poner la función sin parámetros. Ejemplo

Dim archivo As String

archivo = Dir("c:\*.exe")

While archivo <> ""
archivo = Dir
Wend

En el ejemplo anterior buscará todos los archivos exe en el directorio c:\. cuando ya no encuentre mas devolverá una cadena vacía y saldrá del bucle While.

Este otro ejemplo verifica si un archivo existe:

Private Function Verificar_Existe(path) As Boolean

If Len(Trim$(Dir$(path))) Then
Verificar_Existe = True
Else
Verificar_Existe = False
End If

MsgBox Verificar_Existe

End Function

Private Sub Form_Load()

Call Verificar_Existe("c:\autoexec.bat")

End Sub

Posicionarse en un registro determinado con Visual Basic 6.0

2009-11-20T19:31:00.001-08:00

Supongamos que tenemos un archivo aleatorio que contiene 452 registros. Ahora queremos recuperar los datos del registro 258. Para posicionarse en un determinado registro hay una sentencia , hay una sentencia llamada Seek. Ejemplo:

Seek #1, 258
Get #1, , mivariable

si queremos posicionarnos en un registro determinado, pero en vez de leer, queremos grabar datos, hacemos la misma operación pero con la sentencia Put:

Seek #1, 258
Put #1, , mivariable

Leer datos en archivos aleatorios en Visual Basic 6.0

2009-11-20T19:30:00.001-08:00

Para leer los registros o datos de un archivo aleatorio se utiliza la sentencia Get. Esta sentencia es exactamente igual que Put, pero la diferencia es que en vez de grabar los datos los recupera para poder utilizarlos luego en el programa.

Grabar datos en archivos aleatorios en Visual Basic 6.0

2009-11-20T19:27:00.000-08:00

Para grabar datos en un archivo de acceso aleatorio se utiliza la sentencia Put.

Un ejemplo paso a paso:

primero declaramos una estructura de datos que contendrá la información de cada registro:

Private Type t_empleados
nombre As String * 15
apellido As String * 15
dirección As String * 30
edad As Integer
End Type

Luego creamos una variable que sea de tipo t_empleados.

Dim empleados As t_empleados
Ahora abrimos el archivo e indicamos en la función Len el tamaño de la estructura

Open "datos.dat" For Random As #1 Len = Len(clientes)

Ahora le asignamos un valor a cada campo de la estructura de esta forma:

empleados.nombre = "Carlos"
empleados.apellido = "Martinez"
empleados.dirección = "Avenida 9 de julio n° 2054"
empleados.edad = 45

Ahora grabamos en el registro n°1 del archivo los datos de esta forma:

Put #1, 1, empleados

Si queremos grabar mas datos, por ejemplo en el registro n° 2 del archivo hacemos lo siguiente:

empleados.nombre = "María"
empleados.apellido = "Gonzales"
empleados.dirección = "Avenida 13 n° 1100"
empleados.edad = 35

Put #1, 2, empleados

Close #1

como vemos ver la sentencia Put lleva 3 parámetros. El primero indica el numero de archivo abierto en el cual estamos trabajando. en el segundo debemos indicar el número de registro en el que se grabarán los datos. Si no ponemos el número de registro, los datos se grabarán en el último registro. Por último en el tercer parámetro le pasamos la variable asociada con la estructura de datos.

Archivos aleatorios o directos con Visual Basic 6.0

2009-11-20T19:25:00.000-08:00

A diferencia de los archivos secuenciales, los archivos aleatorios almacenan datos en forma de registros. Como habíamos dicho en el capítulo anterior para leer datos de un archivo secuencial había que leer todo el archivo, es decir que no podíamos leer por ejemplo los datos que estuviesen en la línea 35 del mismo sin antes pasar por todos los datos anteriores, por eso su nombre de archivo secuencial.

En cambio los archivos aleatorios, también llamados archivos directos, almacenan los datos con una estructura diferente. Los datos se guardan en registros mediante una estructura definida de tipo Type (estructura definida por nosotros) también llamada UDT

Por ejemplo si tuviesemos 25 registros, cada uno con datos (apellido, email, telefono,etc..), y quisiera acceder al registro 17, puedo leer los datos del registro 17 sin tener que leer los 16 registros anteriores, ganando con ello mas velocidad y teniendo una estructura de datos definida.

Para abrir un archivo aleatorio para trabajar con él, se utiliza la sentencia Open con algunos cambios en lo que se refiere a los archivos secuenciales

Ejemplo:

open "elarchivo.dat" for random as #1 len = len(mivariable)

Como podemos ver para abrir un archivo de acceso aleatorio se utiliza la palabra Random (aleatorio). Luego debemos indicar el número de archivo para identificarlo, y por último una opción nueva : Len.

cada registro en el archivo, que es una estructura de datos Type, tiene que tener una longitud fija. Mediante la función Len de visual Basic debemos indicar el tamaño de la estructura de datos que vamos a utilizar. para que quede mas claro un ejemplo:

Primero definimos una estructura de datos:

Private Type t_clientes

nombre As String * 20
apellido As String * 15
dirección As String * 30
edad As Integer

End Type

Después creamos una variable llamada clientes de tipo t_clientes

Dim clientes As t_clientes

ahora abrimos nuestro archivo, y en el parámetro de la función Len le pasamos la variable para que visual basic calcule el tamaño de la estructura t_clientes

Open "datos.dat" For Random As #1 Len = Len(clientes)

La estructura de datos debe tener un tamaño fijo, no datos variables como en el caso de los archivos secuenciales, de ahí que se indicara en el Type en las variables mediante el asterisco en el caso de los String.

En cada campo de la estructura de datos debemos indicar el tamaño de la variable. En el caso del campo nombre de tipo string le hemos asignado una longitud fija de 20 bytes, en el apellido 15 y en la dirección 30 bytes. La variable o el campo edad que es de tipo integer, no debemos indicar el tamaño de la variable, ya que sabemos que un número integer ocupa 2 bytes.

En total esta estructura t_clientes tiene una longitud de 67 bytes (30 + 20 + 15 + 2 ).

Si no indicáramos en la sentencia Open el tamaño de la estructura, visual basic, por defecto asumiría la estructura de un tamaño de 128 bytes, y si nuestra estructura tendría mayor tamaño ocurriría un error en tiempo de ejecución, por lo cual siempre debemos utilizar la función len para calcular el tamaño de la misma.

Escribir datos en archivos de texto con Visual Basic 6.0

2009-06-28T09:46:00.001-07:00

Para escribir datos en archivos de texto se utiliza la sentencia Print y Write.

Ejemplo:

Dim nombre As String
Dim edad As Integer
Dim telefono As String
Open "c:\miarchivo.txt" For Append As #1Print #1, "esta es una línea"
Print #1, "esta es otra línea"
Print #1, nombre, edad, telefonoClose #1

En este ejemplo agregamos datos a un archivo existente llamado miArchivo.txt con la sentencia Print.

Primero abrimos el archivo con Open. luego la sentencia Print lleva 2 parámetros. el primero indica el archivo que estamos manipulando (el archivo n°1, dentro del código), el segundo parámetro indica los datos que se agregarán en el mismo. En el segundo parámetro podemos poner un dato directamente (una cadena, número, etc...),, por último cerramos el archivo.

Escribir datos con la sentencia Write

A diferencia de Print, la sentencia Write escribe datos en un archivo separados por comas.

Ejemplo:

Dim nombre As StringDim apellido As String
apellido = "Peres"
nombre = "Carlos"Open App.Path & "\Archivo.txt" For Output As #1Write #1, nombre, apellidoClose #1

Como podemos ver la sentencia Write escribe los datos en el archivo separados por coma. En la primera línea escribirá el contenido de las variables nombre y apellido . También se pueden pasar los datos directamente a Write sin usar variables, por ejemplo:

Write #1, "Un dato", "Otro dato", "Otro mas"

Nota importante: cuando escribimos datos con la sentencia Print se utiliza la sentencia Line Input para leer los datos del archivo. En cambio cuando escribimos datos separados por comas con la sentencia Write debemos utilizar la sencia Input

Para que esta página no sea tan extensa, he armado 10 ejercicios que utilizan todo lo visto hasta aquí, o sea el tema relacionado a los archivos secuenciales. Dentro del código se encuentra detallado cada paso y lo podés descargar al final de esta página.

Leer el contenido de un archivo de texto con la función Input con Visual Basic 6.0

2009-06-28T09:44:00.000-07:00

La función input, a diferencia de Line Input que Lee por línea, Input lee todo el contenido del archivo de una sola ves, es decir no necesitamos, como en el ejemplo anterior, utilizar un bucle.

El modo de usarlo es el siguiente:

Primero se abre el archivo con Open, por ejemplo:

Open Path_Archivo For Input As #1

Luego se asigna a una variable, el contenido que devolverá la función Input:

Contenido = Input(LOF(1), #1)

Un ejemplo:

Lo siguiente lee el contenido de un archivo txt y lo carga en un textBox multilínea

Colocar un TextBox llamado txt_Path ( para especificar la ruta del archivo ).

El Textbox que mostrará los datos del fichero, colocarle el nombre txt_Contenido

Código en un botón:

On Error GoTo Err_Sub

Dim n_File As Integer
Dim Contenido As String

'Número de archivo libre
n_File = FreeFile

'Abre el archivo indicado
Open txt_Path For Input As n_File

'Lee todo los datos del archivo y lo almacena en la variable
Contenido = Input$(LOF(n_File), #n_File)

'Cierra el archivo abierto
Close n_File

'Carga el contenido de la variable en el TextBox
txt_Contenido = Contenido

Exit Sub

Err_Sub:

MsgBox Err.Description, vbCritical

Ejemplo para leer un archivo de texto utilizando Line Input en Visual Basic 6.0

2009-06-28T09:40:00.000-07:00

Lo siguiente, lee un archivo de texto línea por línea, y carga el contenido en un control ListBox. colocar un control List1, un Command1 y un Text1 para indicar el path del archivo a leer:

Option Explicit

Private Sub Command1_Click()
On Error GoTo errSub

Dim n_File As Integer
Dim Linea As String

'Elimina el contenido del listbox
List1.Clear

'Número de archivo libre
n_File = FreeFile

'Abre el archivo para leer los datos
Open text1.Text For Input As n_File

'Recorre linea a linea el mismo y añade las lineas al control List
Do While Not EOF(n_File)

'Lee la linea
Line Input #n_File, Linea
List1.AddItem Linea
Loop

Exit Sub
errSub:
'error
MsgBox "Número de error: " & Err.Number & vbNewLine & _
"Descripción del error: " & Err.Description, vbCritical
End Sub

Private Sub Form_Load()

Command1.Caption = " Cargar en Listbox "

End Sub

Eliminar Objetos no Utilizados en Java

2009-02-18T20:21:00.000-08:00

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

2009-02-18T20:18:00.000-08:00

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

2009-02-18T20:14:00.000-08:00

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

2009-02-18T19:59:00.000-08:00

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

2009-02-18T19:48:00.000-08:00

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.

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

2009-02-15T07:36:00.000-08:00

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

2009-02-15T07:35:00.001-08:00

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

2009-02-15T07:33:00.000-08:00

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

2009-02-15T07:32:00.001-08:00

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?

2009-02-15T07:27:00.000-08:00

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

Clave primaria en Mysql

2008-12-07T10:34:00.000-08:00

Una clave primaria es un campo (o varios) que identifica 1 solo registro (fila) en una tabla.

Para un valor del campo clave existe solamente 1 registro. Los valores no se repiten ni pueden ser nulos.

Veamos un ejemplo, si tenemos una tabla con datos de personas, el número de documento puede establecerse como clave primaria, es un valor que no se repite; puede haber personas con igual apellido y nombre, incluso el mismo domicilio (padre e hijo por ejemplo), pero su documento será siempre distinto.

Si tenemos la tabla "usuarios", el nombre de cada usuario puede establecerse como clave primaria, es un valor que no se repite; puede haber usuarios con igual clave, pero su nombre de usuario será siempre distinto.

Establecemos que un campo sea clave primaria al momento de creación de la tabla:

create table usuarios (
nombre varchar(20),
clave varchar(10),
primary key(nombre)
);

Para definir un campo como clave primaria agregamos "primary key" luego de la definición de todos los campos y entre paréntesis colocamos el nombre del campo que queremos como clave.

Si visualizamos la estructura de la tabla con "describe" vemos que el campo "nombre" es clave primaria y no acepta valores nulos(más adelante explicaremos esto detalladamente).

Ingresamos algunos registros:

insert into usuarios (nombre, clave)
values ('Leonardo','payaso');
insert into usuarios (nombre, clave)
values ('MarioPerez','Marito');
insert into usuarios (nombre, clave)
values ('Marcelo','River');
insert into usuarios (nombre, clave)
values ('Gustavo','River');

Si intentamos ingresar un valor para el campo clave que ya existe, aparece un mensaje de error indicando que el registro no se cargó pues el dato clave existe. Esto sucede porque los campos definidos como clave primaria no pueden repetirse.

Ingresamos un registro con un nombre de usuario repetido, por ejemplo:

insert into usuarios (nombre, clave)
values ('Gustavo','Boca');

Una tabla sólo puede tener una clave primaria. Cualquier campo (de cualquier tipo) puede ser clave primaria, debe cumplir como requisito, que sus valores no se repitan.

Al establecer una clave primaria estamos indexando la tabla, es decir, creando un índice para dicha tabla; a este tema lo veremos más adelante.

Modificación de registros de una tabla (update) en Mysql

2008-12-07T10:29:00.000-08:00

Para modificar uno o varios datos de uno o varios registros utilizamos "update" (actualizar).

Por ejemplo, en nuestra tabla "usuarios", queremos cambiar los valores de todas las claves, por "RealMadrid":

update usuarios set clave='RealMadrid';

Utilizamos "update" junto al nombre de la tabla y "set" junto con el campo a modificar y su nuevo valor.

El cambio afectará a todos los registros.

Podemos modificar algunos registros, para ello debemos establecer condiciones de selección con "where".

Por ejemplo, queremos cambiar el valor correspondiente a la clave de nuestro usuario llamado 'MarioPerez', queremos como nueva clave 'Boca', necesitamos una condición "where" que afecte solamente a este registro:

update usuarios set clave='Boca'
where nombre='MarioPerez';

Si no encuentra registros que cumplan con la condición del "where", ningún registro es afectado.

Las condiciones no son obligatorias, pero si omitimos la cláusula "where", la actualización afectará a todos los registros.

También se puede actualizar varios campos en una sola instrucción:

update usuarios set nombre='MarceloDuarte', clave='Marce'
where nombre='Marcelo';

Para ello colocamos "update", el nombre de la tabla, "set" junto al nombre del campo y el nuevo valor y separado por coma, el otro nombre del campo con su nuevo valor.

Borrado de registros de una tabla (delete) en Mysql

2008-12-07T10:27:00.000-08:00

Para eliminar los registros de una tabla usamos el comando "delete":

delete from usuarios;

La ejecución del comando indicado en la línea anterior borra TODOS los registros de la tabla.

Si queremos eliminar uno o varios registros debemos indicar cuál o cuáles, para ello utilizamos el comando "delete" junto con la clausula "where" con la cual establecemos la condición que deben cumplir los registros a borrar. Por ejemplo, queremos eliminar aquel registro cuyo nombre de usuario es 'Leonardo':

delete from usuarios where nombre='Leonardo';
Si solicitamos el borrado de un registro que no existe, es decir, ningún registro cumple con la condición especificada, no se borrarán registros, pues no encontró registros con ese dato.

Operadores Relacionales ( = <> < <= > >= ) en Mysql

2008-12-07T10:25:00.000-08:00

Hemos aprendido a especificar condiciones de igualdad para seleccionar registros de una tabla; por ejemplo:

select titulo,autor,editorial from libros where autor='Borges';

Utilizamos el operador relacional de igualdad.

Los operadores relacionales vinculan un campo con un valor para que MySQL compare cada registro (el campo especificado) con el valor dado.

Los operadores relacionales son los siguientes:

= igual
<> distinto
> mayor
< menor
>= mayor o igual
<= menor o igual

Podemos seleccionar los registros cuyo autor sea diferente de 'Borges', para ello usamos la condición:

select titulo,autor,editorial from libros where autor<>'Borges';

Podemos comparar valores numéricos. Por ejemplo, queremos mostrar los libros cuyos precios sean mayores a 20 pesos:

select titulo,autor,editorial,precio from libros where precio>20;

También, los libros cuyo precio sea menor o igual a 30:

select titulo,autor,editorial,precio from libros where precio<=30;

Recuperación de registros específicos (select - where) en Mysql

2008-12-07T10:23:00.000-08:00

Hemos aprendido cómo ver todos los registros de una tabla:

select nombre, clave from usuarios;

El comando "select" recupera los registros de una tabla. Detallando los nombres de los campos separados por comas, indicamos que seleccione todos los campos de la tabla que nombramos.

Existe una cláusula, "where" que es opcional, con ella podemos especificar condiciones para la consulta "select". Es decir, podemos recuperar algunos registros, sólo los que cumplan con ciertas condiciones indicadas con la cláusula "where". Por ejemplo, queremos ver el usuario cuyo nombre es "MarioPerez", para ello utilizamos "where" y luego de ella, la condición:

select nombre, clave from usuarios where nombre='MarioPerez';

Para las condiciones se utilizan operadores relacionales (tema que trataremos más adelante en detalle). El signo igual(=) es un operador relacional. Para la siguiente selección de registros especificamos una condición que solicita los usuarios cuya clave es igual a 'bocajunior':

select nombre, clave from usuarios where clave='bocajunior';

Si ningún registro cumple la condición establecida con el "where", no aparecerá ningún registro.

Recuperación de algunos campos (select) en Mysql

2008-12-07T10:19:00.000-08:00

Ya hemos visto cómo ver todos los registros de una tabla:

select * from libros;

El comando "select" recupera los registros de una tabla. Con el asterisco (*) indicamos que seleccione todos los campos de la tabla que nombramos.

Podemos especificar el nombre de los campos que queremos ver separándolos por comas:

select titulo,autor,editorial from libros;

En la sentencia anterior la consulta mostrará sólo los campos "titulo", "autor" y "editorial". En la siguiente sentencia, veremos los campos correspondientes al título y precio de todos los libros:

select titulo,precio from libros;

Para ver solamente la editorial y la cantidad de libros tipeamos:

select editorial,cantidad from libros;

Típos de datos básicos de un campo de una tabla en Mysql

2008-12-07T10:16:00.000-08:00

como sabemos que al crear una tabla debemos resolver qué campos (columnas) tendrá y que tipo de datos almacenará cada uno de ellos, es decir, su estructura. Estos son algunos tipos de datos básicos:

- varchar: se usa para almacenar cadenas de caracteres. Una cadena es una secuencia de caracteres. Se coloca entre comillas (simples): 'Hola'. El tipo "varchar" define una cadena de longitud variable en la cual determinamos el máximo de caracteres. Puede guardar hasta 255 caracteres. Para almacenar cadenas de hasta 30 caracteres, definimos un campo de tipo varchar(30). Si asignamos una cadena de caracteres de mayor longitud que la definida, la cadena se corta. Por ejemplo, si definimos un campo de tipo varchar(10) y le asignamos la cadena 'Buenas tardes', se almacenará 'Buenas tar' ajustándose a la longitud de 10 caracteres.

- integer: se usa para guardar valores numéricos enteros, de -2000000000 a 2000000000 aprox. Definimos campos de este tipo cuando queremos representar, por ejemplo, cantidades.

- float: se usa para almacenar valores numéricos decimales. Se utiliza como separador el punto (.). Definimos campos de este tipo para precios, por ejemplo.

Antes de crear una tabla debemos pensar en sus campos y optar por el tipo de dato adecuado para cada uno de ellos. Por ejemplo, si en un campo almacenaremos números enteros, el tipo "float" sería una mala elección; si vamos a guardar precios, el tipo "float" es correcto, no así "integer" que no tiene decimales.

Carga de registros a una tabla y su recuperación en Mysql

2008-12-07T10:12:00.000-08:00

Un registro es una fila de la tabla que contiene los datos propiamente dichos. Cada registro tiene un dato por cada columna.

Recordemos como crear la tabla "usuarios":

create table usuarios (
nombre varchar(30),
clave varchar(10)
);

Al ingresar los datos de cada registro debe tenerse en cuenta la cantidad y el orden de los campos.

Ahora vamos a agregar un registro a la tabla:

insert into usuarios (nombre, clave) values ('MarioPerez','Mariope');

Usamos "insert into". Especificamos los nombres de los campos entre paréntesis y separados por comas y luego los valores para cada campo, también entre paréntesis y separados por comas.

La tabla usuarios ahora la podemos graficar de la siguiente forma:

nombre clave
MarioPerez Mariope

Es importante ingresar los valores en el mismo orden en que se nombran los campos, si ingresamos los datos en otro orden, no aparece un mensaje de error y los datos se guardan de modo incorrecto.

Note que los datos ingresados, como corresponden a campos de cadenas de caracteres se colocan entre comillas simples. Las comillas simples son OBLIGATORIAS.

Para ver los registros de una tabla usamos "select":

select nombre,clave from usuarios;

Aparece un registro.

El comando "select" recupera los registros de una tabla. Luego del comando select indicamos los nombres de los campos a rescatar.

Creación de una tabla y Mostrar sus campos en Mysql

2008-12-07T10:03:00.000-08:00

Una base de datos almacena sus datos en tablas.

Una tabla es una estructura de datos que organiza los datos en columnas y filas; cada columna es un campo (o atributo) y cada fila, un registro. La intersección de una columna con una fila, contiene un dato específico, un solo valor.

Cada registro contiene un dato por cada columna de la tabla.

Cada campo (columna) debe tener un nombre. El nombre del campo hace referencia a la información que almacenará.

Cada campo (columna) también debe definir el tipo de dato que almacenará.

NOMBRE CLAVE
MarioPerez Mariope
MariaGarcia Mary
DiegoRodriguez z8080

Gráficamente acá tenemos la tabla usuarios, que contiene dos campos llamados:nombre y clave. Luego tenemos tres registros almacenados en esta tabla, el primero almacena en el campo nombre el valor "MarioPerez" y en el campo clave "Mariope", y así sucesivamente con los otros dos registros.

Las tablas forman parte de una base de datos.

Nosotros trabajaremos con la base de datos llamada "administracion", que ya hemos creado en el servidor mysqlya.com.ar.

Para ver las tablas existentes en una base de datos tipeamos:

show tables;

Deben aparecer todas las tablas que han creado los visitantes al sitio mysqlya.com.ar

Al crear una tabla debemos resolver qué campos (columnas) tendrá y que tipo de datos almacenarán cada uno de ellos, es decir, su estructura.

La tabla debe ser definida con un nombre que la identifique y con el cual accederemos a ella.

Creamos una tabla llamada "usuarios", tipeamos:

create table usuarios (
nombre varchar(30),
clave varchar(10)
);

Si intentamos crear una tabla con un nombre ya existente (existe otra tabla con ese nombre), mostrará un mensaje de error indicando que la acción no se realizó porque ya existe una tabla con el mismo nombre.

Para ver las tablas existentes en una base de datos tipeamos nuevamente:

show tables;

Ahora aparece "usuarios" entre otras que ya pueden estar creadas.

Cuando se crea una tabla debemos indicar su nombre y definir sus campos con su tipo de dato. En esta tabla "usuarios" definimos 2 campos:

- nombre: que contendrá una cadena de hasta 30 caracteres de longitud,
que almacenará el nombre de usuario y
- clave: otra cadena de caracteres de 10 de longitud, que guardará la clave de
cada usuario.

Cada usuario ocupará un registro de esta tabla, con su respectivo nombre y clave.

Para ver la estructura de una tabla usamos el comando "describe" junto al nombre de la tabla:

describe usuarios;

Aparece lo siguiente:

Field Type Null
_________________________
nombre varchar(30) YES
clave varchar(10) YES

Esta es la estructura de la tabla "usuarios"; nos muestra cada campo, su tipo, lo que ocupa en bytes y otros datos como la aceptación de valores nulos etc, que veremos más adelante en detalle.

Para eliminar una tabla usamos "drop table". Tipeamos:

drop table usuarios;

Si tipeamos nuevamente:

drop table usuarios;

Aparece un mensaje de error, indicando que no existe, ya que intentamos borrar una tabla inexistente.

Para evitar este mensaje podemos tipear:

drop table if exists usuarios;

En la sentencia precedente especificamos que elimine la tabla "usuarios" si existe.

Ejemplo para crear un arreglo de controles en Visual Basic 6.0

2008-10-26T18:23:00.000-07:00

Para crear un arreglo de controles podemos hacerlo de 2 maneras.

La primera opción es copiar un control ya dibujado y pegarlo en el formulario. Luego visual basic nos mostrará un diálogo preguntándonos si queremos crear una matriz de controles. Al contestar que si, ya se ha creado un arreglo con 2 controles, en este caso el primer control tendrá el índice 0 y el que pegamos el índice 1. Si queremos seguir agregando mas controles cuando peguemos nuevamente otro control visual basic no nos preguntará nuevamente si deseamos crear una matriz del control ya que esta ya está creada, y por lo tanto agregará un nuevo control y le agregará el número de índice correspondiente para diferenciarlo del resto, en este caso el 2. Ahora si observas en la propiedad index de los controles que forman el arreglo verás que estos tienen un número de índice que antes no tenían al no formar parte de un arreglo de controles

Nota: cualquier control de visual basic que no tenga un arreglo creado, la propiedad index de los mismos no tendrá ningún número o valor, ya que esta propiedad está reservada para los controles que formen parte de un vector o arreglo.

La otra opción para crear un arreglo, es ingresar directamente el número de índice en la propiedad index del control del cual queremos crear un arreglo.

Ejemplo:

El ejemplo consiste en crear 10 Arreglos de TextBox y lo que se va a hacer es mediante un bucle poner la propiedad Enabled de los controles en False, es decir los vamos a deshabilitar a todos.

Como te darás cuenta, si tuvieses que hacer esto manualmente, es decir deshabilitar cada TextBox individualmente tendrías que escribir

text1.enabled = False

y así para cada uno de los controles. en cambio haciendo un arreglo de controles, recorremos mediante un For todos los controles refiriendonos al índice y estableciéndole la propiedad Enabled en False para deshabilitarlos.

Create un arreglo de 10 TextBox Para eso coloca un text1 en el formulario. después copialo y pegalo, vb te va a preguntará si querés hacer un arreglo, decile que si, hasta que tengas 10 o los que quieras.

Si te fijás ahora en la ventana de propiedades, cuando seleccionas un textBox en la propiedad index te vas a dar cuenta que poseen un número, ese es el índice que los identifica, y por medio de ese índice nos vamos a referir en el bucle For

El código de este ejemplo bien simple quedaría así:

Dim i As Integer

For i = 0 To 9

text1(i).Enabled = False

Next

Como podés ver, le pasamos en el parámetro índice el valor de la variable i para referirnos a ese text1 en particular y asignarle la propiedad Enabled en False.

Arreglos de controles en visual basic 6.0

2008-10-26T18:20:00.000-07:00

hasta ahora se vió los aspectos de los vectores y matrices como estructuras que nos permiten almacenar datos y resolver problemas lógicos en nuestros programas. Ahora veremos los Arreglos de controles o vectores de controles

Un arreglo de controles es un conjunto de controles, todos de la misma clase (todos TextBox, todos Label, etc...) que poseen un mismo nombre y cada uno posee un número de índice que los identifica y los hace únicos con respecto a los demás, y conformando entonces un vector de controles. por ejemplo en vez de tener 3 Command, llamados command1, command2 y command3, puedo crear un arreglo de 3 botones. Estos 3 botones comparten el mismo nombre pero cada botón se distingue del resto por un número de índice, es decir si por ejemplo nuestro botón de comando se llama cmd pasaría a tener un cmd(1), un cmd (2) y un cmd(3).

En un arreglo de controles todos los controles deben ser del mismo tipo y además no puede haber un control dentro del arreglo que tenga el mismo número de índice, ya que sería imposible identificarlo en el conjunto, además VB no lo permitiría y nos mostraría un error.

Las ventajas principales que tenemos cuando trabajamos con un vector de controles son las siguientes:

Todos los controles que forman el arreglo comparten el mismo procedimiento de código, con lo cual si tenemos muchos controles que tienen que ejecutar la misma instrucción no debemos escribir código de más en cada control.
Tener 20 cajas de texto, por ejemplo, consumen mucha mas memoria que utilizar un vector de 20 cajas de texto.

Es posible crear controles en tiempo de ejecución, a partir de un arreglo de controles ya creado.

Es mas fácil manipular y establecer las propiedades en un vector de controles refiriendonos al subíndice de los mismos.

Funciónes Join, Split y Filter en visual basic 6.0

2008-10-26T18:15:00.000-07:00

Visual basic en su sexta versión incorpora estas 3 funciones para trabajar solo con vectores. Estas funciones están relacionadas con el tratamiento de las cadenas de caracteres.

Función Join

Esta función se utiliza para unir en una sola variable el conjunto de subcadenas de un vector. Esta función tiene solo 2 parámetros y es muy fácil de usar. Ejemplo:

Dim micadena as string
Dim vector(1 To 3) As String

vector(1) = "Carlos"
vector(2) = "Pedro"
vector(3) = "Juan"

Ahora ejecutando Join, la variable micadena pasaría a valer "Carlos-Pedro-Juan"

micadena = join (vector, "-")

Nota: En el primer parámetro de la función debemos indicar el vector en el cual trabajar, y en el segundo se debe indicar un delimitador de caracter para separar las cadenas. Si no especificamos ninguno, visual basic utilizará por defecto un espacio vacío o en blanco (" ") para separar cada subcadena .

Función Split:

Esta función hace el trabajo inverso de la función Join.

Split se utiliza para rellenar un vector dinámico que contiene un número de subcadenas a partir de una cadena que le pasamos como parámetro a la función.

Para aclarar un poco un ejemplo

Private Sub Form_Load()

'Una variable para almacenar una cadena
Dim Micadena As String 'Vector dinámico
Dim Vector() As String

'Le damos un valor a la variable
Micadena = "maria/natalia/romina"

'Ejecutamos la función Split
Vector = Split(Micadena, "/")

'Ahora el vector dinámico pasaría a _
contener los siguientes valores:

Vector(0) = "maría"
Vector(1) = "natalia"
Vector(2) = "Romina"

End Sub

Nota: una cosa importante es que en el vector anterior no se ha declarado un rango , ya que la función devuelve un vector cuya cantidad de elementos se ignora, es decir no se conoce.

Enlaces relacionados a split
Pasar un archivo de texto a un array o matriz usando split

Función Filter :

La función Filter se utiliza para filtrar subcadenas de un vector dependiendo de un determinado criterio de búsqueda. Los parámetros que lleva la función son los siguientes:

Filter (vector donde buscar, cadena a buscar, valor booleano que indica si incluir o excluir la cadena)

Ejemplo:

' Vector
Dim Alumnos(1 To 4) As String

' Vector dinámico para almacenar el resultado
Dim Resultado() As String

Alumnos(1) = "Luciano"
Alumnos(2) = "Lucas"
Alumnos(3) = "juan"
Alumnos(4) = "Natalia"

' Ejecutamos Filter

Resultado = Filter(Alumnos, "Lu", True)

' Ahora el vector dinámico "resultado" pasa a contener

MsgBox Resultado(0), vbInformation ' Luciano
MsgBox Resultado(1), vbInformation ' Lucas

Funciones de VB para trabajar con Arreglos (LBound y UBound) en Visual Basic 6.0

2008-10-26T18:12:00.000-07:00

Estas funciones son ideales para trabajar con vectores y matrices que han sido declaradas dinámicamente

Lbound y Ubound nos devuelve un número de tipo Long que nos permite saber el límite superior e inferior de un vector o una matriz.

Ejemplo de Ubound y Bound

Private Sub Form_Load()

'Variables Para almacenar los límites superior e inferior
Dim LimiteInferior As Long
Dim LimiteSuperior As Long

'Declaramos 3 matrices, de una dimensión, _
de dos dimensiones y de 3
Dim UnVector(1 To 520) As Integer
Dim UnaMatriz(20, 5 To 100) As String
Dim OtraMatriz(10, 20, 30) As Long

' Devuelve 1
LimiteInferior = LBound(UnVector)
' Devuelve 520
LimiteSuperior = UBound(UnVector)
' Devuelve 0
LimiteInferior = LBound(UnaMatriz, 1)
' Devuelve 20
LimiteSuperior = UBound(UnaMatriz, 1)
' Devuelve 5
LimiteInferior = LBound(UnaMatriz, 2)
' Devuelve 100
LimiteSuperior = UBound(UnaMatriz, 2)
' Devuelve 0
LimiteInferior = LBound(OtraMatriz, 1)
' Devuelve 10
LimiteSuperior = UBound(OtraMatriz, 1)
' Devuelve 0
LimiteInferior = LBound(OtraMatriz, 2)
' Devuelve 20
LimiteSuperior = UBound(OtraMatriz, 2)

' Devuelve 0
LimiteInferior = LBound(OtraMatriz, 3)
' Devuelve 30
LimiteSuperior = UBound(OtraMatriz, 3)

End Sub

Como habrás visto en los ejemplos anteriores, para conocer los limites superiores e inferiores en los vectores, solo se debe pasar como parámetro a las funciones Lbound y Ubound, el nombre del vector con el cual queremos trabajar.

En cambio en las matrices se añade un segundo parámetro en el cual debemos indicar el número de la dimensión en la cual queremos recuperar los valores.

Ejemplo de vectores y arreglos dinámicos en Visual Basic 6.0

2008-10-26T18:09:00.001-07:00

En lo siguiente, primero declaramos un vector de la forma como lo hacemos siempre con la diferencia de que en vez de colocar un tamaño declaramos el vector solo con los paréntesis :

Dim alumnos () as string

Ahora le establecemos un tamaño, por ejemplo de 4 elementos y le agregamos valores:

ReDim alumnos(1 To 4) As String

alumnos(1) = "Luciano"
alumnos(2) = "Esteban"
alumnos(3) = "Mariano"
alumnos(4) = "Pedro"

Ahora para redimensionar el tamaño del vector por ejemplo a 7 elementos, utilizamos la función ReDim Preserve, para preservar los 4 valores anteriores y le agregamos 3 valores mas:

ReDim Preserve alumnos(1 To 7)

alumnos(5) = "Karina"
alumnos(6) = "Raúl"
alumnos(7) = "Romina"

Nota: si utilizamos la sentencia ReDim, o mejor dicho si redimensionamos el vector sin utilizar la sentencia ReDim preserve, los valores que contenía el vector anteriormente se perderán

Eliminar o vaciar un vector

Para eliminar un array, arreglo o vector, podemos utilizar Erase, por ejemplo:

Erase Nombre_Del_Vector

Vectores dinámicos en Visual Basic 6.0

2008-10-26T18:05:00.000-07:00

Visual basic posee una sentencia o función que nos permite cambiar el largo de un vector en tiempo de ejecución, dándonos así mas flexibilidad, y de esta manera no desperdiciar memoria y recursos de la pc creando vectores mas largos de lo que realmente necesitamos.

Esta función se llama ReDim y ReDim Preserve.

Ejemplo de matriz de 2 dimensiones en Visual Basic 6.0

2008-10-26T18:02:00.000-07:00

Matriz bidimensionales de 6 x 8 (de 2 dimensiones).

Dim personas (1 to 6, 1 to 8) as string

Si luego quisiera acceder a los datos de la misma basta con referirnos a los subíndices

Por ejemplo:

personas (1, 1) = "Natalia"
personas (2, 1) = "pedro"
personas (1, 7) = "valeria"
personas (1, 8) = "josé"
personas (2, 2) = "carolina"
personas (4, 1) = "raquel"
personas (6, 2) = "eustaquio"
personas (6, 5) = "maria"
personas (6, 8) = "mariana"

El total de índices posibles para almacenar datos o valores en el ejemplo anterior es de 48 datos, ya que si multiplicamos 6 x 8 nos da como total 48 valores posibles para utilizar en la matriz bidimensional.

En este ejemplo creamos una matriz de 3 dimensiones de 3 x 3 x 3

Dim cubo (1 to 3, 1 to 3, 1 to 3) as integer

para acceder a los datos sería exactamente de la misma manera pero debemos utilizar un índice mas.

Ejemplo:

cubo (1, 1 , 1) = 50
cubo (1, 1 , 2) = 50
cubo (1, 1 , 3) = 50
cubo (1, 2 , 1) = 50
cubo (1, 2 , 2) = 50
cubo (1, 2 , 3) = 50
cubo (1, 3 , 1) = 50
cubo (1, 3 , 2) = 50
cubo (1, 3 , 3) = 50
cubo (2, 1 , 1) = 50
cubo (2, 1 , 2) = 50
cubo (2, 1 , 3) = 50
cubo (2, 2 , 1) = 50
cubo (2, 2 , 2) = 50
cubo (2, 2 , 3) = 50
cubo (2, 3 , 1) = 50
cubo (2, 3 , 2) = 50
cubo (2, 3 , 3) = 50
cubo (3, 1 , 1) = 50
cubo (3, 1 , 2) = 50
cubo (3, 1 , 3) = 50
cubo (3, 2 , 1) = 50
cubo (3, 2 , 2) = 50
cubo (3, 2 , 3) = 50
cubo (3, 3 , 1) = 50
cubo (3, 3 , 2) = 50
cubo (3, 3 , 3) = 50

En el ejemplo anterior, que es un poco extenso, es para que veas todos los posibles valores que puedes almacenar en una matriz de 3 x 3 x 3, y que da como resultado un arreglo de 27 valores posibles.

Matrices en Visual Basic 6.0

2008-10-26T17:58:00.000-07:00

Las matrices son arreglos de mas de 1 dimensión (2 o mas), a diferencia de los vectores que poseen una sola dimensión.

Podemos imaginar una matriz bidimensional ( 2 dimensiones) , como una cuadrícula con filas y columnas, donde las filas representarían las coordenadas x y las columnas las coordenadas y.

A una matriz de 3 dimensiones o tridimensional se la puede imaginar con las coordenadas x, y, z, y esta es ideal para representar figuras en el espacio por ejemplo.

Las matrices se declaran en el código de manera igual que los vectores, con la diferencia que debemos indicar mas subíndices de acuerdo a la cantidad de dimensiones que posea la matriz.

por lo general no se suele utilizar matrices de mas de 3 dimensiones..

¡Las Primeras "1000 VISITAS"!

2008-10-21T19:18:00.000-07:00

Bueno pues aquí estamos festejando las primeras mil visitas de este blog ha escasos 2meses de haberlo publicado, este blog esta diseñado por un servidor para que sea de gran ayuda a todas aquellas personas que desean aprender algo nuevo cada día.

Mis mas sinceros agradecimientos a aquellas personas que visitan este blog, esperando que la información contenida aquí sea de gran utilidad para los usuarios, reiterandoles que si tienen alguna duda solo escríbanme a mi correo electronico electronico_44@hotmail.com, y tratare de aclarar las dudas que tengan en el menor tiempo posible.

Esfuércense por lo que quieren, que en el momento menos esperado obtendremos resultados, solo hay que tener un poco de paciencia. Edg@r

Muchísimas Gracias.

Utilizar una estructura Type o UDT en un arreglo con Visual Basic 6.0

2008-10-21T19:16:00.000-07:00

Como vimos, en un arreglo podemos almacenar datos de cualquier tipo pero no mezclarlos, es decir podemos crear arreglos de tipo string, de tipo Integer etc,,, pero sin duda que lo mas importante y de mas utilidad a la hora de programar es la utilización de datos definidos por nosotros mediante una estructura Type

Por ejemplo:

Option Explicit

' Estructura de dato para el vector
Private Type agenda

nombre As String
apellido As String
cpostal As Integer

End Type

' Declaramos el vector
Dim personas(1 To 3) As agenda

Private Sub Form_Load()

' Llenamos con datos para el elemento 1 del arreglo

personas(1).nombre = "carlos"
personas(1).apellido = "Martínez"
personas(1).cpostal = 1900

' Llenamos con datos para el elemento 2 del arreglo

personas(2).nombre = "Héctor"
personas(2).apellido = "rosales"
personas(2).cpostal = 1898

' Llenamos con datos para el elemento 3 del arreglo

personas(3).nombre = "Albert"
personas(3).apellido = "Einstein"
personas(3).cpostal = 1324

End Sub

Para utilizar una estructura definida por nosotros en vectores o matrices, se hace de la forma habitual, con la diferencia que debemos declarar el arreglo utilizando el tipo de dato Type que hayamos creado, en este caso Dim personas(1 to 3) as agenda

Acceder a los datos de un arreglo en Visual Basic 6.0

2008-10-21T19:11:00.000-07:00

Para acceder a los datos de un arreglo o vector, debemos hacerlo mediante el índice o número del elemento del mismo. Por ejemplo:

Dim alumnos(1 To 4) As String

alumnos(1) = "juan"
alumnos(2) = "micaela"
alumnos(3) = "maría"
alumnos(4) = "ignacio"

Primero declaramos un arreglo llamado alumnos, de tipo string y que contendrá 4 elementos. Luego le asignamos un valor de cadena como a cualquier otra variable de tipo string, pero con la diferencia que para referirnos al elemento utilizamos el n° de índice del mismo.

Otro ejemplo

Dim paises(2) As String

' Llena el vector con datos
paises(0) = "Argentina"
paises(1) = "Perú"
paises(2) = "Brasil"

' Recorre los elementos del vector
For x = 0 To 2

MsgBox "Nombre del país : " & paises(x)

Next x

En este último ejemplo, declaramos y creamos un vector de 3 elementos que contendrá el nombre de 3 países. Luego en un bucle For utilizamos la función MsgBox para mostrar los elementos del arreglo, pasándole como parámetro del índice la variable x del bucle For.

Declaración de los arreglos en el código con Visual Basic 6.0

2008-10-21T19:09:00.000-07:00

Para crear un arreglo se debe en primer lugar declararlo como cualquier otra variable, la única diferencia es que debemos indicar la cantidad de elementos que contendrá el arreglo, colocando el número de índice entre paréntesis. Por ejemplo :

Lo siguiente crea un arreglo de 15 elementos o datos de tipo integer

Dim miArreglo (1 to 15) as integer

Esto crea un arreglo de 11 elementos o datos de tipo String

Dim empleados (10) as String

Como podemos ver en el primer ejemplo hemos declarado un arreglo llamado miArreglo y entre paréntesis hemos declarado el rango de capacidad del mismo, es decir la cantidad de datos que podrá contener

El primer número , el 1 , indica el límite inferior del mismo, y el número 15 indica el límite máximo del arreglo, conformando de esta manera un arreglo que podrá almacenar 15 datos de tipo string.

En el segundo ejemplo, declaramos un arreglo de 11 elementos de tipo string. Como podés ver hemos indicado solo un número que representa el valor máximo del mismo. Cabe aclarar que hemos puesto de índice el número 10, pero en realidad el arreglo contiene 11 elementos ya que cuando NO indicamos el limite inferior , se asume que el mismo comienza desde el 0.

Importante: los arreglos se dividen en 2 grupos, los vectores y las matrices. Los vectores son arreglos que contienen una sola dimensión y las matrices 2 o mas dimensiones.

Arreglos y Vectores en Visual Basic 6.0

2008-10-21T19:07:00.000-07:00

Los Arreglos se utilizan para almacenar un conjunto de variables, que sean del mismo tipo de dato, y todas estas bajo un mismo nombre.

Por ejemplo imaginemos que tenemos 20 variables de tipo String que almacenan nombres (nombre1, nombre2, etc..). si yo ahora quisiera pasar todas estas cadenas a minúsculas tendría que utilizar la función Lcase con cada variable: nombre1 = Lcase(nombre1), nombre2 = Lcase(nombre2), etc..

En cambio si utilizara un arreglo solucionaría mi problema solo a esto

Dim nombres(30) As String

For x = 0 To 30

nombres(x) = LCase(nombres(x))

Next

Siguiendo el ejemplo anterior: en vez de escribir la sentencia Lcase 30 veces para cada variable, hemos utilizado un arreglo llamado nombres con un número de índice 30 , es decir que almacena 30 datos de tipo String

Funciones para presentar mensajes en Visual Basic 6.0

2008-10-21T19:05:00.000-07:00

Visual Basic posee 2 tipos de funciones para presentar mensajes, ellas son MsgBox e InputBox.

Función InputBox:

La función InputBox presenta un mensaje al usuario, permitiéndole ingresar un valor en una caja de texto:

Como se dijo la función InputBox presenta un cuadro de diálogo donde el usuario puede ingresar un texto y luego aceptar o cancelar dicho cuadro de diálogo.

Los parámetros principales de esta función son:

InputBox (Promt,Title, Default)

El parámetro Prompt específica la leyenda que mostrará la caja de mensajes.
El parámetro Title especifica el título que llevará el cuadro de diálogo.
El parámetro Default es el texto que mostrará la caja de texto.

El aspecto mas importante de InputBox es que nos devuelve una cadena con lo que haya ingresado el usuario en la caja de texto. Luego podemos realizar una tarea específica dependiendo del valor devuelto.

Ejemplo:

Dim retorno As String

retorno = InputBox("Ingrese algo en la caja de texto", "Ejemplo")

MsgBox "Usted ingresó:" & retorno

En el ejemplo anterior, en la variable Retorno se almacenará el valor que haya ingresado el usuario cuando haga Click en el botón de Aceptar.

Cuando el usuario presiona Candelar, el InputBox devuelve una cadena vacía. Esto es importante tenerlo en cuenta para realizar una o tal acción

Si quiseramos por ejemplo desplegar un InputBox, y que este no se cierre hasta que el usuario si o si haya ingresado un valor, podemos hacerlo de la siguiente forma, utilizando una condición en un bucle Do Loop

Código fuente en el formulario

Private Sub Form_Load()

Dim Dato As String

' Hasta que no se ingrese un dato, _
el InputBox no se cerrará
Do
Dato = InputBox("Ingresar algun dato", " Ejemplo ")
Loop Until Dato <> ""

'Muestra el valor
MsgBox Dato, vbInformation

End Sub

Función MsgBox:

La función MsgBox, que ya se vió varias veces en distintos ejemplos, es muy fácil de usar y se utiliza para mostrar distintos tipos de mensajes.

Los parámetros mas importantes son:

Title : Es la leyenda que aparecerá en el título del mensaje.
Texto : Es el Texto que mostrará el mensaje.
Botones: En este parámetro se colocan las constantes que determinarán si la caja tiene uno o varios botones y el tipo de mensaje: informativo, de exclamación de alerta etc... Cuando escribimos la coma dentro de la función en el parámetro botones, Visual Basic despliega una lista con las opciones o constantes que podemos utilizar.

Funciones para calcular fechas en Visual Basic 6.0

2008-10-21T19:03:00.000-07:00

Visual basic cuenta con una serie de funciones que nos permiten calcular fechas y horas, por ejemplo generar un intervalo de fechas, sumar y restar fechas y horas y otras operaciones y cálculos

DateAdd : Devuelve un Variant que contiene una fecha que indica el intervalo de tiempo que se ha agregado

DateDiff : Devuelve el número de intervalos de tiempo entre dos fechas determinadas

DatePart : Devuelve una parte específica de una fecha dada

DateSerial : Devuelve un valor Date para un año, mes y día determinados

Ejemplos

El siguiente ejemplo utiliza la función DateDiff para mostrar el itervalo entre dos fechas. El intervalo lo muestra en segundos , minutos, dias, semanas meses y años, como muestra el siguiente gráfico

Colocar en el formulario un Command1.

Option Explicit

' recibe las dos fechas como parámetros
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Private Sub Calcular(Fecha_Inicial As Date, _
Fecha_Final As Date)

Const Formato As String = "#,##0"

Me.Cls
Me.Print "Calcular Intervalos entre las fechas " & Fecha_Inicial & _
" hasta :" & Fecha_Final & vbNewLine & String(150, "-") & vbNewLine

Me.Print Format(DateDiff("s", Fecha_Inicial, Fecha_Final), Formato) & " segundos"
Me.Print Format(DateDiff("n", Fecha_Inicial, Fecha_Final), Formato) & " minutos"
Me.Print Format(DateDiff("h", Fecha_Inicial, Fecha_Final), Formato) & " horas"

Me.Print Format(DateDiff("y", Fecha_Inicial, Fecha_Final), Formato) & " dias"
Me.Print Format(DateDiff("WW", Fecha_Inicial, Fecha_Final), Formato) & " semanas"
Me.Print Format(DateDiff("m", Fecha_Inicial, Fecha_Final), Formato) & " meses"
Me.Print Format(DateDiff("yyyy", Fecha_Inicial, Fecha_Final), Formato) & " años"

End Sub

Private Sub Command1_Click()
' le pasa las dos fechas a la función
Call Calcular("01/01/2000", Date)
End Sub

Private Sub Form_Load()

Me.AutoRedraw = True
Command1.Caption = "calcular intervalos "

End Sub

Ejemplo con DateAdd

Lo siguiente, muestra como añadir y restar fechas

' agrega 10 años a la fecha actual
MsgBox DateAdd("yyyy", 10, Date)

' Agrega cinco meses a la fecha actual
MsgBox DateAdd("m", 5, Date)

' resta 1 dias a la fecha actual ( usa el signo -)
MsgBox DateAdd("y", -1, Date)

Nota: para restar, usar el signo negativo, como se usa en el último ejemplo.

Para poder restar y agregar segundos a una hora, usar en el parámetro intervalo la "S", para minutos usar la "n", para horas la "h", para restar y sumar semanas la "ww".

Funciones de formato para fechas y hora en Visual Basic 6.0

2008-10-21T19:01:00.000-07:00

Ejemplos de los principales Formatos con nombre para el manejo de Fechas y Horas:

Funciones para Fechas

Dim cadena As String

cadena = Format("06/08/78", "General Date") ' Devuelve: "06/08/1978"

cadena = Format("19/08/79", "Long Date") ' Devuelve : "Jueves 19 de Agosto de 1979".

cadena = Format("19/8/79", "Medium Date") ' Devuelve: "19-Ago-1979"

cadena = Format("17:08", "Short Time") ' "05:08"

cadena = Format("17:08", "Medium Time") ' "05:08 PM"

cadena = Format("17:08", "Long Time") ' "05:08:00 PM"

Funciónes de Formato (Format) en Visual Basic 6.0

2008-10-21T18:58:00.000-07:00

La función Format es mas completa que las anteriores funciones, porque puede manejar mas tipos de datos, y no devuelve solo cadenas, esta también puede devolver números y fechas.

La función Format posee dos parámetros:

Format (Expresión, formato)

En el primero debemos colocar cualquier expresión válida. El segundo es opcional y a continuación veremos una descripción de los formatos de VB:

GeneralNumber: Devuelve el número sin formato.
Currency: Devuelve el número en formato moneda, con el símbolo "$" y 2 decimales a las derecha.
Fixed: Devuelve como mínimo un dígito a la izquierda y 2 ala derecha del decimal.
Standar: Similar a Fixed pero incluye un separador de miles.
Percent: Multiplica el número por cien y le agrega el símbolo "%"
True/False: Devuelve Verdadero para un valor distinto de 0,y Falso para 0.
On/OFF: Devuelve "Activado" para un valor distinto de 0, y "Desactivado" para 0.
La forma de pasar el parámetro es entre comillas.

Ejemplo:

cadena = Format(75, "Currency") ' Devolvería: "$75,00"

Nota: Si ingresamos un número decimal, debemos utilizar el "." y no la coma "," ya que la coma determina el comienzo de otro parámetro dentro de la función y Visual basic daría error de sintaxis

Crear una Base de Datos en MYSQL

2008-10-05T15:14:00.000-07:00

El comando para crear una base de datos MySQL es el siguiente:

mysqladmin -u root create base_datos

Con este comando conseguimos crear la una base de datos en el servidor de bases de datos de nuestro servidor.

Una vez conseguido esto debemos crear las tablas en la base de datos, la descripción de las tablas contienen la estructura de la información que almacenaremos en ellas. Para lo cual usaremos en lenguaje de consultas SQL común para todas las bases de datos relacionales.

En este ejemplo creamos una tabla llamada prueba con 3 campos: un campo identificador, que nos servirá para identificar unívocamente una fila con el valor de dicho campo, otro campo con el nombre de una persona y por último un campo con el apellido de la persona.

Para crear la tabla puede usar la herramienta de administración de MySQL de su servidor web o puede escribir un fichero de texto con el contenido de la sentencia SQL equivalente y luego decirle al motor de base de datos que la ejecute con la siguiente instrucción:

mysql -u root base_datos <prueba.sql

prueba.sql

CREATE TABLE prueba (
ID_Prueba int(11) DEFAULT '0' NOT NULL auto_increment,
Nombre varchar(100),
Apellidos varchar(100),
PRIMARY KEY (ID_Prueba),
UNIQUE ID_Prueba (ID_Prueba)

Estilos de Caracter en HTML

2008-10-05T15:10:00.000-07:00

Estos estilo son tags que afectan a palabras o carácteres dentro de otras entidades de HTML modificando el aspecto de ese texto para que sea diferente del texto que lo rodea. Existen dos tipos de estilos:

Estilos lógicos: Indican como se va a emplear el texto que realzamos, no el como se va a formatear.
- <em>.....</em>: Indica que los carácteres estarán enfatizados de alguna manera, generalmente en cursiva aunque dependerá del navegador.
- <strong>.....</strong>: Los carácteres tendrán mayor énfasis, generalmente en negrita.
- <code>.....</code>: Muestra como una fuente monoespaciada, generalmente Courier.
- <samp>.....</samp>: Muy similar a code.
- <kdb>.....</kdb>: Texto que el usuario debe escribir.
- <var>.....</var>:Nombre de una variable que deba ser reemplazada por su valor real. Generalmente en cursiva o subrayada.
- <dfn>.....</dfn>:Se usa para resaltar una palabra que se va a definir.
- <cite>.....</cite>: Se usa para citas cortas.

Estilos físicos: Modifican la presentación real del texto.
- <b>.....</b>: Pone el texto en negrita.
- <i>.....</i>: Pone el texto en cursiva.
- <tt>.....</tt>: Pone el texto en fuente monoespaciada.
- <u>.....</u>: Subraya el texto afectado.

Listas en HTML

2008-10-05T15:09:00.001-07:00

Junto con encabezados y párrafos, son otro de los elementos HTML más comunes. Pueden darse cinco tipos diferentes de listas, cada uno con tags distintas aunque con alguna en común:

Listas numeradas u ordenadas: Se engloban por las tags <ol>.....</ol> y cada elemento de la lista estará encabezado por la tag <li> que puede o no llevar la tag de cierre </li>. Es conveniente que cada elemento de la lista esté en una línea nueva aunque todo seguido consiga en la presentación el mismo efecto. Cuando el navegador interpreta una lista ordenada, numera y sangra cada elemento en forma secuencial, aunque se introduzcan modificaciones

Listas con viñetas o sin orden: Se engloban por las tags <ul>.....</ul> y cada elemento de la lista, también estará encabezado por la tag <li>. El resultado es que el navegador inserta viñetas (marcadores) delante de cada elemento.

Listas de menú y de directorio: Están en desuso puesto que su resultado suele ser, prácticamente, idéntico al de las listas con viñetas.
- Menú: Englobadas por las tags <menu>.....</menu> y cada elemento encabezado por la tag <li>.
- Directorio: Englobadas por las tags <dir>.....</dir> y cada elemento encabezado por la tag <li>.

Listas de glosario: Cada elemento de la lista está compuesto por un término y una definición y cada una de estas partes tiene su propia tag. Estas listas se engloban con las tags <dl>.....</dl>. Para el término se usa la tag <dt> y para la definición la tag <dd>. Generalmente el navegador colocará término y definición en dos líneas diferentes pero esto se puede evitar añadiendo a la tag de apertura el atributo compact: <dl compact>.

Listas anidadas: Consiste en poner una lista dentro de otra, de manera que la lista secundaria sangre respecto a la principal. Puede jugar con los diferentes tipos de lista pero recuerde estructurar bien las tags: Las tags de la lista principal englobarán todo el conjunto de las listas y las tags de las listas secundarías se cerraran antes de volver a la lista principal. Ahora quizá le empiece a convenir sangrar el propio código conforme lo va escribiendo en HTML.

Manejo de URL en HTML

2008-10-05T15:03:00.002-07:00

Los URL son las direcciones de las informaciones que buscamos en Internet. Los URL constan de tres partes:

Protocolo: Es el programa que utilizará el navegador para obtener el archivo elegido. Les suena HTTP, FTP, Gopher...
Nombre del host: Se trata del sistema donde se encuentra almacenada la información que buscamos.
Ruta del fichero: Se trata de la ubicación del archivo dentro del host.
http://www.bienvenidos.es/publico/saludos.html

Entre los principales tipos de URL destacan:

HTTP: Son los más populares ya que son los utilizados por los servidores de WWW para mandar documentos a través de Internet.
FTP: Se utilizan para apuntar hacia los archivos que estén en servidores que usan el protocolo FTP (File Transfer Protocol). Este protocolo es normalmente utilizado para enviar y recibir ficheros. Es el protocolo que se usa para enviar nuestras páginas al servidor de internet. Como ya se puede imaginar en estos servidores se almacenan los archivos que forman parte de nuestra presentación web.
File: Apuntan hacia archivos contenidos en el mismo disco que se encuentra el navegador. No resulta muy interesante poner estos URL en nuestras presentaciones puesto que otra persona que desde otro sistema apunte hacia este URL, generalmente fallará en su intento y no podrá tener acceso a él.
Mailto: Se usa para mandar correos electrónicos. Cuando seleccionamos este tipo de URL se abre la aplicación de correo electrónico de nuestro ordenador para enviar un correo a la dirección hacia la que apunta el URL. La forma estandar es: mailto:webmaster@bienvenidos.es
News: Son URL de grupos de noticias, en estos servidores se almacenan mensajes el los que se discuten sobre direfentes temas.

<HTML>

<HEAD>

<TITLE>Ejemplo 5</TITLE>

</HEAD>

<BODY>

<H1>Diferentes tipos de URLs</H1>

Enlace a <A HREF="http://www.webestilo.com">WebEstilo</A>.

<br>

Enlace al servidor de FTP

de <A HREF="ftp://ftp.mozilla.org/pub/mozilla/">Mozilla</A>.

<br>

Enlace a <A HREF="file:///C:">la unidad C

de su ordenador</A>.

<br>

Enlace a <a href="mailto:webmaster@bienvenidos.es">

mailto:webmaster@bienvenidos.es</a>.

<br>

Enlace a las <A HREF="news://msnews.microsoft.com">News de Microsoft</A>.

<br>

</BODY>

</HTML>

Crear Enlaces en HTML

2008-10-05T15:03:00.001-07:00

Para generar un enlace a otro documento necesitamos el nombre de un archivo (o su dirección URL) y el texto que servirá de punto de activación del otro documento. Este segundo elemento será el que veamos en pantalla y que se servirá del primero para saltar de documento.

Los enlaces se generan mediante la tag <A>.....</A> y, a diferencia de los vistos anteriormente, llevará siempre dentro de la tag un atributo ya sea <A HREF=""> o <A NAME="">.

<A HREF="URL">.....</A>: Es el más habitual de los atributos y sirve para saltar entre diferentes URLs. De momento veremos:
- Saltar en una presentación del archivo 1 al archivo 2: En el archivo 1 incluiremos la directiva <A HREF="archivo2.html">Siguiente página</a>
- Saltar de nuestra presentación a otra presentación web llamada www.bienvenidos.es: <A HREF="http://www.bienvenidos.es">Visita esta página</A>

<A NAME="parte1">Primera parte</A>: Utilizamos el atributo name para dar nombre a una sección de nuestro documento. Posteriormente, cuando en nuestro documento queramos incluir un vínculo a dicha sección escribiremos: <A HREF="#parte1">Ir a la primera parte</A>

Objetivos de los Sistemas Gestores de Base de Datos

2008-10-05T14:40:00.000-07:00

Abstracción de la información. Los SGBD ahorran a los usuarios detalles acerca del almacenamiento físico de los datos. Da lo mismo si una base de datos ocupa uno o cientos de archivos, este hecho se hace transparente al usuario. Así, se definen varios niveles de abstracción.

Independencia. La independencia de los datos consiste en la capacidad de modificar el esquema (físico o lógico) de una base de datos sin tener que realizar cambios en las aplicaciones que se sirven de ella.

Consistencia. En aquellos casos en los que no se ha logrado eliminar la redundancia, será necesario vigilar que aquella información que aparece repetida se actualice de forma coherente, es decir, que todos los datos repetidos se actualicen de forma simultánea. Por otra parte, la base de datos representa una realidad determinada que tiene determinadas condiciones, por ejemplo que los menores de edad no pueden tener licencia de conducir. El sistema no debería aceptar datos de un conductor menor de edad. En los SGBD existen herramientas que facilitan la programación de este tipo de condiciones.

Seguridad. La información almacenada en una base de datos puede llegar a tener un gran valor. Los SGBD deben garantizar que esta información se encuentra segura frente a usuarios malintencionados, que intenten leer información privilegiada; frente a ataques que deseen manipular o destruir la información; o simplemente ante las torpezas de algún usuario autorizado pero despistado. Normalmente, los SGBD disponen de un complejo sistema de permisos a usuarios y grupos de usuarios, que permiten otorgar diversas categorías de permisos.

Integridad. Se trata de adoptar las medidas necesarias para garantizar la validez de los datos almacenados. Es decir, se trata de proteger los datos ante fallos de hardware, datos introducidos por usuarios descuidados, o cualquier otra circunstancia capaz de corromper la información almacenada. Los SGBD proveen mecanismos para garantizar la recuperación de la base de datos hasta un estado consistente (ver Consistencia, más arriba) conocido en forma automática.

Respaldo. Los SGBD deben proporcionar una forma eficiente de realizar copias de respaldo de la información almacenada en ellos, y de restaurar a partir de estas copias los datos que se hayan podido perder.

Control de la concurrencia. En la mayoría de entornos (excepto quizás el doméstico), lo más habitual es que sean muchas las personas que acceden a una base de datos, bien para recuperar información, bien para almacenarla. Y es también frecuente que dichos accesos se realicen de forma simultánea. Así pues, un SGBD debe controlar este acceso concurrente a la información, que podría derivar en inconsistencias.

Manejo de Transacciones. Una Transacción es un programa que se ejecuta como una sola operación. Esto quiere decir que el estado luego de una ejecución en la que se produce una falla es el mismo que se obtendría si el programa no se hubiera ejecutado. Los SGBD proveen mecanismos para programar las modificaciones de los datos de una forma mucho más simple que si no se dispusiera de ellos.

Tiempo de respuesta. Lógicamente, es deseable minimizar el tiempo que el SGBD tarda en darnos la información solicitada y en almacenar los cambios realizados.

Topologías para Redes

2008-10-05T14:20:00.000-07:00

La topología o forma lógica de una red se define como la forma de tender el cable a estaciones de trabajo individuales; por muros, suelos y techos del edificio. Existe un número de factores a considerar para determinar cual topología es la más apropiada para una situación dada.

La topología en una red es la configuración adoptada por las estaciones de trabajo para conectarse entre si.

Topologías más Comunes

Bus: Esta topología permite que todas las estaciones reciban la información que se transmite, una estación transmite y todas las restantes escuchan. Consiste en un cable con un terminador en cada extremo del que se cuelgan todos los elementos de una red. Todos los nodos de la red están unidos a este cable: el cual recibe el nombre de "Backbone Cable". Tanto Ethernet como Local Talk pueden utilizar esta topología.

El bus es pasivo, no se produce regeneración de las señales en cada nodo. Los nodos en una red de "bus" transmiten la información y esperan que ésta no vaya a chocar con otra información transmitida por otro de los nodos. Si esto ocurre, cada nodo espera una pequeña cantidad de tiempo al azar, después intenta retransmitir la información.

Anillo: Las estaciones están unidas unas con otras formando un círculo por medio de un cable común. El último nodo de la cadena se conecta al primero cerrando el anillo. Las señales circulan en un solo sentido alrededor del círculo, regenerándose en cada nodo. Con esta metodología, cada nodo examina la información que es enviada a través del anillo. Si la información no está dirigida al nodo que la examina, la pasa al siguiente en el anillo. La desventaja del anillo es que si se rompe una conexión, se cae la red completa.

Estrella: Los datos en estas redes fluyen del emisor hasta el concentrador, este realiza todas las funciones de la red, además actúa como amplificador de los datos.

La red se une en un único punto, normalmente con un panel de control centralizado, como un concentrador de cableado. Los bloques de información son dirigidos a través del panel de control central hacia sus destinos. Este esquema tiene una ventaja al tener un panel de control que monitorea el tráfico y evita las colisiones y una conexión interrumpida no afecta al resto de la red.

Híbridas: El bus lineal, la estrella y el anillo se combinan algunas veces para formar combinaciones de redes híbridas.

Anillo en Estrella: Esta topología se utiliza con el fin de facilitar la administración de la red. Físicamente, la red es una estrella centralizada en un concentrador, mientras que a nivel lógico, la red es un anillo.

"Bus" en Estrella: El fin es igual a la topología anterior. En este caso la red es un "bus" que se cablea físicamente como una estrella por medio de concentradores.

Estrella Jerárquica: Esta estructura de cableado se utiliza en la mayor parte de las redes locales actuales, por medio de concentradores dispuestos en cascada par formar una red jerárquica.

Árbol: Esta estructura se utiliza en aplicaciones de televisión por cable, sobre la cual podrían basarse las futuras estructuras de redes que alcancen los hogares. También se ha utilizado en aplicaciones de redes locales analógicas de banda ancha.

Trama: Esta estructura de red es típica de las WAN, pero también se puede utilizar en algunas aplicaciones de redes locales (LAN). Las estaciones de trabajo están conectadas cada una con todas las demás.

Programas Informaticos

2008-10-05T13:44:00.000-07:00

El comportamiento de un programa depende del tipo de lenguaje usado para escribirlo...

En cualquier caso, casi todos los lenguajes de programación se basan en el mismo principio:

el programa consiste en un conjunto de comandos que el equipo debe ejecutar. El equipo ejecuta los comandos a medida que va leyendo el archivo (de arriba hacia abajo) hasta que alcanza un comando (al que a menudo se hace referencia como un comando ramificado) que ordena al equipo ir a una ubicación específica del programa. En cierto modo, se parece a la búsqueda del tesoro, donde el equipo debe seguir las pistas y ejecutar los comandos hasta alcanzar el final del programa y detenerse.

El concepto de variables
Las variables se utilizan en la mayoría de los lenguajes, donde un nombre se asocia a un contenido. Por ejemplo, podemos llamar a una variable "maniquí" y asignarle el valor 8.

Tipos de datos
Algunos lenguajes permiten asociar cualquier tipo de dato con una variable (ya sea un número completo o un carácter), dicho lenguaje se denomina lenguaje sin tipos.
Como puede verse en el capítulo representación de datos, el tipo de datos establece el número de bytes en que el dato está codificado, es decir, la cantidad de memoria que este dato ocupa, así como el formato en el que está representado.
Por esta razón, los lenguajes evolucionados (C, Java) son lenguajes con tipo, lo que significa que una variable no se asocia solamente con un nombre sino también con un tipo de datos que debe especificarse cuando se declara la variable; es decir, cuando el nombre de la variable se escribe por primera vez, debe especificar en el compilador el tipo de datos que esta variable contendrá (la manera de declarar la variable dependerá del lenguaje utilizado).

Sintaxis
Los lenguajes de programación requieren una sintaxis estricta, por lo tanto, no es posible escribir de la manera que se desea.

Así, algunos lenguajes distinguen entre minúsculas y mayúsculas, lo que significa que un nombre escrito en minúscula no es considerado el equivalente del mismo nombre escrito en mayúscula. En este caso, la variable "Maniquí" sería diferente a la variable "maniquí".

Los nombres de variables requieren comúnmente una longitud máxima (dependiendo del lenguaje) y de un determinado conjunto de caracteres. Generalmente, se utilizan los siguientes caracteres:

abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890_ De esta forma, un espacio (" ") se considera un tipo de carácter diferente, llamado un carácter especial. Por lo tanto, no es muy común que un lenguaje permita el uso de caracteres especiales en nombres de variables.

Palabras reservadas
En la mayoría de los lenguajes, existe un puñado de palabras que no deben utilizarse como variables de nombres, llamadas palabras reservadas. Se especifican en el capítulo correspondiente al lenguaje específico.

Constantes
Las constantes son datos cuyo valor no puede modificarse. Por lo general, se definen al comienzo del programa. El valor de la constante puede ser de cualquier tipo permitido por el lenguaje de programación.

Comentarios
Al escribir un programa es útil poder agregar líneas de texto a las que el compilador no considera como códigos. Estas líneas de texto generalmente están precedidas (o rodeadas) por comandos especiales que ordenan al compilador omitirlas.

Los comentarios son útiles para aclarar cómo está escrito el programa, explicando las partes del código. Los comentarios también sirven si otra persona está tratando de comprender cómo funciona el programa leyendo el archivo fuente, o incluso, si la persona que escribió el programa está leyendo el archivo de origen nuevamente, varios años después de haber escrito el código...

Lenguajes de Programación

2008-10-05T13:31:00.000-07:00

CLASIFICACIÓN DE LOS LENGUAJES DE PROGRAMACIÓN

Los lenguajes de programación se determinan según el nivel de abstracción, Según la forma de ejecución y Según el paradigma de programación que poseen cada uno de ellos y esos pueden ser:

SEGÚN SU NIVEL DE ABSTRACCIÓN

Lenguajes Maquina
Estan escritos en lenguajes directamente inteligibles por la maquina (computadora), ya que sus intrucciones son cadenas binarias (0 y 1). Da la posibilidad de cargar (transferir un programa a la memoria) sin necesidad de traducción posterior lo que supone una velocidad de ejecución superior, solo que con poca fiabilidad y dificuldad de verificar y poner a punto los programas.

Lenguajes de bajo nivel
Los lenguajes de bajo nivel son lenguajes de programación que se acercan al funcionamiento de una computadora. El lenguaje de más bajo nivel es, por excelencia, el código máquina. A éste le sigue el lenguaje ensamblador, ya que al programar en ensamblador se trabajan con los registros de memoria de la computadora de forma directa.

Lenguajes de medio nivel
Hay lenguajes de programación que son considerados por algunos expertos como lenguajes de medio nivel (como es el caso del lenguaje C) al tener ciertas características que los acercan a los lenguajes de bajo nivel pero teniendo, al mismo tiempo, ciertas cualidades que lo hacen un lenguaje más cercano al humano y, por tanto, de alto nivel.

Lenguajes de alto nivel
Los lenguajes de alto nivel son normalmente fáciles de aprender porque están formados por elementos de lenguajes naturales, como el inglés. En BASIC, el lenguaje de alto nivel más conocido, los comandos como "IF CONTADOR = 10 THEN STOP" pueden utilizarse para pedir a la computadora que pare si CONTADOR es igual a 10. Por desgracia para muchas personas esta forma de trabajar es un poco frustrante, dado que a pesar de que las computadoras parecen comprender un lenguaje natural, lo hacen en realidad de una forma rígida y sistemática.

SEGÚN LA FORMA DE EJECUCIÓN

Lenguajes compilados
Naturalmente, un programa que se escribe en un lenguaje de alto nivel también tiene que traducirse a un código que pueda utilizar la máquina. Los programas traductores que pueden realizar esta operación se llaman compiladores. Éstos, como los programas ensambladores avanzados, pueden generar muchas líneas de código de máquina por cada proposición del programa fuente. Se requiere una corrida de compilación antes de procesar los datos de un problema.

Los compiladores son aquellos cuya función es traducir un programa escrito en un determinado lenguaje a un idioma que la computadora entienda (lenguaje máquina con código binario).

Al usar un lenguaje compilado (como lo son los lenguajes del popular Visual Studio de Microsoft), el programa desarrollado nunca se ejecuta mientras haya errores, sino hasta que luego de haber compilado el programa, ya no aparecen errores en el código
Lenguajes interpretados

Se puede también utilizar una alternativa diferente de los compiladores para traducir lenguajes de alto nivel. En vez de traducir el programa fuente y grabar en forma permanente el código objeto que se produce durante la corrida de compilación para utilizarlo en una corrida de producción futura, el programador sólo carga el programa fuente en la computadora junto con los datos que se van a procesar. A continuación, un programa intérprete, almacenado en el sistema operativo del disco, o incluido de manera permanente dentro de la máquina, convierte cada proposición del programa fuente en lenguaje de máquina conforme vaya siendo necesario durante el proceso de los datos. No se graba el código objeto para utilizarlo posteriormente.
La siguiente vez que se utilice una instrucción, se le debe interpretar otra vez y traducir a lenguaje máquina. Por ejemplo, durante el procesamiento repetitivo de los pasos de un ciclo, cada instrucción del ciclo tendrá que volver a ser interpretado cada vez que se ejecute el ciclo, lo cual hace que el programa sea más lento en tiempo de ejecución (porque se va revisando el código en tiempo de ejecución) pero más rápido en tiempo de diseño (porque no se tiene que estar compilando a cada momento el código completo). El intérprete elimina la necesidad de realizar una corrida de compilación después de cada modificación del programa cuando se quiere agregar funciones o corregir errores; pero es obvio que un programa objeto compilado con antelación deberá ejecutarse con mucha mayor rapidez que uno que se debe interpretar a cada paso durante una corrida de producción

SEGUN EL PARADIGMA DE PROGRAMACION

Un paradigma de programación representa un enfoque particular o filosofía para la construcción del software. No es mejor uno que otro, sino que cada uno tiene ventajas y desventajas. Dependiendo de la situación un paradigma resulta más apropiado que otro.

Atendiendo al paradigma de programación, se pueden clasificar los lenguajes en :
• El paradigma imperativo o por procedimientos es considerado el más común y está representado, por ejemplo, por el C o por BASIC.
• El paradigma funcional está representado por la familia de lenguajes LISP (en particular Scheme), ML o Haskell.
• El paradigma lógico, un ejemplo es PROLOG.
• El paradigma orientado a objetos. Un lenguaje completamente orientado a objetos es Smalltalk.

Nota: La representación orientada a objetos mejora la estructura de los datos y por lo tanto se ha aplicado a diferentes paradigmas como Redes de Petri, Imperativo Secuencial, Lógica de Predicados, Funcional, etc. No obstante, la manipulación no queda fundamentalmente afectada y por lo tanto el paradigma inicial tampoco a pesar de ser re-orientado a objetos.

Si bien puede seleccionarse la forma pura de estos paradigmas al momento de programar, en la práctica es habitual que se mezclen, dando lugar a la programación multiparadigma.

Actualmente el paradigma de programación más usado debido a múltiples ventajas respecto a sus anteriores, es la programación orientada a objetos.

Lenguajes imperativos

• BASIC
• C
• C++
• Java
• C#
• Perl
• unerg

Lenguajes Funcionales

Puros:
• Haskell
• Miranda
Híbridos:
• Lisp
• Scheme
• Ocaml
• Standard ML
• ML
• Scala

Lenguajes Lógicos
• Prolog

Lenguajes orientados a objetos
• ActionScript
• Ada
• C++
• C#
• VB.NET
• Visual FoxPro
• Clarion
• Delphi
• Harbour
• Eiffel
• Java
• JavaScript
• Lexico (en castellano)
• Objective-C
• Ocaml
• Oz
• Perl (soporta herencia múltiple)
• PHP (en su versión 5)
• Python
• Ruby
• Smalltalk
• Magik (SmallWorld)

Funciones de formato en Visual Basic 6.0

2008-09-28T20:12:00.000-07:00

Visual Basic posee varias funciones para darle formato a distintos tipos de datos e información. A continuación se ve algunos ejemplos de las principales funciones:

FormatCurrency: Esta función se utiliza para trabajar con números con formato en dinero. Ejemplo:

si tenemos un número 3 y utilizamos la función nos devolvería "$3".

FormatPercent: Esta función es utilizada para trabajar con porcentajes. Ejemplo :
si tendríamos un número 321, nos devolvería: "32,1%" .
FormatDateTime: Esta función trabaja con fechas y horas.
FormatNumber: Formatea expresiones números

Resultado = FormatPercent(321) 'devuelve: "32.100,00%"
Resultado = FormatCurrency(3) 'devuelve: "$3,00"
Resultado = FormatDateTime("6-8-1978") 'La función devolvería: "06/08/1978"

NumDigitsAfterDecimal: Parámetro de tipo opcional. Este indicará cuantos números decimales devolverá la función:

Ejemplo

cadena = FormatCurrency(325, 3) 'Devuelve: "$325,000"

Ejemplo de la función FormatDateTime

Esta función, en el primer parámetro se le debe pasar la fecha u hora a formatear, y el segundo parámetro es el tipo de formato, pueden ser 5 tipos.

vbGeneralDate, vbLongDate, vbShortDate, vbLongTime y vbShortTime.

Este parámetro es de tipo opcional. al colocar la coma dentro de la función , visual basic despliega la lista de constanetas mencionadas, como muestra el gráfico:

Un ejemplo para ver estos formatos utilizando FormatDateTime: Colocar cinco option Button, cada botón de opción mostrará los diferentes formatos en el caption del formulario, es decir en la barra de título.

Código en el formulario:

Private Sub Form_Load()

Option1.Caption = " vbGeneralDate "
Option2.Caption = " vbLongDate "
Option3.Caption = " vbShortDate "
Option4.Caption = " vbLongTime "
Option5.Caption = " vbShortTime "

End Sub

Private Sub Option1_Click()
Me.Caption = FormatDateTime(Now, vbGeneralDate)
End Sub

Private Sub Option2_Click()
Me.Caption = FormatDateTime(Now, vbLongDate)
End Sub

Private Sub Option3_Click()
Me.Caption = FormatDateTime(Now, vbShortDate)
End Sub

Private Sub Option4_Click()
Me.Caption = FormatDateTime(Now, vbLongTime)
End Sub

Private Sub Option5_Click()
Me.Caption = FormatDateTime(Now, vbShortTime)
End Sub

FormatNumber - Ejemplos:

Formatea 0.489698 a 0,49

Dim Numero As Double

Numero = 0.489698
Numero = FormatNumber(Numero, 2, vbFalse)

MsgBox Numero
Formatea 1.958754 a 1,96

Dim Numero As Double

Numero = 1.958754
Numero = FormatNumber(Numero, 2)

MsgBox Numero

Funciones Matemáticas en Visual Basic 6.0

2008-09-28T19:29:00.001-07:00

Las principales funciones matemáticas provistas por Visual Basic son:

Abs: Devuelve el valor absoluto de una expresión numérica.
Atn: Devuelve el arco tangente de un número.
Cos: Devuelve el coseno de un ángulo.
Exp: Devuelve el número "e" elevado a una potencia.
Log: Devuelve el logaritmo natural de un número.
Sgn: Devuelve un valor indicando el signo de un número.
Sin: Devuelve el seno de un ángulo.
Sqr: Devuelve la raíz cuadrada de un número.
Tan: Devuelve la tangente de un ángulo.

Funcion para el tratamiento de números (Rnd y Randomize) en Visual Basic 6.0

2008-09-28T19:26:00.000-07:00

Para generar números aleatorios, Visual Basic incluye 2 funciones: Rnd y Randomize.

La función Rnd devuelve un número aleatorio, y esta posee un solo parámetro.

Ejemplo :

Rnd (número)

Pero para poder generar dichos números aleatorios, debemos utilizar previamente la función Randomize con la siguiente fórmula:

Dim LimiteInferior As Integer
Dim LimiteSuperior As Integer

LimiteInferior = 20

LimiteSuperior = 40

MsgBox Int((LimiteInferior - LimiteSuperior + 1) * Rnd + LimiteInferior)

En el ejemplo, se generarán números aleatorios comprendidos entre el 20 y el 40.

Funcion para el tratamiento de números (Round) en Visual Basic 6.0

2008-09-28T19:23:00.000-07:00

La función Round se utiliza para redondear un número decimal, devolviendo un número entero.

Ejemplo:

Dim Mimumero As Long

Minumero = Round(245.8) '(La función devuelve 246)
Minumero = Round(245.3) '(La función devuelve 245)
Minumero = Round(245.5) '(La función devuelve 245)

Round posee un parámetro opcional por si queremos incluir los dígitos decimales.

Función para el manejo de cadena (Str y Val) en Visual Basic 6.0

2008-09-28T19:20:00.001-07:00

La función Val convierte una cadena en un número y la función Str un número en una cadena.

Ejemplos:

cadena = "123456"
cadena = Val(cadena)

'Ahora cadena vale 123456

cadena2 = 123456
cadena2 = Str(cadena2)

'Ahora cadena2 vale "123456"

Tipos de Redes

2008-09-28T19:12:00.000-07:00

REDES DE ÁREA LOCAL: las redes de área local (local area networks ) llevan mensajes a velocidades relativamente grande entre computadores conectados a un único medio de comunicaciones : un cable de par trenzado. Un cable coaxial o una fibra óptica. Un segmento es una sección de cable que da servicio y que puede tener varios computadores conectados, el ancho de banda del mismo se reparte entre dichas computadores. Las redes de área local mayores están compuestas por varios segmentos interconectados por conmutadores(switches) o concentradores(hubs. El ancho de banda total del sistema es grande y la latencia pequeña, salvo cuando el tráfico es muy alto.

En los años 70s se han desarrollado varias tecnologías de redes de área local, destacándose Ethernet como tecnología dominante para las redes de área amplia; estando esta carente de garantías necesarias sobre latencia y ancho de banda necesario para la aplicación multimedia. Como consecuencia de esta surge ATM para cubrir estas falencias impidiendo su costo su implementación en redes de área local. Entonces en su lugar se implementan las redes Ethernet de alta velocidad que resuelven estas limitaciones no superando la eficiencia de ATM.

REDES DE ÁREA EXTENSA: estas pueden llevar mensajes entre nodos que están a menudo en diferentes organizaciones y quizás separadas por grandes distancias, pero a una velocidad menor que las redes LAN. El medio de comunicación esta compuesto por un conjunto de círculos de enlazadas mediante computadores dedicados, llamados rotures o encaminadores. Esto gestiona la red de comunicaciones y encaminan mensajes o paquetes hacia su destino. En la mayoría de las redes se produce un retardo en cada punto de la ruta a causa de las operaciones de encaminamiento, por lo que la latencia total de la transmisión de un mensaje depende de la ruta seguida y de la carga de trafico en los distintos segmentos que atraviese. La velocidad de las señales electrónicas en la mayoría de los medios es cercana a la velocidad de la luz, y esto impone un límite inferior a la latencia de las transmisiones para las transmisiones de larga distancia.

REDES DE ÁREA METROPOLITANA: las redes de área metropolitana (metropolitan area networks)se basan en el gran ancho de banda de las cableadas de cobre y fibra óptica recientemente instalados para la transmisión de videos, voz, y otro tipo de datos. Varias han sido las tecnologías utilizadas para implementar el encaminamiento en las redes LAN, desde Ethernet hasta ATM. IEEE ha publicado la especificación 802.6[IEEE 1994], diseñado expresamente para satisfacer las necesidades de las redes WAN. Las conexiones de línea de suscripción digital ,DLS( digital subscribe line) y los MODEM de cable son un ejemplo de esto. DSL utiliza generalmente conmutadores digitales sobre par trenzado a velocidades entre 0.25 y 6.0 Mbps; la utilización de este par trenzado para las conexiones limita la distancia al conmutador a 1.5 kilómetros . una conexión de MODEM por cable utiliza una señalización análoga sobre el cable coaxil de televisión para conseguir velocidades de 1.5 Mbps con un alcance superior que DSL.

REDES INALÁMBRICAS: la conexión de los dispositivos portátiles y de mano necesitan redes de comunicaciones inalámbricas(wireless networks). Algunos de ellos son la IEEE802.11(wave lan) son verdaderas redes LAN inalámbricas (wireless local área networks;WLAN) diseñados para ser utilizados en vez de los LAN . También se encuentran las redes de area personal inalámbricas, incluida la red europea mediante el Sistema Global para Comunicaciones Moviles, GSM( global system for mobile communication). En los Estados Unidos , la mayoría de los teléfonos móviles están actualmente basados en la análoga red de radio celular AMPS, sobre la cual se encuentra la red digital de comunicaciones de Paquetes de Datos Digitales Celular, CDPD( Cellular Digital Packet Data).

Dado el restringido ancho de banda disponible y las otras limitaciones de los conjuntos de protocolos llamados Protocolos de Aplicación Inalámbrica WAP(Wireless Aplication Protocol)

INTERREDES: una Interred es un sistema de comunicación compuesto por varias redes que se han enlazado juntas para proporcionar unas posibilidades de comunicación ocultando las tecnologías y los protocolos y métodos de interconexión de las redes individuales que la componen.

Estas son necesarias para el desarrollo de sistemas distribuidos abiertos extensibles. En ellas se puede integrar una gran variedad de tecnología de redes de área local y amplia, para proporcionar la capacidad de trabajo en red necesaria para cada grupo de usuario. Así, las intercedes aportan gran parte de los beneficios de los sistemas abiertos a las comunicaciones de los sistemas distribuidos.

Las intercedes se construyen a partir de varias redes. Estas están interconectadas por computadoras dedicadas llamadas routers y computadores de propósito general llamadas gateways, y por un subsistema integrado de comunicaciones producidos por una capa de software que soporta el direccionamiento y la transmisión de datos a los computadores a través de la interred. Los resultados pueden contemplarse como una red virtual construida a partir de solapar una capa de interred sobre un medio de comunicación que consiste en varias redes, routers y gateways subyacentes.

COMPORACION DE REDES: en las redes inalámbricas los paquetes se pierden con frecuencia debido a las interferencias externas, en cambio, en el resto de los tipos de redes la fiabilidad de los mecanismos de transmisión es muy alta. En todos los tipos de redes las perdidas de paquetes son como consecuencia de los retardos de procesamiento o por los desbordamientos en los destinos.

Los paquetes pueden entregarse en diferente orden al que fueron transmitidos. También se pueden entregar copias duplicadas de paquetes, tanto la retransmisión del paquete como el original llegan a su destino.

Todos los fallos descriptos son ocultados por TCP y por otros protocolos llamados protocolos fiables, que hacen posible que las aplicaciones supongan que todo lo que es transmitido será recibido por destinatario. Existen, sin embargo, buenas razones para utilizar protocolos menos fiables como UDP en algunos casos de sistemas distribuidos, y en aquellas circunstancias en las que los programas de aplicación puedan tolerar los fallos.

El Origen de las Redes

2008-09-28T19:07:00.000-07:00

El origen del protocolo TCP/IP, se debe a un proyecto de investigación, financiado por la DARPA, (Defense Advanced Research Projects Agency, o Agencia de Proyectos Avanzados de Investigación en Defensa), en 1969. La ARPANET, fue una red experimental que se convirtió en funcional a mediados de 1975, tras haber sido admitida su funcionalidad.

En 1983, el nuevo conjunto de protocolos TCP/IP, fue adoptado como estándar y todas las máquinas de la red tuvieron la necesidad de él. Cuando, finalmente, ARPANET creció y se convirtió en Internet, (integrándose luego ella misma a Internet, en 1990), el uso de TCP/IP se propagó incluso a redes ajenas a ella. Ahora, muchas compañías empresariales construyen redes TCP/IP, e Internet ha crecido hasta tal punto, que se la puede considerar como la corriente principal de consumo tecnológico. Actualmente, es difícil leer un periódico sin ver referencias sobre Internet; casi todo el mundo ya puede usarla.

Para apreciar algo palpable sobre lo que hemos discutido anteriormente, supongamos como ejemplo, la Universidad Groucho Marx, (GMU), la cual se encuentra en algún lugar de Federilandia. La mayoría de las divisiones de la universidad tienen su propia red local, mientras que algunas comparten una sola y otras poseen muchas de ellas. Todas se encuentran interconectadas, y están enlazadas a Internet por un simple enlace de alta velocidad.

Supóngase que se tiene una máquina GNU/Linux conectada a una LAN de servidores Unix en la división de Matemáticas, y su nombre es erdos. Para acceder a un servidor que se encuentra en la división de Física, cuyo nombre es, por ejemplo quark, se deberá introducir la siguiente orden: $ rlogin quark.physics
Welcome to the Physics Department at GMU
(ttyq2) login:

Ante este indicador se podrá introducir un nombre de usuario, por ejemplo sebastian, y una contraseña. Luego, si todo es correcto, nos encontraremos frente a un intérprete de órdenes (shell)[1] de quark, en la cual, se podrá escribir como si se estuviera sentado frente a la misma consola del sistema. Tras salir del intérprete, se nos presentará nuevamente el antiguo indicador de órdenes de nuestra máquina. Se ha usado aquí, tan sólo una de las muchas aplicaciones instantáneas e interactivas que TCP/IP proporciona: remote login (registro remoto).

Mientras se trabaja en quark, puede que se desee ejecutar una aplicación de interfaz gráfica, como por ejemplo un procesador de textos, un programa de diseño gráfico, o hasta un navegador de Internet. El sistema de ventanas X es un entorno gráfico para el usuario, totalmente funcional bajo redes y está disponible para muchos tipos de sistemas informáticos. Para hacerle saber a la aplicación que se desea tener interfaz gráfica en la pantalla de nuestro nodo, se necesitará determinar la variable de entorno DISPLAY: $ DISPLAY=erdos.maths:0.0
$ export DISPLAY

Si ahora se ejecuta la aplicación gráfica, ésta se comunicará con el servidor X de nuestro nodo en lugar de hacerlo con el de quark, y como consecuencia las ventanas aparecerán en nuestra la pantalla y no en la de nuestro servidor. Por supuesto, esto requiere que se esté ejecutando X11 en erdos. Lo más importante aquí es que TCP/IP permite el envío y reenvío de paquetes X11 entre quark y erdos, haciendo que el usuario tenga la ilusión de que trabaja en una única máquina. Trabajando de este modo, la red será bastante transparente.

Otra aplicación muy importante en una red TCP/IP es NFS, que significa Network File System (Sistema de Ficheros de Redes). Es otra forma de hacer de la red un sistema transparente, ya que, básicamente, permite al usuario trabajar con los ficheros y directorios de otros nodos como si fueran locales. Por ejemplo, todos los directorios \home de cada usuario pueden alojarse en un servidor central. Desde éste, los demás nodos de la LAN pueden montarlos cuando sea necesario. El resultado es que los usuarios pueden registrarse en el sistema y encontrarse siempre en el mismo directorio \home. De modo similar, es posible compartir grandes cantidades de datos, (como una base de datos, documentación o programas ejecutables), entre muchos nodos, almacenando físicamente una sola copia de dichos datos en un servidor, y permitiendo a los nodos en cuestión acceso a él. Se volverá a hablar de NFS en Capítulo 14.

Por supuesto, estos son sólo ejemplos de lo que se puede hacer en redes TCP/IP. Las posibilidades son casi infinitas, y el lector irá conociéndolas a medida que avance en el libro.

En las siguientes secciones, se estudiará más detenidamente, de qué manera funciona una red TCP/IP. Esta información ayudará a entender cómo y por qué se debe configurar una máquina. Se empezará examinando el hardware, y desde allí con las demás cuestiones.

Iniciando con "Redes de Computadoras"

2008-09-28T19:03:00.000-07:00

El concepto de trabajo en redes es probablemente tan antiguo como lo es el de las telecomunicaciones. Imagínese por un momento, gente viviendo en la Edad de Piedra, en donde los individuos usen tambores para transmitirse mensajes. Supóngase que un hombre de las cavernas A quiere invitar a otro hombre B a una partida de choques de piedra. Lamentablemente viven tan distantes, que a B le sería imposible escuchar el tambor de A cuando éste lo llame. ¿Qué puede hacer A para remediar esto? Él podría 1) ir caminando al sitio de B, 2) conseguir un tambor más grande, o 3) pedirle a C, quien vive a mitad de camino que reenvíe el mensaje. La tercera elección es denominada Trabajo en Redes.

Por supuesto, la humanidad ha avanzado un poco desde la la Edad de Piedra; ya no se usan aquellos primitivos artefactos ni tenemos los mismos inconvenientes que nuestros antepasados. En la actualidad, contamos con computadoras que hablan con otras sobre una colección de cables, fibra óptica, microondas, etc. tan grande como para llenar el estadio en el partido de fútbol de los sábados[1] A continuación, se hará referencia a los conceptos y métodos que son utilizados para llevar a cabo todo esto. Sin embargo, dejaremos de lado tanto el tema de los cables, como la parte del fútbol.

En esta guía se describirán tres tipos de redes. Sin embargo, se discutirá más profundamente TCP/IP puesto que es el protocolo más usado, ya sea en Redes Locales (Local Area Networks, LANs), o en Redes de Área Amplia (Wide Area Networks, WANs), como por ejemplo, Internet. También se echará un vistazo a UUCP e IPX. UUCP fue antiguamente el medio general para transportar las noticias y los mensajes de correo, mediante una conexión telefónica. Es menos usado en estos días, pero sigue siendo útil en muchas situaciones. El protocolo IPX es usado más frecuentemente en los entornos Novell NetWare, y se detallará cómo usarlo para conectar una máquina GNU/Linux a una red Novell. Cada uno de estos protocolos de red son usados para transportar datos entre computadoras. Se discutirá aquí cómo son usados y se hará una introducción a sus principios fundamentales.

Se define una red, como una colección de nodos (del inglés hosts), capaces de comunicarse entre sí, a veces confiando en los servicios de un número determinado de máquinas que se encargan de transmitir datos entre quienes que lo demanden. Los nodos son casi siempre computadoras, pero no necesariamente; se puede pensar, sin equivocación, en terminales X o impresoras inteligentes como nodos. Por otro lado, a las pequeñas aglomeraciones de éstos, se las denomina sitios, (sites).

La comunicación, sería imposible sin algún tipo de lenguaje o código. En la jerga de las redes de computadoras, estos lenguajes se denominan conjuntamente como protocolos. No obstante, no se debería pensar aquí en lenguajes ya escritos y definidos, sino más bien en el código de comportamiento altamente formalizado, que se observa en una población cuando se reúnen jefes de estado, por citar un ejemplo. Así, los protocolos usados en las redes de computadoras no son más que reglas muy estrictas de intercambio de mensajes entre dos o más servidores.

Usar los Objetos Creados en Java

2008-09-21T08:53:00.000-07:00

Una vez que se ha creado un objeto, probablemente querrás hacer algo con él. Supón, por ejemplo, que después de crear un nuevo rectángulo, quieres moverlo a una posición diferente (es decir, el rectángulo es un objeto en un programa de dibujo y el usuario quiere moverlo a otra posición de la página).

La clase Rectangle proporciona dos formas equivalentes de mover el rectángulo.

Manipular directamente las variables x e y del objeto.

Llamar el método move().

La opción 2 se considera "más orientada a objetos" y más segura porque se manipulan las variables del objeto indirectamente a través de una capa protectora de métodos, en vez de manejarlas directamente. Manipular directamente las variables de un objeto se considera propenso a errores; se podría colocar el objeto en un estado de inconsistencia.

Sin embargo, una clase no podría (y no debería) hacer que sus variables estuvieran disponibles para la manipulación directa por otros objetos, si fuera posible que esas manipulaciones situaran el objeto en un estado de inconsistencia. Java proporciona un mecanismo mediante el que las clases pueden restringir o permitir el acceso a sus variables y métodos a otros objetos de otros tipos.

Esta sección explica la llamada a métodos y la manipulación de variables que se han hecho accesibles a otras clases. Para aprender más sobre el control de acceso a miembros puedes ir Controlar el Acceso a Miembros de una Clase.

Las variables x e y de Rectangle son accesibles desde otras clases. Por eso podemos asumir que la manipulación directa de estas variables es segura.

Referenciar Variables de un Objeto

Primero, enfoquemos cómo inspeccionar y modificar la posición del rectángulo mediante la manipulación directa de las variables x e y. La siguiente sección mostrará como mover el rectángulo llamando al método move().

Para acceder a las variables de un objeto, sólo se tiene que añadir el nombre de la variable al del objeto referenciado introduciendo un punto en el medio ('.').

objetoReferenciado.variable

Supón que tienes un rectángulo llamado rect en tu programa. puedes acceder a las variables x e y con rect.x y rect.y, respectivamente.

Ahora que ya tienes un nombre para las variables de rect, puedes utilizar ese nombre en sentencias y expresiones Java como si fueran nombres de variables "normales". Así, para mover el rectángulo a una nueva posición podrías escribir.

rect.x = 15; // cambia la posición x
rect.y = 37; // cambia la posición y

La clase Rectangle tiene otras dos variables--width y height--que son accesibles para objetos fuera de Rectangle. Se puede utilizar la misma notación con ellas: rect.width y rect.height. Entonces se puede calcular el área del rectángulo utilizando esta sentencia.

area = rect.height * rect.width;

Cuando se accede a una variable a través de un objeto, se está refiriendo a las variables de un objeto particular. Si cubo fuera también un rectángulo con una altura y anchura diferentes de rect, esta instrucción.

area = cubo.height * cubo.width;

calcula el área de un rectángulo llamado cubo y dará un resultado diferente que la instrucción anterior (que calculaba el área de un rectángulo llamado rect).

Observa que la primera parte del nombre de una variable de un objeto (el objetoReferenciado en objetoReferenciado.variable) debe ser una referencia a un objeto. Como se puede utilizar un nombre de variable aquí, también se puede utilizar en cualquier expresión que devuelva una referencia a un objeto. Recuerda que el operador new devuelve una referencia a un objeto. Por eso, se puede utilizar el valor devuelto por new para acceder a las variables del nuevo objeto.

height = new Rectangle().height;

Llamar a Métodos de un Objeto

Llamar a un método de un objeto es similar a obtener una variable del objeto. Para llamar a un método del objeto, simplemente se añade al nombre del objeto referenciado el nombre del método, separados por un punto ('.'), y se proporcionan los argumentos del método entre paréntesis. Si el método no necesita argumentos, se utilizan los paréntesis vacios.

objetoReferenciado.nombreMétodo(listaArgumentos);
o
objetoReferenciado.nombreMétodo();

Veamos que significa esto en términos de movimiento del rectángulo. Para mover rect a una nueva posición utilizando el método move() escribe esto.

rect.move(15, 37);

Esta sentencia Java llama al método move() de rect con dos parámetros enteros, 15 y 37. Esta sentencia tiene el efecto de mover el objeto rect igual que se hizo en las sentencias anteriores en las que se moficaban directamente los valores x e y del objeto.

rect.x = 15;
rect.y = 37;

Si se quiere mover un rectángulo diferente, uno llamado cubo, la nueva posición se podría escribir.

cubo.move(244, 47);

Como se ha visto en estos ejemplos, las llamadas a métodos se hacen directamente a un objeto específico; el objeto especificado en la llamada al método es el que responde a la instrucción.

Las llamadas a métodos también se conocen como mensajes.

Como en la vida real, los mensajes se deben dirigir a un receptor particular.

Se pueden obtener distintos resultados dependiendo del receptor de su mensaje.

En el ejemplo anterior, se ha enviado el mensaje move() al objeto llamado rect para que éste mueva su posición.

Cuando se envía el mensaje move() al objeto llamado cubo, el que se mueve es cubo. Son resultados muy distintos.

Una llamada a un método es una expresión (puedes ver Expresiones para más información) y evalúa a algún valor. El valor de una llamada a un método es su valor de retorno, si tiene alguno.

Normalmente se asignará el valor de retorno de un método a una variable o se utilizará la llamada al método dentro del ámbito de otra expresión o sentencia.

El método move() no devuelve ningún valor (está declarado como void). Sin embargo, el método inside() de Rectangle si lo hace. Este método toma dos coordendas x e y, y devuelte true si este punto está dentro del rectángulo.

Se puede utilizar el método inside() para hacer algo especial en algún punto, como decir la posición del ratón cuando está dentro del rectangulo.

if (rect.inside(mouse.x, mouse.y)) {

// ratón dentro del rectángulo

} else {

// ratón fuera del rectángulo

}

Recuerda que una llamada a un método es un mensaje al objeto nombrado. En este caso, el objeto nombrado es rect. Entonces.

rect.inside(mouse.x, mouse.y)

le pregunta a rect si la posición del cursor del ratón se encuentra entre las coordenadas mouse.x y mouse.y. Se podría obtener una respuesta diferente si envía el mismo mensaje a cubo.

Como se explicó anteriormente, el objetoReferenciado en la llamada al método objetoReferenciado.metodo() debe ser una referencia a un objeto. Como se puede utilizar un nombre de variable aquí, también se puede utilizar en cualquier expresión que devuelva una referencia a un objeto. Recuerda que el operador new devuelve una referencia a un objeto. Por eso, se puede utilizar el valor devuelto por new para acceder a las variables del nuevo objeto.

new Rectangle(0, 0, 100, 50).equals(anotherRect)

La expresión new Rectangle(0, 0, 100, 50) evalúa a una referencia a un objeto que se refiere a un objeto Rectangle.

Entonces, como verás, se puede utilizar la notación de punto ('.') para llamar al método equals() del nuevo objeto Rectangle para determinar si el rectangúlo nuevo es igual al especificado en la lista de argumentos de equals().

Creando Objetos en Java

2008-09-21T08:49:00.000-07:00

En Java, se crea un objeto mediante la creación de un objeto de una clase o, en otras palabras, ejemplarizando una clase. Aprenderás cómo crear una clase más adelante en Crear Clases.

Hasta entonces, los ejemplos contenidos aquí crean objetos a apartir de clases que ya existen en el entorno Java.

Frecuentemente, se verá la creación de un objeto Java con un sentencia como esta.

Date hoy = new Date();

Esta sentencia crea un objeto Date (Date es una clase del paquete java,util). Esta sentencia realmente realiza tres acciones: declaración, ejemplarización e inicialización.

Date hoy es una declaración de variable que sólo le dice al compilador que el nombre hoy se va a utilizar para referirse a un objeto cuyo tipo es Date, el operador new ejemplariza la clase Date (creando un nuevo objeto Date), y Date() inicializa el objeto.

Declarar un Objeto

Ya que la declaración de un objeto es una parte innecesaria de la creación de un objeto, las declaraciones aparecen frecuentemente en la misma línea que la creación del objeto. Como cualquier otra declaración de variable, las declaraciones de objetos pueden aparecer solitarias como esta.

Date hoy;

De la misma forma, declarar una variable para contener un objeto es exactamente igual que declarar una variable que va a contener un tipo primitivo.

tipo nombre

donde tipo es el tipo de dato del objeto y nombre es el nombre que va a utilizar el objeto. En Java, las clases e interfaces son como tipos de datos. Entonces tipo puede ser el nombre de una clase o de un interface.

Las declaraciones notifican al compilador que se va a utilizar nombre para referirse a una variable cuyo tipo es tipo. Las declaraciones no crean nuevos objetos. Date hoy no crea un objeto Date, sólo crea un nombre de variable para contener un objeto Date. Para ejemplarizar la clase Date, o cualquier otra clase, se utiliza el operador new.

Ejemplarizar una Clase

El operador new ejemplariza una clase mediante la asignación de memoria para el objeto nuevo de ese tipo. new necesita un sólo argumento: una llamada al método constructor. Los métodos constructores son métodos especiales proporcionados por cada clase Java que son reponsables de la inicialización de los nuevos objetos de ese tipo. El operador new crea el objeto, el constructor lo inicializa.

Aquí tienes un ejemplo del uso del operador new para crear un objeto Rectangle (Rectangle es una clase del paquete java.awt).

new Rectangle(0, 0, 100, 200);

En el ejemplo, Rectangle(0, 0, 100, 200) es una llamada al constructor de la clase Rectangle.

El operador new devuelve una referencia al objeto recien creado. Esta referencia puede ser asignada a una variable del tipo apropiado.

Rectangle rect = new Rectangle(0, 0, 100, 200);

(Recuerda que una clase esencialmente define un tipo de dato de referencia. Por eso, Rectangle puede utilizarse como un tipo de dato en los programas Java. El valor de cualquier variable cuyo tipo sea un tipo de referencia, es una referencia (un puntero) al valor real o conjunto de valores representado por la variable.

Inicializar un Objeto

Como mencioné anteriormente, las clases porporcionan métodos constructores para incializar los nuevos objetos de ese tipo. Una clase podría proporcionar múltiples constructores para realizar diferentes tipos de inicialización en los nuevos objetos.

Cuando veas la implementación de una clase, reconocerás los constructores porque tienen el mismo nombre que la clase y no tienen tipo de retorno. Recuerda la creación del objeto Date en el sección inicial. El constructor utilizado no tenía ningún argumento.

Date()

Un constructor que no tiene ningún argumento, como el mostrado arriba, es conocido como constructor por defecto. Al igual que Date, la mayoría de las clases tienen al menos un constructor, el constructor por defecto.

Si una clase tiene varios constructores, todos ellos tienen el mismo nombre pero se deben diferenciar en el número o el tipo de sus argumentos. Cada constructor inicializa el nuevo objeto de una forma diferente. Junto al constructor por defecto, la clase Date proporciona otro constructor que inicializa el nuevo objeto con un nuevo año, mes y día.

Date cumpleaños = new Date(1963, 8, 30);

El compilador puede diferenciar los constructores a través del tipo y del número de sus argumentos.

Sentencias de Control en Java

2008-09-21T08:37:00.000-07:00

Sentencias de Control de Flujo en Java

Las sentencias de control de flujo determinan el orden en que se ejecutarán las otras sentencias dentro del programa. El lenguaje Java soporta varias sentencias de control de flujo, incluyendo.

Sentencias palabras clave

toma de decisiones if-else, switch-case
bucles for, while, do-while
excepciones try-catch-finally, throw
miscelaneas break, continue, label:, return

Nota: Aunque goto es una palabra reservada, actualmente el lenguaje Java no la soporta. Podemos utilizar las rupturas etiquetadas en su lugar.

La sentencia if-else
La sentencia if-else de java proporciona a los programas la posibilidad de ejecutar selectivamente otras sentencias basándose en algún criterio.

Por ejemplo, supon que tu programa imprime información de depurado basándose en el valor de una variable booleana llamada DEBUG. Si DEBUG fuera verdadera true, el programa imprimiría la información de depurado, como por ejemplo, el valor de una variable como x. Si DEBUG es false el programa procederá normalmente. Un segmento de código que implemente esto se podría parecer a este.

if (DEBUG)
System.out.println("DEBUG: x = " + x);

Esta es la versión más sencilla de la sentencia if: la sentencia gobernada por if se ejecuta si alguna codición es verdadera. Generalmente, la forma sencilla de if se puede escribir así.

if (expresión)
sentencia

Pero, ¿y si quieres ejecutar un juego diferente de sentencias si la expresión es falsa? Bien, puedes utilizar la sentencia else. Echemos un vistazo a otro ejemplo. Supon que tu programa necesita realizar diferentes acciones dependiendo de que el usuario pulse el botón OK o el botón Cancel en un ventana de alarma. Se podría hacer esto utilizando una sentencia if.

// Respuesta dependiente del botoón que haya pulsado el usuario
// OK o Cancel

if (respuesta == OK) {

// Código para la acción OK

} else {

// código para la acción Cancel

}

Este uso particular de la sentencia else es la forma de capturarlo todo.

Existe otra forma de la sentecia else, else if que ejecuta una sentencia basada en otra expresión. Por ejemplo, supon que has escrito un programa que asigna notas basadas en la puntuación de un examen, un Sobresaliente para una puntuación del 90% o superior, un Notable para el 80% o superior y demás. odrías utilizar una sentencia if con una serie de comparaciones else if y una setencia else para escribir este código.

int puntuacion;
String nota;

if (puntuacion >= 90) {
nota = "Sobresaliente";
} else if (puntuacion >= 80) {
nota = "Notable";
} else if (puntuacion >= 70) {
nota = "Bien";
} else if (puntuacion >= 60) {
nota = "Suficiente";
} else {
nota = "Insuficiente";
}

Una sentencia if puede tener cualquier número de sentencias de acompañamiento else if.

Podrías haber observado que algunos valores de puntuacion pueden satisfacer más una de las expresiones que componen la sentencia if. Por ejemplo, una puntuación de 76 podría evaluarse como true para dos expresiones de esta sentencia:puntuacion >= 70 y puntuacion >= 60.

Sin embargo, en el momento de ejecución, el sistema procesa una sentencia if compuesta como una sóla; una vez que se ha satisfecho una condición (76 >= 70), se ejecuta la sentencia apropiada (nota = "Bien";), y el control sale fuera de la sentencia if sin evaluar las condiciones restantes.

La sentencia switch

La sentencia switch se utiliza para realizar sentencias condicionalmente basadas en alguna expresión. Por ejemplo, supon que tu programa contiene un entero llamado mes cuyo valor indica el mes en alguna fecha. Supon que también quieres mostrar el nombre del mes basándose en su número entero equivalente. Podrías utilizar la sentencia switch de Java para realizar esta tarea.

int mes;

switch (mes) {
case 1: System.out.println("Enero"); break;
case 2: System.out.println("Febrero"); break;
case 3: System.out.println("Marzo"); break;
case 4: System.out.println("Abril"); break;
case 5: System.out.println("May0"); break;
case 6: System.out.println("Junio"); break;
case 7: System.out.println("Julio"); break;
case 8: System.out.println("Agosto"); break;
case 9: System.out.println("Septiembre"); break;
case 10: System.out.println("Octubre"); break;
case 11: System.out.println("Noviembre"); break;
case 12: System.out.println("Diciembre"); break;
}

La sentencia switch evalúa su expresión, en este caso el valor de mes, y ejecuta la sentencia case apropiada.

Decidir cuando utilizar las sentencias if o switch dependen del juicio personal. Puedes decidir cual utilizar basándose en la buena lectura del código o en otros factores.

Cada sentencia case debe ser única y el valor proporcionado a cada sentencia case debe ser del mismo tipo que el tipo de dato devuelto por la expresión proporcionada a la sentencia switch.

Otro punto de interes en la sentencia switch son las sentencias break después de cada case.

La sentencia break hace que el control salga de la sentencia switch y continúe con la siguiente línea.

La sentencia break es necesaria porque las sentencias case se siguen ejecutando hacia abajo. Esto es, sin un break explícito, el flujo de control seguiría secuencialmente a través de las sentencias case siguientes.

En el ejemplo anterior, no se quiere que el flujo vaya de una sentencia case a otra, por eso se han tenido que poner las sentencias break.

Sin embargo, hay ciertos escenario en los que querrás que el control proceda secuencialmente a través de las sentencias case. Como este código que calcula el número de días de un mes de acuerdo con el ritmico refrán que dice "Treinta dias tiene Septiembre...".

int mes;
int numeroDias;

switch (mes) {
case 1.
case 3.
case 5.
case 7.
case 8.
case 10.
case 12.
numeroDias = 31;
break;
case 4.
case 6.
case 9.
case 11.
numeroDias = 30;
break;
case 2.
if ( ((ano % 4 == 0) && !(ano % 100 == 0)) || ano % 400 == 0) )
numeroDias = 29;
else
numeroDias = 28;
break;
}

Finalmente, puede utilizar la sentencia default al final de la sentencia switch para manejar los valores que no se han manejado explícitamente por una de las sentencias case.

int mes;

switch (mes) {
case 1: System.out.println("Enero"); break;
case 2: System.out.println("Febrero"); break;
case 3: System.out.println("Marzo"); break;
case 4: System.out.println("Abril"); break;
case 5: System.out.println("Mayo"); break;
case 6: System.out.println("Junio"); break;
case 7: System.out.println("Julio"); break;
case 8: System.out.println("Agosto"); break;
case 9: System.out.println("Septiembre"); break;
case 10: System.out.println("Octubre"); break;
case 11: System.out.println("Noviembre"); break;
case 12: System.out.println("Diciembre"); break;
default: System.out.println("Ee, no es un mes válido!");
break;
}

Sentencias de Bucle
Generalmente hablando, una sentencia while realiza una acción mientras se cumpla una cierta condición. La sintaxis general de la sentencia while es.

while (expresión)
sentencia

Esto es, mientras la expresión sea verdadera, ejecutará la sentencia.

sentencia puede ser una sóla sentencia o puede ser un bloque de sentencias. Un bloque de sentencias es un juego de sentencias legales de java contenidas dentro de corchetes('{'y '}').

Por ejemplo, supon que además de incrementar contador dentro de un bucle while también quieres imprimir el contador cada vez que se lea un carácter. Podrías escribir esto en su lugar.

while (System.in.read() != -1) {
contador++;
System.out.println("Se ha leido un el carácter = " + contador);
}

Por convención el corchete abierto '{' se coloca al final de la misma línea donde se encuentra la sentencia while y el corchete cerrado '}' empieza una nueva línea indentada a la línea en la que se encuentra el while.

Además de while Java tiene otros dos constructores de bucles que puedes utilizar en tus programas.

el bucle for y el bucle do-while.

Primero el bucle for. Puedes utilizar este bucle cuando conozcas los límites del bucle (su instrucción de inicialización, su criterio de terminación y su instrucción de incremento). Por ejemplo, el bucle for se utiliza frecuentemente para iterar sobre los elementos de un array, o los caracteres de una cadena.

// a es un array de cualquier tipo

int i;
int length = a.length;
for (i = 0; i < length; i++) {

// hace algo en el elemento i del array a

}

Si sabes cuando estas escribiendo el programa que quieres empezar en el inicio del array, parar al final y utilizar cada uno de los elementos. Entonces la sentencia for es una buena elección. La forma general del bucle for puede expresarse asi.

for (inicialización; terminación; incremento)
sentencias

inicialización es la sentencia que inicializa el bucle -- se ejecuta una vez al iniciar el bucle.

terminación es una sentecia que determina cuando se termina el bucle. Esta expresión se evalúa al principio de cada iteracción en el bucle. Cuando la expreión se evalúa a false el bucle se termina.

Finalmente, incremento es una expresión que se invoca en cada interacción del bucle. Cualquiera (o todos) de estos componentes puden ser una sentencia vacía (un punto y coma).

Java proporciona otro bucle, el bucle do-while,que es similar al bucle while que se vió al principio, excepto en que la expresión se avalú al final del bucle.

do {
sentencias
} while (Expresión Booleana);

La sentencia do-while se usa muy poco en la construcción de bucles pero tiene sus usos. Por ejemplo, es conveniente utilizar la sentencia do-while cuando el bucle debe ejecutarse al menos una vez. Por ejemplo, para leer información de un fichero, sabemos que al menos debe leer un carácter.

int c;
InputStream in;
. . .
do {
c = in.read();
. . .
} while (c != -1);

Sentencias de Manejo de Excepciones

Cuando ocurre un error dentro de un método Java, el método puede lanzar una excepción para indicar a su llamador que ha ocurrido un error y que el error está utilizando la sentencia throw.

El método llamador puede utilizar las sentencias try, catch, y finally para capturar y manejar la excepción.

Puedes ver Manejar Errores Utilizando Excepciones para obtener más información sobre el lanzamiento y manejo de excepciones.

Sentencias de Ruptura

Ya has visto la sentencia break en acción dentro de la sentencia switch anteriormente. Como se observó anteriormente, la sentencia break hace que el control del flujo salte a la sentencia siguiente a la actual.

Hay otra forma de break que hace que el flujo de control salte a una sentencia etiquetada.

Se puede etiquetar una sentencia utilizando un identificador legal de Java (la etiqueta) seguido por dos puntos (:) antes de la sentencia.

SaltaAqui: algunaSentenciaJava

Para saltar a la sentencia etiquetada utilice esta forma de la sentencia break.

break SaltaAqui;

Las rupturas etiquetadas son una alternativa a la sentencia goto que no está soportada por el lenguaje Java.

Se puede utiliza la sentencia continue dentro de un bucle para saltar de la sentencia actual hacia el principio del bucle o a una sentencia etiquetada.

Considera esta implementación del método indexOf() de la clase String que utiliza la forma de continue que continúa en una sentencia etiquetada.

public int indexOf(String str, int fromIndex) {
char[] v1 = value;
char[] v2 = str.value;
int max = offset + (count - str.count);
test.
for (int i = offset + ((fromIndex < 0) ? 0 : fromIndex); i <= max ; i++) {
int n = str.count;
int j = i;
int k = str.offset;
while (n-- != 0) {
if (v1[j++] != v2[k++]) {
continue test;
}
}
return i - offset;
}
return -1;
}

Nota: Sólo se puede llamar a la sentencia continue desde dentro de un bucle.

la sentencia return.

Esta sentencia se utiliza para salir del método actual y volver a la sentencia siguiente a la que originó la llamada en el método original.

Existen dos formas de return: una que devuelve un valor y otra que no lo hace.

Para devolver un valor, simplemente se pone el valor (o una expresión que calcule el valor) detrás de la palabra return.

return ++count;

El valor devuelto por return debe corresponder con el tipo del valor de retorno de la declaración del método.

Cuando un método se declara como void utiliza la forma de return que no devuelve ningún valor.

return;

Función para el manejo de cadena (Left, Right y Mid) en Visual Basic 6.0

2008-09-21T08:26:00.000-07:00

Estas funciones son utilizadas para extraer partes de una cadena.

La función Left:

tiene 2 parámetros: El primero es la cadena de la cual se extraerán caracteres, y el segundo un número desde el cual comenzar a extraer caracteres desde la parte izquierda.

Ejemplo:

Dim Cadena As String

Cadena = Left("Ya es la madrugada", 9)

'Cadena, que es un string, sería igual a: "Ya es la"

Función Right:

Es igual que la función Left pero comienza a extraer caracteres desde el lado derecho de la cadena.

La función Mid:

Tiene la misma función que las anteriores pero posee tres parámetros. Su sintaxis es:

Mid (cadena, inicio, longitud)

El parámetro cadena es la cadena a extraer caracteres. El parámetro Inicio es donde comenzar y el parámetro longitud, es la cantidad de caracteres a extraer de la cadena de caracteres

Ejemplos:

Dim nombre As String
nombre = Mid("River perdió la copa", 7, 6)

'La variable nombre sería igual a: "perdió"

Este Otro ejemplo usa la función Mid para realizar un simple efecto tipo máquina de escribir.

Colocar en un formulario un CommandButton y el siguiente código fuente en el form.

Option Explicit

Sub Pausa(Segundos As Double)

Dim inicio As Double

' Devuelve la cantidad de segundos desde que inicio windows
inicio = Timer

Do While (Timer - inicio) < Segundos
' pausa
DoEvents
Loop
End Sub

Private Sub Command1_Click()

Dim texto As String

texto = "... Hola mundo --->>> "

Call MostrarTexto(texto, 0.1, Me)

End Sub

Private Sub MostrarTexto(Frase As String, _
Segundos As Double, _
Destino As Object)

Dim LenFrase As Integer
Dim i As Integer
Dim Caracter As String
Dim texto As String

LenFrase = Len(Frase)

Do While i <= LenFrase
Destino.Cls

DoEvents
i = i + 1
' Obtiene el siguiente caracter
Caracter = Mid(Frase, i, 1)
' texto actual
texto = texto & Caracter
Destino.Print texto ' Imprimi e/ dibuja el texto
' pausa o delay
Pausa Segundos
DoEvents
Loop
End Sub

Private Sub Form_Load()
Me.FontSize = 12
Me.Font.Bold = True
Me.ForeColor = vbRed
Command1.Caption = " Efecto de texto con mid "
End Sub

Private Sub Form_Unload(Cancel As Integer)
End
End Sub

Función para el manejo de cadena (InsTr) en Visual Basic 6.0

2008-09-21T08:24:00.000-07:00

La función InStr se utiliza para buscar una cadena o parte de una cadena dentro de otra cadena.

Si la función encuentra la cadena a buscar devuelve un número que representa la posición donde encontró la cadena, si no la encuentra devuelve un 0.

Los parámetros que lleva esta función son:

InStr (comienzo, Cadena donde buscar , La Cadena a buscar)
Como esta función devuelve un número debemos almacenarla en una variable de tipo numérica para utilizarla.

Ejemplo:

Dim posicion As Integer

posicion = InStr("Estoy tomando mate", "mate")
En este ejemplo la función encontró la cadena "mate" en la posición 15, o sea que la variable posición pasa a valer 15.

Si observamos bien, la función en el primer parámetro, denominado comienzo, nos pide que le digamos desde que posición comenzar a buscar. En nuestro ejemplo, este parámetro lo obviamos, esto quiere decir que comenzará desde la posición 0 de la cadena a buscar. Pero podríamos especificar una posición en particular, por ejemplo desde la 5 , 10 etc..., según lo que necesitemos hacer.

Otro ejemplo de InsTr :

Este ejemplo, muestra como buscar dentro de un control TextBox, el cual tiene dos opciones, un botón para buscar la primera frase, y otro que sigue buscando a partir de donde esté ubicda la selección.

Para armar el ejemplo colocar un Textbox llamado Text_Buscar que es donde se ingresará la frase y otro TextBox llamado Text1 que tendrá el texto. Este ultimo con la propiedad Multiline en True.

También colocar dos CommandButton: Command1 y Command2

Colocar el siguiente código fuente en el formulario:

Option Explicit

Private m_Pos As Integer

Sub buscar_cadena(ByVal Posicion As Integer)

Dim p As Integer, Frase As String

Frase = txt_Buscar

p = InStr(Posicion, Text1, Frase)

If p > 0 Then
m_Pos = p

With Text1
.SelStart = m_Pos - 1
.SelLength = Len(Frase)
.SetFocus
End With
Else
MsgBox "No se encontró la frase", vbInformation
Text1.SetFocus
End If
End Sub

Private Sub Command1_Click()
'Busca a pratir de la primera pocición
Call buscar_cadena(1)
End Sub

Private Sub Command2_Click()
'Busca a partir del valor que tenga m_Pos

Call buscar_cadena(m_Pos + 1)

End Sub

Private Sub Form_Load()
Command1.Caption = "Buscar"
Command2.Caption = "Buscar siguiente"
Me.Caption = "Ejemplo de InStr "
End Sub

Nota: también hay una función similar a Instr llamada InstrRev , y lo que hace es devolver la posición de la primera concurrencia de una cadena dentro de otra cadena, pero comenzando por el extremo derecho de la misma.

Función para el manejo de cadena (Asc y Chr) en Visual Basic 6.0

2008-09-21T08:22:00.000-07:00

La función Asc nos permite obtener el código ASCII de un de terminado caracter.

Ejempos:

Si queremos obtener el código ASCII del caracter "a", que es el número 97 podríamos hacer lo siguiente:

Dim num As Integer

num = Asc("a")

En definitiva la función Asc lleva un solo parámetro de tipo String del cual queremos obtener dicho número.

La Función Chr actúa a la inversa de la función Asc, esto quiere decir, que a partir de un determinado número nos devolverá el caracter ASCII.

Obviamente que en vez de pasarle a la función un parámetro String es decir la letra, debemos pasarle un número ASCII y nos devolverá el carácter asociado.

Ejemplo:

Dim letra As String

letra = Chr(97)

La variable pasa a valer en este caso el caracter "a"

Función para el manejo de cadena (Len) en Visual Basic 6.0

2008-09-21T08:20:00.000-07:00

La función Len nos permite conocer la cantidad de caracteres que tiene una determinada cadena. O sea que esta función nos devuelve un número.

Ejemplo:

Len (Aquí va la cadena que queremos averiguar su tamaño)

Como la función Len devuelve un número debemos asignar ese número devuelto en una variable de tipo numérica.

Ejemplo:

Dim TamanoCadena As Long

Dim MiCadena As String

MiCadena = "Me Llamo Eustaquio"

TamanoCadena = Len(MiCadena)

El valor de la variable TamanoCadena pasaría a valer 18.

Hay que tener en cuenta que la función Len también toma en cuenta los espacios vacíos.

Función para el manejo de cadena (Trim, LTrim y RTrim) en Visual Basic 6.0

2008-09-21T08:19:00.001-07:00

Estas tres funciones se utilizan para eliminar los espacios vacíos de una cadena.

LTrim elimina los espacios vacíos de la parte izquierda de la cadena, RTrim de la parte derecha y Trim de ambas partes.

Ejemplos:

Tenemos una variable llamada ciudad con el valor " Barcelona". Para eliminar los espacios vacíos de la izquierda haríamos lo siguiente:

ciudad = LTrim(ciudad)

Si en un TextBox quisieramos borrar todos los espacios vacíos de la parte derecha de la cadena:

MiText = RTrim(MiText)

La Función Trim elimina todos los espacios vacíos de ambos lados de la cadena. Ejemplo:

Pais = " Argentina "
País = Trim(Pais)

Ahora el valor de País es igual a: "Argentina".

Función para el manejo de cadena (Lcase y Ucase) en Visual Basic 6.0

2008-09-21T08:17:00.001-07:00

Estas dos funciones se utilizan para convertir cadenas de texto a minúscula y mayúscula.
La función Lcase cambia o convierte una cadena de texto a minúscula y un ejemplo de como utilizarla sería así:

Lcase (cadena que queremos convertir a minúsculas)

Ejemplo:

Dim cadena As String

cadena = "HOLA MUNDO"

'Convertimos
cadena = LCase(cadena)

'La variable cadena ahora vale "hola mundo"

La función Ucase funciona de la misma manera que Lcase pero convierte el contenido de una cadena a mayúsculas.

Por ejemplo, si tenemos un control Label1 que contiene un texto que dice: "Porcentaje de sueldos", escribiendo la siguiente línea:

Label1 = UCase(Label1)

El control Label1 pasaría a mostrar o mejor dicho contener en su propiedad caption:"PORCENTAJE DE SUELDOS

Modelos de Base de Datos

2008-09-12T20:03:00.000-07:00

Modelo de datos jerárquico

Este modelo utiliza árboles para la representación lógica de los datos. Este árbol esta compuesto de unos elementos llamados nodos. El nivel más alto del árbol se denomina raíz. Cada nodo representa un registro con sus correspondientes campos.

La representación gráfica de este modelo se realiza mediante la creación de un árbol invertido, los diferentes niveles quedan unidos mediante relaciones.

En este modelo solo se pueden representar relaciones 1:M, por lo que presenta varios inconvenientes:

No se admiten relaciones N:M
Un segmento hijo no puede tener más de un padre.
No se permiten más de una relación entre dos segmentos.
Para acceder a cualquier segmento es necesario comenzar por el segmento raíz
El árbol se debe de recorrer en el orden designado.

Modelo de datos en red

En este modelo las entidades se representan como nodos y sus relaciones son las líneas que los unen. En esta estructura cualquier componente puede relacionarse con cualquier otro.
A diferencia del modelo jerárquico, en este modelo, un hijo puede tener varios padres.
Los conceptos básicos en el modelo en red son:
El tipo de registro, que representa un nodo.
Elemento, que es un campo de datos.
Agregado de datos, que define un conjunto de datos con nombre.

Este modelo de datos permite representar relaciones N:M

Modelo de datos relacional

Este modelo es el más utilizado actualmente ya que utiliza tablas bidimensionales para la representación lógica de los datos y sus relaciones.

Algunas de sus principales caracteristicas son:

Puede ser entendido y usado por cualquier usuario.
Permite ampliar el esquema conceptual sin modificar las aplicaciones de gestión.
Los usuarios no necesitan saber donde se encuentran los datos físicamente.

El modelo deductivo: los datos se representan como una tabla, pero se manipulan mediante cálculos de predicados.

El modelo de orientación a objetos (ODBMS, object-oriented database management system [sistema de administración de bases de datos orientadas a objetos]): los datos se almacenan como objetos, que son estructuras denominadas clases que muestran los datos que contienen. Los campos son instancias de estas clases.

Un dato Importante : A fines de la década de 1990, las bases de datos relacionales eran las más utilizadas (comprendían aproximadamente tres cuartos de todas las bases de datos).

Comenzando con Base de Datos

2008-09-12T19:35:00.000-07:00

Una base de datos es un “almacén” que nos permite guardar grandes cantidades de información de forma organizada para que luego podamos encontrar y utilizar fácilmente.

El término de bases de datos fue escuchado por primera vez en 1963, en un simposio celebrado en California, USA. Una base de datos se puede definir como un conjunto de información relacionada que se encuentra agrupada ó estructurada.

Desde el punto de vista informático, la base de datos es un sistema formado por un conjunto de datos almacenados en discos que permiten el acceso directo a ellos y un conjunto de programas que manipulen ese conjunto de datos.

Cada base de datos se compone de una o más tablas que guarda un conjunto de datos. Cada tabla tiene una o más columnas y filas. Las columnas guardan una parte de la información sobre cada elemento que queramos guardar en la tabla, cada fila de la tabla conforma un registro.

Definición de base de datos

Se define una base de datos como una serie de datos organizados y relacionados entre sí, los cuales son recolectados y explotados por los sistemas de información de una empresa o negocio en particular.

Características

Entre las principales características de los sistemas de base de datos podemos mencionar:

Independencia lógica y física de los datos.
Redundancia mínima.
Acceso concurrente por parte de múltiples usuarios.
Integridad de los datos.
Consultas complejas optimizadas.
Seguridad de acceso y auditoria.
Respaldo y recuperación.
Acceso a través de lenguajes de programación estándar.
Sistema de Gestión de Base de Datos (SGBD)
Los Sistemas de Gestión de Base de Datos (en inglés DataBase Management System) son un tipo de software muy específico, dedicado a servir de interfaz entre la base de datos, el usuario y las aplicaciones que la utilizan. Se compone de un lenguaje de definición de datos, de un lenguaje de manipulación de datos y de un lenguaje de consulta.

Ventajas de las bases de datos

Control sobre la redundancia de datos:
Los sistemas de ficheros almacenan varias copias de los mismos datos en ficheros distintos. Esto hace que se desperdicie espacio de almacenamiento, además de provocar la falta de consistencia de datos.

En los sistemas de bases de datos todos estos ficheros están integrados, por lo que no se almacenan varias copias de los mismos datos. Sin embargo, en una base de datos no se puede eliminar la redundancia completamente, ya que en ocasiones es necesaria para modelar las relaciones entre los datos.

Consistencia de datos:
Eliminando o controlando las redundancias de datos se reduce en gran medida el riesgo de que haya inconsistencias. Si un dato está almacenado una sola vez, cualquier actualización se debe realizar sólo una vez, y está disponible para todos los usuarios inmediatamente. Si un dato está duplicado y el sistema conoce esta redundancia, el propio sistema puede encargarse de garantizar que todas las copias se mantienen consistentes.

Compartición de datos:
En los sistemas de ficheros, los ficheros pertenecen a las personas o a los departamentos que los utilizan. Pero en los sistemas de bases de datos, la base de datos pertenece a la empresa y puede ser compartida por todos los usuarios que estén autorizados.

Mantenimiento de estándares:
Gracias a la integración es más fácil respetar los estándares necesarios, tanto los establecidos a nivel de la empresa como los nacionales e internacionales. Estos estándares pueden establecerse sobre el formato de los datos para facilitar su intercambio, pueden ser estándares de documentación, procedimientos de actualización y también reglas de acceso.

Mejora en la integridad de datos:
La integridad de la base de datos se refiere a la validez y la consistencia de los datos almacenados. Normalmente, la integridad se expresa mediante restricciones o reglas que no se pueden violar. Estas restricciones se pueden aplicar tanto a los datos, como a sus relaciones, y es el SGBD quien se debe encargar de mantenerlas.

Mejora en la seguridad:
La seguridad de la base de datos es la protección de la base de datos frente a usuarios no autorizados. Sin unas buenas medidas de seguridad, la integración de datos en los sistemas de bases de datos hace que éstos sean más vulnerables que en los sistemas de ficheros.

Mejora en la accesibilidad a los datos:
Muchos SGBD proporcionan lenguajes de consultas o generadores de informes que permiten al usuario hacer cualquier tipo de consulta sobre los datos, sin que sea necesario que un programador escriba una aplicación que realice tal tarea.

Mejora en la productividad:
El SGBD proporciona muchas de las funciones estándar que el programador necesita escribir en un sistema de ficheros. A nivel básico, el SGBD proporciona todas las rutinas de manejo de ficheros típicas de los programas de aplicación.

El hecho de disponer de estas funciones permite al programador centrarse mejor en la función específica requerida por los usuarios, sin tener que preocuparse de los detalles de implementación de bajo nivel.

Mejora en el mantenimiento:
En los sistemas de ficheros, las descripciones de los datos se encuentran inmersas en los programas de aplicación que los manejan.

Esto hace que los programas sean dependientes de los datos, de modo que un cambio en su estructura, o un cambio en el modo en que se almacena en disco, requiere cambios importantes en los programas cuyos datos se ven afectados.

Sin embargo, los SGBD separan las descripciones de los datos de las aplicaciones. Esto es lo que se conoce como independencia de datos, gracias a la cual se simplifica el mantenimiento de las aplicaciones que acceden a la base de datos.

Aumento de la concurrencia:
En algunos sistemas de ficheros, si hay varios usuarios que pueden acceder simultáneamente a un mismo fichero, es posible que el acceso interfiera entre ellos de modo que se pierda información o se pierda la integridad. La mayoría de los SGBD gestionan el acceso concurrente a la base de datos y garantizan que no ocurran problemas de este tipo.

Mejora en los servicios de copias de seguridad:
Muchos sistemas de ficheros dejan que sea el usuario quien proporcione las medidas necesarias para proteger los datos ante fallos en el sistema o en las aplicaciones. Los usuarios tienen que hacer copias de seguridad cada día, y si se produce algún fallo, utilizar estas copias para restaurarlos.

En este caso, todo el trabajo realizado sobre los datos desde que se hizo la última copia de seguridad se pierde y se tiene que volver a realizar. Sin embargo, los SGBD actuales funcionan de modo que se minimiza la cantidad de trabajo perdido cuando se produce un fallo.

Desventajas de las bases de datos

Complejidad:
Los SGBD son conjuntos de programas que pueden llegar a ser complejos con una gran funcionalidad. Es preciso comprender muy bien esta funcionalidad para poder realizar un buen uso de ellos.

Coste del equipamiento adicional:
Tanto el SGBD, como la propia base de datos, pueden hacer que sea necesario adquirir más espacio de almacenamiento. Además, para alcanzar las prestaciones deseadas, es posible que sea necesario adquirir una máquina más grande o una máquina que se dedique solamente al SGBD. Todo esto hará que la implantación de un sistema de bases de datos sea más cara.

Vulnerable a los fallos:
El hecho de que todo esté centralizado en el SGBD hace que el sistema sea más vulnerable ante los fallos que puedan producirse. Es por ello que deben tenerse copias de seguridad (Backup).

Tipos de Campos

Cada Sistema de Base de Datos posee tipos de campos que pueden ser similares o diferentes. Entre los más comunes podemos nombrar:

Numérico: entre los diferentes tipos de campos numéricos podemos encontrar enteros “sin decimales” y reales “decimales”.
Booleanos: poseen dos estados: Verdadero “Si” y Falso “No”.
Memos: son campos alfanuméricos de longitud ilimitada. Presentan el inconveniente de no poder ser indexados.
Fechas: almacenan fechas facilitando posteriormente su explotación. Almacenar fechas de esta forma posibilita ordenar los registros por fechas o calcular los días entre una fecha y otra.
Alfanuméricos: contienen cifras y letras. Presentan una longitud limitada (255 caracteres).
Autoincrementables: son campos numéricos enteros que incrementan en una unidad su valor para cada registro incorporado. Su utilidad resulta: Servir de identificador ya que resultan exclusivos de un registro.

Tipos de Base de Datos

Entre los diferentes tipos de base de datos, podemos encontrar los siguientes:

MySql: es una base de datos con licencia GPL basada en un servidor. Se caracteriza por su rapidez. No es recomendable usar para grandes volúmenes de datos.

PostgreSql y Oracle: Son sistemas de base de datos poderosos. Administra muy bien grandes cantidades de datos, y suelen ser utilizadas en intranets y sistemas de gran calibre.
Access: Es una base de datos desarrollada por Microsoft. Esta base de datos, debe ser creada bajo el programa access, el cual crea un archivo .mdb con la estructura ya explicada.

Microsoft SQL Server: es una base de datos más potente que access desarrollada por Microsoft. Se utiliza para manejar grandes volúmenes de informaciones.

Las Funciones en Visual Basic 6.0

2008-09-12T12:46:00.000-07:00

Las funciones son casi exactamente iguales que los procedimientos con respecto a la forma en que se los llama y se los crea o declara en el código, en como se le pasa los parámetros etc..

La diferencia fundamental con respecto a los procedimientos o subrutinas es que estos, luego de ejecutar el código que tengan en su interior, al final retornan un valor, y este valor luego lo podemos utilizar para una determinada tarea. En cambio los procedimientos, solo ejecutan el código que contienen y luego mueren por decirlo de alguna manera.

Para declarar o crear una función podríamos escribir lo siguiente:

Private Function Total(Valor1 As Integer, Valor2 As Integer) As Long

Total = Valor1 + Valor2

End Function

Seguramente notaste que declaramos la función llamada Total, y al final de los parámetros dice As Long , esto es por que como dijimos las funciones retornan o devuelven un valor, o sea que en este caso la función es de tipo Long, o mejor dicho devolverá un valor de tipo Long., y luego ese valor devuelto lo podemos utilizar en otra parte del programa.

Las Funciones pueden retornar casi cualquier tipo de datos, como números, cadenas, fechas, arreglos y vectores

Para llamar a la función anterior podríamos hacerlo de la siguiente manera:

Label1.caption = Total 502, 1478

En este caso el control Label1 llamaría a la función Total , la función realizaría la suma de los valores pasados como parámetros y por último el valor final de la suma se lo asignaría al control label1.

Pasar parámetros por valor (ByVal) y por referencia (ByRef ) en Visual Basic 6.0

2008-09-12T12:45:00.000-07:00

los parámetros en las funciones y procedimientos, se pueden enviar de dos maneras: por Valor y por Referencia.

Si están declarados como ByVal, los mismos serán por valor, si se declaran como ByRef serán por referencia.

La diferencia entre uno y otro método de paso de parámetros, es que en ByVal se envía una copia de la variable, y de esta manera si se efectúa un cambio en el procedimiento, solo tendrá efecto dentro del procedimiento o función, una ves que termine y finalice el mismo, la variable original pasará a valer el dato que tenía, es decir no se modifica

En los parámetros enviados por Referencia, lo que se hace es enviar un puntero de la variable original. Entonces, si en la función o procedimiento se cambia el valor de la variable, el cambio seguirá manteniéndose una ves que finalice la ejecución del procedimiento o función.

Ejemplo de envío de parámetros por Valor ( ByVal )

Código de ejemplo

Private Sub Command1_Click()

Dim Un_Valor As Long

Un_Valor = 100

'Se envía la variable por Valor ( ByVal )

Call Sumar(Un_Valor)

'Muestra el valor que es 100, ( no se modificó en la función Sumar )
MsgBox Un_Valor

End Sub

Sub Sumar(ByVal Valor As Long)
'Modifica la variable
Valor = Valor + 100

End Sub

En el ejemplo anterior hay una Sub llamada Sumar que recibe como parámetro una variable enviada por valor con ByVal ( es decir es una copia de la variable original ). al presionar el Commmand1.

Al entrar en la Sub Sumar, el dato se modifica ( Valor = Valor + 100). Cuando finaliza el procedimiento Sumar y retorna a la línea siguiente de la llamada a la Sub sumar, muestra mediante un MsgBox el valor de la misma, en este caso es 100, y NO 200 que es el cambio que tuvo dentro del procedimiento Sumar ( Valor = Valor + 100 ).

Con esto queda visto que en realidad al enviarla como ByVal, se envía una copia de la variable original y cualquier cambio que se produzca, será solo en el ámbito del procedimiento o función

Ejemplo de envío de parámetros por Referencia ( ByRef )

Este ejemplo es igual que el anterior, pero en la Sub sumar , la variable Valor se declara con ByRef ( por Referencia )

Código

Private Sub Command1_Click()

Dim Un_Valor As Long

Un_Valor = 100

'Se envía la variable por Referencia ( ByRef ) con el valor 100

Call Sumar(Un_Valor)

'Muestra el valor que ahora es 200, ( ya que se modificó en la Sub Sumar)
MsgBox Un_Valor

End Sub

Sub Sumar(ByRef Valor As Long)
'Modifica la variable
Valor = Valor + 100

End Sub

Al probar el código, ahora el Msgox al mostrar el valor de la variable, es de 200, y NO de 100 como en el ejemplo de ByVal.

Esto demuestra que al enviar la variable como referencia, si la misma se modifica dentro del procedimiento o función, se está modificando la variable REAL, es decir cualquier cambio que se le haga a la misma, se mantendrá, ya que se está modificando la variable Real ( no es una copia )

Nota Importante: cuando no se indica a un parámetro de una función o Rutina ni ByVal, ni ByRef, se asume que la misma se está enviando como referencia (ByRef).

Es decir lo siguiente recibe el parámetro como Referencia

Sub Sumar(Valor As Long)
.. que es lo mismo a esto:

Sub Sumar(ByRef Valor As Long)

Función isMissing en Visual Basic 6.0

2008-09-12T12:43:00.000-07:00

Esta función se utiliza cuando utilizamos parámetros opcionales en una función o procedimiento, y nosotros, dentro del mismo queremos saber y averiguar si se han enviado los parámetros opcionales

El uso de IsMissing muy simple. Esta función retorna el valor True si NO se ha enviado el parámetro que queremos comprobar, y devuelve False si el parámetro ha sido enviado:

por ejemplo , colocar dos CommandButton

Private Sub Mostrar_Dato(Optional Nombre As Variant)

' Si IsMissing devuelve Verdadero, es por que no se envíó
If IsMissing(Nombre) = True Then
MsgBox " NO Se ha enviado el parámetro NOMBRE ", vbInformation
Else
MsgBox " Se ha enviado el parámetro NOMBRE ", vbInformation
End If

End Sub

'Acá No se envía el parámetro
Private Sub Command1_Click()
Mostrar_Dato
End Sub

'Acá Si se envía el parámetro

Private Sub Command2_Click()
Mostrar_Dato "María"
End Sub

Pasar Parámetros a los procedimientos en Visual Basic 6.0

2008-09-12T12:40:00.000-07:00

Se utilizan los parámetros en los procedimientos para que el procedimiento no ejecute siempre las mismas líneas de código y pueda variar, teniendo la posibilidad de hacerlo mas dinámicamente. En ciertas ocaciones no es necesario enviar parámetros, pero en otras es prácticamente fundamental. Los parámetros son datos, casi de cualquier tipo, que se pasan seguido del nombre del procedimiento, y si es mas de uno deben ir separados por comas (,). Ejemplo:

DatosPersonales "Luciano", 25, "La plata"

En este ejemplo pasamos tres parámetros: El primero es un nombre y es un dato de tipo String y por ende debe ir entre comillas. El segundo es un número y el tercero también un string. , o sea una cadena de caracteres

Pero la cosa no queda acá. Si nosotros vamos a pasar parámetros a un procedimiento, cuando creamos el procedimiento debemos establecer que tipo de parámetros va a recibir el mismo. Ejemplo:

Private Sub DatosPersonales(nombre As String, edad As Integer, ciudad As String)

Label1 = nombre
Label2 = edad
Label3 = ciudad

End Sub

siguiendo, el ejemplo anterior creamos un procedimiento con tres parámetros. Cada parámetro se declara como se hace con las variables, o sea que debemos darles un nombre a la variable y definir el tipo de dato ( sin utilizar la palabra Dim ) que recibirá cuando las llamemos.

Ahora podríamos por ejemplo, en el evento click de un Command1, llamar al procedimiento y pasarle los parámetros.

Coloca un Command1 , 3 controles Label, copia en la ventana de código el procedimiento anterior llamado DatosPersonales, y ahora pega el siguiente código

Private sub command1_click()

DatosPersonales "Luciano", 25, "La plata"

End sub

Al presionar el botón se llamará al procedimiento que habíamos creado anteriormente, y le pasará los valores de los parámetros en el orden en que estén establecidos declarados en el procedimiento. Esto quiere decir que el primer parámetro con el valor "Luciano" se almacenará o asignará a la variable nombre , el valor 25 se le asignará a la variable edad y el último valor a la variable ciudad.

Después que las variables ya cargaron el valor las podemos utilizar dentro del procedimiento, como en el ejemplo anterior que le asignamos a un control Label1 el contenido de la variable nombre, al Label2 el contenido de edad y al Label3 el contenido de la variable ciudad.

Es muy importante respetar el orden en que pasamos los parámetros en un procedimiento, por que por ejemplo en el caso anterior si hubiésemos pasado los parámetros de esta forma:

DatosPersonales 25, "Luciano", "La plata"

el segundo parámetro "Luciano" se almacenaría en la variable Edad que es de tipo Integer y se produciría un error en tiempo de ejecución por no coincidir los tipos de datos, ya que la variable espera un valor numérico de tipo Integer y nosotros le estamos pasando una cadena de caracteres, un dato de tipo String

Otra cosa importante es que cuando creamos, por ejemplo un procedimiento que va a recibir 2 parámetros, cuando lo llamemos, no podemos enviarle solo 1 parámetro, debemos obligatoriamente pasarle los 2 parámetros que hubiésemos declarado en el mismo. Un ejemplo que daría un error en tiempo de ejecución por no pasar adecuadamente los parámetros sería:

Private Sub sumar(a As Integer, b As Integer)

Label1 = a + b

End Sub

hasta aquí creamos un procedimiento llamado sumar que recibirá 2 parámetros de tipo Integer, si nosotros llamamos al procedimiento y le pasamos un solo valor, por ejemplo:

Call sumar ( 456 )

Esto daría un error de compilación por que el procedimiento espera recibir 2 parámetros ..y nosotros le estamos pasando o enviando solo uno de ellos.

Precisamente el cartel de error que te mostraría visual basic sería el siguiente:

Nota: hay una sentencia llamada Optional que SI permite pasar parámetros de forma opcional, por ejemplo:

Private Sub Con_Parametro_Opcional(Nombre As String, _
Optional Email As String)
MsgBox Nombre

MsgBox Email

End Sub

Ahora si llamas a la rutina anterior, y omites el parámetro Email, esta no dará error, por ejemplo:

Call Con_Parametro_Opcional("Maria")

Nota: Los parámetros opcionales, si o si deben estar declarados al final de la lista de parámetros, por ejemplo esto no se puede hacer:

Private sub una_Rutina ( Optional Email As String, Nombre as String )

Subrutinas y Procedimientos propios en Visual Basic 6.0

2008-09-12T12:35:00.001-07:00

También podemos crear nuestros propios Procedimientos y Subrutinas de código para ejecutar una determinada tarea.

Para crear un procedimiento de código se debe escribir la palabra Private sub o Public sub (depende el alcance), seguida del nombre del procedimiento (un nombre que queramos) y los parámetros, si es que le enviaremos parámetros (los parámetros son opcionales). Además el procedimiento debe ser escrito en un lugar vacío de la ventana de código, es decir nno se puede crear un procedimiento dentro de otro

Un ejemplo para crear un procedimiento:

Private Sub ProcedimientoBorrar()

label1 = ""
label2 = ""
label3 = ""

End Sub

En este ejemplo creamos un procedimiento muy simple que tendrá la función específica de borrar el contenido de 3 controles label.

¿ Pero ahora te preguntarás como hago para que se ejecute el procedimiento que he creado ?.

Muy fácil. Solo debemos escribir el nombre del procedimiento en el lugar donde queremos que se ejecute. Por ejemplo supongamos que tenemos un formulario con 3 controles Label (Label1, Label2 y Label3), También un Commandbutton llamado Command1 y en la ventana de código hemos escrito el procedimiento del ejemplo anterior. Si nosotros queremos llamar al procedimiento, que borrará el contenido de los label cuando hagamos click en el Command1 lo haríamos así:

Private Sub command1_click()

ProcedimientoBorrar

End Sub

Al presionar el Command1 visual basic detectaría el nombre ProcedimientoBorrar, y automáticamente saltaría al lugar donde creamos el procedimiento y ejecutaría las líneas de código que haya en ese procedimiento.

También podemos llamar a un procedimiento utilizando la palabra Call, que quiere decir llamar, seguida del nombre del procedimiento, pero en este caso si utilizamos call y nuestro procedimiento contiene parámetros, debemos pasarlos entre paréntesis ( los parámetros de procedimientos y funciones se explican a continuación)

una vez que se ha terminado de ejecutar las instrucciones que estén dentro del bloque del procedimiento, volvería a la línea siguiente de donde fue llamado el mismo, y ejecutaría todas las líneas restantes de código. En este caso no ejecutaría nada mas por que no hemos puesto ninguna otra instrucción debajo de ProcedimientoBorrar.

La principal ventaja de crear procedimientos de código es que evita tener que escribir varias veces las mismas instrucciones en un programa, el código se hace mucho mas funcional y entendible, se pueden dividir un problema (una rutina), en varios procedimientos y probarlos independientemente, y además la posibilidad de enviar parámetros a los procedimientos.

Chevrolet Camaro 2010

2008-09-08T16:47:00.000-07:00

Dejando a un lado solo un poquito la programacion, Solo para fortalecer las pupilas y dejando en claro que solo las pupilas por que esta nueva versión de este cochesito lo tendremos hasta el 2010, les presento el Camaro 2010. La producción de la nueva generación de este deportivo americano comenzará a finales del presente año, mientras que su comercialización en Estados Unidos iniciará a principios del 2009, y es probable que poco tiempo después arribe también a las agencias mexicanas de la marca.

En un principio estará disponible en carrocería coupé y en tres versiones distintas de equipamientos: LS, LT y la más rabiosa y potente representada por el Camaro SS.

Como se puede apreciar en las fotos, el estilo de este nuevo Muscle Car se mantiene fiel a las poderosas y seductoras formas del prototipo que develó General Motors en el Salón del Automóvil de Detroit del 2006, una moderna interpretación del modelo SS de 1969.

Sus afiladas y musculosas formas, en adición a nuevos elementos de estilo vanguardista y de fuerte contraste, como por ejemplo su agresiva parrilla, los atractivos faros, las cortas y musculosas salpicaderas; así como el cofre y la defensa en forma de la punta de una flecha, entre otros, le imprimen una belleza indómita que despierta admiración y respeto a su paso.

aqui les dejo el enlace de la fuente principal: VisionAutomotriz

Subrutinas de Codigos en Visual Basic 6.0

2008-09-08T12:50:00.000-07:00

Se denomina subrutina a una porción de código que tiene como principal función ejecutar una determinada tarea. Estas tienen un nombre para poder identificarlas y luego poder llamarlas para poder utilizarlas.

Las subrutinas tienen un principio y un fin y estas pueden tener distinto tipo de alcance, o sea pueden ser de tipo privadas o públicas.

En el siguiente ejemplo se muestra una subrutina que crea visual basic automáticamente cuando en un formulario insertamos un botón llamado Command1 y desde la ventana de eventos seleccionamos el evento click del mismo

Private Sub Command1_Click()

End Sub

Ahora, si colocamos por ejemplo un control TextBox llamado TextPedidos y hacemos doble click sobre el mismo, se crea el procedimiento por defecto para los TextBox, que es el evento Change

Private Sub TextPedidos_Change()

End Sub

En estos 2 últimos ejemplos tenemos una subrutina o procedimiento de tipo Privado, esto quiere decir que la podemos utilizar solo en el formulario o módulo donde está declarada o escrita

La palabra sub le sigue el nombre de la rutina que la identifica. En este caso Command1_click() y en el otro ejemplo TxtPedidos_Change().

Si quisiéramos que estos procedimientos se puedan llamar desde otro formulario, lo que tendríamos que hacer es cambiar el alcance del procedimiento, en ves de Private Sub cambiarlo por Public Sub. si hacemos esto, ese procedimiento de código puede ser utilizado desde cualquier parte del proyecto.

Operadores en Visual Basic 6.0

2008-09-08T12:47:00.000-07:00

Los operadores nos permiten operar, validar, comparar, asignar, distinguir, etc.., los datos e instrucciones de código de nuestros programas. A continuación los operadores mas importantes.

Operadores aritméticos

Estos operadores nos permiten trabajar con cálculos matemáticos como la suma (+), resta (-), división (/) y multiplicación (*).

Ejemplos:

a = 5
b = 15
c = a + b ' en este caso la variable c contendría el valor 20
ganancia = 500
perdida = 200
total = ganancia - perdida 'la variable total pasaría a valer 300
x = 100
y = 20

z = x / y ' La Variable z vale 5

x = 100
y = 20

z = x * y ' La Variable z vale 2000

Operadores lógicos

Se utilizan en expresiones para devolver resultados del tipo True o False, es decir Verdadero o falso. Los mas comunes son el operador And y el operador Or

Ejemplos:

If (x = 10) And (nombre = "maría") Then

'solo se ejecutará el código dentro de este bloque IF si la variable
'x vale 10 y la variable nombre es igual a maría

End If
If (m = 10) Or (nombre = "pedro") Then

'el código se ejecutará si por lo menos una variable es correcta
'es decir si por lo menos se cumple una condición

End If

Operadores de comparación

Los operadores de comparación se utilizan para comparar expresiones de cualquier tipo. Los mas importantes son: El operador de igualdad (=), menor que (<), mayor que (>), distinto a(<>)

Ejemplos:

If label1.Caption = "06/08/1978" Then

'si el control label1 en su caption contiene esa fecha
'se ejecutará el código que este aquí

End If
if x > 6 then
'si la variable x es mayor que 6 se ejecutará el código que este aquí
end if
If país <> "Estados unidos" Then
'si la variable país es distinta a "Estados unidos" se ejecutará el código
End If
While c <= 87

'mientras la variable c sea menor o igual a 87 se ejecutará
'el bucle While

Wend

Por último quedaría por ver el operador de concatenación (&) que se utiliza para unir cadenas de caracteres.

Por ejemplo:

nombre = "Jose"
apellido = "Peralta"

nombrecompleto = nombre & apellido

'La variable nombrecompleto pasaría a contener la unión de las otras dos variables
'es decir Jose Peralta

NOTA: Al igual que los tipos de datos hay mas operadores en Visual Basic 6.0, pero estos son los mas basico y que se utilizaran constantemente.

Estructuras de control en Visual Basic 6.0

2008-09-08T12:41:00.000-07:00

Las estructuras de control se utilizan para controlar el flujo del programa en una rutina o función. Mediante ellas podemos controlar, mediante una condición, que se ejecute una determinada línea o bloque de líneas de código .. o que no se ejecuten.

Estructura If - Then - Else

Esta estructura permite mediante una condición, que se ejecute o no se ejecute determinada tarea o línea de código.

Por ejemplo supongamos que tenemos en un formulario un control Label con la propiedad Caption con el valor 50

If Label1.Caption = "X" Then
msgbox "mi label tiene un valor de X"
else
msgbox "mi label NO tiene un valor de X"
end if

Esto traducido al español significaría lo siguiente:

Si (If) la propiedad caption del label1 que tengo en el formulario es igual (=) a "X" entonces (Then) que muestre un determinado mensaje, si no (Else) que muestre el otro mensaje.

En conclusión lo que hace esta estructura es evaluar una condición, si se cumple, que se ejecute determinada tarea. si no se cumple, se ejecutará las líneas de código que estén bajo la cláusula Else. Luego tenemos que cerrar la estructura con la palabra end if.

Tenemos que aclarar que no es obligatorio usar If y else juntos en la misma cláusula. Por ejemplo podríamos utilizar solo una estructura If sin else. Por ejemplo:

Private Sub Command1_Click()
'Si la propiedad caption del Label1 es "Hola" entonces se termina el programa
If Label1.Caption = "Hola" Then

End

End If

'Si no, se prosigue con esta línea

MsgBox "No se ejecutó el bloque If Anterior porque el Caption del control Label1 no era Hola"

End Sub

Coloca un Label1 y un Command1. En la propiedad caption del Label1 escribe "Hola". Al ejecutar el programa y presionar el Command1, se termina el programa con la sentencia End de Visual Basic (End sirve para finalizar completamente la ejecución de nuestro programa). En cambio si ahora le cambia el caption al Label1 y volvés a ejecutar el proyecto, podés ver que la instrucción End no se ejecuta, si no que la pasa por alto y sigue con las restantes líneas, en este caso ejecuta la función MsgBox con el mensaje.

Estructura While - Wend

Esta estructura de control repetirá sin detenerse un determinado código mientras se cumpla una condición.

Por ejemplo supongamos que tenemos una variable llamada x que tiene un valor de 100.

while x = 100
...se ejecutan todas las líneas de código que estén aquí
wend

Esto traducido al español significaría lo siguiente:

Mientras (While) la variable x sea igual a 100, y no cambie su valor, se formará un bucle interminable, hasta que x cambie a cualquier otro valor disto de 100. Si x cambia el valor, por ejemplo a 234 saldría del bucle While - wend y seguiría ejecutando el resto del código, si es que hay mas código o instrucciones a ejecutar.

Un ejemplo, agrega un Command1 al formulario y un control Text1. Cuando ejecutemos el ejemplo, se deberá escribir un número dentro del control textBox. Entonces se creará un bucle While, que mostrará en el Caption del formulario, es decir en la barra de título, el intervalo desde 0 hasta el número que hayamos ingresado en el Text1. Es decir si ingresamos el número 9000, en el caption del formulario se imprimirán los número desde 0 hasta 9000.

Para hacer esto, dentro del bucle While pondremos una variable llamada Contador, que en cada pasada se incrementará en 1, pero cuando la variable Contador sea igual al número que haya en el Text1, se finalizará el bucle y se mostrará un mensaje que finalizó el mismo

Private Sub Command1_Click()
Dim contador As Integer 'Declaramos la variable

While contador <> Text1

'Mostramos en el formulario el valor de la variable contador
Me.Caption = contador

'Incrementamos la variable en 1
contador = contador + 1

Wend

MsgBox "Terminó el bucle"

End Sub

Estructura For - next

La estructura es utilizada para generar una repetición de instrucciones o bucle, pero no evalúa una condición como en el caso del bucle While, si no que lo hace entre un número inicial y un número final que le debemos indicar al mismo.

Por ejemplo, tenemos un formulario con un Label1 y declaramos una variable de tipo integer llamada "contador" como en el caso anterior

Private Sub Command1_Click()
Dim contador As Integer

For contador = 0 To 100

Label1.Caption = contador

Next contador

End Sub

Esto traducido significaría lo siguiente:

Primero, tenemos una variable llamada "contador". Mediante el bucle For - next podemos controlar la cantidad de veces que queremos repetir un determinado proceso o instrucción. Esta posee un principio y un fin, en este caso el principio sería 0 y el fin 100, de manera que la variable contador se incrementará en 1 hasta que llegue a 100, y repetirá 100 veces todas las instrucciones que estén bajo la cláusula For-next. En este caso nuestro control Label1 mostraría el contenido de la variable contador

Para ver en forma detallada y paso a paso esto, pongamos un ejemplo que lo que hace es repetir 10 veces (desde el 1 hasta el 10 en el intervalo del bucle For) y mostrará un mensaje con el valor de la variable Contador. Una ves que llegue a 10, terminará.

Colocá un Command1. Doble Click en el botón para escribir dentro del procedimiento que se ejecutará cuando lo presionemos. El código:

Dim contador As Integer

For contador = 1 To 10

MsgBox "La variable Contador vale: " & contador

Next contador

MsgBox "Fin del bucle For"

Estructura Select case

La estructura Select Case se suele utilizar para evitar el uso de muchas cláusulas If y de esta manera no tener que anidarlas. La claúsula Select evalúa una condición y las cláusulas case contienen valores, si el valor que contiene la cláusula case es igual a la condición que se evaluó, ejecutará las instrucciones en dicha cláusula.

Dim Nombre As String

Nombre = Text1

Select Case Nombre

Case "Jorge"

MsgBox "Se ejecutó la cláusula case: " & Nombre
Case "Pedro"

MsgBox "Se ejecutó la cláusula case: " & Nombre

Case "Carolina"

MsgBox "Se ejecutó la cláusula case: " & Nombre

End Select

Esta estructura es muy práctica. En el ejemplo anterior, la cláusula Select case contiene como condición el valor de la variable llamada Nombre. Esa Variable toma el valor que tenga un control Text1, entonces buscará en todas las cláusulas case, y si encuentra una igual a la condición, ejecutará solo las instrucciones de la cláusula case que tenga el mismo valor, por ejemplo si ingresara el nombre "Martín" no se ejecutará ninguna cláusula Case. En cambio si ingreso "Jorge" se ejecutará solo las instrucciones que estén en la sección Case "Jorge" y asi...

En el caso anterior solo hemos colocado un valor para cada Case. Si quisieramos colocar mas valores podríamos hacerlo de esta forma:

Private Sub Form_Load()

Dim x As Integer

x = 10 'Le ponemos un valor a x

Select Case x

Case 5, 10
MsgBox "Se ejecutó el case que tiene el 5 y el 10"
'Se ejecuta esta sección

Case 15, 20
'Esto no se ejecuta
Case 25, 30
'Esto tampoco
End Select

End Sub

es decir que podemos listar los valores en los Case separados por comas. En el caso anterior se ejecutará el case 5, 10 ya que la variable x vale 10.

Constantes en Visual Basic 6.0

2008-09-08T12:38:00.000-07:00

Las constantes, como las variables, se utilizan para guardar datos y valores para nuestro programa, pero a diferencia de estas últimas, el contenido que almacenen no cambia, siempre es "constante".

A diferencia de las variables que se declaran con la palabra Dim, las Constantes se declaran con la palabra Const.

Ejemplo:

Const NUMERO = 53

En la línea anterior he creado una constante, que se llama NUMERO y va a almacenar un número , y este valor, cuando se ejecute mi programa se mantendrá invariable.

Otro ejemplo, en el cual se muestra claramente el uso de una constante:

Const PI = 3.1416

Tipos de Datos en Visual Basic 6.0

2008-09-08T12:35:00.001-07:00

Los tipos de datos, indican el tipo de valor que puede almacenar una variable. Los principales tipos de datos:

Números enteros: dentro de los números enteros tenemos varios tipos de datos dependiendo el rango que queramos utilizar:

Byte: puede almacenar números enteros dentro del rango desde 0 a 255
Integer: puede almacenar números enteros dentro del rango -32.768 a 32.767
Long: puede almacenar números enteros dentro del rango -2.147.483.648 hasta 2.147.483.648 .
Números decimales: para almacenar números decimales contamos con los siguientes tipos de datos:

Single: almacena números decimales en el rango +/- 1e-45 hasta 3e38
Double: desde +/- 5e-324 hasta 1.8e308
Cadenas de caracteres: las cadenas de caracteres se definen con la palabra String y tienen un rango de hasta 2 billones de caracteres.

Tipos de valores lógicos: para almacenar tipos de valores lógicos como verdadero o falso, se utiliza la palabra Boolean y sus 2 posibles valores son True (verdadero) y False (falso).

Fechas y horas: Para almacenar fechas y horas se utiliza la palabra Date

Tipo variant : Las variables de este tipo pueden almacenar cualquier tipo de valor, pero ocupan mas memoria.

Nota: hay mas tipos de datos, incluso el mismo programador puede crear sus propios tipos.

Tipos de Datos en Visual Basic 6.0

2008-09-08T12:35:00.000-07:00

Variables en Visual Basic 6.0

2008-09-08T12:30:00.000-07:00

Las variables, como su nombre lo indica, se utilizan para almacenar valores que tienen la propiedad de variar el contenido. Cuando hablamos de contenido nos referimos a cualquier tipo de datos, por ejemplo un nombre, una fecha, un color, un número etc.

A las variables se les asigna un nombre para poder utilizarlas. Por ejemplo puedo crear una variable llamada fecha y esta almacenará una fecha. A los nombres de las variables se los denomina identificadores. Cuando creamos variables, tenemos que tratar de asignarles un nombre que se relacione con el tipo de dato que queremos almacenar. Por ejemplo no tendría mucho sentido crear una variable llamada m y allí guardar o almacenar un nombre o un apellido, por que cuando echemos vista al código resultaría mas difícil deducir que tipo de dato estoy guardando. Por ejemplo en este último caso sería mucho mas lógico crear una variable llamada “nombres” y allí guardar "Luis", "Francisco", "Antonio" etc..

En visual basic a las variables conviene declararlas, o sea, avisarle a vb que vamos a utilizar dichas variables. A estas se las declara en el comienzo del código y se les antepone la palabra reservada Dim, luego el nombre que nosotros queramos y seguido el tipo de dato que almacenará, por ejemplo si quiero almacenar en una variable llamada Numero

Dim NUMERO As Integer

La palabra Integer le avisa a visual basic que voy a guardar un número entero. Después de declararla le podemos asignar un valor con el operador "=", ejemplo:

Dim NUMERO As Integer

NUMERO = 1500

Pero hay que tener en cuenta que al declarar una variable, en este caso, de tipo integer, no podríamos almacenar en ella otro tipo diferente al cual esta declarada como por ejemplo una fecha o cualquier otro tipo de datos que no sea un número entero. Si sucedería esto nuestro programa daría un error en tiempo de ejecución, mostrándonos "no coinciden los tipos de datos".

Programación Orientada a Objetos

2008-09-08T11:44:00.000-07:00

Actualmente una de las áreas más candentes en la industria y en el ámbito académico es la orientación a objetos. La orientación a objetos promete mejoras de amplio alcance en la forma de diseño, desarrollo y mantenimiento del software ofreciendo una solución a largo plazo a los problemas y preocupaciones que han existido desde el comienzo en el desarrollo de software: la falta de portabilidad del código y reusabilidad, código que es dificil de modificar, ciclos de desarrollo largos y tecnicas de codificacion no intuituvas.

Un lenguaje orientado a objetos ataca estos problemas. Tiene tres características basicas: debe estar basado en objetos, basado en clases y capaz de tener herencia de clases. Muchos lenguajes cumplen uno o dos de estos puntos; muchos menos cumplen los tres. La barrera más difícil de sortear es usualmente la herencia.

El concepto de programación orientada a objetos (OOP) no es nuevo, lenguajes clásicos como SmallTalk se basan en ella. Dado que la OOP. se basa en la idea natural de la existencia de un mundo lleno de objetos y que la resolución del problema se realiza en términos de objetos, un lenguaje se dice que está basado en objetos si soporta objetos como una característica fundamental del mismo.

El elemento fundamental de la OOP es, como su nombre lo indica, el objeto. Podemos definir un objeto como un conjunto complejo de datos y programas que poseen estructura y forman parte de una organización.

Esta definición especifica varias propiedades importantes de los objetos. En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto número de componentes bién estructurados. En segundo lugar, cada objeto no es un ente aislado, sino que forma parte de una organización jerárquica o de otro tipo.

ESTRUCTURA DE UN OBJETO

Un objeto puede considerarse como una especie de cápsula dividida en tres partes:

1 - RELACIONES

2 - PROPIEDADES

3 - METODOS

Cada uno de estos componentes desempeña un papel totalmente independiente:

Las relaciones permiten que el objeto se insterte en la organización y están formadas esencialmente por punteros a otros objetos.

Las propiedades distinguen un objeto determinado de los restantes que forman parte de la misma organización y tiene valores que dependen de la propiedad de que se trate. Las propiedades de un objeto pueden ser heredadas a sus descendientes en la organización.

Los métodos son las operaciones que pueden realizarse sobre el objeto, que normalmente estarán incorporados en forma de programas (código) que el objeto es capaz de ejecutar y que también pone a disposición de sus descendientes a través de la herencia.

Encapsulamiento y ocultación

Como hemos visto, cada objeto es una estructura compleja en cuyo interior hay datos y programas, todos ellos relacionados entre sí, como si estuvieran encerrados conjuntamente en una cápsula. Esta propiedad (encapsulamiento), es una de las características fundamentales en la OOP.

Los objetos son inaccesibles, e impiden que otros objetos, los usuarios, o incluso los programadores conozcan cómo está distribuída la información o qué información hay disponible. Esta propiedad de los objetos se denomina ocultación de la información.

Esto no quiere decir, sin embargo, que sea imposible conocer lo necesario respecto a un objeto y a lo que contiene. Si así fuera no se podría hacer gran cosa con él. Lo que sucede es que las peticiones de información a un objeto. deben realizarse a través de mensajes dirigidos a él, con la orden de realizar la operación pertinente. La respuesta a estas ordenes será la información requerida, siempre que el objeto considere que quien envía el mensaje está autorizado para obtenerla.

El hecho de que cada objeto sea una cápsula facilita enormemente que un objeto determinado pueda ser transportado a otro punto de la organización, o incluso a otra organización totalmente diferente que precise de él. Si el objeto ha sido bien construído, sus métodos seguirán funcionando en el nuevo entorno sin problemas. Esta cualidad hace que la OOP sea muy apta para la reutilización de programas.

Organización de los objetos

En principio, los objetos forman siempre una organización jerárquica, en el sentido de que ciertos objetos son superiores a otros de cierto modo.

Existen varios tipos tipos de jerarquías: serán simples cuando su estructura pueda ser representada por medio de un "arbol". En otros casos puede ser más compleja.

En cualquier caso, sea la estructura simple o compleja, podrán distinguirse en ella tres niveles de objetos.

-La raíz de la jerarquía. Se trata de un objeto único y especial. Este se caracteríza por estar en el nivel más alto de la estructura y suele recibir un nombre muy genérico, que indica su categoría especial, como por ejemplo objeto madre, Raíz o Entidad.

-Los objetos intermedios. Son aquellos que descienden directamente de la raíz y que a su vez tienen descendientes. Representan conjuntos o clases de objetos, que pueden ser muy generales o muy especializados, según la aplicación. Normalmente reciben nombres genéricos que denotan al conjunto de objetos que representan, por ejemplo, VENTANA, CUENTA, FICHERO. En un conjunto reciben el nombre de clases o tipos si descienden de otra clase o subclase.

-Los objetos terminales. Son todos aquellos que descienden de una clase o subclase y no tienen descendientes. Suelen llamarse casos particulares, instancias o ítems porque representan los elementos del conjunto representado por la clase o subclase a la que pertenecen.

Veamos ahora en detalle los tres elementos mencionados en "Estructura de un Objeto".

1. RELACIONES

Las relaciones entre objetos son, precisamente, los enlaces que permiten a un objeto relacionarse con aquellos que forman parte de la misma organización.

Las hay de dos tipos fundamentales:

-Relaciones jerárquicas. Son esenciales para la existencia misma de la aplicación porque la construyen. Son bidireccionales, es decir, un objeto es padre de otro cuando el primer objeto se encuentra situado inmediatamente encima del segundo en la organización en la que ambos forman parte; asimismo, si un objeto es padre de otro, el segundo es hijo del primero (en la fig. 2, B es padre de D,E y F, es decir, D,E y F son hijos de B; en la fig. 3, los objetos B y C son padres de F, que a su vez es hijo de ambos).

Una organización jerárquica simple puede definirse como aquella en la que un objeto puede tener un solo padre, mientras que en una organizacion jerárquica compleja un hijo puede tener varios padres).

-Relaciones semánticas. Se refieren a las relaciones que no tienen nada que ver con la organización de la que forman parte los objetos que las establecen. Sus propiedades y consecuencia solo dependen de los objetos en sí mismos (de su significado) y no de su posición en la organización.

Se puede ver mejor con un ejemplo: supongamos que vamos a construir un diccionario informatizado que permita al usuario obtener la definición de una palabra cualquiera. Supongamos que, en dicho diccionario, las palabras son objetos y que la organización jerárquica es la que proviene de forma natural de la estructura de nuestros conocimientos sobre el mundo.

La raíz del diccionario podría llamarse TEMAS. De éste término genérico descenderán tres grandes ramas de objetos llamadas VIDA, MUNDO y HOMBRE. El primero (vida) comprenderá las ciencias biológicas: Biología y Medicina. El segundo (mundo), las ciencias de la naturaleza inerte: las Matemáticas, la Física, la Química y la Geología. El tercero (hombre) comprenderá las ciencias humanas: la Geografía, la Historia, etc.

Veamos un ejemplo: estableceremos la relación trabajo entre los objetos NEWTON y OPTICA y la interpretaremos diciendo que significa que Newton trabajó en óptica (véase la fig. 4). La relación es, evidentemente, semántica, pués no establece ninguna connotación jerárquica entre NEWTON y OPTICA y su interpretación depende exclusivamente del significado de ambos objetos.

La existencia de esta relación nos permitirá responder a preguntas como:

¿Quién trabajó en óptica?

¿En qué trabajó Newton?

¿Quien trabajó en Física?

Las dos primeras se deducen inmediatamente de la existencia de la relación trabajo. Para la tercera observamos que si Newton trabajó en óptica automáticamente sabemos que trabajó en Física, por ser óptica una rama de la Física (en nuestro diccionario, el objeto OPTICA es hijo del objeto FISICA). Entonces gracias a la OOP podemos responder a la tercera pregunta sin necesidad de establecer una relación entre NEWTON y FISICA, apoyandonos sólo en la relación definida entre NEWTON y OPTICA y en que OPTICA es hijo de FISICA. De este modo se elimina toda redundancia innecesaria y la cantidad de información que tendremos que definir para todo el diccionario será mínima.

2. PROPIEDADES

Todo objeto puede tener cierto número de propiedades, cada una de las cuales tendrá, a su vez, uno o varios valores. En OOP, las propiedades corresponden a las clásicas "variables" de la programación estructurada. Son, por lo tanto, datos encapsulados dentro del objeto, junto con los métodos (programas) y las relaciones (punteros a otros objetos). Las propiedades de un objeto pueden tener un valor único o pueden contener un conjunto de valores mas o menos estructurados (matrices, vectores, listas, etc.). Además, los valores pueden ser de cualquier tipo (numérico, alfabético, etc.) si el sistema de programación lo permite.

Pero existe una diferencia con las "variables", y es que las propiedades se pueden heredar de unos objetos a otros. En consecuencia, un objeto puede tener una propiedad de maneras diferentes:

-Propiedades propias. Están formadas dentro de la cápsula del objeto.

-Propiedades heredadas. Estan definidas en un objeto diferente, antepasado de éste (padre,"abuelo", etc.). A veces estas propiedades se llaman propiedades miembro porque el objeto las posee por el mero hecho de ser miembro de una clase.

3. METODOS

Una operación que realiza acceso a los datos. Podemos definir método como un programa procedimental o procedural escrito en cualquier lenguaje, que está asociado a un objeto determinado y cuya ejecución sólo puede desencadenarse a través de un mensaje recibido por éste o por sus descendientes.

Son sinónimos de 'método' todos aquellos términos que se han aplicado tradicionalmente a los programas, como procedimiento, función, rutina, etc. Sin embargo, es conveniente utilizar el término 'método' para que se distingan claramente las propiedades especiales que adquiere un programa en el entorno OOP, que afectan fundamentalmente a la forma de invocarlo (únicamente a través de un mensaje) y a su campo de acción, limitado a un objeto y a sus descendientes, aunque posiblemente no a todos.

Si los métodos son programas, se deduce que podrían tener argumentos, o parámetros. Puesto que los métodos pueden heredarse de unos objetos a otros, un objeto puede disponer de un método de dos maneras diferentes:

-Métodos propios. Están incluídos dentro de la cápsula del objeto.

-Métodos heredados. Estan definidos en un objeto diferente, antepasado de éste (padre,"abuelo", etc.). A veces estos métodos se llaman métodos miembro porque el objeto los posee por el mero hecho de ser miembro de una clase.

Polimorfísmo

Una de las características fundamentales de la OOP es el polimorfísmo, que no es otra cosa que la posibilidad de construir varios métodos con el mismo nombre, pero con relación a la clase a la que pertenece cada uno, con comportamientos diferentes. Esto conlleva la habilidad de enviar un mismo mensaje a objetos de clases diferentes. Estos objetos recibirían el mismo mensaje global pero responderían a él de formas diferentes; por ejemplo, un mensaje "+" a un objeto ENTERO significaría suma, mientras que para un objeto STRING significaría concatenación ("pegar" strings uno seguido al otro)

Demonios

Es un tipo especial de métodos, relativamente poco frecuente en los sistemas de OOP, que se activa automáticamente cuando sucede algo especial. Es decir, es un programa, como los métodos ordinarios, pero se diferencia de estos porque su ejecución no se activa con un mensaje, sino que se desencadena autmáticamente cuando ocurre un suceso determinado: la asignación de un valor a una propiedad de un objeto, la lectura de un valor determinado, etc.

Los demonios, cuando existen, se diferencian de otros métodos por que no son heredables y porque a veces están ligados a una de las propiedades de un objeto, mas que al objeto entero.

CONSIDERACIONES FINALES

Beneficios que se obtienen del desarrollo con OOP

Día a día los costos del Hardware decrecen. Así surgen nuevas áreas de aplicación cotidianamente: procesamiento de imágenes y sonido, bases de datos multimediales, automatización de oficinas, ambientes de ingeniería de software, etc. Aún en las aplicaciones tradicionales encontramos que definir interfases hombre-máquina "a-la-Windows" suele ser bastante conveniente.

Lamentablemente, los costos de producción de software siguen aumentando; el mantenimiento y la modificación de sistemas complejos suele ser una tarea trabajosa; cada aplicación, (aunque tenga aspectos similares a otra) suele encararse como un proyecto nuevo, etc.

Todos estos problemas aún no han sido solucionados en forma completa. Pero como los objetos son portables (teóricamente) mientras que la herencia permite la reusabilidad del código orientado a objetos, es más sencillo modificar código existente porque los objetos no interaccionan excepto a través de mensajes; en consecuencia un cambio en la codificación de un objeto no afectará la operación con otro objeto siempre que los métodos respectivos permanezcan intactos. La introducción de tecnología de objetos como una herramienta concepual para analizar, diseñar e implementar aplicaciones permite obtener aplicaciones más modificables, fácilmente extendibles y a partir de componentes reusables. Esta reusabilidad del código disminuye el tiempo que se utiliza en el desarrollo y hace que el desarrollo del software sea mas intuitivo porque la gente piensa naturalmente en términos de objetos más que en términos de algoritmos de software.

Problemas derivados de la utilización de OOP en la actualidad

Un sistema orientado a objetos, por lo visto, puede parecer un paraíso virtual. El problema sin embargo surge en la implementación de tal sistema. Muchas compañías oyen acerca de los beneficios de un sistema orientado a objetos e invierten gran cantidad de recursos luego comienzan a darse cuenta que han impuesto una nueva cultura que es ajena a los programadores actuales. Específicamente los siguientes temas suelen aparecer repetidamente:

Curvas de aprendizaje largas. Un sistema orientado a objetos ve al mundo en una forma única. Involucra la conceptualización de todos los elementos de un programa, desde subsistemas a los datos, en la forma de objetos. Toda la comunicación entre los objetos debe realizarse en la forma de mensajes. Esta no es la forma en que están escritos los programas orientados a objetos actualmente; al hacer la transición a un sistema orientado a objetos la mayoría de los programadores deben capacitarse nuevamente antes de poder usarlo.

Dependencia del lenguaje. A pesar de la portabilidad conceptual de los objetos en un sistema orientado a objetos, en la práctica existen muchas dependencias. Muchos lenguajes orientados a objetos están compitiendo actualmente para dominar el mercado. Cambiar el lenguaje de implementación de un sistema orientado a objetos no es una tarea sencilla; por ejemplo C++ soporta el concepto de herencia multiple mientras que SmallTalk no lo soporta; en consecuencia la elección de un lenguaje tiene ramificaciones de diseño muy importamtes.

Determinacion de las clases. Una clase es un molde que se utiliza para crear nuevos objetos. En consecuencia es importante crear el conjunto de clases adecuado para un proyecto. Desafortunadamente la definición de las clases es más un arte que una ciencia. Si bien hay muchas jerarquías de clase predefinidas usualmente se deben crear clases específicas para la aplicación que se este desarrollando. Luego, en 6 meses ó 1 año se da cuenta que las clases que se establecieron no son posibles; en ese caso será necesario reestructurar la jerarquía de clases devastando totalmente la planificación original.

Performance. En un sistema donde todo es un objeto y toda interaccion es a través de mensajes, el tráfico de mensajes afecta la performance. A medida que la tecnología avanza y la velocidad de microprocesamiento, potencia y tamaño de la memoria aumentan, la situacion mejorará; pero en la situación actual, un diseño de una aplicación orientada a objetos que no tiene en cuenta la performance no será viable comercialmente.

Idealmente, habría una forma de atacar estos problemas eficientemente al mismo tiempo que se obtienen los beneficios del desarrollo de una estrategia orientada a objetos. Deberia existir una metodología fácil de aprender e independiente del lenguaje, y facil de reestructurar que no drene la performance del sistema .

Consejos para una buena programacion en Visual Basic 6.0

2008-09-03T08:14:00.000-07:00

1. Requerir declaración de variables.

Esto es sumamente importante por que una de las caracteristicas del lenguaje es que se puedes utiliza variables sin ser declaradas, Visual Basic crea automáticamente una variable con ese nombre que se este utilizando, que puede usar como si la hubiera declarado explícitamente. Aunque es cómodo, puede provocar errores sutiles en el código si se equivoca de nombre de variable. un ejemplo en donde se puede obtener problemas:

Function SafeSqr(num)
TempVal = Abs(num)
SafeSqr = Sqr(TemVal)
End Function

A primera vista, parece igual. Pero como se ha escrito erróneamente la variable TempVal en la tercera línea, la función devolverá siempre cero. Cuando Visual Basic encuentra un nombre nuevo, no puede averiguar si realmente desea declarar una variable nueva o simplemente ha escrito de forma errónea una variable existente, por lo que crea una variable nueva con ese nombre.

Para requerir la declaración de variables

Haga click en el menú “Herramientas” > “Opciones” en el cuadro de dialogo que se muestra has click en la casilla de verificación “Requerir declaración de variables” que se encuentra en la pestaña “Editor”

Al hacer esto aparece en el editor de código (En la parte superior) Option Explicit.

Para que VB detecte el error y otros mas, ejecuta el programa presionando Ctrl + F5 que es “Iniciar con compilación completa”

Para que siempre que ejecutes un programa lo haga con compilación completa dale click a la pestaña “General” del cuadro “opciones” (del menú herramientas) y desactiva la casilla “Compilar a petición” con esto VB analizara el código antes de la ejecución y mostrara los errores. Una ves desactivada “Compilar a petición” se puede ejecutar el programa con F5 o haciendo click en “El play”.

2. Escribir la variables y nombre de controles con mayúsculas y minúsculas

si vas ha usar una variable por ejemplo VariableNumero escríbela así con la V mayúscula y la N mayúscula a esto se le conoce como notacion camello, y cuando codifiques si lo hacen en minuscula y escribes el nombre de la variable y al salir de la lines editada automaticamente te lo convertira en el nombre de la variable como la declaraste y de podras dar cuenta si la escribiste bien o no.

ademas de esto al ponerle nombre a los controles que estes utilizando, debes hacer un habito de ponerle un identificador del tipo de control al que pertenece, por ejemplo:

txt = Textbox
btn = Botón de comando
lb = Label
Ptb = PictureBox
Frm = Forms
Opt = Option
Etc...

3. Para largas horas de trabajo configura el editor.

si vas a estar mucho tiempo en el pc, programando claro esta puedes configurar el editor, y ponerle los colores que sean de tu agrado esto con el fin de que no se cansen tu ojos o proboquen algun tipo de malestar visual. para hacer esto lo puedes hacer en:

has click en HERRAMIENTAS > OPCIONES y en el cuadro que se muestra, dale click en la pestaña FORMATO DE EDITOR allí encontraras una lista de las opciones a configurar y abajo los colores. Para cambiar el fondo debes configurarlo como mínimo en 3 opciones 1º en TEXTO NORMAL , 2º TEXTO DE PALABRAS CLAVES y 3º TEXTO IDENTIFICADOR cambia también el color de las letras allí.

4. Definir el tipo y ámbito de una variable

Una variable tiene un tipo ya sea Integer, double etc... y un ámbito public, static, private, dim se recomienda analizar primero para que va ha ser utilizada la variable y donde se va usar. Ejemplo:

esto es para decalarar una variable del tipo en que se balla a utilizar, por ejemplo

Dim Resultado As Double

si lo voy a utlizar en gran parte del sistema, se puede agregar un modulo y ahi declarar la variable, pero de esta forma:

Public Resultado As Double

en caso de que se utilice para un procedimiento local, se puede declarar como:

Dim Resultado As Double

Novedades en el lenguaje Visual Basic 6.0

2008-09-03T08:07:00.000-07:00

El núcleo principal del lenguaje Visual Basic a sufrido algunas novedades. Para una mejor lectura y una mejor comprensión vamos a proceder a dividirlos en dos subgrupos: el primero de ellos será el de las novedades del lenguaje en sí mismas y el segundo las novedades en lo referente a funciones de cadena.

Dichas modificaciones o ampliaciones corresponden al núcleo del lenguaje y por consiguiente van a ser aplicables a todas las ediciones de Visual Basic 6.0. Una de las novedades es que ahora las funciones y los diferentes procedimientos de propiedades van a ser capaces de devolver arrays.

En todas las ediciones se ofrecen unos objetos de sistema llamados File System Object.

I Drive: objeto que permite obtener más información sobre las distintas unidades de disco que posee el sistema, información tal como, por ejemplo, su nombre de recurso compartido o el espacio. No es necesario que estén conectadas al sistema las unidades de las cuales vamos a obtener información, es decir, puede, por ejemplo accederse a ellas desde una red de área local. Además las unidades pueden ser también de CD-ROM, disco RAM, etc.

I Fólder: dicho objeto permite crear, borrar y mover carpetas, así como requerir ala sistema información diversa sobre los directorios.

I FileSystemObject: el principal objeto de todo el grupo y es el que nos proporciona acceso al sistema de ficheros del ordenador.

I TextStream: objeto que permitirá leer y escribir fichero de texto.

La función CallByName permitirá acceder a una determinada propiedad o método especificando una cadena que contenga el nombre de la propiedad o el método.

Otra novedad disponible en todas las versiones es que ahora con la función CreateObject, la cual nos permitía crear una referencia a un objeto Actives, podremos especificar entre sus argumentos si lo deseamos, un nombre de máquina para así crear objetos en máquinas remotas.

La función StrConv ha sido convenientemente ampliada y ahora tiene un argumento opcional: StrConv (string, conversión, LCID) Dicho argumento permite especificar un identificador de localización distinto al identificador establecido por defecto que en este caso sería el del sistema.

NUEVAS FUNCIONES DE CADENA:

Han sido añadidas a un total de catorce nuevas funciones, en todas las versiones del lenguaje, para ampliar su funcionalidad, estas de verdad son muy utiles en lo personal las utilizo mucho.

WeekDayName: esta función devolverá una cadena indicando un determinado día de la semana.

Split: retornará un array unidimensional que contendrá un determinado número de subcadenas.

Round: devolverá un número redondeado.

Replace: devuelve una cadena en la que se ha reemplazado una determinada subcadena por otra subcadena un determinado número de veces.

I MonthName: esta función retornará una cadena indicando un mes determinado del año.

FormatPercent: devuelve una expresión convenientemente formateada como un porcentaje, es decir, multiplicada por cien con el carácter de porcentaje (%).

FormatNumber: devuelve una expresión formateada como un número.

FormatDateTime: devolverá una expresión convenientemente formateada como una fecha o bien como una hora.

Funcionamiento del Visual Basic 6.0

2008-09-03T08:04:00.000-07:00

Lo que podemos hacer con Visual Basic es desde diseñar interfaces de usuario innovadoras hasta utilizar objetos de otras aplicaciones, desde manipular texto y gráficos a trabajar con bases de datos, Visual Basic proporciona las herramientas que necesitaremos para realizar correctamente nuestro trabajo.

Utilizar los controles estándar de Visual Basic. Describe los controles intrínsecos de Visual Basic y cómo los puede utilizar.

Programar con objetos. Trata en profundidad los objetos, incluida la creación de clases y el uso de Diseñadores Active X.

Programar con componentes. Trata las técnicas para utilizar componentes active X en sus propias aplicaciones.

Responder a eventos del mouse y del teclado. Descripción del procesamiento de las entradas del usuario, incluidos los eventos relacionados con arrastrar y colocar.

Trabajar con texto y gráficos. Explica cómo debe utilizar los métodos gráficos y de texto de Visual Basic para presentar e imprimir.

Depurar su código y tratar los errores. Explica qué debe hacer cuando algo no funciona de la manera prevista, en tiempo de diseño o en tiempo de ejecución.

Tener acceso a datos. Técnicas para trabajar con bases de datos y procesar archivos.

Diseñar buscando el rendimiento y la compatibilidad. Técnicas de optimización para hacer sus aplicaciones más rápidas o más pequeñas.

Características de Visual Basic 6.0

2008-09-02T07:25:00.000-07:00

Código nativo: Ediciones profesional y empresarial. Puede compilar un proyecto de Visual Basic con código nativo para una ejecución más rápida. También puede personalizar el código nativo con las nuevas opciones del compilador y depurar el código nativo con el entorno de Visual C++.

Creación de sus propios controles Active X: Ediciones profesional y empresarial. Puede combinar los controles existentes o crear el suyo desde cero. Los controles Active X creados con Visual Basic tienen eventos, compatibilidad con enlace a datos, soporte de licencias, páginas de propiedades, características para Internet y mucho más.

Múltiples proyectos: Todas las ediciones. Puede abrir múltiples proyectos en la misma instancia de Visual Basic. Se utiliza para depurar los controles Active X.

Creación de documentos Active X: Ediciones profesional y empresarial. Los documentos Active X, tan fáciles e intuitivos como diseñar las aplicaciones tradicionales de Visual Basic, despliegan sus aplicaciones de Visual Basic en las ventanas de Internet e Intranet.

Asistentes: Todas las ediciones. En la Edición de aprendizaje, el Asistente para aplicaciones es nuevo y se ha mejorado el Asistente para instalar con el fin de permitir la creación de archivos de dependencias para un proyecto estándar. Ediciones profesional y empresarial. En la edición profesional, son nuevos el Asistente para interfaz de controles Active X, el Asistente para la migración de documentos Active X, el Asistente para formularios de datos y el Asistente de páginas de propiedades. El asistente para instalar se ha mejorado de modo que sea compatible con la distribución a través de Internet, la instalación de componentes remotos de servidor mediante COM distribuido (DCOM) y Automatización remota, y la posibilidad de crear archivos de dependencias para proyectos y componentes creados con Visual Basic. La Edición profesional también incluye la barra de herramientas Asistente y el Administrador de asistentes.

Modelo de extensibilidad: Ediciones profesional y empresarial. El nuevo modelo le permite extender por programa el entorno de desarrollo y controlar proyectos, eventos, código y elementos visuales.

Declaración, desencadenamiento y tratamiento de sus propios eventos: Todas las ediciones. Los objetos proporcionados por sus componentes pueden desencadenar eventos que otras aplicaciones pueden tratar. Puede tratar los eventos desencadenados por otras aplicaciones, o por sus propios objetos, mediante variables WithEvents. Los eventos son una alternativa simple a las devoluciones de llamadas asíncronas.

Mejoras en el editor de código: Todas las ediciones. Bloque con comentarios y Bloque sin comentarios agregan y quitan el carácter de comentario de cada línea de un bloque de texto seleccionado . Lista de propiedades y métodos presenta una lista desplegable con las propiedades disponibles para cada control. Información rápida automática muestra la sintaxis de instrucciones y funciones. Los indicadores de margen marcan los puntos de interrupción y la instrucción actual; el indicador Siguiente instrucción se puede arrastrar. Los nuevos botones Ver procedimiento y Ver módulo completo facilitan ver tanto el procedimiento seleccionado como el código completo de un módulo. Puede arrastrar y colocar desde la ventana de código a la ventana Inspección. La inspección instantánea en el modo de depuración le permite ver los valores actuales como información sobre herramientas.

Transferencia de componentes por Internet: Ediciones profesional y empresarial. Puede utilizar el Asistente para instalar con el fin de empaquetar sus componentes de forma específica para su despliegue en el Web.

Enumeraciones: Todas las ediciones. Con la Edición de aprendizaje, ahora puede definir constantes con nombre relacionadas al agruparlas en un enumerador o Enum. Ediciones profesional y empresarial Con la edición profesional, es posible incluir tipos enumerados en la biblioteca de tipos de los componentes Active X para su uso por parte de cualquier programador que utilice el componente.

Arrastrar y colocar OLE: Todas las ediciones. La mayoría de los controles ahora son compatibles con operaciones de arrastrar y colocar entre aplicaciones OLE; por ejemplo, puede arrastrar el contenido de un documento de Word a un control TextBox.

Eventos en JavaScript

2008-08-30T21:16:00.000-07:00

Un evento es un mecanismo por el cual podemos detectar las acciones que realiza el usuario y llamar automáticamente a la función que tengamos asociada. Desde esta función realizaremos las acciones que tengamos desarrolladas.

SINTAXIS:

<elemento nombre_evento=nombre_funcion([parametros]);>

La siguiente lista muestra los eventos y manipuladores de JavaScript:

EVENTO SE PRODUCE AL..
onLoad: Terminar de cargar una página o frame (entrar).
onUnLoad: Descargar una página o frame (salir).
onAbort: Abortar la carga de una página.
onError: Producirse algún error en la carga de la página.
onMouseOver: Pasar el ratón por encima de un enlace, area o frame.
onMouseOut: Dejar de estar el ratón encima de un enlace, area o frame.
onMouseMove: Mover el ratón por el documento.
onKeyUp: Presionar una tecla.
onClick: Hacer click con el ratón.
onResize: Dimensionar la ventana del navegador.
onMove: Mover la ventana del navegador.
onChange: Modificar texto en un control de edición. Sucede al perder el foco.
onSelect: Seleccionar texto en un control de edición.
onFocus: Situar el foco en un control.
onBlur: Perder el foco un control.
onSubmit: Enviar un formulario.
onReset: Inicializar un formulario.

Sentencias de Control en JavaScript

2008-08-30T21:10:00.000-07:00

Es la manera que tiene JavaScript de provocar que el flujo de la ejecución avance y se ramifique en función de los cambios y estado de los datos.

IF-ELSE:

La ejecución atraviesa un conjunto de estados boolean que determinan que bloques de código se ejecutan. Con la utilización de esta sentencia nunca se realizarán ambos bloques de código.

SINTAXIS: En caso de ser una sola sentencia por parte las llaves son opcionales.

if (expresion-booleana)
{
Sentencia(s);
{
[else]
{
Sentencia(s);
}

La cláusula else es opcional. La expresión puede ser de cualquier tipo y más de una (siempre que se unan mediante operadores lógicos).Otra opción posible es la utilización de if anidados, es decir unos dentro de otros compartiendo la cláusula else.

SWITCH:

Es una sentencia muy similar a if-else. Si los valores con los que se compara son números se pone directamente el pero si es texto se debe encerrar entre comillas. La sintaxis de esta sentencia es:

SINTAXIS:

switch (expresión){
case constante1:
sentencia(s);
break;
case constante2:
sentencia(s);
break;
case constante3:
sentencia(s);
break;
case constanteN:
sentencia(s);
break;
[default:]
sentencia(s);
}
El valor de la expresión se compara con cada una de las constantes de la sentencia case, si coincide alguno, se ejecuta el código que le sigue, y cuando ejecuta break sale de este bloque hasta salir del switch. Si ninguno coincide se realiza el bloque default (opcinal), si no lo hay no se ejecuta nada.

En el caso que varias sentencias case realicen la misma ejecución se pueden agrupar, utilizando una sola sentencia break. Evitamos de este modo duplicar líneas de código. La sintaxis es la siguiente:

SINTAXIS:

switch (expresión){
case constante1:
case constante5:
sentencia(s);
break;
case constante3:
sentencia(s);
break;
[default:]
sentencia(s);
}
WHILE:

Ejecuta repetidamente el mismo bloque de código hasta que se cumpla una condición de terminación. Hay cuatro partes en todos los bucles. Inicialización, cuerpo, iteración y condición.

SINTAXIS:

[inicialización;]
while(condicion[es])
{
cuerpo;
[iteración;]
}

DO..WHILE:

Es lo mismo que en el caso anterior pero aquí como mínimo siempre se ejecutará el cuerpo del bucle una vez, en el tipo de bucle anterior es posible que no se ejecute ni una sola vez el contenido de este.

SINTAXIS:

[inicialización;]
do{
cuerpo;
[iteración;]
}while(condición);

FOR:

Realiza las mismas operaciones que en los casos anteriores pero la sintaxis es una forma compacta. Normalmente la condición para terminar es de tipo numérico. La iteración puede ser cualquier expresión matemática valida. Si de los 3 términos que necesita no se pone ninguno se convierte en un bucle infinito.

SINTAXIS: En caso de ser una sola sentencia por parte las llaves son opcionales.

for (inicio;cond_fin;iteración)
{
sentencia(S);
}

Dentro de las sentencias de control se pueden incluir las sentencias de ruptura ya que van muy ligadas a los bucles. Estas sentencias de ruptura son continue y break. A continuación vamos a ver como actúa cada una de ellas

La sentencia continue lo que hace es ignorar las sentencias que tiene el bucle y saltar directamente a la condición para ver si sigue siendo verdadera, si es así, sigue dentro del bucle, en caso contrario, saldría directamente de el.

La sentencia break tiene una operatoria más drástica que la sentencia continue, en vez de saltar a la línea de la condición para comprobar su estado, lo que hace es abandonar directamente el bucle dándolo por terminado.

Operadores en JavaScript

2008-08-30T21:07:00.000-07:00

JavaScript define TRES tipos de operadores: aritméticos, relacionales y lógicos. También hay definido un operador para realizar determinadas tareas, como las asignaciones.

ASIGNACION (=)

En JavaScript se puede utilizar el operador de asignación en cualquier expresión valida. Solo con utilizar un signo de igualdad se realiza la asignación. El operador destino (parte izquierda) debe ser siempre una variable, mientras que en la parte derecha puede ser cualquier expresión valida. Es posible realizar asignaciones múltiples, igualar variables entre si y a un valor.

SINTAXIS:

variable=valor;

variable=variable1;

variable=variable1=variable2=variableN=valor;

ARITMÉTICOS

Pueden aplicarse a todo tipo de expresiones. Son utilizados para realizar operaciones matemáticas sencillas, aunque uniéndolos se puede realizar cualquier tipo de operaciones. En la siguiente tabla se muestran todos los operadores aritméticos.

OPERADOR DESCRIPCIÓN
- Resta.
+ Suma
* Multiplica
/ Divide
% Resto de una división
-- Decremento en 1.
++ Incrementa en 1.
vari+=valor Incrementa el valor de vari.
vari-=valor decrementa el valor de vari.
vari*=valor Multiplica el valor de vari.

LÓGICOS Y RELACIONALES

Los operadores relacionales hacen referencia a la relación entre unos valores y otros Los lógicos se refiere a la forma en que esas relaciones pueden conectarse entre si. Los veremos a la par por la estrecha relación en la que trabajan.

OPERADORES RELACIONALES OPERADORES LÓGICOS
OPERADOR DESCRIPCIÓN OPERADOR DESCRIPCIÓN
< Menor que. && Y (AND)
> Mayor que. | | O (OR)
<= Menor o igual. ¡! NO (NOT)
>= Mayor o igual
= = Igual
¡! = Distinto

Variables en JavaScript

2008-08-30T21:04:00.000-07:00

Espacio de memoria con un nombre reservado para guardar información mientras la página este cargada. El primer paso para poder trabajar con variables es declararlas, que es lugar donde se les da su nombre y su ámbito.

Para dar nombre a una variable debemos tener en cuenta las siguientes normas:

1. No pueden contener espacios.

2. Distingue entre mayúsculas y minúsculas.

3. No pueden contener acentos, puntos o cualquier signo gramatical.

4. No pueden comenzar con un dígito ni contener la letra “ñ”.

5. Nombre único y exclusivo para cada variable salvo que estén es 2 funciones distintas.

El ámbito de una variable define si la variable se podrá utilizar en cualquier parte del documento (es global). O si solo se podrá utilizar dentro de una función determinada (es local). La declaración de las variables globales se realiza dentro de las etiquetas <script> pero fuera de cualquier función. La declaración de las variables locales se realiza dentro de la función que nos interese usar esa variable.

La sintaxis para declarar una variable es igual en ambos casos, la única diferencia es el lugar donde las declaramos. La siguiente línea nos muestra como hacerlo:

var nombre_variable[=valor];

El tipo de variable es asignado automáticamente por JavaScript. Depende del primer valor que se guarde en la variable. Por tanto los tipos de variable existentes son los que mostramos en la siguiente tabla:

TIPO VALORES
numérica Cualquier tipo numérico
boolean True o False.
String Texto o letra.

Otro aspecto importante, es la conversión de datos, que en JavaScript es automática. Transforma los datos de todas la variables en una expresión según el tipo de la primera variable. No es muy segura y puede acarrear muchos problemas.

EJEMPLO:

num1=”12”;
num2=10;

x=num1+num2; // daria como resultado 1210.
y=num2+num1; // daria como resultado 22.

Para evitar problemas en las conversiones, se pueden utilizar métodos ya implementados que realizan la conversión de una manera más segura.

TIPO DE CONVERSION SINTAXIS
De texto a numero entero. var_numerica=parseInt(var_texto);
De texto a coma flotante (decimal). var_numerica=parseFloat(var_texto);
De numérica a texto. Es automática sin peligro.

CONSTANTES (“literales”)

Los valores iniciales que se les asigna son invariables. Estos no son variables, sino expresiones constantes. Los tipos de literales son los mismos que en las variables, según el primer dato que almacenemos será de un tipo u otro.

TIPO VALORES
numérica Cualquier tipo numérico
boolean True o False.
String Texto o letra.

Normas de código en JavaScript

2008-08-30T21:00:00.000-07:00

Las normas para poder escribir cualquier código de JavaScript se basan en 5 puntos básicos y que debemos cumplir siempre. Estas normas son las siguientes:

1. Todo el código (sentencias) esta dentro de funciones.

2. Las funciones se desarrollan entre las etiquetas <script> y </script>.

3. Las etiquetas <script> deben colocarse entre las etiquetas <head> y </head>.

4. Las etiquetas <title> no pueden estar colocadas entre las de <script>.

5. La llamada a la función se hace a través de un evento de un elemento del documento.