aplicativos v (visual script y javascript)

Transcripción

INSTITUTO SUPERIOR TECNOLÓGICO
NORBERT WIENER
Manual del Alumno
ASIGNATURA:
Aplicativos V
(Visual Basic Script y Javascript)
PROGRAMA: S3C
Lima-Perú
2
Manual del Alumno
INDICE
Introducción ................................................................................................................................................. 6
ActiveX Scripting ..................................................................................................................................... 6
VBScript en otras aplicaciones y exploradores ........................................................................................ 6
INTERPRETACIÓN ................................................................................................................................ 6
COMPILACIÓN ...................................................................................................................................... 7
Agregar código de VBScript a una página HTML ....................................................................................... 7
La etiqueta <SCRIPT> ............................................................................................................................. 7
Tipos de datos de VBScript ........................................................................................................................ 10
¿Cuáles son los tipos de datos de VBScript? .......................................................................................... 10
Subtipos de Variant ................................................................................................................................ 10
Variables de VBScript ................................................................................................................................ 11
¿Qué es una variable? ............................................................................................................................. 11
Declaración de variables ......................................................................................................................... 11
Restricciones de nombre ......................................................................................................................... 12
Alcance y vida de las variables............................................................................................................... 12
Asignación de valores a variables .......................................................................................................... 12
Constantes de VBScript .............................................................................................................................. 13
¿Qué es una constante? ........................................................................................................................... 13
Creación de constantes ........................................................................................................................... 13
Variables escalares y variables de matrices ................................................................................................ 14
Instrucción Dim .......................................................................................................................................... 15
Descripción ............................................................................................................................................. 15
Sintaxis : Dim nombredevariable[([subíndices])][, nombredevariable[([subíndices])]] . . . ............... 15
Comentarios............................................................................................................................................ 15
Operadores de VBScript ............................................................................................................................. 17
Prioridad de los operadores .................................................................................................................... 17
Operadores de VBScript ............................................................................................................................. 18
Funciones ................................................................................................................................................... 18
Función Abs ........................................................................................................................................... 18
Función Array......................................................................................................................................... 18
Función Asc ............................................................................................................................................ 19
Instrucción Call ...................................................................................................................................... 19
Función CBool ....................................................................................................................................... 19
Función CByte ........................................................................................................................................ 20
Función CCur ......................................................................................................................................... 20
Función CDate ........................................................................................................................................ 21
Función CDbl ......................................................................................................................................... 21
Función Chr ............................................................................................................................................ 21
Función CInt ........................................................................................................................................... 22
Función CLng ......................................................................................................................................... 22
Función CSng ......................................................................................................................................... 23
Función CStr........................................................................................................................................... 23
Función Exp ........................................................................................................................................... 24
Funciones Int y Fix ................................................................................................................................. 24
Función GetObject.................................................................................................................................. 24
Función Hour .......................................................................................................................................... 26
Función IsDate ....................................................................................................................................... 26
Función LBound ..................................................................................................................................... 27
Función LCase ........................................................................................................................................ 27
Función Left ........................................................................................................................................... 27
Función Len ............................................................................................................................................ 27
Función LoadPicture .............................................................................................................................. 28
Funciones LTrim, RTrim y Trim ............................................................................................................ 28
Función Mid ........................................................................................................................................... 28
Función Minute ...................................................................................................................................... 29
Función Month ....................................................................................................................................... 29
Función MonthName .............................................................................................................................. 29
3
Manual del Alumno
Función Now .......................................................................................................................................... 30
Función RGB .......................................................................................................................................... 30
Función Right ......................................................................................................................................... 30
Función Rnd ........................................................................................................................................... 31
Función Round ....................................................................................................................................... 32
Función Second ...................................................................................................................................... 32
Función Sgn ............................................................................................................................................ 32
Función Space ........................................................................................................................................ 33
Función Sqr ............................................................................................................................................ 33
Función String ........................................................................................................................................ 33
Función UBound .................................................................................................................................... 34
Función UCase ....................................................................................................................................... 34
Función VarType .................................................................................................................................... 35
Función Weekday ................................................................................................................................... 35
Función WeekdayName ......................................................................................................................... 36
Función Year .......................................................................................................................................... 37
Procedimientos de VBScript ...................................................................................................................... 38
Tipos de procedimientos ......................................................................................................................... 38
Procedimientos Sub .................................................................................................................................... 38
Instrucción Sub ....................................................................................................................................... 38
Procedimientos Function ............................................................................................................................ 39
Instrucción Function ............................................................................................................................... 40
Obtención de datos dentro y fuera de procedimientos ................................................................................ 42
Uso de los procedimientos Sub y Function en código ................................................................................ 42
Uso de instrucciones condicionales ............................................................................................................ 43
Control de la ejecución del programa ......................................................................................................... 43
Toma de decisiones utilizando If ... Then ... Else ....................................................................................... 43
Instrucción If...Then...Else ..................................................................................................................... 43
Ejecución de instrucciones si una condición es True ............................................................................. 44
Ejecución de ciertas instrucciones si la condición es True y ejecución de otras si es False ................... 44
Decisión entre varias alternativas ........................................................................................................... 45
Toma de decisiones utilizando Select Case ................................................................................................ 45
Instrucción Select Case............................................................................................................................... 46
Bucles mediante código .............................................................................................................................. 47
Uso de bucles para repetir código ............................................................................................................... 47
Uso de bucles Do ........................................................................................................................................ 47
Instrucción Do...Loop ............................................................................................................................. 47
Repetición de instrucciones mientras una condición es True ..................................................................... 48
Repetición de una instrucción hasta que una condición pasa a ser True .................................................... 49
Salida de una instrucción Do ... Loop desde dentro del bucle .................................................................... 49
Uso de While ... Wend................................................................................................................................ 50
Instrucción While...Wend ....................................................................................................................... 50
Uso de For ... Next ..................................................................................................................................... 50
Instrucción For...Next ............................................................................................................................. 51
Uso de For Each...Next............................................................................................................................... 52
Instrucción For Each...Next .................................................................................................................... 53
Operador de Concatenación & .................................................................................................................. 55
Operador +.................................................................................................................................................. 55
Operadores de comparación ....................................................................................................................... 56
Función InStr .......................................................................................................................................... 58
Función IsNumeric ................................................................................................................................. 58
Formateo de Números ................................................................................................................................ 59
Función FormatNumber ......................................................................................................................... 59
Función FormatCurrency ........................................................................................................................ 60
Función FormatPercent .......................................................................................................................... 62
InputBoxes y Message Box ........................................................................................................................ 63
Función InputBox ................................................................................................................................... 63
Función MsgBox .................................................................................................................................... 64
Función Date .......................................................................................................................................... 67
4
Manual del Alumno
Función DateAdd ................................................................................................................................... 67
Función DateDiff .................................................................................................................................... 68
Función Day ........................................................................................................................................... 69
Función Time ......................................................................................................................................... 69
Función TimeSerial ................................................................................................................................ 70
Función TimeValue ................................................................................................................................ 70
Tipos de eventos ......................................................................................................................................... 70
Eventos de ratón ..................................................................................................................................... 70
Eventos de teclado .................................................................................................................................. 71
Eventos de enfoque................................................................................................................................. 71
Eventos de formulario ............................................................................................................................ 71
Eventos de carga de página .................................................................................................................... 71
Modelo de Objetos ..................................................................................................................................... 72
Evento onMouseOver ......................................................................................................................... 72
Objeto form ............................................................................................................................................ 74
Objeto window ....................................................................................................................................... 74
Objeto document .................................................................................................................................... 75
Objeto form ............................................................................................................................................ 76
Objeto location ....................................................................................................................................... 76
Objeto navigator ..................................................................................................................................... 76
Objeto history ......................................................................................................................................... 77
Introducción a Java Script .......................................................................................................................... 78
Escritura de Código en Java Script ............................................................................................................. 78
Instrucciones ........................................................................................................................................... 78
Comentarios............................................................................................................................................ 79
Asignaciones e igualdad ......................................................................................................................... 79
Expresiones ............................................................................................................................................ 79
Caracteristicas ............................................................................................................................................ 80
Diferencia con JAVA ................................................................................................................................. 80
Principales aplicaciones.............................................................................................................................. 80
Donde incluirlo ........................................................................................................................................... 81
En el cuerpo del documento ................................................................................................................... 81
En archivo aparte .................................................................................................................................... 81
Usando manejadores de evento .............................................................................................................. 81
Haciendo una llamada a función ............................................................................................................ 82
Variables de Java Script ............................................................................................................................. 83
Declarar variables ................................................................................................................................... 83
Nombrar variables .................................................................................................................................. 83
Conversión.............................................................................................................................................. 84
Tipos de Datos ............................................................................................................................................ 85
¿Qué son los tipos de datos de JScript? .................................................................................................. 85
Tipo de dato Cadena ............................................................................................................................... 85
Tipo de dato numérico ............................................................................................................................ 85
Tipo Boolean .......................................................................................................................................... 86
Tipo de dato no definido ......................................................................................................................... 86
Tipo de dato Null .................................................................................................................................... 86
Operadores de Java Script .......................................................................................................................... 87
Precedencia de operadores...................................................................................................................... 87
Arreglos y Cadenas .................................................................................................................................... 89
Indexación de matrices ........................................................................................................................... 89
Referencias a matrices ............................................................................................................................ 89
Objetos Intrínsecos ..................................................................................................................................... 90
Objeto Array ........................................................................................................................................... 90
Objeto String .......................................................................................................................................... 91
Objeto Math............................................................................................................................................ 91
Objeto Date............................................................................................................................................. 91
Objeto Number ....................................................................................................................................... 93
Control del Flujo del Programa .................................................................................................................. 94
¿Por qué controlar el flujo de la ejecución? ............................................................................................ 94
5
Manual del Alumno
Usar instrucciones condicionales ............................................................................................................ 94
Operador condicional ............................................................................................................................. 95
Usar repeticiones o bucles ...................................................................................................................... 95
Usar bucles for........................................................................................................................................ 95
Usar bucles for...in.................................................................................................................................. 96
Usar bucles while ................................................................................................................................... 96
Usar instrucciones break y continue ....................................................................................................... 97
Objeto window ........................................................................................................................................... 98
open ........................................................................................................................................................ 98
close ........................................................................................................................................................ 98
alert ......................................................................................................................................................... 99
status ....................................................................................................................................................... 99
defaultStatus ........................................................................................................................................... 99
Objeto document ........................................................................................................................................ 99
write ........................................................................................................................................................ 99
lastModified............................................................................................................................................ 99
bgColor ................................................................................................................................................... 99
Objeto history ............................................................................................................................................. 99
Objeto form .............................................................................................................................................. 100
submit ................................................................................................................................................... 100
text ........................................................................................................................................................ 100
Objeto date ............................................................................................................................................... 100
Objeto math .............................................................................................................................................. 100
Objeto navigator ....................................................................................................................................... 100
Objeto screen ............................................................................................................................................ 100
Eventos ..................................................................................................................................................... 101
Lista de Eventos ................................................................................................................................... 101
Un ejemplo ........................................................................................................................................... 101
Objeto event ............................................................................................................................................. 102
DHTML .................................................................................................................................................... 103
Qué es CSS ............................................................................................................................................... 103
ANIMACIONES ...................................................................................................................................... 106
ESTILOS .............................................................................................................................................. 106
EJEMPLOS .......................................................................................................................................... 107
Cookies ..................................................................................................................................................... 110
Funciones básicas ..................................................................................................................................... 110
Un ejemplo ............................................................................................................................................... 111
6
Manual del Alumno
Semana 1 : VBScript y la Web
Introducción
Microsoft Visual Basic Scripting Edition, el miembro más reciente de la familia de lenguajes de
programación Visual Basic, suministra una automatización activa a una amplia variedad de entornos,
incluidas las secuencias de comandos del cliente de Web en Microsoft Internet Explorer y las secuencias
de comandos del servidor de Web en Microsoft Internet Information Server.
Si ya conoce Visual Basic o Visual Basic for Applications, VBScript le será muy familiar. Incluso si no
conoce Visual Basic, una vez que lo haya aprendido podrá programar con toda la familia de lenguajes
Visual Basic.
ActiveX Scripting
VBScript se comunica con las aplicaciones de host mediante ActiveX™ Scripting. Con ActiveX
Scripting, evita que los exploradores y otras aplicaciones host necesiten escribir código especial de
integración para cada componente de la secuencia de comandos. ActiveX Scripting permite a un host
compilar una secuencia de comandos, obtener y llamar puntos de entrada, y administrar el espacio de
nombres disponible para el programador. Con ActiveX Scripting, los distribuidores de lenguajes pueden
crear run times de lenguaje estándar para la secuencia de comandos. Microsoft proporcionará soporte de
tiempo de ejecución para VBScript. Microsoft está trabajando con varios grupos de Internet para definir
el estándar de ActiveX Scripting de modo que se puedan intercambiar los motores de automatización.
ActiveX Scripting se utiliza en Microsoft® Internet Explorer y en Microsoft® Internet Information
Server.
VBScript en otras aplicaciones y exploradores
Como programador, puede licenciar su implementación de origen de VBScript sin cargo para utilizarla en
sus productos. Microsoft proporcionará implementaciones binarias de VBScript para la API de
Windows® de 32 bits, la API de Windows de 16 bits y la de Macintosh®. VBScript se integra con
exploradores de World Wide Web. VBScript y ActiveX Scripting también se pueden utilizar como un
lenguaje de automatización general en otras aplicaciones.
INTERPRETACIÓN
VENTAJAS
INCONVENIENTES
El código es cómodo para depurar, ya
que no es necesario volver a compilar
tras un cambio.
La ejecución se ralentiza, al
ser necesaria la interpretación
línea a línea cada vez.
No es necesario disponer de un
compilador, ya que el intérprete (que
forma parte del navegador) ejecuta el
script.
El código es visible y puede
ser objeto de plagio por parte
de otras personas.
El mantenimiento es fácil y rápido,
por parte del autor o de otro
programador.
El usuario tiene acceso al
código y puede modificarlo,
estropeando alguna
operación.
7
Manual del Alumno
COMPILACIÓN
VENTAJAS
El código compilado se ejecuta
muy rápido, al no ser necesaria
una traducción cada vez.
El código compilado no puede
ser "abierto" por otras personas.
No es necesario transmitir el
código fuente.
El código compilado puede
estar, íntegramente, incluido en
un solo fichero.
INCONVENIENTES
Es necesario disponer de un
compilador-linkador para el proceso
de la compilación.
El código compilado suele ocupar
bastante en disco, ya que incorpora
en el propio código algunas librerías
del sistema.
Depurar un programa implica volver
a compilar tras los cambios.
El código en VBScript puede, además, estar diseñado para su ejecución en el lado
del cliente o en el del servidor. La diferencia es que un código que se ejecuta en el
lado del servidor no es visible en el lado del cliente. Este recibe los resultados, pero
no el código. El código que se debe de ejecutar en el lado del servidor estará
incluido en la página web correspondiente entre los tags <% y %> . Además
habrá que renombrar la página para aplicarle la extensión .asp (Active Server Page
-página activa en servidor-). El funcionamiento intrínseco de la ASP's está fuera de
los objetivos de éste temario, aunque lo comentaremos por encima al final. Este
texto se refiere, por tanto, al lenguaje VBScript en el lado del cliente.
El lenguaje VBScript solo funciona correctamente con el navegador Internet
Explorer 4.0 y superiores, por lo que será necesario disponer del mismo. Los
usuarios de otros navegadores no podrán disfrutar de la potencia y versatilidad del
VBScript.
Agregar código de VBScript a una página HTML
Puede usar el elemento SCRIPT para agregar código de VBScript a una página
HTML.
La etiqueta <SCRIPT>
El código de VBScript se presenta en una página HTML dentro de una parejas de
etiquetas <SCRIPT>. Por ejemplo, un procedimiento que comprueba una fecha de
envío aparece como:
8
Manual del Alumno
<SCRIPT LANGUAGE="VBScript">
<!-Function PuedeEntregar(Dt)
PuedeEntregar = (CDate(Dt) - Now()) > 2
End Function
-->
</SCRIPT>
Las etiquetas <SCRIPT> de comienzo y fin rodean el código. El atributo LANGUAGE
indica el lenguaje de secuencia de comandos. Necesita especificar el lenguaje
porque los exploradores pueden utilizar otros lenguajes de secuencia de comandos.
Observe que la función PuedeEntregar aparece entre etiquetas de comentario (<!-y -->). Esto evita que los exploradores que no entienden la etiqueta <SCRIPT>
muestra el código.
Como el ejemplo es una función general —no está vinculado a ningún control de
formulario en particular— puede incluirlo en la sección HEAD de la página:
<HTML>
<HEAD>
<TITLE>Haga su pedido</TITLE>
<!-Function PuedeEntregar(Dt)
PuedeEntregar = (CDate(Dt) - Now()) > 2
End Function
-->
</SCRIPT>
</HEAD>
<BODY>
...
Puede utilizar procedimientos en código en cualquier lugar de una página. Puede
colocar procedimientos en las secciones BODY y HEAD. Sin embargo, puede que
desee colocar todos los procedimientos en la sección HEAD para mantener todo el
código junto. Mantener el código en la sección HEAD asegura que todo el código se
lee y decodifica antes de que se necesite debido a una llamada dentro de la sección
BODY.
Una excepción destacable a esta regla es que puede desear proporcionar
formularios en línea con código de secuencia de comandos para responder a
eventos de objetos del formulario. Por ejemplo, puede incluir código de secuencia
de comandos para responder a un clic en un botón en el formulario:
<HTML>
<HEAD>
<TITLE>Probar eventos de botón</TITLE>
</HEAD>
<BODY>
<FORM NAME="Formulario1">
<INPUT TYPE="Button" NAME="Boton1" VALUE="Clic">
9
Manual del Alumno
<SCRIPT FOR="Boton1" EVENT="onClick"
LANGUAGE="VBScript">
MsgBox "¡Botón presionado!"
</SCRIPT>
</FORM>
</BODY>
</HTML>
La mayoría del código aparecerá en procedimientos Sub o Function y sólo se
llamará cuando el código que ha escrito provoca su ejecución. Sin embargo, puede
escribir código de VBScript fuera de procedimientos, pero dentro de un bloque
SCRIPT. Este código se ejecuta sólo una vez, cuando se carga la página HTML. Esto
le permite inicializar los datos o cambiar dinámicamente la apariencia de su página
Web cuando se carga.
10
Manual del Alumno
Semana 2 : Bases de VBScript
Tipos de datos de VBScript
¿Cuáles son los tipos de datos de VBScript?
VBScript sólo tiene un tipo de datos que se llama Variant. Un tipo Variant es una
clase especial de tipo de datos que puede contener diferentes tipos de información,
dependiendo de cómo se utilice. Como Variant es el único tipo de datos en
VBScript, también es el único tipo de datos devuelto por todas las funciones en
VBScript.
En su forma más sencilla, un tipo Variant puede contener tanto información
numérica como de cadena. Un tipo Variant se comporta como un número cuando
se utiliza en un contexto numérico y como una cadena cuando se utiliza en un
contexto de cadena. Esto quiere decir que si trabaja con datos que parecen
números, VBScript asume que son números y realiza lo que es más adecuado para
números. Igualmente, si trabaja con datos que sólo pueden ser datos de cadena,
VBScript los trata como datos de cadena. Por supuesto, siempre puede hacer que
los números se comporten como cadenas, escribiéndolos entre comillas (" ").
Subtipos de Variant
Más allá de las simples clasificaciones numéricas y de cadena, un tipo Variant
puede hacer más distinciones acerca de la naturaleza específica de la información
numérica. Por ejemplo, puede tener información numérica que representa una
fecha o una hora. Cuando se utiliza con datos de fecha u hora, el resultado se
expresa siempre como una fecha o una hora. Por supuesto, también puede tener
una amplia variedad de información numérica en el intervalo de tamaños de
sencillos valores Boolean a enormes números de signo flotante. Estas categorías
diferentes de información que puede contener un tipo Variant se llaman subtipos.
La mayoría de las veces sólo se puede establecer el tipo de datos que desea en un
tipo Variant y se comporta del modo más adecuado para el tipo de datos que
contiene.
La tabla siguiente muestra varios subtipos de datos que puede contener un tipo
Variant.
Subtipo
Descripción
Empty
Variant está sin inicializar. El valor es 0 para variables numéricas o una
cadena de longitud cero ("") para variables de cadena.
Null
Variant contiene intencionadamente datos no válidos.
Boolean
Contiene True o False.
11
Manual del Alumno
Byte
Contiene un entero entre 0 y 255.
Integer
Contiene un entero -32.768 y 32.767.
Currency
-922.337.203.685.477,5808 a 922.337.203.685.477,5807.
Long
Contiene un entero -2.147.483.648 y 2.147.483.647.
Single
Contiene un número de precisión simple y signo flotante entre -3,402823E38
y -1,401298E-45 para valores negativos, y entre 1,401298E-45 y
3.402823E38 para valores negativos.
Double
Contiene un número de precisión doble y punto flotante en el intervalo de 1,79769313486232E308 y -4,94065645841247E-324 para valores negativos,
y entre 4,94065645841247E-324 y 1,79769313486232E308 para valores
positivos.
Date
(Time)
Contiene un número que representa una fecha entre el 1 de enero de 100 y el
31 de diciembre de 9999.
String
Contiene una cadena de longitud variable que puede contener hasta 2 mil
millones de caracteres de longitud.
Object
Contiene un objeto.
Error
Contiene un número de error.
Puede usar las funciones de conversión para convertir datos un subtipo a otro.
Además la función VarType devuelve información acerca de cómo se almacenan
los datos en un tipo Variant.
Variables de VBScript
¿Qué es una variable?
Una variable es un marcador de posición útil que hace referencia a una ubicación de
la memoria del equipo donde puede almacenar información de programa que puede
cambiar durante el tiempo en que se ejecuta la secuencia de comandos. Por
ejemplo, podría crear una variable llamada CuentaClics para almacenar el número
de veces que el usuario hizo clic en un objeto de una determinada página Web. El
lugar donde se ubica la variable en la memoria del equipo no es importante. Lo que
es importante es que sólo tiene que hacer referencia a su nombre para ver o
cambiar su valor. En VBScript, las variables siempre son de un tipo de datos
fundamental, Variant.
Declaración de variables
Declare variables explícitamente en la secuencia de comandos utilizando la
instrucción Dim, la instrucción Public y la instrucción Private. Por ejemplo:
Dim GradosFahrenheit
Declare múltiples variables separando cada nombre de variable por una coma. Por
ejemplo:
12
Manual del Alumno
Dim Arriba, Abajo, Izquierda, Derecha
También puede declarar una variable implícitamente por el simple uso de su
nombre en alguna parte de la secuencia de comandos. Esto no se considera
adecuado, ya que podría escribir mal el nombre de la variable en uno o más lugares
provocando resultados inesperados cuando ejecuta el código. Por este motivo,
existe la instrucción Option Explicit para solicitar una declaración explícita de
todas las variables. La instrucción Option Explicit debe ser la primera instrucción
en la secuencia de comandos.
Restricciones de nombre
Los nombres de variables siguen las normas estándar de denominación en
VBScript. Un nombre de variable:
Debe comenzar con un carácter alfabético.
No puede contener un punto.
No debe superar 255 caracteres.
Debe ser único en el alcance donde se declara.
Alcance y vida de las variables
El alcance de una variable se determina cuando se declara. Cuando declara una
variable dentro de un procedimiento, sólo el código dentro de ese procedimiento
puede tener acceso o cambiar el valor de esa variable. Tiene scope local y se llama
variable de nivel de procedimiento. i declara una variable fuera de un
procedimiento, la hace reconocible en todos los procedimientos de la secuencia de
comandos. Este tipo de variable de nivel de secuencia de comandos y tiene alcance
de nivel de secuencia de comandos.
El tiempo que una variable existe es su vida. La vida de una variable de nivel de
secuencia de comandos se extiende desde el momento en que se declaró hasta el
momento en que finaliza la ejecución de la secuencia de comandos. A nivel de
procedimiento, una variable existe sólo cuando se encuentra en el procedimiento.
Cuando sale del procedimiento, la variable se destruye. Las variables locales son
adecuadas como espacio de almacenamiento temporal cuando se ejecuta un
procedimiento. Puede tener variables locales del mismo nombre en varios
procedimientos diferentes porque cada una sólo se reconoce en el procedimiento en
que se declaró.
Asignación de valores a variables
Los valores se asignan a variables creeando un expresión de la siguiente manera: la
variable está en la parte izquierda de la expresión y el valor que desea asignar a la
misma está a la derecha. Por ejemplo:
B = 200
13
Manual del Alumno
Constantes de VBScript
¿Qué es una constante?
Una constante es un nombre significativo que contiene un número o una cadena
que nunca cambia. VBScript define un número de constantes intrínsecas. Puede
obtener información sobre estas constantes intrínsecas en Referencia del lenguaje
VBScript.
Creación de constantes
En VBScript puede crear constantes definidas por el usuario utilizando la instrucción
Const. Utilizando la instrucción Const, puede crear constantes numéricas o de
cadena con nombres significativos y asignarlas a valores literales. Por ejemplo:
Const MiCadena = "Esta es mi cadena."
Const MiEdad = 49
Observe que el literal de cadena se escribe entre comillas (" "). Las comillas son la
mejor y más clara forma de diferenciar valores de cadena y valores numéricos. Los
literales de fecha y los literales de hora se representan encerrándolos entre signos
de número (#). Por ejemplo:
Const FechaCorte = #6-1-97#
Puede que desee adoptar una combinación de nombres para diferenciar constantes
de variables. Esto impedirá que intente reasignar sus valores mientras se ejecuta la
secuencia de comandos. Por ejemplo, podría desear utilizar un prefijo "vb" en los
nombres de constantes o puede dar nombre a las constantes en mayúsculas. Al
diferenciar las constantes de las variables elimina la confusión cuando desarrolla
secuencias de comando complejas.
14
Manual del Alumno
Semana 3 : Arreglos
Variables escalares y variables de matrices
Muchas veces, sólo desea asignar un único valor a una variable que ha declarado.
Una variable que contiene un único valor es una variable escalar. Otras veces, es
útil asignar más de un valor relacionado a una única variable. Entonces puede crear
una variable que pueda contener una serie de valores. Esto se llama una variable
de matriz. Las variables matriz se declaran de la misma forma que las variables
escalares. La diferencia es que una declaración de una variable de matriz utiliza
paréntesis ( ) a continuación del nombre de la variable. En el siguiente ejemplo se
declara una matriz de una dimensión que contiene 11 elementos:
Dim A(10)
Aunque el número que se muestra entre paréntesis es 10, todas las matrices en
VBScript son de base cero, por lo que la matriz realmente contiene 11 elementos.
En una matriz de base cero, el número de elementos de la misma siempre es el
número mostrado entre paréntesis más uno. Este tipo de matriz se llama una
matriz de tamaño fijo.
Asigne datos a cada elemento de la matriz utilizando un índice dentro de la matriz.
Comenzando en cero y terminando en 10, es posible asignar datos a los elementos
de una matriz del siguiente modo:
A(0) = 256
A(1) = 324
A(2) = 100
. . .
A(10) = 55
Del mismo modo, se pueden recuperar los datos de cualquier elemento utilizando el
índice que desee dentro del elemento de la matriz deseado. Por ejemplo:
. . .
AlgunaVariable = A(8)
. . .
Las matrices no están limitadas a una única dimensión. Puede tener hasta 60
dimensiones aunque la mayoría de las personas no pueden comprender más de tres
o cuatro. Las dimensiones múltiples se declaran separando con comas los números
de tamaño de la matriz dentro del paréntesis. En el siguiente ejemplo, la variable
MiTabla es una matriz bidimensional que consta de 6 filas y 11 columnas:
Dim MiTabla(5, 10)
En una matriz bidimensional, el primer número siempre es el número de filas y el
segundo el número de columnas.
15
Manual del Alumno
Instrucción Dim
Descripción
Declara variables y asigna espacio de almacenamiento.
Sintaxis : Dim nombredevariable[([subíndices])][,
nombredevariable[([subíndices])]] . . .
La sintaxis de la instrucción Dim tiene las siguientes partes:
Parte
Descripción
nombredevariable Nombre de la variable que cumple con las convenciones estándar de
asignación de nombres de variables.
subíndices
Dimensiones de una variable de matriz; se pueden declarar hasta 60
dimensiones múltiples. El argumento subíndices usa la siguiente
sintaxis:
límitesuperior [,límitesuperior] . . .
El límite inferior de una matriz siempre es cero.
Comentarios
Las variables declaradas con Dim a nivel de secuencia de comandos están
disponibles para todos los procedimientos dentro de la secuencia de comandos. A
nivel de procedimiento, las variables sólo están disponibles dentro del
procedimiento.
También puede usar la instrucción Dim con paréntesis vacíos para declarar una
matriz dinámica. Después de declarar una matriz dinámica, use la instrucción
ReDim dentro de un procedimiento para definir el número de dimensiones y
elementos de la matriz. Si intenta volver a declarar una dimensión para una
variable de matriz cuyo tamaño se especificó explícitamente en una instrucción
Dim, se produce un error.
Cuando se inician las variables, una variable numérica se inicia a 0 y una cadena se
inicia a una cadena de longitud cero ("").
Sugerencia Al usar la instrucción Dim en un procedimiento, generalmente se coloca la instrucción Dim
al principio del procedimiento.
Los siguientes ejemplos muestran el uso de la instrucción Dim:
Dim Nombres(9)
' Declara una matriz con 10 elementos.
Dim Nombres()
' Declara una matriz dinámica
Dim MiVar, MiNum ' Declara dos variables
16
Manual del Alumno
También puede declarar una matriz cuyo tamaño cambia durante el tiempo en que
se ejecuta la secuencia de comandos. Esto se llama una matriz dinámica. La matriz
inicialmente se declara dentro de un procedimiento utilizando la instrucción Dim
como con cualquier tipo de matriz o la instrucción ReDim. Sin embargo, en una
matriz dinámica, no se establece un tamaño o un número de dimensiones dentro
del paréntesis.
Por ejemplo:
Dim MiMatriz()
ReDim OtraMatriz()
Para utilizar una matriz dinámica, debe utilizar a continuación ReDim para
determinar el número de dimensiones y el tamaño de cada una de ellas. En el
siguiente ejemplo, ReDim establece el tamaño inicial de la matriz dinámica a 25.
La siguiente instrucción ReDim cambia el tamaño de la matriz a 30, pero utiliza la
palabra clave Preserve para conservar el contenido de la matriz cuando se produce
el cambio de tamaño.
ReDim MiMatriz(25)
. . .
ReDim Preserve MiMatriz(30)
No hay límite en cuanto al número de veces que puede cambiar el tamaño de una
matriz dinámica, pero debe saber que si hace una matriz más pequeña de lo que
era, pierde los datos de los elementos eliminados.
17
Manual del Alumno
Semana 4 : Operadores y Funciones en VBScript
Operadores de VBScript
VBScript tiene un completo conjunto de operadores, incluyendo operadores
aritméticos, operadores de comparación, operadores de concatenación y
operadores lógicos.
Prioridad de los operadores
Cuando se producen varias operaciones en una expresión, cada parte se evalúa y
se resuelve en un orden predeterminado. Este orden se conoce como prioridad de
los operadores. Puede utilizar paréntesis para invalidar el orden de prioridad y
forzar que se evalúen algunas partes de una expresión antes que otras. Las
operaciones entre paréntesis siempre se ejecutan antes que las de fuera. Sin
embargo, dentro de los paréntesis se mantiene la prioridad de los operadores.
Cuando las expresiones contienen operadores de más de una categoría, se evalúan
primero los operadores aritméticos, a continuación los operadores de comparación
y por último los lógicos. Todos los operadores de comparación tienen la misma
prioridad; esto quiere decir que se evalúan en el orden en que aparecen, de
izquierda a derecha. Los operadores aritméticos y lógicos se evalúan en el siguiente
orden de prioridad.
Aritmético
Descripción
De comparación
Símbolo Descripción
Lógico
Símbolo Descripción
Símbolo
Exponenciación
^
Igualdad
=
Logical
negation
Not
Negación unaria
-
Desigualdad
<>
Logical
conjunction
And
Multiplicación
*
Menor que
<
Disyunción
lógica
Or
División
/
Mayor que
>
Exclusión
lógica
Xor
División entera
\
Menor o igual
que
<=
Equivalencia
lógica
Eqv
Mod
Mayor o igual
que
>=
Implicación
lógica
Imp
Equivalencia de
objeto
Is
Módulo aritmético
Suma
+
Resta
-
Concatenación de
cadenas
&
18
Manual del Alumno
Cuando una multiplicación y una división se producen juntas en una expresión,
cada operación se evalúa como ocurre de izquierda a derecha. Del mismo modo,
cuando una suma y una resta se producen juntas en una expresión, cada operación
se evalúa según el orden de aparición, de izquierda a derecha.
El operador de concatenación de cadenas (&) no es un operador aritmético, pero en
la prioridad se ejecuta después de todos los operadores aritméticos y antes de
todos los operadores de comparación. El operador Is es un operador de
comparación de referencia de objeto. No compara objetos o sus valores; sólo se
comprueba para determinar si dos referencias a objetos se refieren al mismo
objeto.
Operadores de VBScript
Función Abs
Devuelve el valor absoluto de un número.
Sintaxis : Abs(número)
El argumento número puede ser cualquier expresión numérica válida. Si número
contiene Null, se devuelve Null ; si es un valor no iniciado, se devuelve cero.
El valor absoluto de un número es su magnitud sin signo. Por ejemplo, Abs(-1) y
Abs(1) devuelven 1.
El siguiente ejemplo usa la función Abs para compute the absolute value of a
number:
Dim MiNumero
MiNumero = Abs(50.3) 'Devuelve 50.3
MiNumero = Abs(-50.3) 'Devuelve 50.3
Función Array
Devuelve un objeto Variant que contiene una matriz.
Sintaxis : Array(listadeargumentos)
El argumento requerido listadeargumentos es una lista de valores separados por
comas, que se asignan a los elementos de una matriz contenida en el objeto
Variant. Si no se especifica ningún argumento, se crea una matriz de longitud
cero.
La notación usada para hacer referencia a un elemento de una matriz, consta del
nombre de la variable seguido de paréntesis que contienen un número de índice
que indica el elemento deseado. En el siguiente ejemplo, la primera instrucción crea
una variable llamada A. La segunda instrucción asigna una matriz a la variable A.
La última instrucción asigna el valor contenido en la segunda matriz a otra variable.
Dim A
A = Array(10,20,20)
19
Manual del Alumno
B = A(2)
Función Asc
Devuelve el código de carácter ANSI que corresponde a la primera letra de una
cadena.
Sintaxis : Asc(cadena)
El argumento cadena es cualquier expresión de cadena válida. Si cadena no
contiene ningún carácter, se produce un error en tiempo de ejecución.
En el ejemplo siguiente, Asc devuelve el código de carácter ANSI de la primera
letra de cada cadena:
Dim MiNumero
MiNumero = Asc("A")
'Devuelve 65
MiNumero = Asc("a")
'Devuelve 97
MiNumero = Asc("Azúcar") 'Devuelve 65
Instrucción Call
Transfiere el control a un procedimiento Sub o Function.
Sintaxis : [Call] nombre [listadeargumentos]
La sintaxis de la instrucción Call tiene las siguientes partes:
Parte
Descripción
Call
Palabra clave opcional. Si se especifica, debe encerrar
listadeargumentosentre paréntesis. Por ejemplo:
Call MiProc(0)
nombre
Requerido. Nombre del procedimiento al que se llama.
listadeargumentos Opcional. List de variables, matrices o expresiones delimitada por
comas que se pasa al procedimiento.
No necesita usar la palabra clave Call al llamar a un procedimiento. Sin embargo, si
usa la palabra clave Call para llamar a un procedimiento que necesita argumentos,
listadeargumentos debe estar encerrado entre paréntesois. Si omite la palabra
clave Call, también debe omitir los paréntesis que encierran a listadeargumentos.
Con cualquier sintaxis de Call que use para llamar a cualquier función intrínseca o
definida por el usuario, se descarta el valor devuelto por la función.
Call MiFuncion("Hola mundo")
Function MiFuncion(texto)
MsgBox texto
End Function
Función CBool
Devuelve una expresión convertida en Variant de subtipo Boolean.
Sintaxis : CBool(expresión)
El argumento expresión es cualquier expresión válida.
20
Manual del Alumno
Si expresión es cero, se devuelve False; de lo contrario, se devuelve True. Si
expresiónno se puede interpretar como valor numérico, se produce un error en
tiempo de ejecución.
El siguiente ejemplo usa la función CBool para convertir una expresión en
Boolean. Si la expresión se evalúa como un valor distinto de cero, CBool devuelve
True; de lo contrario, devuelve False.
Dim A, B, Comprobacion
A = 5: B = 5
' Inicia variables
Comprobacion = CBool(A = B)
' Comprobacion contiene True
A = 0
' Define la variable
Comprobacion = CBool(A)
' Comprobacion contiene
False
Función CByte
Devuelve una expresión que se convirtió en Variant de subtipo Byte.
Sintaxis : CByte(expresión)
En general, puede documentar su código con las funciones de conversión de
subtipos para mostrar que el resultado de alguna operación se debe expresar como
un tipo de datos particular, en lugar del tipo de datos predeterminado. Por ejemplo,
use CByte para forzar aritmética de tipo byte en casos en los que normalmente se
usaría aritmética de moneda, precisión simple, precisión doble o entero.
Si expresión está fuera del intervalo aceptable para el subtipo Byte, se produce un
error. El siguiente ejemplo usa la función CByte para convertir una expresión en
byte:
Dim MiDoble, MiByte
MiDoble = 125.5678
MiByte = CByte(MiDoble)
' MiDoble es un Double
' MiByte contiene 126
Función CCur
Devuelve una expresión que se convirtió en Variant de subtipo Currency.
Sintaxis : CCur(expresión)
Debe usar la función CCur para proporcionar conversiones internacionales estándar
desde cualquier tipo de datos al subtipo Currency. Por ejemplo, distintos
separadores de decimales o de miles se reconocen correctamente según la
configuración local de su sistema.
El siguiente ejemplo usa la función CCur para convertir una expresión en tipo de
datos Currency:
Dim MiDoble, MiMoneda
MiDoble = 543.214588
MiMoneda = CCur(MiDoble * 2)
MiDoble * 2 (1086.429176)
' MiDoble es de tipo Double
' Convierte el resultado de
' en tipo de datos Currency
(1086.4292)
21
Manual del Alumno
Función CDate
Devuelve una expresión que se convirtió en Variant del subtipo Date.
Sintaxis : CDate(fecha)
El argumento fecha es cualquier expresión de fecha válida.
Use la función IsDate para determinar si se puede convertir fecha en una fecha u
hora. CDate reconoce literales de fecha y literales de hora, así como algunos
números que se encuentran dentro del rango de fechas aceptable. Al convertir un
número a fecha, la parte entera del número se convierte en una fecha. Cualquier
parte fraccionaria del número se convierte en una hora del día, a partir de
medianoche.
En el siguiente ejemplo se usa la función CDate para convertir una cadena en una
fecha. En general, no se recomienda establecer fechas y horas como cadenas
mediante programación (como se muestra en este ejemplo). En su lugar, use
literales de fecha y hora, como #10/19/1962# o #4:45:23 PM#.
MiFecha = "19 de octubre de 1962"
' Define la fecha
MiHoraCorta = CDate(MiFecha)
' Convierte al tipo de
datos Date
MiHoraCompleta = "4:35:47 PM"
' Define la hora
completa
MiHoraCorta = CDate(MiHoraCompleta)
' Convierte al
tipo de datos Date
Función CDbl
Devuelve una expresión que se convirtió en Variant de subtipo Double.
Sintaxis : CDbl(expresión)
subtipos para mostrar que el resultado de alguna operación se debe expresar como
use CDbl o CSng para forzar aritmética de doble precisión o simple precisión en
casos en los que normalmente se usaría aritmética de moneda o de entero.
Este ejemplo usa la función CDbl para convertir una expresión en Double.
Dim MiMoneda, MiDoble
MiMoneda = CCur(234.456784)
tipo Currency.
MiDoble = CDbl(MiMoneda * 8.2 * 0.01)
resultado en Double.
' MiMoneda es de
' Convierte el
Función Chr
Devuelve el carácter asociado al código de carácter ANSI especificado.
Sintaxis : Chr(códigodecarácter)
El argumento códigodecarácter es un número que identifica un carácter.
Los números entre 0 y 31 son iguales a los códigos ASCII estándar, no imprimibles.
Por ejemplo, Chr(10) devuelve un carácter de avance de línea.
22
Manual del Alumno
El siguiente ejemplo usa la función Chr para devolver el carácter asociado al código
de carácter especificado:
Dim MiCaracter
MiCaracter = Chr(65)
'
'
'
'
Devuelve
Devuelve
Devuelve
Devuelve
A.
a.
>.
%.
Función CInt
Devuelve una expresión que se convirtió enVariant del subtipo Integer.
Sintaxis : CInt(expresión)
subtipos para mostrar que el resultado de alguna operación se debería expresar
como un tipo de datos particular, en lugar del tipo de datos predeterminado. Por
ejemplo, use CInt o CLng para forzar aritmética de enteros en casos en los que
normalmente se usaría aritmética de moneda, precisión simple o precisión doble.
Si expresión está fuera del intervalo aceptable para el subtipo Integer, se produce
un error.
El siguiente ejemplo usa la función CInt para convert a value to an Integer:
Dim MiDoble, MiEntero
MiDoble = 2345.5678
' MiDoble es de tipo Double.
MiEntero = CInt(MiDoble)
' MiEntero contiene 2346.
Función CLng
Devuelve una expresión que se convirtió en Variant del subtipo Long.
Sintaxis : CLng(expresión)
subtipos para mostrar que el resultado de alguna operación se debería expresar
ejemplo, use CInt o CLng para forzar aritmética de enteros en casos en los que,
normalmente, se usaría aritmética de precisión simple o precisión doble.
Si expresión está fuera del intervalo aceptable para el subtipo Long, se produce un
error.
El siguiente ejemplo usa la función CLng para convertir un valor en Long:
Dim MiVal1, MiVal2, MiLong1, MiLong2
MiVal1 = 25427.45: MiVal2 = 25427.55
are Doubles.
MiLong1 = CLng(MiVal1)
MiLong2 = CLng(MiVal2)
' MiVal1, MiVal2
' MiLong1 contiene 25427.
' MiLong2 contiene 25428.
23
Manual del Alumno
Función CSng
Devuelve una expresión que se convirtió en Variant del subtipo Single.
Sintaxis : CSng(expresión)
En general, puede documentar su código con las funciones de conversión de tipos
de datos para mostrar que el resultado de algunas operaciones se debería expresar
ejemplo, use CDbl o CSng para forzar aritmética de precisión doble o precisión
simple en casos en los que, normalmente, se usaría aritmética de moneda o de
enteros.
Si expresión está fuera del intervalo aceptable para el subtipo Single, se produce
un error.
El siguiente ejemplo usa la función CSng para convertir un valor en Single:
Dim MiDoble1, MiDoble2, MiSimple1, MiSimple2 ' MiDoble1,
MiDoble2 are Doubles.
MiDoble1 = 75.3421115: MiDoble2 = 75.3421555
MiSimple1 = CSng(MiDoble1)
' MiSimple1 contiene
75.34211.
MiSimple2 = CSng(MiDoble2)
' MiSimple2 contiene
75.34216.
Función CStr
Devuelve una expresión que se convirtió en Variant del subtipo String.
Sintaxis : CStr(expresión)
En general, puede documentar su código con funciones de conversión de tipos de
datos para mostrar que el resultado de alguna operación se debería expresar como
use CStr para forzar que el resultado se exprese como String.
Los datos almacenados en expresión determinan el valor devuelto de acuerdo con
la siguiente tabla:
Si expresión es
CStr devuelve
Boolean
Un valor de tipo String que contiene True o False.
Date
Un valor de tipo String que contiene una fecha en formato de fecha
corta de su sistema.
Null
Un error en tiempo de ejecución.
Empty
Un valor de tipo String de longitud cero ("").
Error
Un valor de tipo String que contiene la palabra Error seguido por el
número de error.
Otro valor
numérico
Un valor de tipo String contiene el número.
24
Manual del Alumno
El siguiente ejemplo usa la función CStr para convertir un valor numérico en
String:
Dim MiDoble, MiCadena
MiDoble = 437.324
MiCadena = CStr(MiDoble)
' MiDoble es de tipo Double.
' MiCadena contiene "437.324".
Función Exp
Devuelve e (la base de los logaritmos naturales) elevado a una potencia.
Sintaxis : Exp(número)
El argumento número puede ser cualquier expresión numérica válida.
Si el valor de número supera 709.782712893, se produce un error. La constante e
aproximadamente igual a 2.718282.
El siguiente ejemplo usa la función Exp para devolver e elevado a una potencia:
Dim MiAngulo, MiSenoH ' Define el ángulo en radianes.
MiAngulo = 1.3
' Calcula el seno hiperbólico.
MiSenoH = (Exp(MiAngulo) - Exp(-1 * MiAngulo)) / 2
Funciones Int y Fix
Devuelve la parte entera de un número.
Sintaxis :
Int(número)
Fix(número)
El argumento número puede ser cualquier expresión numérica válida. Si número
contiene Null, se devuelve Null.
Int y Fix quitan la parte fraccional de número y devuelven el valor entero
resultante.
La diferencia entre Int y Fix es que si número es negativo, Int devuelve el primer
entero negativo menor o igual a número, mientras que Fix devuelve el primer
entero negativo mayor o igual a número. Por ejemplo, Int convierte -8.4 a -9, y
Fix convierte -8.4 a -8.
Fix(número) es equivalente a:
Sgn(número) * Int(Abs(número))
Los siguientes ejemplo muestran cómo devuelven partes enteras de números las
funciones Int y Fix:
MiNumero
MiNumero
MiNumero
MiNumero
MiNumero
MiNumero
=
=
=
=
=
=
Int(99.8)
Fix(99.2)
Int(-99.8)
Fix(-99.8)
Int(-99.2)
Fix(-99.2)
'
'
'
'
'
'
Devuelve
Devuelve
Devuelve
Devuelve
Devuelve
Devuelve
99.
99.
-100.
-99.
-100.
-99.
Función GetObject
Devuelve una referencia a un objeto de automatización desde un archivo.
Sintaxis : GetObject([nombrederuta] [, clase])
La sintaxis de la función GetObject tiene las siguientes partes:
25
Manual del Alumno
Parte
Descripción
nombrederuta Opcional; String. Ruta y nombre completos del archivo que contiene el
objeto que desea recuperar. Si se omite nombrederuta, se requiere clase.
clase
Opcional; String. Clase del objeto.
El argumento claseusa la sintaxis nombredeaplicación.tipodeobjeto y tiene las
siguientes partes:
Parte
Descripción
nombredeaplicación Requerido; String. Nombre de la aplicación que proporciona el
objeto.
tipodeobjeto
Requerido; String. Tipo o clase de objeto que desea crear.
Use la función GetObject para tener acceso a un objeto de automatización desde
un archivo y asignar el objeto a una variable de objeto. Use la instrucción Set para
asignar el objeto devuelto por GetObject a la variable de objeto. Por ejemplo:
Dim CADObject
Set CADObject = GetObject("C:\CAD\SCHEMA.CAD")
Cuando se ejecuta este código, se inicia la aplicación asociada con el nombre de
ruta especificado y el objeto del archivo especificado se activa. Si nombrederuta es
una cadena de longitud cero (""), GetObject devuelve una nueva instancia de
objeto del tipo especificado. Si se omite el argumento nombrederuta, GetObject
devuelve un objeto activo del tipo especificado. Si no existe ningún objeto del tipo
especificado, se produce un error.
Algunas aplicaciones le permiten activar parte de un archivo. Agregue un signo de
admiración (!) al final del nombre del archivo y, a continuación, agregue una
cadena que identifique la parte del archivo que desea activar. Para obtener
información acerca de cómo crear esta cadena, consulte la documentación de la
aplicación que creó el objeto.
Por ejemplo, en una aplicación de dibujo podría tener varias capas de un dibujo
almacenado en un archivo. Podría usar el siguiente código para activar una capa de
un dibujo llamado SCHEMA.CAD:
Set ObjetoCapa = GetObject("C:\CAD\SCHEMA.CAD!Layer3")
Si no especifica la clase de objeto, la automatización determina la aplicación que
debe iniciar el objeto para activarlo, basado en el nombre de archivo
proporcionado. Sin embargo, es posible que algunos archivos admitan más de una
clase de objeto. Por ejemplo, un dibujo puede admitir tres tipos de objeto distintos:
un objeto Application, un objeto Drawing y un objeto Toolbar, y todos forman parte
del mismo archivo. Para especificar qué objeto desea activar en un archivo, use el
argumento opcional clase. Por ejemplo:
Dim MiObjeto
Set
MiObjeto
=
"FIGMENT.DRAWING")
GetObject("C:\DIBUJOS\EJEMPLO.DRW",
26
Manual del Alumno
En el ejemplo anterior, FIGMENT es el nombre de una aplicación de dibujo y
DRAWING es uno de los tipos de objeto que admite. Una vez activado un objeto, se
hace referencia a él en el código mediante la variable de objeto definida. En el
ejemplo anterior, se tiene acceso a las propiedades y métodos del nuevo objeto con
la variable de objeto MiObjeto. Por ejemplo:
MiObjeto.Line 9, 90
MiObjeto.InsertText 9, 100, "Hola mundo."
MiObjeto.SaveAs "C:\DIBUJOS\EJEMPLO.DRW"
Función Hour
Devuelve un número entero entre 0 y 23, ambos incluidos, que representa la hora
del día.
Sintaxis : Hour(hora)
El argumento hora es cualquier expresión que pueda representar una hora. Si hora
El siguiente ejemplo usa la función Hour para obtener la hora a partir de la hora
actual:
Dim MiHoraCompleta, MiHora
MiHoraCompleta = Now
MiHora = Hour(MiHoraCompleta) ' MiHora contiene el número
que representa la hora actual.
Función IsDate
Devuelve un valor de tipo Boolean que indica si una expresión se puede o no
convertir en una fecha.
Sintaxis : IsDate(expresión)
El argumento expresión puede ser cualquier expresión de fecha o expresión de
cadena reconocible como fecha u hora.
IsDate devuelve True si la expresión es una fecha o si se puede convertir en una
fecha válida. De lo contrario, devuelve False. En Microsoft Windows, el intervalo
válido de fechas es desde el 1 de enero del año 100 hasta el 31 de diciembre del
año 9999; los intervalos varían según el sistema operativo.
El siguiente ejemplo usa la función IsDate para determinar si una expresión se
puede o no convertir en una fecha:
Dim MiFecha, SuFecha, NingunaFecha, MiComprobacion
MiFecha = "October 19, 1962": SuFecha = #10/19/62#:
NingunaFecha = "Hola"
MiComprobacion = IsDate(MiFecha)
' Devuelve True.
MiComprobacion = IsDate(SuFecha)
' Devuelve True.
MiComprobacion = IsDate(NingunaFecha)
' Devuelve False.
27
Manual del Alumno
Función LBound
Devuelve el subíndice más pequeño disponible para la dimensión indicada de una
matriz.
Sintaxis : LBound(nombredematriz[, dimensión])
La sintaxis de la función LBound tiene las siguientes partes:
Parte
Descripción
nombredematriz Nombre de la variable de matriz, que cumple con las convenciones
estándar de asignación de nombres de variables.
dimensión
Número entero que indica de qué dimensión se devuelve el límite
inferior. Use 1 para la primera dimensión, 2 para la segunda y así
sucesivamente. Si se omite dimensión, se asume 1.
Función LCase
Devuelve una cadena convertida a minúsculas.
Sintaxis : LCase(cadena)
El argumento cadena es cualquier expresión de cadena válida. Si cadena contiene
Null, se devuelve Null.
Función Left
Devuelve un número de caracteres especificado a partir del lado izquierdo de una
cadena.
Sintaxis : Left(cadena, longitud)
La sintaxis de la función Left tiene los siguientes argumentos:
Parte
Descripción
cadena
Expresión de cadena a partir de la que se devuelven los caracteres que están más
a la izquierda. Si cadena contiene Null, se devuelve Null.
longitud Expresión numérica que indica cuántos caracteres se van a devolver. Si es igual a
0, se devuelve una cadena de longitud cero (""). Si es mayor o igual al número de
caracteres de cadena, se devuelve la cadena completa.
Función Len
Devuelve el número de caracteres en una cadena o el número de bytes necesarios
para almacenar una variable.
Sintaxis : Len(cadena | nombredevariable)
La sintaxis de la función Len tiene las siguientes partes:
Parte
Descripción
cadena
Cualquier expresión de cadena válida. Si cadena contiene Null, se
devuelve Null.
nombredevariable Cualquier nombre de variable válido. Si nombrevariable contiene Null,
se devuelve Null.
28
Manual del Alumno
En el siguiente ejemplo se usa la función Len para devolver el número de
caracteres que contiene una cadena:
Dim MiCadena
MiCadena = Len("VBSCRIPT") MiCadena contiene 8.
Función LoadPicture
Devuelve un objeto de imagen. Sólo está disponible en plataformas de 32 bits.
Sintaxis : LoadPicture(nombredeimagen)
El argumento nombredeimagen es una expresión de cadena que indica el nombre
del archivo de imagen que se va a cargar.
Los formatos gráficos reconocidos por LoadPicture incluyen archivos de mapa de
bits (.bmp), archivos de iconos (.ico), archivos cifrados de longitud continua (.rle),
metaarchivos (.wmf), metaarchivos mejorados (.emf), archivos GIF (.gif) y archivos
JPEG (.jpg).
Funciones LTrim, RTrim y Trim
Devuelve una copia de una cadena sin espacios iniciales (LTrim), espacios finales
(RTrim) o ambos (Trim).
Sintaxis : LTrim(cadena)
RTrim(cadena) Trim(cadena)
Los siguientes ejemplos usan las funciones LTrim, RTrim y Trim para recortar
espacios iniciales, espacios finales y ambos, respectivamente:
Dim MiVar
MiVar = LTrim(" vbscript ")
MiVar = RTrim(" vbscript ")
MiVar = Trim(" vbscript ")
'MiVar contiene "vbscript ".
'MiVar contiene " vbscript".
'MiVar contiene "vbscript".
Función Mid
Devuelve un números especificado de caracteres a partir de una cadena.
Sintaxis : Mid(cadena, inicio[, longitud])
La sintaxis de la función Mid tiene los siguientes argumentos:
Parte
Descripción
cadena
Expresión de cadena a partir de la que se devuelven los caracteres. Si cadena
inicio
Posición de carácter en cadena en la que comienza la parte que se va a obtener.
Si inicio es mayor que el número de caracteres que hay en cadena, Mid devuelve
una cadena de longitud cero ("").
longitud Número de caracteres que se va a devolver. Si se omite o si hay menos caracteres
que longitud en el texto (incluido el carácter que está en la posición inicio), se
devuelven todos los caracteres desde la posición inicio hasta el final de la
cadena.
Para determinar el número de caracteres que hay en cadena, use la función Len.
29
Manual del Alumno
El siguiente ejemplo usa la función Mid para devolver seis caracteres, comenzando
en el cuarto carácter, en una cadena:
Dim MiVar
MiVar = Mid("VB Script es divertido", 4, 6) 'MiVar contiene
"Script".
Función Minute
Devuelve un número entero entre 0 y 59, ambos incluidos, que representa el
minuto de la hora.
Sintaxis : Minute(hora)
El argumento hora es cualquier expresión que puede representar una hora. Si hora
El siguiente ejemplo usa la función Minute para devolver el minuto de la hora:
Dim MiVar
MiVar = Minute(Now)
Función Month
Devuelve un número entero entre 1 y 12, ambos incluidos, que representa el mes
del año.
Sintaxis : Month(fecha)
El argumento fecha es cualquier expresión que pueda representar una fecha. Si
fecha contien Null, se devuelve Null.
El siguiente ejemplo usa la función Mes para devolver el mes actual:
Dim MiVar
MiVar = Month(Now) ' MiVar contiene el número
correspondiente al mes actual.
Función MonthName
Devuelve una cadena que indica el mes especificado.
Sintaxis : MonthName(mes[, abreviar])
La sintaxis de la función MonthName tiene las siguientes partes:
Parte
Descripción
mes
Requerido. La designación numérica del mes. Por ejemplo, enero es 1,
febrero es 2 y así sucesivamente.
abreviar
Opcional. Valor de tipo Boolean que indica si el nombre del mes se debe
abreviar. Si se omite, el valor predeterminado es False, que significa que el
nombre del mes no se debe abreviar.
El siguiente ejemplo usa la función MonthName para devolver un nombre de mes
abreviado para una expresión de fecha:
Dim MiVar
MiVar = MonthName(10, True) ' MiVar contiene "Oct".
30
Manual del Alumno
Función Now
Devuelve la fecha y hora actuales según la configuración de la fecha y hora de su
sistema.
Sintaxis : Now
El siguiente ejemplo usa la función Now para devolver la fecha y hora actuales:
Dim MiVar
MiVar = Now ' MiVar contiene la fecha y hora actuales.
Función RGB
Devuelve un número entero que representa un valor de un color RGB.
Sintaxis : RGB(rojo, verde, azul)
La función RGB tiene las siguientes partes:
Parte Descripción
rojo
Requerido. Número en el intervalo entre 0 y 255 que representa el componente rojo
del color.
verde
Requerido. Número en el intervalo entre 0 y 255 que representa el componente
verde del color.
azul
Requerido. Número en el intervalo entre 0 y 255 que representa el componente azul
del color.
Los métodos y propiedades de aplicaciones que aceptan una especificación de color
esperan que la especificación sea un número que represente un valor de un color
RGB. Un valor de un color RGB especifica la intensidad relativa de rojo, verde y azul
para producir la visualización de un color específico.
El byte menos significativo contiene el valor del rojo, el byte del medio contiene el
valor del verde y el byte más significativo contiene el valor del azul.
Para aplicaciones que requieren que el orden de los bytes se invierta, la siguiente
función proporcion la misma información con los bytes invertidos:
Function InvertirRGB(rojo, verde, azul)
InvertirRGB= CLng(azul + (verde * 256) + (rojo *
65536))
End Function
Se asume que el valor de cualquier argumento RGB que exceda 255, es 255.
Función Right
Devuelve un número de caracteres especificado a partir del lado derecho de una
cadena.
Sintaxis : Right(cadena, longitud)
La sintaxis de la función Right tiene los siguientes argumentos:
31
Manual del Alumno
Parte
Descripción
cadena
Expresión de cadena desde la que se devuelven los caracteres que están más a la
derecha. Si cadena contiene Null, se devuelve Null.
longitud Expresión numérica que indica cuántos caracteres se van a devolver. Si es igual a
0, se devuelve una cadena de longitud cero. Si es mayor o igual al número de
caracteres que hay en cadena, se devuelve toda la cadena.
Para determinar el número de caracteres que hay en cadena, use la función Len.
El siguiente ejemplo usa la función Right para devolver un número especificado de
caracteres a partir del lado derecho de una cadena:
Dim CualquierCadena, MiCad
CualquierCadena = "Hola mundo"
MiCad = Right(CualquierCadena, 1)
'Define la
' Devuelve
' Devuelve
' Devuelve
cadena.
"d".
" mundo".
"Hola mundo".
Función Rnd
Devuelve un número aleatorio.
Sintaxis : Rnd[(número)]
La función Rnd devuelve un valor menor que 1 pero mayor o igual a 0. El valor de
número determina cómo Rnd genera un número aleatorio:
Si número es
Rnd genera
Menor que cero
El mismo número cada vez, con número como semilla.
Mayor que cero
El siguiente número aleatorio de la secuencia.
Igual a cero
El último número generado.
No suministrado
El siguiente número aleatorio de la secuencia.
Para cualquier semilla inicial proporcionada, se genera la misma secuencia de
números porque cada llamada sucesiva a la función Rnd usa el número anterior
como semilla para el siguiente número de la secuencia.
Antes de llamar a Rnd, use la instrucción Randomize sin ningún argumento para
iniciar el generador de números aleatorios con una semilla basada en el reloj del
sistema.
Para producir enteros aleatorios dentro de un intervalo específico, use esta fórmula:
Int((límitesuperior - límiteinferior + 1) * Rnd +
límiteinferior)
Aquí, límitesuperior es el número más alto del intervalo y límiteinferior es el
número más bajo del intervalo.
32
Manual del Alumno
Función Round
Devuelve un número redondeado a un número especificado de posiciones
decimales.
Sintaxis : Round(expresión[, posicionesdecimales])
La sintaxis de la función Round tiene las siguientes partes:
Parte
Descripción
expresión
Requerido. Expresión numérica que se va a redondear.
posicionesdecimales Opcional. Número que indica cuántas posiciones a la derecha del
decimal se incluyen en el redondeo. Si se omite, la función Round
devuelve enteros.
El siguiente ejemplo usa la función Round para redondear un número a dos
posiciones decimales:
Dim MiVar, pi
pi = 3.14159
MiVar = Round(pi, 2) 'MiVar contiene 3.14.
Función Second
Devuelve un número entero entre 0 y 59, ambos incluidos, que representa el
segundo del minuto.
Sintaxis : Second(hora)
El argumento hora es cualquier expresión que pueda representar una hora. Si hora
El siguiente ejemplo usa la función Second para devolver el segundo actual:
Dim MiSeg
MiSeg = Second(Now) 'MiSeg contiene el número que
representa el segundo actual.
Función Sgn
Devuelve un entero que indica el signo de un número.
Sintaxis : Sgn(número)
Valores devueltos
La función Sgn devuelve los siguientes valores:
Si número es
Sgn devuelve
Mayor que cero
1
Igual a cero
0
Menor que cero
-1
El signo del argumento número determina el valor devuelto de la función Sgn.
El siguiente ejemplo usa la función Sgn para determinar el signo de un número:
Dim MiVar1, MiVar2, MiVar3, MiSigno
33
Manual del Alumno
MiVar1 = 12: MiVar2 = -2.4: MiVar3 = 0
MiSigno = Sgn(MiVar1)
' Devuelve 1.
' Devuelve -1.
' Devuelve 0.
Función Space
Devuelve una cadena que consta del número de espacios especificado.
Sintaxis : Space(número)
El argumento número es el número de espacios que desea en la cadena.
El siguiente ejemplo usa la función Space para devolver una cadena que consta de
un número de espacios especificado:
Dim MiCadena
MiCadena = Space(10)
' Devuelve una
cadena con 10 espacios.
MiCadena = "Hola" & Space(10) & "mundo" ' Inserta 10
espacios entre las dos cadenas.
Función Sqr
Devuelve la raíz cuadrada de un número.
Sintaxis : Sqr(número)
El argumento número puede ser cualquier expresión numérica válida mayor o igual
a 0.
El siguiente ejemplo usa la función Sqr para calcular la raíz cuadrada de un
número:
Dim MyRaiz
MyRaiz = Sqr(4)
MyRaiz = Sqr(23)
MyRaiz = Sqr(0)
MyRaiz = Sqr(-4)
'
'
'
'
Devuelve 2.
Devuelve 4.79583152331272.
Devuelve 0.
Genera un error en tiempo de ejecución.
Función String
Devuelve una cadena de caracteres repetidos de la longitud especificada.
Sintaxis : String(número, carácter)
La sintaxis de la función String tiene los siguientes argumentos:
Parte
Descripción
número
Longitud de la cadena devuelta. Si número contiene Null, se devuelve Null.
carácter Código de carácter que especifica el carácter o expresión de cadena cuyo primer
carácter se usa para generar la cadena devuelta. Si carácter contiene Null, se
devuelve Null.
Si especifica un número para carácter mayor que 255, String convierte el número
en un código de carácter válido con la fórmula:
carácter Mod 256
El siguiente ejemplo usa la función String para devolver cadenas de caracteres
repetidos de la longitud especificada:
34
Manual del Alumno
Dim MiCadena
MiCadena = String(5, "*")
MiCadena = String(5, 42)
MiCadena = String(10, "ABC")
' Devuelve "*****".
' Devuelve "*****".
' Devuelve "AAAAAAAAAA".
Función UBound
Devuelve el mayor subíndice disponible para la dimensión indicada de una matriz.
Sintaxis : UBound(nombredematriz[, dimensión])
La sintaxis de la función UBound tiene las siguientes partes:
Parte
Descripción
nombredematriz Requerido. nombre de la variable de matriz que cumple con el estándar
de asignación de nombres de variables.
dimensión
Opcional. Número entero que indica para qué dimensión se va a devolver
el límite superior. Use 1 para la primera dimensión, 2 para la segunda y
así sucesivamente. Si se omite dimensión, se asume que es igual a 1.
La función UBound se usa con la función LBound para determinar el tamaño de
una matriz. Use la función LBound para buscar el límite inferior de una dimensión
de una matriz.
El límite inferior de cualquier dimensión siempre es igual a 0. Como resultado,
UBound devuelve los siguientes valores para una matriz con estas dimensiones:
Dim A(100,3,4)
Instrucción
Valor devuelto
UBound(A, 1)
100
UBound(A, 2)
3
UBound(A, 3)
4
Función UCase
Devuelve una cadena que se convirtió en mayúsculas.
Sintaxis : UCase(cadena)
Sólo se convierten en mayúsculas las letras minúsculas; todas las letras
mayúsculas y caracteres que no son letras no cambian.
El siguiente ejemplo usa la función UCase para devolver una versión en
mayúsculas de una cadena:
Dim MiPalabra
MiPalabra = UCase("Hola mundo")
' Devuelve "HOLA MUNDO".
35
Manual del Alumno
Función VarType
Devuelve un valor que indica el subtipo de una variable.
Sintaxis : VarType(nombredevariable)
El argumento nombredevariable puede ser cualquier variable.
Valores devueltos
La función VarType devuelve los siguientes valores:
Constante
Valor
Descripción
vbEmpty
0
Empty (no iniciado)
vbNull
1
Null (datos no válidos)
vbInteger
2
Entero
vbLong
3
Entero largo
vbSingle
4
Número de coma flotante de precisión simple
vbDouble
5
Número de coma flotante de precisión doble
vbCurrency
6
Moneda
vbDate
7
Fecha
vbString
8
Cadena
vbObject
9
objeto de automatización
vbError
10
Error
vbBoolean
11
Valor de tipo Boolean
vbVariant
12
Valor de tipo Variant (sólo se usa con matrices de valores de tipo
Variant)
vbDataObject
13
Un objeto de acceso a datos
vbByte
17
Valor de tipo Byte
vbArray
8192
Matriz
Nota Estas constantes las especifica VBScript. Como resultado, los nombres se pueden usar en cualquier
parte del código en lugar de los valores reales.
Función Weekday
Devuelve un número entero que representa el día de la semana.
Sintaxis : Weekday(fecha, [primerdíasemana])
La sintaxis de la función Weekday tiene los siguientes argumentos:
Parte
Descripción
fecha
Cualquier expresión que pueda representar una fecha. Si fecha contiene
primerdíasemana Una constante que especifica el primer día de la semana. Si se omite, se
asume vbSunday.
36
Manual del Alumno
Valores
El argumento primerdíasemana tiene los siguientes valores:
Constante
Valor
Descripción
vbUseSystem
0
Usar configuración de API NLS.
vbSunday
1
Domingo
vbMonday
2
Lunes
vbTuesday
3
Martes
vbWednesday
4
Miércoles
vbThursday
5
Jueves
vbFriday
6
Viernes
vbSaturday
7
Sábado
Valores devueltos
La función Weekday puede devolver cualquiera de los siguientes valores:
Constante
Valor
Descripción
vbSunday
1
Domingo
vbMonday
2
Lunes
vbTuesday
3
Martes
vbWednesday
4
Miércoles
vbThursday
5
Jueves
vbFriday
6
Viernes
vbSaturday
7
Sábado
El siguiente ejemplo usa la función Weekday para obtener el día de la semana de
una fecha especificada:
Dim MiFecha, MiDiaDeLaSemana
MiFecha = #19 de octubre de 1962#
' Asigna una fecha.
MiDiaDeLaSemana = Weekday(MiFecha)
' MiDiaDeLaSemana
contiene 6 porque MiFecha representa un viernes.
Función WeekdayName
Devuelve una cadena que indica el día de la semana especificado.
Sintaxis : WeekdayName(díasemana, abreviar, primerdíasemana)
La sintaxis de la función WeekdayName tiene las siguientes partes:
Parte
Descripción
díasemana
Requerido. La designación numérica para el día de la semana. El valor
numérico de cada día depende de la configuración del valor
primerdíasemana.
abreviar
Opcional. Valor de tipo Boolean que indica si el nombre del día de la
semana se debe abreviar. Si se omite, el valor predeterminado es False,
que significa que el nombre del día de la semana no se abrevia.
37
Manual del Alumno
primerdíasemana Opcional. Valor numérico que indica el primer día de la semana.
Consulte la sección Valores para saber cuáles son los valores
permitidos.
Valores
El argumento primerdíasemana puede tener los siguientes valores:
Constante
Valor Descripción
vbUseSystem
0
vbSunday
1
Domingo (predeterminado)
vbMonday
2
Lunes
vbTuesday
3
Martes
vbWednesday
4
Miércoles
vbThursday
5
Jueves
vbFriday
6
Viernes
vbSaturday
7
Sábado
El siguiente ejemplo usa la función WeekDayName para devolver el día
especificado:
Dim MiFecha
MiFecha = WeekDayName(6, True)
'MiFecha contiene Vie.
Función Year
Devuelve un número entero que representa el año.
Sintaxis : Year(fecha)
El argumento fecha es cualquier expresión que pueda representar una fecha. Si
fecha contiene Null, se devuelve Null.
El siguiente ejemplo usa la función Year para obtener el año a partir de una fecha
especificada:
Dim MiFecha, MiAno
MiFecha = #19 de octubre de 1962#
' Asigna una fecha.
MiAno = Year(MiFecha)
' MiAno contiene 1962.
38
Manual del Alumno
Semana 5 : Procedimientos en VBScript
Procedimientos de VBScript
Tipos de procedimientos
En VBScript hay dos tipos de procedimientos; el procedimiento Sub y el
procedimiento Function.
Procedimientos Sub
Un procedimiento Sub es una serie de instrucciones de VBScript, entre
instrucciones Sub y End Sub, que ejecutan acciones pero no devuelven ningún
valor. Un procedimiento Sub puede tener argumentos (constantes, variables o
expresiones que se transfieren por una llamada a un procedimiento). Si un
procedimiento Sub no tiene argumentos, su instrucción Sub debe incluir un par de
paréntesis vacíos ().
El siguiente procedimiento Sub utiliza dos funciones de VBScript intrínsecas o
incorporadas, MsgBox y InputBox, para preguntar al usuario cierta información.
Después muestra los resultados del cálculo en base a esa información. El cálculo se
ejecuta en un procedimiento Function creado mediante VBScript. Se muestra en la
explicación del procedimiento Function a continuación.
Sub ConvertirTemp()
temp = InputBox("Escriba la temperatura en grados Farenheit.", 1)
MsgBox "La temperatura es de " & Celsius(temp) & " grados Celsius."
End Sub
Instrucción Sub
Declara el nombre, argumentos y código de que forman el cuerpo de un
procedimiento Sub.
Sintaxis : [Public | Private] Sub nombre [(listadeargumentos)]
[instrucciones]
[Exit Sub]
[instrucciones]
End Sub
La sintaxis de la instrucción Sub tiene las siguientes partes:
Parte
Descripción
Public
Indica que el procedimiento Sub es accesible desde todos los demás
procedimientos en todas las secuencias de comandos.
Private
Indica que el procedimiento Sub es accesible sólo desde los
procedimientos de la secuencia de comandos en la que se declara.
nombre
Nombre del procedimiento Sub; sigue la convención de nomenclatura
estándar de variables.
listadeargumentos Lista de variables que representan los argumentos pasados al
procedimiento Sub al ser llamado. Las distintas variables se separan
39
Manual del Alumno
con comas.
instrucciones
Cualquier grupo de instrucciones para ser ejecutadas dentro del cuerpo
del procedimiento Sub.
El argumento listadeargumentos tiene las siguiente sintaxis y las siguientes partes:
[ByVal | ByRef] nombredevariable[( )]
Parte
Descripción
ByVal
Indica que el argumento se pasa por valor.
ByRef
Indica que el argumento se pasa por referencia.
nombredevariable Nombre de la variable que representa el argumento; sigue la
convención de nomenclatura estándar de variables.
Si no se especifica explícitamente mediante Public o Private, los procedimientos
Sub son públicos de forma predeterminada, esto es, son visibles a todos los demás
procedimientos en la secuencia de comandos. El valor de las variables en un
procedimiento Sub no se preserva entre llamadas al procedimiento.
Todo el código ejecutable debe estar contenido en procedimientos. No se puede
definir un procedimiento Sub dentro de otro procedimiento Sub o Function.
La instrucción Exit Sub produce la salida inmediata del procedimiento Sub. La
ejecución del programa continúa con la instrucción siguiente a la que llamó al
procedimiento Sub. Puede aparecer cualquier número de instrucciones Exit Sub en
cualquier parte de un procedimiento Sub.
Como un procedimiento Function, un procedimiento Sub es un procedimiento
independiente que puede tomar argumentos, ejecutar una serie de instrucciones y
cambiar el valor de sus argumentos. Sin embargo, a diferencia de un procedimiento
Function, que devuelve un valor, un procedimiento Sub no puede utilizarse en una
expresión.
Puede llamar un procedimiento Sub mediante el nombre del procedimiento seguido
por la lista de argumentos. Vea la instrucción Call para obtener información
específica acerca de como llamar procedimientos Sub.
Procedimientos Function
Un procedimiento Function es una serie de instrucciones VBScript entre
instrucciones Function y End Function. Un procedimiento Function es similar a
un procedimiento Sub, pero también puede devolver un valor. Un procedimiento
Function puede tener argumentos (constantes, variables o expresiones que se
transfieren por una llamada a un procedimiento). Si un procedimiento Function no
tiene argumentos, su instrucción Function debe incluir un par de paréntesis vacíos.
Un procedimiento Function devuelve un valor asignando un valor a su nombre en
una o más instrucciones del procedimiento. El tipo de datos devuelto por un
procedimiento Function siempre es un tipo Variant.
En el siguiente ejemplo, la función Celsius calcula los grados Celsius a partir de
grados Fahrenheit. Cuando se llama a la función desde el procedimiento Sub
ConvertTemp, se transfiere a la función una variable que contiene el valor del
40
Manual del Alumno
argumento. El resultado del cálculo se devuelve al procedimiento que realizó la
llamada y se muestra en un cuadro de mensajes.
Sub ConvertirTemp()
temp = InputBox("Escriba la temperatura en grados Farenheit.", 1)
MsgBox "La temperatura es de " & Celsius(temp) & " grados Celsius."
End Sub
Function Celsius(fGrados)
Celsius = (fGrados - 32) * 5 / 9
End Function
Instrucción Function
Declara el nombre, argumentos y código que forma el cuerpo de un procedimiento
Function.
Sintaxis : [Public | Private] Function nombre [(listadeargumentos)]
[instrucciones]
[nombre = expresión]
[Exit Function]
[instrucciones]
[nombre = expresión]
End Function
La sintaxis de la instrucción Function tiene las siguientes partes:
Parte
Descripción
Public
Indica que el procedimiento Function es accesible para todos los
demás procedimientos de todas las secuencias de comandos.
Private
Indica que el procedimiento Function es accesible sólo para los demás
procedimientos de la secuencia de comandos donde está declarado.
nombre
Nombre de Function que cumple con las convenciones estándar de
asignación de nombres de variables.
listadeargumentos Lista de variables que representa los argumentos que se pasan al
procedimiento Function cuando se llama. Múltiples variables se
separan con comas.
instrucciones
Cualquier grupo de instrucciones que se va a ejecutar dentro del cuerpo
del procedimiento Function.
expresión
Valor devuelto por Function.
El argumento listadeargumentos tiene la siguiente sintaxis y partes:
[ByVal | ByRef] nombredevariable[( )]
Parte
Descripción
ByVal
Indica que el argumento se pasa por valor.
ByRef
Indica que el argumento se pasa por referencia.
nombredevariable Nombre de la variable que representa el argumento. Cumple con las
convenciones estándar de asignación de nombres de variables.
41
Manual del Alumno
Si no se especifica explícitamente mediane Public o Private, los procedimientos
Function son públicos de manera predeterminada, es decir, son visibles a todos los
demás procedimientos de su secuencia de comandos. El valor de las variables
locales de un procedimiento Function no se mantiene entre llamadas al
procedimiento.
Todo el código ejecutable debe estar contenido en procedimientos. No se puede
definir un procedimiento Function dentro de otro procedimiento Function o Sub.
La instrucción Exit Function produce una salida inmediata desde un procedimiento
Function. La exjecución del programa continúa con la instrucción siguiente a la
instrucción que llamó al procedimiento Function. Puede aparecer cualquier número
de instrucciones Exit Function en cualquier parte de un procedimiento Function.
Al igual que los procedimientos Sub, un procedimiento Function es un
procedimiento separado que puede recibir argumentos, realizar una seria de
instrucciones y cambiar los valores de sus argumentos. Sin embargo, a diferencia
de un procedimiento Sub, puede usar un procedimiento Function en la parte
derecha de una expresión de la misma forma que usa las funciones intrínsecas,
como Sqr, Cos o Chr, cuando desee usar el valor devuelto por la función.
Para llamar a un procedimiento Function se usa el nombre de la función, seguido
de la lista de argumentos entre paréntesis, en una expresión. Vea la instrucción
Call para obtener información específica acerca de cómo llamar procedimientos
Function.
Precaución Los procedimientos Function pueden ser recursivos; es decir, se pueden llamar a ellos
mismos para realizar una tarea determinada. Sin embargo, la recursividad puede producir un
desbordamiento de la pila.
Para devolver un valor desde una función, asigne el valor al nombre de la función.
Puede aparecer cualquier cantidad de asignaciones de ese tipo en cualquier lugar,
dentro del procedimiento. Si no se asigna ningún valor a nombre, el procedimiento
devuelve un valor predeterminado: una función numérica devuelve 0 y una función
de cadena devuelve una cadena de longitud cero (""). Una función que devuelve
una referencia a un objeto devuelve Nothing si no se asigna ninguna referencia de
objeto a nombre (mediante el uso de Set) dentro de Function.
El siguiente ejemplo muestra cómo asignar un valor devuelto a una función llamada
BusquedaBinaria. En este caso, se aigna False al nombre para indicar que no se
encontró algún valor.
Function BusquedaBinaria(. . .)
. . .
' Valor no encontrado. Devuelve un valor False.
If inferior > superior Then
BusquedaBinaria = False
Exit Function
End If
. . .
End Function
Las variables usadas en procedimientos Function pueden ser de dos categorías:
las que se declaran explícitamente dentro del procedimiento y las que no. Las
variables que se declaran explícitamente en un procedimiento (mediante el uso de
Dim o el equivalente) son siempre locales al procedimiento. Las variables que se
usan pero no se declaran explícitamente en un procedimiento también son locales a
42
Manual del Alumno
menos que se declaren explícitamente en un nivel superior desde fuera del
procedimiento.
Obtención de datos dentro y fuera de procedimientos
Cada fragmento de datos se transfiere a los procedimientos utilizando un
argumento. Los argumentos sirven como marcadores de posición para los datos
que desea transferir al procedimiento. Cuando crea un procedimiento utilizando la
instrucción Sub o la instrucción Function, se deben incluir paréntesis después del
nombre del procedimiento. Los argumentos se colocan dentro de estos paréntesis,
separados por comas. En el siguiente ejemplo, fGrados es un marcador de posición
para el valor que se va a transferir a la función Celsius para la conversión:
Function Celsius(fGrados)
Celsius = (fGrados - 32) * 5 / 9
End Function
Para obtener datos fuera de un procedimiento, debe utilizar un procedimiento
Function. Recuerde que un procedimiento Function puede devolver un valor,
mientras que un procedimiento Sub no puede hacerlo.
Uso de los procedimientos Sub y Function en código
Un procedimiento Function en el código, siempre se debe utilizar en la parte
derecha de una asignación de variable o en una expresión. Por ejemplo:
Temp = Celsius(fGrados)
o
MsgBox "La temperatura Celsius es de " & Celsius(fGrados) & " grados."
Para llamar a un procedimiento Sub desde otro procedimiento, escriba sólo el
nombre del procedimiento junto con los valores de los argumentos necesarios,
separados por una coma. La instrucción Call no se necesita, pero si la utiliza, debe
escrirbir los argumentos entre paréntesis.
El siguiente ejemplo muestra dos llamadas al procedimiento MiProc. Uno utiliza la
instrucción Call en el código y el otro no. Ambos procedimientos hacen
exactamente lo mismo.
Call MiProc(primerarg, segundoarg)
MiProc primerarg, segundoarg
Observe que los paréntesis se omiten en la llamada cuando no se utiliza la
instrucción Call.
43
Manual del Alumno
Semana 6 : Estructuras de control.
Uso de instrucciones condicionales
Control de la ejecución del programa
YPuede controlar el flujo de su secuencia de comandos con instrucciones
condicionales e instrucciones de bucle. Utilizando instrucciones condicionales, puede
escribir código de VBScript que tome decisiones y repita acciones. Las siguientes
instrucciones condicionales están disponibles en VBScript:
Instrucción If...Then...Else
Instrucción Select Case
Toma de decisiones utilizando If ... Then ... Else
La instrucción If...Then...Else sse utiliza para evaluar si una condición es True o
False y después especificar qué instrucciones ejecutar, dependiendo del resultado.
Normalmente, la condición es una expresión que utiliza un operador de
comparación para comparar un valor o una variable con otra. Para obtener más
información acerca de los operadores de comparación, consulte Operadores de
comparación. Las instrucciones If...Then...Else se pueden anidar en tantos niveles
como necesite.
Instrucción If...Then...Else
Ejecuta de manera condicional un grupo de instrucciones, según el valor de una
expresión.
Sintaxis :
If condición Then instrucciones[Else instruccioneselse]
O puede usar la sintaxis en forma de bloque:
If condición Then
[instrucciones]
[ElseIf condición-n Then
[instruccioneselseif]] . . .
[Else
[instruccioneselse]]
End If
La sintaxis de la instrucción If...Then...Else tiene las siguientes partes:
Parte
Descripción
condición
Uno o más de los siguientes dos tipos de expresiones:
Una expresión numérica o expresión de cadena que se evalúa a True o
False. Si condición es Null, condición se trata como False.
Una expresión de la forma TypeOf nombredeobjeto Is tipodeobjeto.
nombredeobjeto es cualquier referencia a un objeto y tipodeobjetoes
44
Manual del Alumno
cualquier tipo de objeto válido. La expresión es igual a True si
nombredeobjeto es el tipo de objeto especificado por tipodeobjeto; en
caso contrario es igual a False.
instrucciones
Una o más instrucciones separadas por dos puntos; que se ejecuta si
condición es True.
condición-n
Igual que condición.
instruccioneselseif Una o más instrucciones que se ejecutan si la condición-n asociada es
True.
instruccioneselse
Una o más instrucciones que se ejecutan si ninguna expresión
condición o condición-n anterior es igual a True.
Ejecución de instrucciones si una condición es True
Si sólo necesita ejecutar una instrucción cuando una condición es True, puede
utilizar la sintaxis de linea única de la instrucción If...Then...Else. El siguiente
ejemplo muestra la sintaxis de línea única; observe que este ejemplo omite la
palabra clave Else.
Sub FechaFija()
Dim miFecha
miFecha = #12/05/95#
If miFecha < Now Then miFecha = Now
End Sub
Si desea ejecutar más de una línea de código, debe utilizar la sintaxis de múltiples
líneas (o de bloque). Esta sintaxis incluye la instrucción End If, como se muestra
en el siguiente ejemplo:
Sub AvisoUsuario(valor)
If valor = 0 Then
EtiquetaAviso.ForeColor = vbRojo
EtiquetaAviso.Font.Bold = True
EtiquetaAviso.Font.Italic = True
End If
End Sub
Ejecución de ciertas instrucciones si la condición es True y
ejecución de otras si es False
Puede utilizar una instrucción If...Then...Else para definir dos bloques de
instrucciones ejecutables: un bloque que se ejecuta si la condición es True y otro
que se ejecuta si la condición es False.
Sub AvisoUsuario(valor)
If valor = 0 Then
EtiquetaAviso.ForeColor =
EtiquetaAviso.Font.Bold =
EtiquetaAviso.Font.Italic
Else
EtiquetaAviso.Forecolor =
EtiquetaAviso.Font.Bold =
vbRojo
True
= True
vbNegro
False
45
Manual del Alumno
EtiquetaAviso.Font.Italic = False
End If
End Sub
Decisión entre varias alternativas
Una variación en la instrucción If...Then...Else le permite elegir entre varias
alternativas. Agregar la cláusula ElseIf amplía la funcionalidad de la instrucción
If...Then...Else para que pueda controlar el flujo del programa basándose en
diferentes posibilidades. Por ejemplo:
Sub ValorDevuelto(valor)
If valor = 0 Then
MsgBox valor
ElseIf value = 1 Then
MsgBox valor
ElseIf value = 2 then
Msgbox valor
Else
Msgbox "¡Valor fuera de límites!"
End If
Puede agregar tantas cláusulas ElseIf como necesite para proporcionar opciones
alternativas. El uso intensivo de cláusulas ElseIf frecuentemente llega a ser
voluminosos. La mejor forma de elegir entre varias alternativas es la instrucción
Select Case.
Toma de decisiones utilizando Select Case
La estructura Select Case proporciona una alternativa a la ejecución de
If...Then...ElseIf selectivamente en un bloque de instrucciones de entre múltiples
bloques de instrucciones. Una instrucción Select Case proporciona una
funcionalidad similar a la instrucción If...Then...Else, pero hace el códgio más
eficiente y legible.
Una estructura Select Case trabaja con una expresión de comprobación sencilla
que se calcula una vez, al comienzo de la estructura. Después el resultado de la
expresión se compara con los valores para cada Case. Si existe una coincidencia,
se ejecuta el bloque de instrucciones asociado con ese Case:
Select Case Document.Formulario1.TipoTarjeta.Options(ÍndiceSeleccionado).Text
Case "MasterCard"
MostrarLogoMC
ValidarCuentaMC
Case "Visa"
MostrarLogoVisa
ValidarCuentaVisa
Case "American Express"
MostrarLogoAMEXCO
ValidarCuentaAMEXCO
Case Else
MostrarOtraImagen
VolverAPedir
End Select
46
Manual del Alumno
Observe que la estructura Select Case calcula una expresión una vez al comienzo
de la estructura. Por el contrario, la estructura If...Then...ElseIf puede evaluar
una expresión diferente en cada instrucción ElseIf. Sólo puede reemplazar una
estructura If...Then...ElseIf con una estructura Select Case si cada instrucción
ElseIf calcula la misma expresión.
Instrucción Select Case
Ejecuta uno de varios grupos de instrucciones, según el valor de una expresión.
Sintaxis
Select Case expresióndecomprobación
[Case listadeexpresiones-n
[instrucciones-n]] . . .
[Case Else listadeexpresiones-n
[instruccioneselse-n]]
End Select
La sintaxis de la instrucción Select Case tiene las siguientes partes:
Parte
Descripción
expresióndecomprobación Cualquier expresión numérica o expresión de cadena.
listadeexpresiones-n
Requerido si aparece Case. Lista delimitada de una o más
expresiones.
instrucciones-n
Una o más instrucciones que se ejecutan si
expresióndecomprobación coincide con cualquier parte de
listadeexpresiones-n.
instruccioneselse-n
Una o más instrucciones ejecutadas si
expresióndecomprobación no coincide con ninguna de las
cláusulas Case.
Si
expresióndecomprobación
coincide
con
alguna
expresión
Case
listadeexpresiones, las instrucciones que aparecen a continuación de la cláusula
Case se ejecutan hasta la siguiente cláusula Case, o para la última cláusula, hasta
End Select. Luego, el control pasa a la instrucción que sigue a End Select. Si
expresióndecomprobación coincide con una expresión listadeexpresiones en más de
una cláusula Case, sólo se ejecutan las instrucciones que siguen a la primera
coincidencia.
La cláusula Case Else se usa para indicar que se ejecute instruccioneselse si no se
encuentra
ninguna
coincidencia
entre
expresióndecomprobación
y
una
listadeexpresiones en cualquier otra selección Case. Aunque no es necesario, es
una buena idea tener una instrucción Case Else en su bloque Select Case para
controlar los valores de expresióndecomprobación imprevistos. Si ningún Case
listadeexpresiones coincide con expresióndecomprobación y no hay una instrucción
Case Else, la ejecución continúa en la instrucción siguiente a End Select.
Las instrucciones Select Case se pueden anidar. cada instrucción Select Case
anidada debe tener una instrucción End Select correspondiente.
El siguiente ejemplo muestra el uso de la instrucción Select Case:
47
Manual del Alumno
Dim Color, MiVar
Sub CambiarFondo (Color)
MiVar = lcase (Color)
Select Case MiVar
Case "rojo"
document.bgColor = "red"
Case "verde" document.bgColor = "green"
Case "azul"
document.bgColor = "blue"
Case Else
MsgBox "seleccione otro color"
End Select
End Sub
Bucles mediante código
Uso de bucles para repetir código
Los bucles le permiten ejecutar un grupo de instrucciones de forma repetida.
Algunos bucles repiten instrucciones hasta que una condición es False; otros
repiten instrucciones hasta que la condición es True. También hay bucles que
repiten instrucciones un número de veces específico.
En VBScript están disponibles las siguientes instrucciones de bucles:
Do...Loop: ejecuta el bucle mientras o hasta que una condición es
True
While...Wend: ejecuta el bucle mientras una condición es True
For...Next: utiliza un contador para ejecutar instrucciones un
número de veces específico
For Each...Next: Repite un grupo de instrucciones para cada
elemento de una colección o para cada elemento de una matriz.
Uso de bucles Do
Puede utilizar las instrucciones Do...Loop para ejecutar un bloque de instrucciones
un número de veces indefinido. Las instrucciones se repiten mientras una condición
es True o hasta que una condición pasa a ser True.
Instrucción Do...Loop
Repite un bloque de instrucciones mientras una condición es True o hasta que una
condición es True.
48
Manual del Alumno
Sintaxis
Do [{While | Until} condición]
[instrucciones]
[Exit Do]
[instrucciones]
Loop
O puede usar la sintaxis:
Do
[instrucciones]
[Exit Do]
[instrucciones]
Loop [{While | Until} condición]
La sintaxis de la instrucción Do...Loop tiene las siguientes partes:
Parte
Descripción
condición
Expresión numérica o expresión de cadena que es True o False. Si
condición es Null, condición se trata como False.
instrucciones Una o más instrucciones que se repiten mientras o hasta que condición es
True.
Repetición de instrucciones mientras una condición es
True
Utilice la palabra clave While para comprobar una condición en una instrucción
Do...Loop. Puede comprobar la condición antes de entrar en el bucle (como se
muestra en el ejemplo CompPrimerWhile a continuación) o puede comprobarla
después de que el bucle se haya ejecutado al menos una vez (como se muestra en
el ejemplo CompUltimoWhile). En el procedimiento CompPrimerWhile, si miNum se
establece a 9 en lugar de 20, las instrucciones que hay dentro del bucle nunca se
ejecutarían. En el procedimiento CompUltimoWhile, las instrucciones que hay
dentro del bucle sólo se ejecutan una vez porque la condición ya es False.
Sub CompPrimerWhile()
Dim contador, miNum
contador = 0
miNum = 20
Do While miNum > 10
miNum = miNum - 1
contador = contador + 1
Loop
MsgBox "El bucle realizó " & contador & " repeticiones."
End Sub
Sub CompUltimoWhile()
Dim contador, miNum
contador = 0
49
Manual del Alumno
miNum = 9
Do
miNum = miNum - 1
Loop While miNum > 10
End Sub
Repetición de una instrucción hasta que una condición
pasa a ser True
Puede utilizar la palabra clave Until de dos formas para comprobar una condición
en una instrucción Do...Loop. Puede comprobar la condición antes de entrar en el
bucle (como se muestra en el ejemplo CompPrimerUntil) o puede comprobarla
después de que el bucle se haya ejecutado al menos una vez (como se muestra en
el ejemplo CompUltimoUntil). Mientras la condición es False se ejecuta el bucle.
Sub CompPrimerUntil()
Dim contador, miNum
contador = 0
miNum = 20
Do Until miNum = 10
miNum = miNum - 1
Loop
End Sub
Sub CompUltimoUntil()
Dim contador, miNum
contador = 0
miNum = 1
Do
miNum = miNum + 1
Loop Until miNum = 10
End Sub
Salida de una instrucción Do ... Loop desde dentro del
bucle
Puede salir de una instrucción Do ... Loop utilizando la instrucción Exit Do. Puesto
que normalmente desea salir sólo en ciertas situaciones, como evitar un bucle sin
fin, debe utilizar la instrucción Exit Do en el bloque de instrucciones True de una
instrucción If...Then...Else. Si la condición es False, el bucle se ejecuta
normalmente.
En el siguiente ejemplo, miNum se asigna a un valor que crea un bucle sin fin. La
instrucción If...Then...Else comprueba esta condición, impidiendo la repetición
infinita.
Sub EjemploSalir()
Dim contador, miNum
contador = 0
miNum = 9
50
Manual del Alumno
Do Until miNum = 10
miNum = miNum - 1
If miNum < 10 Then Exit Do
Loop
End Sub
Uso de While ... Wend
La instrucción While ... Wend se proporciona en VBScript para las personas que
están familiarizadas con su uso. Sin embargo, se recomienda que utilice Do ...
Loop debido a la escasa flexibilidad de la instrucción While ... Wend.
Instrucción While...Wend
Ejecuta una serie de instrucciones mientras un condición dada se evalúe como
True.
Sintaxis :
While condición
[instrucciones]
Wend
La sintaxis de la instrucción While...Wend tiene las siguientes partes:
Parte
Descripción
condición
expresión numérica o expresión de cadena que se evalúa como True o
False. Si condición es Null, condición se trata como False.
instrucciones Una o más instrucciones ejecutadas mientras la condición se evalúe como
True.
Si condición se evalúa como True, todas las instrucciones en instrucciones se
ejecutan hasta que se encuentre la instrucción Wend. Entonces el control vuelve a
la instrucción While y condición se comprueba de nuevo. Si condición se sigue
evaluando como True, el proceso se repite. Si no se evalúa como True, la
ejecución continua con la instrucción que sigue a la instrucción Wend.
Los bucles While...Wend se pueden anidar en cualquier nivel. Cada Wend coincide
con el While más cercano.
Uso de For ... Next
Puede utilizar las instrucciones For...Next para ejecutar un bloque de instrucciones
un número de veces específico. Para bucles, utilice una variable de tipo contador
cuyo valor aumente o disminuya con cada repetición del bucle.
51
Manual del Alumno
Por ejemplo, el siguiente procedimiento ejecuta 50 veces un procedimiento llamado
MiProc. La instrucción For especifica la variable de tipo contador x y los valores
inicial y final de la misma. La instrucción Next aumenta la variable de tipo contador
de 1 en 1.
Sub HazMiProc50Veces()
Dim x
For x = 1 To 50
MiProc
Next
End Sub
Utilizando la palabra clave Step puede aumentar o disminuir la variable tipo
contador en el valor que especifique. En el siguiente ejemplo, la variable tipo
contador aumenta de 2 en 2 cada vez que se repite el bucle. Cuando el bucle
finaliza, total es la suma de 2, 4, 6, 8 y 10.
Sub TotalesdePares()
Dim j, total
For j = 2 To 10 Step 2
total = total + j
Next
MsgBox "El total es " & total
End Sub
Para disminuir la variable tipo contador, utilice un valor Step negativo. Cuando lo
haga, debe especificar un valor final que sea menor que el valor inicial. En el
siguiente ejemplo, la variable tipo contador miNum disminuye de 2 en 2 cada vez
que se repite el bucle. Cuando el bucle termina, total es la suma de 16, 14, 12, 10,
8, 6, 4 y 2.
Sub NuevoTotal()
Dim miNum, total
For miNum = 16 To 2 Step -2
total = total + miNum
Next
MsgBox "El total es " & total
End Sub
Puede salir de cualquier instrucción For...Next antes de que el contador alcance su
valor final utilizando la instrucción Exit For. Como normalmente desea salir sólo en
ciertas situaciones, como cuando se produce un error, debe utilizar la instrucción
Exit For en el bloque de instrucciones True de una instrucción If...Then...Else. Si
la condición es False, el bucle se ejecuta normalmente.
Instrucción For...Next
Repite un grupo de instrucciones un número especificado de veces.
Sintaxis :
For contador = inicio To fin [Step paso]
[instrucciones]
[Exit For]
[instrucciones]
Next
52
Manual del Alumno
La sintaxis de la instrucción For...Next tiene las siguientes partes:
Parte
Descripción
contador
Variable numérica que se usa como contador de bucle. La variable no puede
ser un elemento de una matriz o un elemento de un tipo definido por el
usuario.
inicio
Valor inicial de contador.
fin
Valor final de contador.
paso
Cantidad que se cambia contador cada vez que se ejecuta el bucle. Si no se
especifica, el valor predeterminado de paso es uno.
instrucciones Una o más instrucciones entre For y Next que se ejecutan el número de
veces especificado.
El argumento paso puede ser positivo o negativo. El valor del argumento paso
determina el procesamiento del bucle como se indica a continuación:
Valor
El bucle se ejecuta si
Positivo o 0
contador <= fin
Negativo
contador >= fin
Una vez iniciado el bucle y una vez se comienzan a ejecutar todas las instrucciones
del bucle, se suma paso a contador. En este punto, las instrucciones del bucle se
vuelven a ejecutar (basado en la misma comprobación que produjo la ejecución
inicial del bucle), o se sale del bucle y continúa la ejecución con la instrucción que
sigue a la instrucción Next.
Uso de For Each...Next
Un bucle For Each...Next es parecido a un bucle For...Next. En lugar de repetir
las instrucciones un número determinado de veces , un bucle For Each...Next
repite un grupo de instrucciones para cada elemento de una colección de objetos
para cada elemento de una matriz. Esto es especialmente útil si no desea conocer
cuántos elementos hay en una colección.
En el ejemplo de código HTML completo siguiente, el contenido de un objeto
Dictionary se utiliza para colocar texto en varios cuadros de texto:
<HTML>
<HEAD><TITLE>Formularios y elementos</TITLE></HEAD>
<!-Sub cmdCambiar_OnClick
Dim d
'Crea una variable
Set d = CreateObject("Scripting.Dictionary")
d.Add "0", "Atenas"
'Agrega algunas claves y elementos
d.Add "1", "Belgrado"
d.Add "2", "El Cairo"
For Each I in d
53
Manual del Alumno
Document.frmForm.Elements(I).Value = D.Item(I)
Next
End Sub
-->
</SCRIPT>
<BODY>
<CENTER>
<FORM NAME="frmForm"
<Input Type = "Text"><p>
<Input Type = "Button" NAME="cmdCambiar" VALUE="Haga clic aquí"><p>
</FORM>
</CENTER>
</BODY>
</HTML>
Instrucción For Each...Next
Repite un grupo de instrucciones para cada elemento de una matriz o colección.
Sintaxis :
For Each elemento In grupo
[instrucciones]
[Exit For]
[instrucciones]
Next [elemento]
La sintaxis de la instrucción For Each...Next tiene las siguientes partes:
Parte
Descripción
elemento
Variable que se usa para iterar por los elementos de la colección o matriz.
Para colecciones, elemento sólo puede ser una variable Variant, una
variable Object genérica o cualquier variable de objeto de automatización
específica. Para matrices, elemento sólo puede ser una variable Variant.
grupo
Nombre de una matriz o colección de objetos.
instrucciones Una o más instrucciones que se ejecutan en cada elemento de grupo.
Se entra en el bloque For Each si al menos hay un elemento en grupo. Una vez
que se ha entrado en el bucle, se ejecutan todas las instrucciones del bucle para el
primer elemento de grupo. Mientras haya más elementos en grupo, las
instrucciones del bucle se siguen ejecutando para cada elemento. Cuando no hay
más elementos en grupo, se sale del bucle y continúa la ejecución con la instrucción
que sigue a la instrucción Next.
Exit For sólo se puede usar dentro de una estructura de control For Each...Next o
For...Next para proporcionar una forma alternativa de salir. Se puede colocar
cualquier cantidad de instrucciones Exit For en cualquier parte del bucle. Exit For
se suele usar con la evaluación de algunas condiciones (por ejemplo, If...Then), y
transfiere el control a la instrucción siguiente a Next.
54
Manual del Alumno
Puede anidar bucles For Each...Next colocando un bucle For Each...Next dentro
de otro. Sin embargo, cada elemento del bucle debe ser único.
Nota Si omite elemento en una instrucción Next, la ejecución continúa como si lo hubiera incluido. Si se
encuentra una instrucción Next antes de su instrucción For correspondiente, se produce un error.
El siguiente ejemplo muestra el uso de la instrucción For Each...Next:
Function MostrarListaDeCarpetas(especificaciondecarpeta)
Dim fso, f, f1, fc, s
Set fso = CreateObject("Scripting.FileSystemObject")
Set f = fso.GetFolder(especificaciondecarpeta)
Set fc = f.Files
For Each f1 in fc
s = s & f1.name
s = s & "<BR>"
Next
MostrarListaDeCarpetas = s
End Function
55
Manual del Alumno
Semana 7 : Cadenas y números.
Operador de Concatenación &
Se utiliza para forzar la concatenación de las cadenas de dos expresiones.
Sintaxis : resultado = expresión1 & expresión2
La sintaxis del operador & consta de las siguientes partes:
Parte
Descripción
resultado
Cualquier variable.
expresión1
Cualquier expresión.
expresión2
Si una expresión no es una cadena de caracteres, se convierte en un tipo String. Si
ambas expresiones son Null, el resultado también es Null. Sin embargo, si sólo
una expresión es Null, esa expresión se considera como una cadena de longitud
cero al concatenarse con la otra expresión. Cualquier expresión Empty se considera
también una cadena de longitud cero.
Null
Un valor que indica que una variable no contiene datos válidos. Null es el
resultado de:
Una asignación explícita de Null a una variable.
Cualquier operación entre expresiones que contienen Null.
Empty
Un valor que indica que una variable no tiene asignado ningún valor inicial.
Las variables Empty son iguales a 0 en un contexto numérico o de longitud
cero ("") en un contexto de cadena.
Operador +
Se utiliza para sumar dos números.
Sintaxis : resultado = expresión1+expresión2
La sintaxis del operador + consta de estas partes:
56
Manual del Alumno
Parte
Descripción
resultado
Cualquier variable numérica.
expresión1
expresión2
Cuando utilice el operador + para concatenar dos cadenas de tipo carácter, debería
utilizar el operador & para que la concatenación elimine la ambigüedad y
proporcione código de documentación propia.
Cuando utilice el operador +, no será capaz de determinar si se producirá una
suma o una concatenación de cadenas.
El subtipo base de las expresiones determina el comportamiento del operador + del
siguiente modo:
Si
Entonces
Ambas expresiones son numéricas
Suma.
Ambas expresiones son del tipo String
Concatenación.
Una expresión es de un tipo de datos numérico y la otra de tipo String
Suma.
Si una de las expresiones o ambas son expresiones de tipo Null, resultado es Null.
Si ambas expresiones son Empty, resultado es Integer. Sin embargo, sólo una de
las expresiones es Empty, se devuelve la otra sin modificaciones como resultado.
Operadores de comparación
Utilizado para comparar expresiones.
Sintaxis :
resultado = expresión1 operadorcomparación expression2
resultado = objeto1 Is objeto2
Los operadores de comparación constan de las siguientes partes:
Parte
Descripción
resultado
Cualquier variable numérica.
expresión
operadorcomparación
Cualquier operador de comparación.
objeto
Cualquier nombre de objeto.
57
Manual del Alumno
El operador Is tiene una funcionalidad de comparación específica que se diferencia
de los operadores en la siguiente tabla. Ésta contiene una lista de operadores de
comparación y las condiciones que determinan si resultado es True, False o Null:
Operador Descripción
True si
False si
Null si
<
Menor que
expresión1 <
expresión2
expresión1 >=
expresión2
expresión1 o
expresión2 = Null
<=
Menor o igual
que
expresión1 <=
expresión2
expresión1 >
expresión2
expresión1 o
expresión2 = Null
>
Mayor que
expresión1 >
expresión2
expresión1 <=
expresión2
expresión1 o
expresión2 = Null
>=
Mayor o igual
que
expresión1 >=
expresión2
expresión1 <
expresión2
expresión1 o
expresión2 = Null
=
Igual a
expresión1 =
expresión2
expresión1 <>
expresión2
expresión1 o
expresión2 = Null
<>
Distinto de
expresión1 <>
expresión2
expresión1 =
expresión2
expresión1 o
expresión2 = Null
Cuando compara dos expresiones, puede no ser capaz de determinar fácilmente si
las expresiones se están comparando como números o como cadenas.
La siguiente tabla muestra cómo se comparan las expresiones o qué resulta de la
comparación, dependiendo del subtipo base:
Si
entonces
Las dos expresiones son
numéricas
Realiza una comparación numérica.
cadenas
Realiza una comparación de cadena.
Una expresión es numérica y la La expresión numérica es menor que la expresión de
otra es una cadena
cadena.
Una expresión es Empty y la
otra es numérica
Ejecuta una comparación numérica, utilizando 0 para la
expresión Empty.
Una expresión es Empty y la
otra es una cadena
Ejecuta una comparación de cadena, utilizando una
cadena de longitud cero para la expresión Empty.
Empty
Las expresiones son iguales.
58
Manual del Alumno
Función InStr
Devuelve la posición de la primera coincidencia de una cadena dentro de otra.
Sintaxis : InStr([inicio, ]cadena1, cadena2[, comparación])
La sintaxis de la función InStr tiene los siguientes argumentos:
Parte
Descripción
inicio
Opcional. Expresión numéricaque establece la posición inicial para cada
búsqueda. Si se omite, la búsqueda comienza en la posición del primer
carácter. Si inicio contiene Null, se produce un erro. El argumento inicio se
requiere si se especifica comparación.
cadena1
Requerido. Expresión de cadena en la que se busca.
cadena2
Requerido. Expresión de cadena buscada.
comparación Opcional. Valor numérico que indica el tipo de comparación que se va a
usar al evaluar subcadenas. Consulte la sección Valores para saber cuáles
son los valores permitidos. Si se omite, se realiza una comparación binaria.
Valores
El argumento comparación puede tener los siguientes valores:
Constante
Valor
Descripción
vbBinaryCompare
0
Realiza una comparación binaria.
vbTextCompare
1
Realiza una comparación de texto.
Valores devueltos
La función InStr devuelve los siguientes valores:
Si
InStr devuelve
cadena1 es de longitud cero
0
cadena1 es Null
Null
cadena2 es de longitud cero
inicio
cadena2 es Null
Null
cadena2 no se encuentra
0
cadena2 se encuentra dentro de cadena1
Posición en la que se encuentra la coincidencia
inicio > Len(cadena2)
0
Función IsNumeric
Devuelve un valor de tipo Boolean que indica si una expresión se puede evaluar
como un número.
59
Manual del Alumno
Sintaxis : IsNumeric(expresión)
El argumento expresión puede ser cualquier expresión.
IsNumeric devuelve True si toda la expresión se reconoce como un número. De lo
contrario, devuelve False. IsNumeric devuelve False si expresión es una
expresión de fecha.
El siguiente ejemplo usa la función IsNumeric para determinar si una variable se
puede evaluar como un número:
Dim MiVar, MiComprobacion
MiVar = 53
' Asigna un valor.
MiComprobacion = IsNumeric(MiVar) ' Devuelve True.
MiVar = "459.95"
' Asigna un valor.
MiComprobacion = IsNumeric(MiVar) ' Devuelve True.
MiVar = "45 Help"
' Asigna un valor.
MiComprobacion = IsNumeric(MiVar) ' Devuelve False.
Formateo de Números
Función FormatNumber
Devuelve una expresión con formato de número.
Sintaxis :
FormatNumber(Expresión [,NúmDígitosDespuésDeDecimal
[,IncluirDígitoInicio [,UsarParéntesisParaNúmerosNegativos
[,GrupoDígitos]]]])
La sintaxis de la función FormatNumber tiene las siguientes partes:
Parte
Descripción
Expresión
Requerido. Expresión a la que se va a aplicar
formato.
NúmDígitosDespuésDeDecimal
Opcional. Valor numérico que indica cúantos
lugares se muestran a la derecha del decimal. El
valor predeterminado es -1, que indica que se usa
la configuración regional del equipo.
IncluirDígitoInicio
Opcional. Constante de tres estados que indica si
se debe mostrar o no un cero inicial para valores
fraccionarios. Consulte la sección Valores para
saber cuáles son los valores permitidos.
60
Manual del Alumno
UsarParéntesisParaNúmerosNegativos Opcional. Constante de tres estados que indica si
se deben encerrar o no los valores negativos entre
paréntesis. Consulte la sección Valores para saber
cuáles son los valores permitidos.
GrupoDígitos
se deben agrupar o no los números con el
delimitador de grupos especificado en el Panel de
control. Consulte la sección Valores para saber
Valores
Los argumentos IncluirDígitoInicio, UsarParéntesisParaNúmerosNegativos y
GrupoDígitos tienen los siguientes valores:
Constante
Valor Descripción
TristateTrue
-1
True
TristateFalse
0
False
TristateUseDefault
-2
Usa la configuración regional del equipo.
Cuando se omiten uno o más de los argumentos opcionales, los valores de los
argumentos omitidos los proporciona la configuración regional del equipo.
Nota Toda la información de configuración y valores se obtiene de la ficha Número de Configuración
regional.
El siguiente ejemplo usa la función FormatNumber para dar formato a un número
para que tenga cuatro lugares decimales:
Function EjemploDeFormatNumber
Dim MiAngulo, MiSecante, MiNumero
MiAngulo = 1.3
' Define un ángulo en radianes.
MiSecante = 1 / Cos(MiAngulo) ' Calcula la secante.
EjemploDeFormatNumber = FormatNumber(MiSecante,4) ' Da formato a MiSecante para que
tenga cuatro lugares decimales.
End Function
Función FormatCurrency
Devuelve una expresión con formato como una valor de moneda, que usa el
símbolo de moneda definido en el panel de control del sistema.
61
Manual del Alumno
Sintaxis :
FormatCurrency(Expresión[,NúmDígitosDespuésDeDecimal
La sintaxis de la función FormatCurrency tiene las siguientes partes:
Parte
Descripción
Expresión
Requerido. Expresión a la que se va a aplicar el
formato.
GrupoDígitos
delimitador de grupos especificado en la
configuración regional del equipo. Consulte la
sección Valores para saber cuáles son los valores
permitidos.
Valores
Los argumentos IncluirDígitoInicio, UsarParéntesisParaNúmerosNegativos y
Constante
Valor Descripción
TristateTrue
-1
True
TristateFalse
0
False
TristateUseDefault
-2
Cuando se omiten uno o más argumentos opcionales, los valores de los argumentos
omitidos los proporciona la configuración regional del equipo. La posición del signo
62
Manual del Alumno
de moneda relativa al valor de moneda se determina con la configuración regional
del sistema.
Nota Toda la información de configuración se obtiene de la ficha Moneda de Configuración regional,
excepto el cero inicial que se obtiene de la ficha Número.
El siguiente ejemplo usa la función FormatCurrency para dar formato de moneda
a la expresión y asignarlo a MiMoneda:
Dim MiMoneda
MiMoneda = FormatCurrency(1000)
'MiMoneda contiene $1000.00
Función FormatPercent
Devuelve una expresión con formato de porcentaje (multiplicada por 100) con una
carácter % inicial.
Sintaxis :
FormatPercent(Expresión[,NúmDígitosDespuésDeDecimal
La sintaxis de la función FormatPercent tiene las siguientes partes:
Parte
Descripción
Expresión
Requerido. Expresión a la que se va a aplicar
formato.
GrupoDígitos
delimitador de grupos especificado en el Panel de
control. Consulte la sección Valores para saber
63
Manual del Alumno
Valores
Los argumentos IncluirDígitoInicio, UsarParéntesisParaNúmerosNegativos
Constante
y
Valor Descripción
TristateTrue
-1
True
TristateFalse
0
False
TristateUseDefault
-2
Cuando se omiten uno o más argumentos opcionales, los valores de los argumentos
omitidos los proporciona la configuración regional del sistema.
Nota Toda la información de configuración y valores se obtiene de la ficha Número de Configuración
regional.
El siguiente ejemplo usa la función FormatPercent para dar formato a una
expresión como porcentaje:
Dim MiPorcentaje
MiPorcentaje = FormatPercent(2/32) 'MiPorcentaje contiene 6.25%
InputBoxes y Message Box
Función InputBox
Muestra una solicitud en un cuadro de diálogo, espera a que el usuario escriba
texto o haga clic en un botón y devuelve el contenido del cuadro de texto.
Sintaxis : InputBox(solicitud[, título][, predeterminado][, posx][,
posy][, archivodeayuda, contexto])
La sintaxis de la función InputBox tiene los siguientes argumentos:
Parte
Descripción
solicitud
Expresión de cadena mostrada como mensaje en el cuadro de diálogo. La
longitud máxima de solicitud es, aproximadamente, 1024 caracteres,
dependiendo del ancho de los caracteres usados. Si solicitud consta de
más de una línea, puede separar las líneas con un carácter de retorno de
carro (Chr(13)), un carácter de avance de línea (Chr(10)) o la
combinación de retorno de carro y avance de línea (Chr(13) & Chr(10))
entre cada línea.
título
Expresión de cadena que se muestra en la barra de título del cuadro de
diálogo. Si omite título, el nombre de la aplicación se muestra en la barra
de título.
predeterminado Expresión de cadena en el cuadro de texto que aparece como respuesta
64
Manual del Alumno
predeterminada si no se proporciona ningún otro texto. Si omite
predeterminado, el cuadro de texto se muestra vacío.
posx
Expresión numérica que especifica, en twips, la distancia horizontal
desde el borde izquierdo del cuadro de diálogo hasta el borde izquierdo
de la pantalla. Si se omite posx, el cuadro de diálogo se centra
horizontalmente.
posy
Expresión numérica que especifica, en twips, la distancia vertical desde
el borde superior del cuadro de diálogo hasta el borde superior de la
pantalla. Si se omite posy, el cuadro de diálogo se centra verticalmente,
aproximadamente a la altura de un tercio de la pantalla.
archivodeayuda Expresión de cadena que identifica el archivo de Ayuda que se va a usar
para proporcionar Ayuda contextual para el cuadro de diálogo. Si se
proporciona archivodeayuda, también se debe proporcionar contexto.
contexto
Expresión numérica que identifica el número de contexto de Ayuda
asignado por el creador de la Ayuda al tema de Ayuda adecuado. Si se
proporciona contexto, también se debe proporcionar archivodeayuda.
Función MsgBox
Muestra un mensaje en un cuadro de diálogo, espera a que el usuario haga clic en
un botón y devuelve un valor que indica en qué botón hizo clic el usuario.
Sintaxis : MsgBox(solicitud[, botones][, título][, archivodeayuda,
contexto])
La sintaxis de la función MsgBox tiene los siguientes argumentos:
Parte
Descripción
solicitud
Expresión de cadena que se muestra como mensaje en el cuadro de
diálogo. La longitud máxima de solicitud es aproximadamente igual a
1024 caracteres, según el ancho de los caracteres usados. Si solicitud
consta de más de una línea, puede seperar las líneas con un carácter de
retorno de carro (Chr(13)), un carácter de avance de línea (Chr(10)) o la
combinación de caracteres de retorno de carro y avance de línea
(Chr(13) y Chr(10)) entre cada línea.
botones
Expresión numérica que es igual a la suma de los valores que especifican
la cantidad y el tipo de botones que se van a mostrar, el estilo de icono
que se va a usar, la identidad del botón predeterminado y el modo de
cuadro de diálogo. Consulte la sección Valores para saber cuáles son los
valores permitidos. Si se omite, el valor predeterminado de botones es 0.
título
Expresión de cadena que se muestra en la barra de título del cuadro de
diálogo. Si omite título, el nombre de la aplicación aparece en la barra de
título.
archivodeayuda Expresión de cadena que identifica el archivo de Ayuda que se va a usar
para proporcionar Ayuda contextual para el cuadro de diálogo. Si se
proporciona archivodeayuda, también se debe proporcionar contexto. No
está disponible en plataformas de 16 bits.
contexto
Expresión numérica que identifica el número de contexto de Ayuda
asignado por el creador de la Ayuda al tema de Ayuda adecuado. Si se
proporciona contexto, también se debe proporcionar archivodeayuda. No
está disponible en plataformas de 16 bits.
65
Manual del Alumno
Valores
Los valores del argumento botones son:
Constante
Valor Descripción
vbOKOnly
0
Sólo muestra el botón Aceptar.
vbOKCancel
1
Muestra los botones Aceptar y Cancelar.
vbAbortRetryIgnore
2
Muestra los botones Anular, Reintentar e Ignorar.
vbYesNoCancel
3
muestra los botones Sí, No y Cancelar.
vbYesNo
4
Muestra los botones Sí y No.
vbRetryCancel
5
Muestra los botones Reintentar y Cancelar.
vbCritical
16
Muestra el icono de mensaje crítico.
vbQuestion
32
Muestra el icono de consulta de advertencia.
vbExclamation
48
Muestra el icono de mensaje de advertencia.
vbInformation
64
Muestra el icono de mensaje de información.
vbDefaultButton1
0
vbDefaultButton2
256
El segundo botón es el botón predeterminado.
vbDefaultButton3
512
El tercer botón es el botón predeterminado.
vbDefaultButton4
768
El cuarto botón es el botón predeterminado.
0
vbApplicationModal
vbSystemModal
4096
El primer botón es el botón predeterminado.
Aplicación modal; el usuario debe responder al cuadro de
mensaje antes de seguir trabajando en la aplicación actual.
Sistema modal; todas las aplicaciones se suspenden hasta
que el usuario responde al cuadro de mensaje.
El primer grupo de valores (0 a 5) describe el número y el tipo de botones
mostrados en el cuadro de diálogo; el segundo grupo (16, 32, 48, 64) describe el
estilo de iconos; el tercer grupo (0, 256, 512, 768) determina cuál es el botón
predeterminado y el cuarto grupo (0, 4096) determina el modo del cuadro de
mensaje. Al sumar números para crear un valor final para el argumento botones,
use sólo un número de cada grupo.
Valores devueltos
La función MsgBox devuelve los siguientes valores:
Constante
Valor Botón
vbOK
1
Aceptar
vbCancel
2
Cancelar
vbAbort
3
Anular
vbRetry
4
Reintentar
vbIgnore
5
Ignorar
vbYes
6
Sí
vbNo
7
No
66
Manual del Alumno
Cuando se proporcionan archivodeayuda y contexto, el usuario puede presionar F1
para ver el tema de Ayuda que corresponde al contexto.
Si el cuadro de diálog muestra un botón Cancelar, si presiona la tecla ESC tiene el
mismo efecto que si hace clic en Cancelar. Si el cuadro de diálogo contiene un
botón Ayuda, se proporcionar Ayuda contextual para el cuadro de diálogo. Sin
embargo, no se devuelve ningún valor hasta que no se presiona cualquiera de los
otros botones.
El siguiente ejemplo usa la función MsgBox para mostrar un cuadro de mensaje y
devolver un valor que describe qué botón se presionó:
Dim MiVar
MiVar = MsgBox ("Hola mundo", 65, "Ejemplo de MsgBox") '
MiVar contiene 1 o 2 según el botón en el que se haga clic.
67
Manual del Alumno
Semana 8 : Fecha / hora y Controladores de Eventos.
Función Date
Devuelve la fecha actual del sistema.
Sintaxis :
Date
El siguiente ejemplo usa la función Date para devolver la fecha actual del sistema:
Dim MiFecha
MiFecha = Date
sistema.
' MiFecha contiene la fecha actual del
Función DateAdd
Devuelve una fecha a la que se agregó un intervalo de tiempo especificado.
Sintaxis : DateAdd(intervalo, número, fecha)
La sintaxis de la función DateAdd tiene las siguientes partes:
Parte
Descripción
intervalo Requerido. Expresión de cadena que es el intervalo que desea agregar. Consulte
la sección Valores para saber cuáles son los valores permitidos.
número
Requerido. Expresión numérica que es el número de intervalo que desea
agregar. La expresión numérica puede ser positiva, para fechas futuras, o
negativas, para fechas pasadas.
fecha
Requerido. Variant o literal que representa la fecha a la que se agrega intervalo.
Valores :
El argumento intervalo puede tener los siguientes valores:
Valor Descripción
w
Día de la
semana
ww
Semana del
año
yyyy
Año
q
Trimestre
m
Mes
h
Hora
y
Día del año
n
Minuto
d
Día
s
Segundo
Puede usar la función DateAdd para sumar o restar un intervalo de tiempo
especificado a una fecha. Por ejemplo, puede usar DateAdd para calcular una
fecha 30 días a partir de hoy o una hora 45 minutos desde ahora. Para agregar días
a fecha, puede usar Día del año ("y"), Día ("d") o Día de la semana ("w").
Instituto Superior Tecnológico
68
Norbert Wiener
Manual del Alumno
La función DateAdd no devolverá una fecha no válida. El siguiente ejemplo suma
un mes al 31 de enero:
Nuevafecha = DateAdd("m", 1, "31-Ene-95")
En este caso, DateAdd devuelve 28-Feb-95, no 31-Feb-95. Si fecha es 31-Ene-96,
devuelve 29-Feb-96 porque 1996 es un año bisiesto.
Si la fecha calculada es anterior al año 100, se produce un error.
Si el número no es un valor de tipo Long, se redondea al número entero más
cercano antes de evaluarlo.
Función DateDiff
Devuelve el número de intervalos entre dos fechas.
Sintaxis : DateDiff(intervalo, fecha1, fecha2 [,primerdíasemana[,
primerasemanaaño]])
La sintaxis de la función DateDiff tiene las siguientes partes:
Parte
Descripción
intervalo
Requerido. Expresión de cadena que es el intervalo que desea usar
para calcular las diferencias entre fecha1 y fecha2. Consulte la
sección Valores para saber cuáles son los valores permitidos.
fecha1, fecha2
Requerido. Expresiones de fecha. Dos fechas que desea usar en el
cálculo.
primerdíasemana
Opcional. Constante que especifica el día de la semana. Si no se
especifica, se asume Domingo. Consulte la sección Valores para saber
primerasemanaaño Opcional. Constante que especifica la primera semana del año. Si no
se especifica, se asume que la primera semana es la semana del 1 de
enero. Consulte la sección Valores para saber cuáles son los valores
permitidos.
Valores
El argumento intervalo puede tener los siguientes valores:
Valor
Descripción
yyyy
Año
q
Trimestre
m
Mes
y
Día del año
d
Día
w
Día de la semana
ww
Semana del año
h
Hora
n
Minuto
s
Segundos
Norbert Wiener
Manual
El argumento primerdíasemana puede tener los siguientes valores:
Constante
69
del Alumno
Valor Descripción
vbUseSystem
0
Usar la configuración de API NLS.
vbSunday
1
Domingo (predeterminado)
vbMonday
2
Lunes
vbTuesday
3
Martes
vbWednesday
4
Miércoles
vbThursday
5
Jueves
vbFriday
6
Viernes
vbSaturday
7
Sábado
El argumento primerasemanaaño puede tener los siguientes valores:
Constante
Valor Descripción
vbUseSystem
0
vbFirstJan1
1
Comienza con la semana del 1 de enero(predeterminado).
vbFirstFourDays
2
Comienza con la semana que tiene al menos cuatro días en el
nuevo año.
vbFirstFullWeek
3
Comienza con la primera semana completa del nuevo año.
Función Day
Devuelve un número entero entre 1 y 31, ambos incluidos, que representa el día
del mes.
Sintaxis : Day(fecha)
El argumento fecha es cualquier expresión que puede representar una fecha. Si
fecha contiene Null, se devuelve Null.
El siguiente ejemplo usa la función Day para obtener el día del mes a partir de una
fecha especificada:
Dim MiDia
MiDia = Day("19 de octubre de 1962")
'MiDia contiene 19.
Función Time
Devuelve un valor Variant del subtipo Date que indica la hora actual del sistema.
Sintaxis : Time
El siguiente ejemplo usa la función Time para devolver la hora actual del sistema:
Dim MiHoraCompleta
MiHoraCompleta = Time
sistema.
' Devuelve la hora actual del
Norbert Wiener
70
Manual del Alumno
Función TimeSerial
Devuelve un valor Variant del subtipo Date que contiene la hora para una hora,
minuto y segundo específicos.
Sintaxis : TimeSerial(hora, minuto, segundo)
La sintaxis de la función TimeSerial tiene los siguientes argumentos:
Parte
Descripción
hora
Número entre 0 (12:00 a.m.) y 23 (11:00 p.m.), ambos inluidos, o una expresión
numérica.
minuto
Cualquier expresión numérica.
segundo Cualquier expresión numérica.
Para especificar una hora, como 11:59:59, el intervalo de números para cada
argumento TimeSerial debería estar dentro del intervalo aceptado para la unidad;
es decir, entre 0 y 23 para las horas y entre 0 y 59 para los minutos y segundos.
Sin embargo, también puede especificar horas ralativas para cada argumento,
mediante el uso de cualquier expresión numérica que represente algún número de
horas, minutos o segundos antes o después de una hora determinada.
Los siguientes ejemplos usan expresiones en lugar de números de hora absolutos.
La función TimeSerial devuelve una hora para 15 minutos antes (-15) de seis
horas antes del mediodía (12 - 6) o 5:45:00 a.m.
TimeSerial(12 - 6, -15, 0)
Cuando cualquier argumento excede el intervalo aceptado para ese argumento, se
incrementa hasta la siguiente unidad mayor según sea adecuado. Por ejemplo, si
especifica 75 minutos, se evalúa como una hora y 15 minutos. Sin embargo, si
cualquier argumento está fuera del intervalo entre -32768 y 32767 o si la hora
especificada por los tres argumentos, directamente o a través de una expresión,
hace que la fecha exceda el intervalo de fechas permitido, se produce un error.
Función TimeValue
Devuelve un valor Variant del subtipo Date containing the time.
Sintaxis : TimeValue(hora)
Normalmente, el argumento hora es una expresión de cadena que representa una
hora desde 0:00:00 (12:00:00 a.m.) hasta 23:59:59 (11:59:59 p.m.), ambas
incluidas. Sin embargo, hora también puede ser cualquier expresión que represente
una hora en ese intervalo. Si hora contiene Null, se devuelve Null.
Tipos de eventos
Aquí se listan los principales eventos que se pueden asociar a una imagen,
hipervínculo, cadena de texto, etc. A continuación aparecen agrupados según
donde se originen (ratón teclado, etc). Estos eventos son los mas usados. Existen
otros, pero no siempre funcionan bien con los dos navegadores, y además son
bastantes exóticos, académicos y de uso poco práctico. No los veremos aquí.
Eventos de ratón
ONCLICK
Se activa con un botón del ratón.
ONDBLCLICK
Se activa si se hace un doble click.
Norbert Wiener
71
Manual del Alumno
ONMOUSEDOWN Se activa si se pulsa el botón izquierdo del mouse.
ONMOUSEMOVE
Se activa si se mueve el mouse.
ONMOUSEOVER
Se activa cuando el puntero se sitúa sobre el objeto que incluye
al evento.
ONMOUSEOUT
Se activa cuando el puntero sale del objeto que incluye al evento.
ONMOUSEUP
Se activa si se suelta un botón pulsado en el mouse (es contrario
a ONCLICK).
ONDRAGSTART
Se activa cuando se inicia un arrastre.
ONSELECTSTART Se activa cuando se inicia una selección con el ratón.
ONSELECT
Se activa cuando se ha realizado una selección con el ratón.
Eventos de teclado
ONKEYDOWN Se activa si se pulsa una tecla cualquiera.
ONKEYPRESS Se activa si se pulsa y suelta una tecla.
ONKEYUP
Se activa cuando se suelta una tecla pulsada.
ONHELP
Se activa si se pulsa la tecla de ayuda (normalmente F1).
Eventos de enfoque
ONFOCUS
Se activa cuando se entra en el ámbito de un elemento al que está
asociado el evento.
ONBLUR
Se activa al abandonar el ámbito del elemento al que está asociado.
Eventos de formulario
ONRESET
Se activa al pulsar un botón de reset de un formulario.
ONSUBMIT Se activa al enviar un formulario.
Eventos de carga de página
ONABORT
Se activa cuando se aborta la carga de la página.
ONERROR
Se activa cuando se produce un error inesperado durante la
carga de la página.
ONLOAD
Se activa cuando se carga la página.
ONUNLOAD
Se activa cuando el usuario descarga la página (es decir, carga
otra o pretende salir del navegador).
ONAFTERUPDATE Se activa si se actualiza o recarga la página.
Semana 9 : Modelo de Objetos del Documento.
Norbert Wiener
72
Manual del Alumno
Modelo de Objetos
En éste apéndice vamos a listar los objetos de que disponemos en VBScript, así
como sus distintas propiedades, métodos y eventos. Este apéndice está dedicado a
los objetos en el lado del Cliente. En el lado del servidor, la lista se amplía
bastante. Como hemos comentado, este manual está orientado a VBScript en el
lado del Cliente. Sin embargo, he incluido una breve introducción a la tecnología
ASP en el mismo. Bien. Empecemos asegurando posiciones. Vamos a puntualizar
cuatro conceptos cuya comprensión es vital para entender el funcionamiento de la
POO y la jerarquía de objetos.
OBJETO:
Es cada una de los elementos que se gestionan en una página web o
en cualquier aplicación informática que tienen una identidad propia. Un objeto
podría ser la ventana de navegación, o el documento activo, o un campo de un
formulario, o una tabla, etc. La lista de los objetos que podemos manejar en
VBScript de Cliente se incluyen en este Apéndice.
PROPIEDAD:
Es cada una de las características de un objeto. Una propiedad
sería el color de fondo de una tabla, la barra de estado de la ventana de
navegación, etc. También llamamos propiedad a un objeto derivado de otro. Se
dice que el objeto derivado es propiedad del objeto padre.
METODO:
Es una operación que se puede realizar dentro de un objeto. Por
ejemplo. Cerrar una ventana sería un método del objeto ventana. Poner el foco en
un campo de formulario sería un método del objeto que representa a ese campo en
concreto.
EVENTO:
Un evento es la previsión de que el usuario realice una determinada
acción. En realidad el usuario puede realizar la acción o no realizarla, pero se deja
prevista en la programación la posibilidad de que la realice. De esta forma, si la
realiza sucederá algo (lo que hayamos programado) como respuesta a esa acción.
Un evento sería pasar el ratón sobre una imagen determinada, hacer clic en una
parte de la pantalla, pulsar una tecla, etc. También existe la posibilidad de prever
eventos del sistema. Un evento de sistema es, por ejemplo, la carga de una página,
o un error en un proceso. Resumiendo: un evento se dispara cuando ocurre la
acción prevista por el mismo. Supongamos el siguiente código. Utiliza el evento
ONMOUSEOVER, asociado al hiperenlace. Cuando el usuario va a pulsar el enlace y
coloca el puntero del ratón sobre el mismo, se dispara el evento, que llama a la
función mensaje(). Esta genera un cuadro de aviso en la pantalla y obliga al usuario
a pulsar el botón Aceptar. Con lo que nunca podrá usar el enlace.
Evento onMouseOver
<HTML>
<HEAD>
<TITLE>Prueba de evento ONMOUSEOVER</TITLE>
<SCRIPT LANGUAGE = "VBScript">
FUNCTION mensaje()
MSGBOX ("Nunca podrás pulsarlo")
END FUNCTION
</SCRIPT>
</HEAD>
<BODY>
Norbert Wiener
73
Manual del Alumno
<H1>
Intenta pulsar el enlace... <BR>
si puedes.
</H1>
<A HREF = "http://www.gratisweb.com/infomegacine" ONMOUSEOVER =
"mensaje()">
Acceder a la página de Latinmail
</A>
</BODY>
</HTML>
Para referirse a una propiedad o un método de un objeto usamos una notación de
puntos. Así:
OBJETO.PROPIEDAD
O bien:
OBJETO.METODO()
Observa que el método lleva unos paréntesis y la propiedad no. Esto es así porque,
en definitiva, los métodos son casos particulares de funciones, asociadas a objetos.
Y, como cabría esperar, algunos métodos reciben argumentos y otros no. Bien.
Veamos la lista de objetos de VBScript de Cliente.
Veamos otro ejemplo, para afianzar conceptos:
VBScript en el navegador
<HTML>
<HEAD>
<TITLE>Otra prueba de POO</TITLE>
</HEAD>
<BODY>
<A HREF = "http://www.gratisweb.com/infomegacine" ONMOUSEOVER
= "window.status = 'El mejor site de cine';return true">
Pulsa aquí para ver infomegacine
</A>
</BODY>
</HTML>
Aquí podemos ver varias cosas que van mas allá de todo lo estudiado hasta ahora.
En primer lugar vamos a aclarar lo que hace el código. Muestra un hiperenlace y,
cuando el usuario pasa el ratón por encima, muestra un mensaje en la barra de
estado, que ya permanece ahí. Bien. Analicemos el código para ver como funciona.
Realmente toda la gracia está en esta línea:
<A HREF = "http://www.gratisweb.com/infomegacine" ONMOUSEOVER
="window.status = 'El mejor site de cine';return true">
La primera parte es un hiperenlace normal de HTML sin mas. Lo primero que nos
interesa ahora es la palabra ONMOUSEOVER, que indica al navegador que detecte
la presencia del cursor del ratón sobre el texto que constituye el hiperenlace.
ONMOUSEOVER es el evento que queremos detectar. A la derecha el signo igual
aparece la acción que queremos desencadenar si se produce el evento especificado.
Esta acción aparece entre comillas dobles. En concreto se trata de establecer un
valor para la propiedad status del objeto window; es decir, el contenido de la barra
de estado de la ventana de navegación. En este caso hemos programado que
aparezca en la barra de estado una cadena literal (el mejor site de cine). Fíjate que
la cadena de texto aparece encerrada entre comillas simples. A continuación
aparece un signo de punto y coma y la instrucción return true. Esta última sirve, en
este caso, para que el cambio de la barra de estado se produzca de forma
inmediata. De no usarla, al poner el ratón sobre el enlace veremos la dirección de
la página especificada y, solo al quitar el ratón, veremos el mensaje que habíamos
74
Norbert Wiener
Manual del Alumno
programado. Evidentemente ésto último no es lo que perseguíamos. Bien. Casi
tenemos completo el estudio de esta línea, salvo por un pequeño detalle. Palabras
reservadas del lenguaje, como son window, status, return y true aparecen en
minúsculas en este ejemplo, cuando hemos dicho que en este temario las palabras
reservadas las poníamos en mayúsculas. Esto es así porque en este caso las
instrucciones no han sido programadas dentro de VBScript, sino directamente en
HTML. Existen algunas instrucciones de los lenguajes de Script que pueden
programarse de esta manera (de hecho, algunas veces DEBEN programarse de esta
manera). En estos casos, el navegador no interpreta las instrucciones como de
VBScript, sino como de JavaScript. Y JavaScript (ya lo veremos en el
correspondiente temario) es, al contrario que VBScript, muy exigente con el tema
de las mayúsculas y minúsculas. Cada palabra debe escribirse de un modo exacto,
y no de otro, o no funcionará. En la lista que incluyo en éste Apéndice de objetos,
propiedades, métodos y eventos he seguido este último criterio, a fin de familiarizar
al lector con la sintaxis mas adecuada.
La lista de los principales objetos de VBScript es:
Objeto window
Objeto location
Objeto document
Objeto navigator
Objeto frame
Objeto history
Objeto link
Objeto anchor
Objeto form
Como ya hemos mencionado en este temario, los objetos siguen una jerarquía. El
de mas alto nivel es el objeto WINDOW, que representa a la ventana activa. Todos
los demás, son objetos derivados de éste. Veamos cuales son las propiedades y
métodos que acepta cada uno, así como los eventos que les afectan.
Objeto window
Representa la ventana activa del navegador y es el mas alto de la jerarquía.
Propiedades:
defaultStatus
se refiere al mensaje que aparecerá por defecto en la barra de
estado.
document
representa al documento HTML en ejecución en ese momento.
frames []
es una matriz que contiene los frames de la ventana.
history
representa un registro histórico de las páginas visitadas en la actual
sesión de uso de Internet.
length
contiene el número total de frames de la ventana.
location
representa a la dirección (URL) actual de Internet.
name
contiene el nombre de la ventana activa.
Norbert Wiener
75
Manual del Alumno
navigator
representa al navegador que estamos utilizando.
self
se refiere a la propia ventana. Es el mismo objeto window.
status
es el mensaje que aparece en la barra de estado en un momento
determinado.
window
representa a la ventana activa o a otra ventana o sub-ventana de
navegación.
Métodos:
close
()
permite cerrar la ventana activa. Su sintaxis es self.close()
open
()
permite abrir una nueva ventana, como sub ventana de la actual. Su
sintaxis es: nueva_ventana = window.open ("URL", "Target", "Opciones")
En la sintaxis expresada, nueva_ventana es el nombre que queremos darle a la
sub-ventana. URL es la dirección de la página que queremos que se cargue en la
sub-ventana. Target es la dirección del frame donde queremos que se abra la
nueva ventana (caso de existir frames) como hacemos en HTML con los
hiperenlaces. Opciones son las propiedades de la nueva ventana, de acuerdo a la
siguiente tabla.
propiedad Tipo de dato Explicación
toolbar
booleano
Ventana con barra de herramientas.
location
booleano
Ventana con barra de direcciones.
directories booleano
Ventana con directorios.
Status
booleano
Ventana con barra de estado
menubar
booleano
Ventana con barra de menús.
scrollbars booleano
Ventana con barras de desplazamiento.
resizable
booleano
Ventana de tamaño redefinible por el usuario.
width
píxeles
Anchura de la ventana
height
píxeles
Altura de la ventana.
top
píxeles
Posición Y de la ventana
left
píxeles
Posición x de la ventana
Eventos:
onLoad
Se ejecuta cuando se carga la página.
onUnload Se ejecuta cuando se descarga (se cierra) la página.
Objeto document
Representa el documento activo.
Propiedades:
alinkColor
Representa el color de los enlaces activos.
bgColor
Representa el color de fondo del documento.
fgColor
Representa el color del texto
lastModified Representa la fecha de la última modificación.
linkColor
Representa el color de los enlaces.
Norbert Wiener
76
Manual del Alumno
location
Representa la URL del documento.
title
Representa el título del documento.
vlinkColor
Representa el color de los enlaces visitados.
Métodos:
Write ()
Escribe un texto.
Writeln() Escribe una línea de texto.
Eventos:
Ninguno
Objeto form
Este objeto se refiere a un formulario empleado en el documento. Se accede a cada
formulario mediante un índice: document.form [índice]
El número de índice se corresponde con el orden de creación de formulario en el
documento.
Propiedades:
action
Representa la URL donde está el programa encargado de procesar un
formulario (al que se llama al activar el botón Submit).
length
Es el número de elementos del formulario.
method Es el método de envío (GET o POST).
Métodos:
submit Se usa para forzar el envío.
Eventos:
onSubmit Se produce cuando se pulsa el botón Submit del formulario.
Objeto location
Contiene la URL de la página actual
Propiedades:
href
Representa la propia URL.
pathname Representa la ruta del disco del servidor donde se aloja la página.
Métodos:
Ninguno.
Eventos:
Ninguno.
Objeto navigator
Representa al navegador actual.
Propiedades:
appName
Es el nombre del navegador.
Norbert Wiener
77
Manual del Alumno
appVersion Se refiere a la versión del navegador.
Métodos:
Ninguno.
Eventos:
Ninguno.
Objeto history
Representa el historial de las páginas visitadas en la sesión actual de uso de
Internet
Propiedades:
length Representa la cantidad total de páginas visitadas.
Métodos:
back ()
navega a la página anterior.
forward() navega a la página siguiente.
go (n)
navega n páginas hacia delante (o hacia atrás, si n es negativo).
Eventos:
Ninguno.
Semana 10 : Examen Parcial.
Norbert Wiener
Semana 11 :
78
Manual del Alumno
JavaScript.
Introducción
JScript es la implementación de Microsoft de la especificación de lenguaje ECMA
262. Es una implementación completa, además de algunas mejoras que aprovechan
las capacidades de Microsoft Internet Explorer. Este tutorial pretende ayudarle a
comenzar a trabajar con JScript.
JScript es un lenguaje de secuencias de comandos basado en objetos e
interpretado. Aunque tiene menos capacidades que los lenguajes orientados a
objetos de altas prestaciones como C++ y Java, JScript es más que suficientemente
eficiente para los propósitos para los que está creado.
JScript no es una versión reducida de cualquier otro lenguaje (sólo está
relacionado, distante e indirectamente, con Java, por ejemplo), ni es una
simplificación de ningún lenguaje. Sin embargo, es un lenguaje limitado. Por
ejemplo, no es posible escribir aplicaciones independientes en JScript y la capacidad
de lectura y escritura de archivos es mínima. Más aún, las secuencias de comandos
de JScript sólo pueden ejecutarse con un intérprete, que bien puede estar en un
servidor Web o en un explorador de Web.
JScript es un lenguaje en el que no necesita declarar los tipos de datos. Esto
significa que no es necesario declarar explícitamente los tipos de datos de las
variables. Más
aún,
en
muchos
casos
JScript
realiza
conversiones,
automáticamente, cuando son necesarias. Por ejemplo, si intenta agregar un
número a un elemento que contiene texto (una cadena), el número se convierte en
texto.
Escritura de Código en Java Script
Al igual que muchos otros lenguajes de programación, Microsoft JScript se escribe
en forma de texto y se organiza en instrucciones, bloques formados por conjuntos
de instrucciones relacionadas y comentarios. En una instrucción puede utilizar
variables, datos inmediatos como cadenas y números, y expresiones.
Instrucciones
Una instrucción de código JScript está formada por uno o más elementos y
símbolos en una misma línea. Cada nueva línea inicia una nueva instrucción, pero
es una buena idea terminar las instrucciones de forma explícita. Puede hacerlo si
agrega un punto y coma (;), que es el carácter de terminación de JScript.
unPajaro = "Colibrí";
var hoy = new Date();
Un grupo de instrucciones JScript encerrado entre llaves ({}) se denomina bloque.
Los bloques de instrucciones se utilizan, por ejemplo, en funciones y expresiones
condicionales. En el siguiente ejemplo la primera instrucción inicia la definición de
una función, que está formada por un bloque de cinco instrucciones. Las tres
últimas instrucciones, que no están incluidas en las llaves, no son un bloque y no
forman parte de la función.
Norbert Wiener
79
Manual del Alumno
function convert(pulgadas) {
pies= pulgadas / 12; // Estas cinco instrucciones están en un bloque.
millas = pies / 5280;
millasNauticas = pies / 6080;
cm = pulgadas * 2.54;
metros = pulgadas / 39.37;
}
km = metros / 1000; // Estas tres instrucciones no están en un bloque.
kradio = km;
mradio= millas;
Comentarios
Un comentario de una sola línea en JScript comienza con un par de barras
inclinadas (//). Un comentario multilínea comienza con una barra inclinada seguida
por un asterisco (/*) y termina con los mismos elementos en orden inverso (*/).
unaBuenaIdea = "Incluya muchos comentarios en su código."; // Este es un comentario de
una sola línea.
/*
Este es un comentario multilínea que explica la instrucción de código anterior.
La instrucción asigna un valor a la variable unaBuenaIdea. El valor que está encerrado
entre comillas, se conoce como un literal. Un literal contiene información de forma
directa y explícita, no hace referencia a la información de forma indirecta. (Las
comillas no forman parte del literal.)
*/
// Este es otro comentario multilínea, escrito como una serie de comentarios de una sola
línea.
// Después de ejecutar la instrucción, puede hacer referencia al contenido de la
variable.
// unaBuenaIdea utilizando su nombre, como en la siguiente instrucción, en la que se
agrega un literal de cadena a
// la variable unaBuenaIdea mediante concatenación para crear una nueva variable.
var ideaAmpliada = unaBuenaIdea + " Nunca puede saber cuándo tendrá que averiguar lo que
hace.";
Asignaciones e igualdad
El signo igual (=) se utiliza en JScript para indicar una acción en la que se asigna
un valor. Es decir, una instrucción de código JScript podría decir
unEntero
= 3;
Significa "Asigna el valor 3 a la variable unEntero" o "unEntero recibe el valor 3".
Cuando desee comparar dos valores para averiguar si son iguales, deberá utilizar
un par de signos de igual (==). Este aspecto se ve con más detalle en Controlar el
flujo del programa.
Expresiones
Una expresión JScript es algo que una persona puede leer como una expresión de
tipo Boolean o como una expresión numérica. Las expresiones contienen caracteres
de símbolos como "+" en lugar de palabras como "sumado a". Una expresión está
formada por cualquier combinación válida de valores, variables, operadores y
expresiones.
var
var
var
var
unaExpresion= "3 * (4 / 5)";
unaSegundaExpresion = "Math.PI * radio * 2";
unaTerceraExpresion = unaSegundaExpresion + "%" + unaExpresion;
unaCuartaExpresion = "(" + unaSegundaExpresion + ") % (" + unaExpresion
Norbert Wiener
80
Manual del Alumno
Caracteristicas
Es simple, no hace falta tener conocimientos de programación para poder
hacer un programa en JavaScript.
Maneja objetos dentro de nuestra página Web y sobre ese objeto podemos
definir diferentes eventos. Dichos objetos facilitan la programacion de
paginas interactivas, a la vez que se evita la posibilidad de ejecutar
comandos que puedan ser peligrosos para la maquina del usuario, tales
como formateo de unidades, modificar archivos etc.
Es dinámico, responde a eventos en tiempo real. Eventos como presionar un
botón, pasar el puntero del mouse sobre un determinado texto o el simple
hecho de cargar la página o caducar un tiempo. Con esto podemos cambiar
totalmente el aspecto de nuestra página al gusto del usuario, evitándonos
tener en el servidor un página para cada gusto, hacer calculos en base a
variables cuyo valor es determinado por el usuario, etc.
Diferencia con JAVA
La principal diferencia es que JAVA es un lenguaje compilado, mientras que
JavaScript es interpretado.
JAVA al compilar crea programas independientes, llamados APPLETS que se
invocan desde una pagina Web, mientras que el codigo de JavaScript va
incluido en la pagina.
Esta orientado a objetos de forma limitada ya que no maneja los conceptos
de clase ni herencia.
En JavaScript no es necesario declarar el tipo de variable, ni debe existir las
referencias a bjetos antes de ejecutarlos, por lo que se hable de una ligazon
dinamica a diferencia de la ligazon estatica del JAVA.
Principales aplicaciones
Si bien hoy en día, JavaScript, es un lenguaje muy usado, sus principales
aplicaciones son:
Responder a eventos locales dentro de la página, como apretar un botón,
La realización de cálculos en tiempo real
La validación de formularios dentro de una página.
La personalización de la página por el usuario, que le permitirá tener una
página web a su medida.
La inclusión de datos del propio sistema, como son la hora y la fecha.
Aunque según pasa el tiempo sus aplicaciones se van incrementando.
Norbert Wiener
81
Manual del Alumno
Donde incluirlo
Antes siquiera de que conozcamos la sintaxis o una primera orden de JavaScript,
debemos saber primero cómo se incluye un script dentro de un documento HTML.
El codigo JavaScript se inserta directamente en nuestra pagina HTM. Hay cuatro (4)
maneras de hacerlo:
En el cuerpo del documento
Es decir entre los comandos <BODY> y </BODY> usando el comando SCRIPT
<HTML>
<HEAD>
<TITLE>Titulo</TITLE>
</HEAD>
<BODY>
<SCRIPT LANGUAGE=JavaScript>

<SCRIPT>
</BODY>
</HTML>
Este codigo se ejecuta inmediatamente al cargar la pagina y lo que produce es un
texto sobre la pagina, para ello use el metodo write del objeto document, que
representa al documento actual.
Nota que use un comentario  para ocultar el codigo a los navegadores que
no soportan JavaScript.
En archivo aparte
En este caso todo el codigo del script esta situado en otro archivo y se hace una llamada.
<HTML>
<HEAD>
</HEAD>
<BODY>
<SCRIPT SRC=codigo.js>
<SCRIPT>
</BODY>
</HTML>
Nota que aqui no fue neceario esconder ningun codigo y que los navegadores que
no soporte el comando SCRIPT simplemente lo ignoraran.
Usando manejadores de evento
Los comandos de JavaScript son evaluados inmediatamente al cargarse la pagina.
Las funciones son almacenadas, pero no ejecutadas, hasta cierto evento.
Norbert Wiener
82
Manual del Alumno
<HTML>
<HEAD>
<BODY>
<A HREF="" onMouseOver="window.status='Figura';return true">
<IMG SRC=fig.gif></A>
</BODY>
</HTML>
Nota que aqui es un evento el que dispara.
Haciendo una llamada a función
Dentro de la cabecera, despues del titulo. Es decir, entre los comandos </TITLE> y
</HEAD> y luego la llamada a la funcion en el cuerpo.
<HTML>
<HEAD>
<SCRIPT LANGUAGE=JavaScript>

<SCRIPT>
</HEAD>
<BODY>
No haga Clic <A HREF="JavaScript:llamada('Curioso!')">AQUI</A>
</BODY>
</HTML>
Observa que aquí se definió la función en la cabecera, pero recién se ejecuta al
hacer clic en el enlace, que es el evento que llama a la función a la cual se le para
un parámetro.
NOTA: Excepto en texto encomillado , JavaScript es sensible a mayúsculas y
minúsculas, por lo que tendrás que tener el cuidado al usar por ejemplo
document.write de escribirlo así, en minúsculas o no se interpretará. Cualquier
error simplemente es ignorado. Se puede usar la comilla simple para los valores de
atributos.
Norbert Wiener
Semana 12 :
83
Manual del Alumno
Scripting Basics.
Variables de Java Script
Las variables se utilizan el Microsoft JScript para almacenar valores en sus
secuencias de comandos. Son un método para recuperar y manipular valores
mediante nombres de cadenas. Cuando se utilizan correctamente pueden ayudar a
comprender el funcionamiento de una secuencia de comandos.
Declarar variables
Aunque no es necesario, se considera una buena práctica declarar las variables
antes de utilizarlas. Se hace utilizando la instrucción var. La única ocasión en la
que se debe utilizar la instrucción var es al declarar variables locales a una función.
En las restantes ocasiones, utilizar la instrucción var para declarar las variables
antes de utilizarlas es una práctica recomendada.
Los siguientes ejemplos de código son sobre la declaración de variables:
var mim = "Un hombre, un plan, un canal, !Panamá!"; // El valor almacenado en mim es
del tipo cadena.
// La frase entre comillas, el valor asignado a mim, es un literal de cadena.
var ror = 3;
// El valor almacenado en ror es de tipo numérico.
var nen = true;
// El valor almacenado en nen es de tipo Boolean.
var fif = 2.718281828
// El valor almacenado en fif es de tipo numérico.
Nombrar variables
JScript es un lenguaje que distingue entre mayúsculas y minúsculas, por tanto, es
diferente llamar a una variable miContador que llamarla MIContador. Además, los
nombres de las variables, que pueden tener cualquier longitud, deben seguir ciertas
reglas:
El primer carácter debe ser una letra (mayúscula o minúscula) o un
carácter de subrayado (_), o un signo de dólar ($).
Los siguientes caracteres pueden ser letras, números, caracteres de
subrayado o signos de dólar.
El nombre de una variable no puede ser una palabra reservada.
Algunos ejemplos de nombres de variables válidos:
_numeropaginas
Parte9
Numero_elementos
Algunos nombres de variables no válidos:
99Globos // Comienza con un número.
Smith&Wesson // El signo & no es un carácter válido para los
nombres de las variables.
En los casos en los que quiera declarar una variable e iniciarla sin proporcionar
ningún valor concreto, deberá asignarle un valor especial, null.
var zaz = null;
var notanto = 3 * zaz;
// En este punto, notanto se convierte en 0.
Norbert Wiener
84
Manual del Alumno
Si declara una variable sin asignarla un valor, la variable existirá, pero será no
definida.
var godot;
var esperarA= 1 * godot;
definida.
//
Asigna el valor NaN a esperarA, ya que godot no está
Una variable se puede definir de forma implícita (sin utilizar var) tan sólo con
asignarle un valor. Sin embargo, no se puede utilizar una variable que aún no haya
sido declarada de ningún modo. Si lo hace obtendrá un error en tiempo de
ejecución.
lel = ""; // La variable se declara de forma implícita.
var unLio = vyv + zez; // Genera un error, ya que vyv y zez no existen.
Conversión
Dado que JScript es un lenguaje en el que no es necesario declarar los tipos de
datos, las variables en JScript técnicamente no tienen un tipo fijo. En cambio,
tienen un tipo equivalente al tipo del valor que contienen. Bajo determinadas
circunstancias, es posible forzar la conversión automática de una variable de un
tipo de dato en un tipo diferente. Se pueden incluir números en las cadenas, pero
las cadenas no se pueden incluir directamente en los números, por lo que se
proporcionan las funciones de conversión explícitas, parseInt() y parseFloat().
var elDesde = 1;
var elHasta = 10;
var queHacer= "Contar desde ";
queHacer+= elDesde + " hasta " + elHasta + ".";
Después de ejecutar este código la variable queHacer contiene "Contar desde 1 hasta 10." El
dato numérico ha sido convertido en una cadena.
var ahoraQue= 0;
ahoraQue+= 1 + "10"; // En este caso, como "10" es una cadena,
// el operador "+=" la concatena..
Después de ejecutar el código, la variable ahoraQue contiene "0110". Para obtener
este resultado se han seguido los siguientes pasos:
1. Comprobar los tipos de 1 y "10". "10" es una cadena, 1 es un
número, por tanto, el número se convertirá en una cadena.
2. Dado que los valores de ambos lados del operador + son cadenas, se
realiza una concatenación de ellas. El resultado es "110"
3. Comprueba los tipos de ambos lados del operador +=. ahoraQue
contiene un número y "110" es una cadena, así que se convierte el
número en una cadena.
4. Como ahora hay cadenas a ambos lados del operador +=, se realiza
una concatenación de cadenas. El resultado es "0110".
5. Este resultado se almacena en ahoraQue.
var entonces = 0;
entonces+= 1 + parseInt("10");
// En este caso, "+=" realiza una suma.
Después de ejecutar este código, la variable entonces contiene el entero 11.
Norbert Wiener
Semana 13 :
85
Manual del Alumno
Tipos de datos y operadores.
Tipos de Datos
¿Qué son los tipos de datos de JScript?
Microsoft JScript tiene seis tipos de datos. Los tipos principales son: numéricos,
cadenas, objetos y Boolean. Los otros dos son null y no definido
.
Tipo de dato Cadena
Las cadenas están delimitadas por comillas simples o dobles. (Utilice comillas
simples para delimitar cadenas que utilicen comillas dobles.) Una cadena también
es un objeto en JScript, pero es un caso especial, con propiedades especiales. A
continuación hay ejemplos de cadenas:
"La vaca saltó sobre la luna."
'"¡Es imposible!" gritó el hombre.'
"42"
Una cadena puede contener cero o más caracteres unicode. Cuando no contiene
ninguno, se denomina cadena de longitud cero ("").
Tipo de dato numérico
JScript permite utilizar números enteros y en coma flotante. Los enteros pueden ser
positivos, 0 o negativos; un número en coma flotante puede contener un punto
decimal, , una "e" (mayúscula o minúscula), que se utiliza para representar "diez a
la potencia de" en notación científica, o ambos. Estos números siguen el estándar
IEEE 754 para la representación numérica. Por último, algunos valores numéricos
son especiales:
NaN, o no un número
Infinito positivo
Infinito negativo
Positivo 0
Negativo 0
Los enteros se pueden representar en base 10 (decimal), base 8 (octal), y base 16
(hexadecimal).
Los enteros octales se especifican anteponiendo un "0" y pueden contener dígitos
del 0 al 7. Si un número está precedido por un "0" pero contiene los dígitos "8" o
"9", es un número decimal. Si un número que de otro modo sería un octal contiene
la letra "e" (o "E") se genera un error.
Los enteros hexadecimales ("hex") se especifican anteponiendo "0x" (la "X" puede
ser mayúscula o minúscula) y pueden contener los dígitos del 0 al 9 y las letras de
la A a la F (mayúsculas o minúsculas). La letra "e" es un dígito permisible en la
notación hexadecimal y no indica la existencia de un número exponencial. Las
86
Norbert Wiener
Manual del Alumno
letras de la A a la F se utilizan para representar, como dígitos simples, los números
que van del 10 al 15 en base 10. Es decir, 0xF equivale a 15 y 0x10 equivale a 16.
Los números octales y hexadecimales pueden ser negativos, pero no fracciones. Un
número que comience con un único "0" y contenga un punto decimal es un número
decimal en coma flotante, si un número que comienza con "0x" o "00" contiene un
punto decimal, cualquier cosa que aparezca a la derecha de dicho punto será
ignorado.
Algunos ejemplos de números:
.0001, 0.0001, 1e-4, 1.0e-4 // Cuatro números en coma flotante, todos
ellos equivalentes.
3.45e2
// Un número en coma flotante,
equivalente a 345.
42
// Un número entero.
0377
// Un entero octal, equivalente a 255.
00.0001
// Como los números octales no pueden
tener decimales, éste equivale a 0.
0378
// Un entero, equivalente a 378.
0Xff
// Un entero hexadecimal, equivalente a
255.
0x37CF
14287.
0x3e7
999.
0x3.45e2
// Como los números hexadecimales no
pueden tener partes decimales, éste equivale a 3.
Tipo Boolean
Los posibles valores de tipo Boolean sontrue y false. Son valores especiales, y no
se pueden utilizar como 1 y 0.
Nota En una comparación, cualquier expresión que se evalúe como 0 se tomará como false, y cualquier
expresión que se evalúe como un número distinto de cero se tomará como true. Así, la siguiente expresión
se evalúa como true:
(false == 0)
Tipo de dato no definido
Un valor no definido es simplemente un valor asignado a una variable después de
crearla, pero antes de que se le haya asignado un valor.
Tipo de dato Null
Un valor null es uno que no tiene valor y no significa nada.
Norbert Wiener
87
Manual del Alumno
\b
\f
feed)
\n
\r
(Carrage
Tambien pueden usar los siguientes
caracteres
indica un retroceso (backspace)
indica un avance de pagina (Form
Indica nuva linea (New Line)
Indica un retorno de carro
return)
Indica un tabulador (Tab)
se puede incluir comillas. Ej:
"José \"Chemo\" del Solar"
\t
\"
Operadores de Java Script
JScript tiene un amplio conjunto de operadores, incluidos aritméticos, lógicos, de
bits y de asignación. También existen algunos operadores variados.
Cálculo
Descripción
Negación
unaria
Lógicos
Símbolo
Descripción
De bits
Símbolo
Descripción
-
NOT lógico
!
NOT de bits
Incremento
++
Menor que
<
Decremento
--
Mayor que
Multiplicación
*
División
/
Asignación
Símbolo
Descripción
Varios
Símbolo
Descripción
Símbolo
~
Asignación
=
delete
delete
Desplazamiento
de bits hacia la
izquierda
<<
Asignación
compuesta
OP=
typeof
typeof
>
Desplazamiento
hacia la
derecha
>>
Menor que o
igual a
<=
Desplazamiento
a la derecha sin
signo
>>>
Mayor que o
igual a
>=
AND de bits
&
Módulo
aritmético
%
Igualdad
==
XOR de bits
^
Adición
+
Desigualdad
!=
OR de bits
|
Sustracción
-
AND lógico
&&
OR lógico
||
Condicional
(trinario)
?:
Coma
void
void
,
Identidad
===
No identidad
!==
Precedencia de operadores
En JScript los operadores se evalúan en un orden particular. Este orden se conoce
como la precedencia de operadores. La siguiente tabla muestra una lista de los
operadores en orden de precedencia de mayor a menor. Los operadores de la
misma fila se evalúan de izquierda a derecha.
Norbert Wiener
88
Manual del Alumno
Operador
Descripción
. [] ()
Acceso a campos, indexación de matrices y llamadas a
funciones
++ -- - ~ ! typeof new
void delete
Operadores unarios, tipos de datos devueltos, creación de
objetos, valores no definidos
*/%
Multiplicación, división, división módulo
+-+
Adición, sustracción, concatenación de cadenas
<< >> >>>
Desplazamiento de bits
< <= > >=
Menor que, menor que o igual a, mayor que, mayor que o igual
a
== != === !==
Igualdad, desigualdad, identidad, no identidad
&
AND de bits
^
XOR de bits
|
OR de bits
&&
AND lógico
||
OR lógico
?:
Condicional
= OP=
Asignación, asignación con operación
,
Evaluación múltiple
Los paréntesis se usan para modificar el orden de evaluación. La expresión
encerrada entre paréntesis se evalúa por completo antes de usar su valor en el
resto de la instrucción.
Un operador con mayor precedencia se evalúa antes que uno con menor
precedencia. Por ejemplo:
z = 78 * (96 + 3 + 45)
En esta expresión hay cinco operadores: =, *, (), + y +. Según las normas de
precedencia, se evalúan en el siguiente orden: (), *, +, +, =.
1. Lo primero es la evaluación de la expresión que está encerrada entre
paréntesis: Hay dos operadores de adición y tienen la misma
precedencia: Se suma 96 y 3 y al total resultante se suma 45, dando
como resultado un valor igual a 144.
2. Lo siguiente es la multiplicación: Se multiplican 78 y 144, dando
como resultado un valor igual a 11232.
3. Por último se realiza la asignación: Se asigna 11232 a z.
Norbert Wiener
89
Manual del Alumno
Arreglos y Cadenas
Indexación de matrices
Las matrices en JScript son sparse. Es decir, si tiene una matriz con tres elementos,
numerados 0, 1 y 2, puede crear un elemento 50 sin preocuparse por los elementos
que van del 3 al 49. Si la matriz tiene una variable automática de longitud (vea
objetos intrínsecos para obtener una explicación sobre el control automático de la
longitud de una matriz), la variable de longitud tendría el valor 51, en lugar de 4.
Se pueden crear matrices en las que no existan espacios vacíos en el número de
elementos, pero no es necesario. De hecho, en JScript, no es necesario que sus
matrices tengan subíndices numéricos.
En JScript, los objetos y las matrices son esencialmente idénticos. La diferencia real
no se encuentra en los datos, si no en el método utilizado para hacer referencia a
los miembros de una matriz o a las propiedades y métodos de un objeto.
Referencias a matrices
Existen dos métodos principales para hacer referencia a los miembros de una
matriz. Normalmente se hace referencia a las matrices utilizando corchetes. Los
paréntesis encierran un valor numérico o una expresión que se evalúa como un
número entero no negativo. El siguiente ejemplo asume que la variable numEntr
está definida y que se le ha asignado un valor en alguna parte de la secuencia de
comandos.
laLista = libretaDirecciones[numEntr];
laPrimeraLinea = laLista [1];
Este método de referencia equivale al método utilizado para hacer referencia a
objetos, aunque en estos últimos debe aparecer después del punto el nombre de
una propiedad existente. Si esa propiedad no existe, el código generará un error.
El segundo método para hacer referencia en una matriz es crear un objeto o matriz
que contenga las propiedades numeradas y generar los números mediante un
bucle. El siguiente ejemplo genera dos matrices, una para el nombre y otra para la
dirección, a partir de la lista de libroDirecciones. Cada una de ellas contiene cuatro
propiedades. Por ejemplo, una instancia de elNombre creada a partir de las
propiedades que van desde [Name1] a [Name4] en laLista, podría contener "G."
"Edward" "Heatherington" "IV", o "George" "" "Sand" "".
laLista = libretaDirecciones[numEntr];
for (i = 1; i
< 4; i++) {
elNombre [i] = laLista["Nombre" + i];
laDireccion[i] = laLista["Direccion" + i];
}
Aunque esta instancia en concreto, es corta y se podría haber escrito fácilmente en
la notación con punto (es decir, haciendo referencia a laLista, elNombre, y
laDireccion como objeto en lugar de hacerlo como matrices), esto no siempre es
90
Norbert Wiener
Manual del Alumno
posible. Es posible que algunas veces una determinada propiedad no exista hasta el
momento de la ejecución, o que no exista forma de saber con antelación cuál será.
Por ejemplo, si la matriz libretaDirecciones estuviera organizada por el apellido en
lugar de estarlo por una lista numérica, el usuario probablemente podría introducir
los nombres, mientras se ejecuta la secuencia de comandos, para buscar a las
personas. El siguiente ejemplo asume la existencia de las definiciones de función
correctas en alguna parte de la secuencia de comandos.
laLista = libretaDirecciones[getName()];
laListaIndiv= laLista [obtenerPrimerNombre ()];
Se trata de una referencia asociativa a la matriz, es decir, la referencia se realiza
mediante cadenas totalmente arbitrarias. Los objetos en JScript son, en realidad,
matrices asociativas. Aunque se puede utilizar (y se utiliza con frecuencia) el estilo
de referencias con "puntos", no es necesario hacerlo.
Objetos Intrínsecos
Microsoft JScript ofrece nueve objetos intrínsecos (o "incorporados"). Estos objetos
son Array, Boolean, Date, Function, Global, Math, Number, Objecty String.
Cada uno de los objetos intrínsecos tienen métodos y propiedades asociados, que
se describen en detalle en la referencia del lenguaje. Algunos objetos también se
describen aquí.
Objeto Array
En JScript, los objetos se controlan como matrices y las matrices se controlan como
objetos. Se puede hacer referencia a las subsecuencias de comandos de una
matriz, que son totalmente equivalentes a las propiedades de un objeto, por
número (o por nombre, si les asigna nombres). Para crear una nueva matriz, utilice
el operador new y el constructor Array(), como en el siguiente ejemplo.
var losMeses = new Array(12)
losMeses[0] = "Ene";
losMeses[1] = "Feb";
losMeses[2] = "Mar";
losMeses[3] = "Abr";
losMeses[4] = "May";
losMeses[5] = "Jun";
losMeses[6] = "Jul";
losMeses[7] = "Ago";
losMeses[8] = "Sep";
losMeses[9] = "Oct";
losMeses[10] = "Nov";
losMeses[11] = "Dic";
}
{
Al crear una matriz utilizando la palabra clave Array, JScript incluye en la matriz
una propiedad length de sólo escritura, que graba el número de entradas de una
matriz. Si no especifica un número, la longitud se establece a 0 y la matriz no tiene
entradas. Si especifica un número, la longitud se establece a ese número. Si
especifica más de un parámetro, los parámetros se utilizan como entradas de la
matriz y el número de parámetros se asigna a la propiedad length, como en el
siguiente ejemplo, que es equivalente al ejemplo anterior.
91
Norbert Wiener
Manual del Alumno
var losMeses = new Array("Ene", "Feb", "Mar", "Abr", "May", "Jun",
"Jul", "Ago", "Sep", "Oct", "Nov", "Dic");
JScript cambia automáticamente el valor de length si agrega elementos a una
matriz que creó con la palabra clave Array.
Objeto String
En JScript, las cadenas son objetos. Esto significa que cada vez que declare una
variable de cadena o utilice un literal de cadena, lo que está haciendo realmente es
crear un nuevo objeto de cadena. El objeto String tiene algunos métodos
incorporados, que puede utilizar con sus cadenas. Uno de esos métodos es el
método substring, que devuelve parte de la cadena. Este método recibe dos
números como argumentos.
unaCadena = "0123456789";
var unaPorcion = unaCadena.substring(4, 7); // Establece unaPorcion a
"456".
var otraPorcion = unaCadena.substring(7, 4); // Establece otraPorcion
a "456".
// Si se utiliza el ejemplo de creación de Array anterior:
primeraLetra = losMeses[5].substring(0,1); // Establece la variable
primeraLetra a "J".
Otra propiedad del objeto String es la propiedad length. Esta propiedad contiene
el número de caracteres que hay en la cadena, que es igual a 0 en una cadena
vacía. Esto es un valor numérico y se puede utilizar directamente en cálculos.
var Longitud = "Hola mundo".length
a 10.
// Establece la variable Longitud
Objeto Math
El objeto Math tiene una cantidad de propiedades y métodos, todos ellos
predefinidos. Las propiedades son números específicos. Uno de estos valores es pi
(aproximadamente 3,14159...). Es la propiedad Math.PI, mostrada en el siguiente
ejemplo.
// Se declara una variable radio y se le asigna un valor numérico.
var areaCirculo = Math.PI * radio * radio; // Observe que Math y PI
están en mayúsculas.
Uno de los métodos incorporados del objeto Math es el método de exponenciación
o pow, que eleva un número a una potencia especificada. El siguiente ejemplo usa
pi y exponenciación.
// Esta fórmula calcula el volumen de una esfera con un radio
especificado.
volumen = (4/3)*(Math.PI*Math.pow(radio,3));
Objeto Date
Utilice el objeto Date para capturar la fecha de hoy y para calcular diferencias entre
fechas. Este objeto tiene varios métodos y propiedades, todos ellos predefinidos. En
92
Norbert Wiener
Manual del Alumno
general, el objeto Date proporciona el día de la semana; el mes, día y año; y la
hora en horas, minutos y segundos. Esta información está basada en el número de
milisegundos transcurridos desde el 1 de enero de 1970, 00:00:00.000 GMT. GMT
son las iniciales de "Greenwich Mean Time"; el término preferido es UTC u "Horario
Universal Coordinado", que hace referencia a señales emitidas por el horario
estándar mundial.
Nota Para JScript, la hora comienza en la medianoche del 1 de enero de 1970; no puede solicitar a
JScript que cree un objeto Date que represente una hora anterior a esa. Si necesita trabajar con horas
anteriores, debe escribir su propio código para hacerlo, una tarea formidable.
Para crear un nuevo objeto Date se utiliza el operador new. El siguiente ejemplo
calcula, para el año actual, el número de días transcurridos y el número de días que
faltan.
/*
Este ejemplo utiliza la matriz de nombres de meses previamente definida.
La primera instrucción asigna la fecha de hoy, en formato "Día Mes Fecha 00:00:00 Año"
, a la variable estoEsHoy.
*/
var estoEsHoy = new Date();
var hoy = new Date(); // Captura la fecha de hoy.
// Extrae el año, mes y día.
var esteAno = hoy.getYear() + 1900;
var esteMes = losMeses[hoy.getMonth()];
var esteDia = esteMes + " " + hoy.getDate() + "," + (parseInt(hoy.getYear()) + 1900);
// Determina el número de días transcurrido desde el inicio.
hoy = Math.round(Date.parse(esteDia)/8.64e7);
// Hace lo mismo con el principio del año.
var primerDia = "1 de enero de " + esteAno;
primerDia = Math.floor(Date.parse(primerDia)/8.64e7);
// Lo vuelve a hacer para el final del año, en caso de que sea un año bisiesto.
var ultimoDia = "31 de diciembre de " + esteAno;
ultimoDia = Math.floor(Date.parse(ultimoDia)/8.64e7);
// Calcula el número de días del año.
var diasEnAno = (ultimoDia - primerDia) + 1;
// Determina cuántos días han transcurrido y cuántos faltan.
var diasTranscurridos= esteDia - primerDia;
var diasFaltan = diasEnAno - diasTranscurridos;
// Establece comentarios para la mayor parte del año.
var comentario1 = diasTranscurridos+ " días han transcurrido en el año.";
var comentario2 = "Eso significa que faltan " + diasFaltan+ " dias para terminar el año
" + esteAno + ".";
// Cubre los casos especiales: inicio y final de año y un solo día.
if (diasTranscurridos == 0) {
comentario1 = "Es uno de enero, " + esteAno + ".";
}
if (diasTranscurridos == 1) {
comentario1 = "Sólo ha transcurrido un día.";
}
if(diasTranscurridos == diasEnAno) {
comentario1 = esteAno + " acaba de terminar.";
}
if (diasFaltan == 0) {
comentario2 = "Los mejores deseos en el nuevo año.";
}
if (diasFaltan == 1) {
comentario2 = "Sólo queda un día para terminar el año " + esteAno + ".";
}
if (diasFaltan == diasEnAno) {
comentario2 = "Feliz año nuevo.";
}
Norbert Wiener
93
Manual del Alumno
Objeto Number
Además de las propiedades numéricas especiales (por ejemplo PI) que están
disponibles en el objeto Math, muchas otras propiedades están disponibles en
Microsoft JScript a través del objeto Number.
Propiedad
Descripción
MAX_VALUE
El número más grande posible, alrededor de 1,79E+308; puede
ser positivo o negativo. (El valor varía ligeramente entre un
sistema y otro.)
MIN_VALUE
El número más pequeño posible, alrededor de 2.22E-308; puede
ser positivo o negativo. (El valor varía ligeramente entre un
sistema y otro.)
NaN
Valor no numérico especial, "no es un número".
POSITIVE_INFINITY
Cualquier valor positivo mayor que Number.MAX_VALUE
se convierte automáticamente a este valor; representado como
"Inf".
NEGATIVE_INFINITY Cualquier valor negativo mayor que -Number.MAX_VALUE
se convierte automáticamente a este valor; representado como "Inf".
Number.NaN es una propiedad especial que se define como "no es un número".
Por ejemplo, una división por cero devuelve NaN. Si intenta analizar una cadena
que no se puede analizar como un número, también devuelve Number.NaN. Si
compara NaN con cualquier otro número o consigo mismo obtiene como resultado
que no son iguales. Para verificar que un resultado es igual a NaN, no compare el
resultado con Number.NaN; utilice la función isNaN().
Norbert Wiener
Semana 14 :
94
Manual del Alumno
Estructuras de control.
Control del Flujo del Programa
¿Por qué controlar el flujo de la ejecución?
Muy frecuentemente, es necesaria una secuencia de comandos para funciones
diferentes bajo diferentes condiciones. Por ejemplo, podría escribir una secuencia
de comandos que comprobara la hora cada hora y que cambiara algún parámetro
durante el transcurso del día. Podría escribir una secuencia de comandos que
acepta algún tipo de entrada y actúa de una u otra forma según la entrada
proporcionada. O podría escribir una secuencia de comandos que repita una acción
especificada.
Es posible comprobar muchos tipos de condiciones. Todas las comprobaciones
condicionales en Microsoft JScript son de tipo Boolean, por lo que el resultado de
cualquier comprobación es true o false. Puede comprobar valores numéricos, de
tipo Boolean o cadenas indistintamente.
JScript proporciona estructuras de control para un amplio intervalo de posibilidades.
Las estructuras de control más sencillas son las instrucciones condicionales.
Usar instrucciones condicionales
JScript admite las instrucciones condicionales if e if...else. En las instrucciones if
se comprueba una condición y si la condición cumple la comprobación, se ejecuta
algún código de JScript que haya escrito. (En la instrucción if...else, se ejecuta un
código distinto si la condición no cumple la comprobación.) La forma más sencilla
de una instrucción if se puede escribir completamente en una sola línea, pero se
usan mucho más las instrucciones if e if...else de múltiples líneas.
Los siguientes ejemplos demuestran distintas sintaxis que puede usar con las
instrucciones if e if...else. El primer ejemplo muestra el tipo de comprobación
Boolean más sencillo. Si (y sólo si) el elemento encerrado entre paréntesis da como
resultado true, se ejecuta la instrucción o el bloque de instrucciones que sigue a la
instrucción if.
// La función smash() se define en cualquier otra parte del código.
if (newShip)
smash(champagneBottle,bow); // Comprobación de tipo Boolean para
saber si newShip es true.
// En este ejemplo, la comprobación no se cumple a menos que ambas
condiciones sean verdaderas.
if (rind.color == "amarillo oscuro" && rind.texture == "arrugas
grandes y pequeñas")
{
laRespuesta = ("¿Es un melón? <br> ");
}
// En este ejemplo, la comprobación se cumple si cualquiera de las
condiciones es verdadera.
var laReaccion = "";
if ((PesoEnLibras > 15) || (PesoEnLibras > 45))
{
laReaccion = ("¡Qué lindo gatito! <br>");
}
Norbert Wiener
95
Manual del Alumno
else
laReaccion = ("¡Es un gato enorme! <br>");
Operador condicional
JScript también admite una forma condicional implícita. Utiliza un signo de
interrogación después de la condición que va a comprobar (en lugar de la palabra if
antes de la condición) y especifica dos alternativas, una para usarla si la condición
se cumple y otra para usarla si no se cumple. Las alternativas están separadas por
dos puntos.
var horas = "";
// Código que especifica que la variable horas tiene el contenido de
// laHora o laHora - 12.
horas += (laHora >= 12) ? " p.m." : " a.m.";
Sugerencia Si tiene que comprobar varias condiciones juntas y sabe que alguna tiene más posibilidades
de cumplirse, o de no cumplirse, que las demás, dependiendo de si las comprobaciones están conectadas
OR (||) o con AND (&&), puede sacrificar la velocidad de ejecución de su secuencia de comandos
colocando esa condición primero en la instrucción condicional. Por ejemplo, si tres condiciones deben ser
verdaderas (usando operadores &&) y la segunda comprobación no se cumple, no se comprueba la tercera
condición.
De forma similar, si de varias condiciones, sólo una debe ser verdadera (usando operadores ||), la
comprobación se detiene cuando cualquier condición cumple la comprobación. Esto es particularmente
efectivo si las condiciones que desea comprobar implican la ejecución de llamadas a funciones o de otro
código.
Un ejemplo de los efectos secundarios de cortocircuito, es que en el siguiente ejemplo no se ejecutará
ejecutarsegundo si ejecutarprimero() devuelve 0 o false.
if ((ejecutarprimero() == 0) || (ejecutarsegundo() == 0))
// algún código
Usar repeticiones o bucles
Existen varias formas de ejecutar una instrucción o un bloque de instrucciones
repetidas veces. En general, la ejecución repetitiva se llama ejecución en bucle.
Normalmente se controla mediante la comprobación de alguna variable cuyo valor
cambia cada vez que se ejecuta el bucle. Microsoft JScript es compatible con
muchos tipos de bucles: for, for...in, while, do...while y switch.
Usar bucles for
La instrucción for especifica una variable de contador, una condición de
comprobación y una acción que actualiza el contador. Justo antes de cada ejecución
del bucle (esto se llama una iteración del bucle), se comprueba la condición.
Después de ejecutar el bucle, la variable de contador se actualiza antes de
comenzar la siguiente iteración.
Si nunca se cumple la condición del bucle, éste nunca se ejecuta. Si la condición del
bucle se cumple siempre, el bucle se convierte en un proceso infinito. Aunque es
posible que lo primero sea necesario en algunos casos, lo segundo, raramente lo
es. Por lo que debe tener cuidado al escribir las condiciones de sus bucles.
Norbert Wiener
96
Manual del Alumno
/*
La expresión de actualización ("icount++" en los siguientes ejemplos)
se ejecuta al final del bucle, después de que el bloque de instrucciones que
forman el
cuerpo del bucle se ejecuta y antes de comprobar la condición.
*/
var limite = 11; // Establece un límite de 11 en el bucle.
var suma = new Array(limite); // Crea una matriz llamada suma con 11
miembros, desde 0 hasta 10.
var laSuma = 0;
suma[0] = 0;
for(var icount = 1; icount < limite; icount++) {
// En este caso,
cuenta desde 1 hasta 10.
laSuma += icount;
suma[icount] = laSuma;
}
var nuevaSuma = 0;
for(var icount = 1; icount > limite; icount++) {
// Esto nunca se ejecuta.
nuevaSuma += icount;
}
var suma = 0;
for(var icount = 1; icount > 0; icount++) {
// Esto es un bucle infinito.
suma += icount;
}
Usar bucles for...in
JScript proporciona un tipo de bucle especial para examinar una a una todas las
propiedades de un objeto. El contador del bucle en un bucle for...in itera por todos
los índices de la matriz. El contador es una cadena, no un número.
for (j in pastaVerde) // pastaVerde es un objeto con varias
propiedades
{
// Varias instrucciones de código JScript.
}
Usar bucles while
El bucle while es muy parecido a un bucle for. La diferencia es que un bucle while
no tiene incorporada una variable de contador o una expresión de actualización. Si
ya tiene alguna condición que cambia y que se refleja en el valor asignado a una
variable y desea usarla para controlar la ejecución repetitiva de una instrucción o
un bloque de instrucciones, utilice un bucle while.
var losMomentos = "";
var laCuenta = 42;
// Inicia la variable de contador.
while (laCuenta >= 1) {
if (laCuenta > 1) {
losMomentos = "Sólo quedan " + laCuenta + " momentos.";
}
else {
losMomentos = "Sólo queda un momento.";
}
laCuenta--;
// Actualiza la variable de contador.
}
losMomentos = "Terminó";
97
Norbert Wiener
Manual del Alumno
Nota Debido a que los bucles while no tienen variables de contador explícitas incorporadas, todavía son
más vulnerables a crear bucles infinitos que otros tipos de bucles. Además, en parte porque no es
necesariamente fácil de descubrir dónde y cuándo se actualiza la condición del bucle, sólo es muy fácil
escribir un bucle while en el que la condición nunca se actualice. Debe tener mucha precaución al diseñar
bucles while.
Usar instrucciones break y continue
Microsoft JScript proporciona una instrucción para detener la ejecución de un bucle.
La instrucción break se puede usar para detener la ejecución si se cumple alguna
condición (que se supone una condición especial). La instrucción continue se
puede usar para pasar inmediatamente a la siguiente iteración, saltando el resto
del bloque de código pero actualizando la variable de contador como sucede si el
bucle es un bucle for o for...in.
var
var
var
var
for
{
elComentario = "";
elResto = 0;
laSalida = 3;
comprobar = 27;
(kcuenta = 1; kcuenta <= 10; kcuenta++)
elResto = comprobar % kcuenta;
if (elResto == laSalida)
{
break; // Sale del bucle al encontrar el primer resto igual a
salida.
}
elComentario = comprobar + " dividido por " + kcuenta + " deja un resto igual
a " + elResto;
}
for (kcuenta = 1; kcuenta <= 10; kcuenta++)
{
elResto = comprobar % kcuenta;
if (elResto != laSalida)
{
continue; // Selecciona sólo los restos iguales a la salida, ignorando
todos los demás.
}
// Código de JScript que usa los restos seleccionados.
}
var losMomentos = "";
var laCuenta = 42; // Se inicia el contador.
while (laCuenta >= 1) {
// if (laCuenta < 10) { // Advertencia
// Este uso de continue crea un bucle infinito.
// continue;
// }
if (laCuenta > 1) {
losMomentos = "Sólo quedan " + laCuenta + " momentos.";
}
else {
losMomentos = "Sólo queda un momento.";
}
laCuenta--; // Se actualiza el contador.
}
laCuenta = "Terminó";
Norbert Wiener
Semana 15 :
98
Manual del Alumno
Ventanas y modelo de objetos.
Objeto window
Es el objeto principal. Define la ventana sobre la que estamos trabajando y tiene
como descendientes los objetos referentes a la barra de tareas, el documento o la
secuencia de direcciones de la última sesión. Ahora veremos su métodos y
propiedades más usadas
open
[Variable=][window.]open("URL","Nombre","Propiedades");
El método open sirve para crear (y abrir) una nueva ventana. Si queremos tener
acceso a ella desde la ventana donde la creamos deberemos asignarle una variable,
si no simplemente invocamos el método: el navegador automáticamente sabrá que
pertenece al objeto window. El parámetro URL contendrá la dirección de la ventana
que estamos abriendo: si está en blanco, la ventana se abrirá con una página en
blanco. El Nombre será el que queramos que se utilize como parámetro de un
TARGET y las Propiedades son una lista separada por comas de algunos de los
siguientes elementos:
toolbar[=yes|no]
location[=yes|no]
directories[=yes|no]
status[=yes|no]
menubar[=yes|no]
scrollbars[=yes|no]
resizable[=yes|no]
width=pixels
height=pixels
Debemos tener cuidado con las propiedades que modifiquemos, es posible que
algunas combinaciones de los mismos no funcionen en todos los navegadores. El
Explorer 4, por ejemplo, da error ante la combinación toolbar=no, directories=no,
menubar=no.
close
Variable.close();
Cierra la ventana Variable.
A no ser que hayamos acabado de abrirla nosotros pedirá al usuario una ventana
para que decida él si quiere o no cerrarla.
Norbert Wiener
99
Manual del Alumno
alert
Variable.alert("Mensaje");
Muestra una ventana de diálogo en la ventana
especificado.
Variable con el mensaje
status
Define la cadena de caracteres que saldrá en la barra de estado en un momento
dado.
defaultStatus
Define la cadena de caracteres que saldrá por defecto en la barra de estado.
Cuando no la especificamos, defaultStatus será igual al último valor que tomó
status.
Objeto document
Es un objeto derivado de window que identifica a un documento HTML.
write
document.write("Cadena");
Escribe en un documento HTML, en el lugar del mismo donde hayamos situado el
script que contiene al mé:todo, la cadena dada. El método writeln hace lo
mismo, pero incluyendo al final un retorno de carro.
lastModified
Contiene la fecha y hora en que se modificó el documento por última vez y se suele
usar en conjunción con write para añadir al final del documento estas
características.
bgColor
Modifica el color de fondo del documento. El color deberá estar en el formato usado
en HTML. Es decir, puede ser red o FF0000.
Objeto history
Este objeto se deriva de document y contiene todas las direcciones que se han
visitado en la sesión actual. Tiene estos tres métodos:
o
document.history.back(): Volver a la página anterior.
o
document.history.forward(): Ir a la página siguiente.
o
document.history.go(donde): Ir a donde se indique, siendo donde un
número tal que go(1)=forward() y go(-1)=back().
Norbert Wiener
100
Manual del Alumno
Objeto form
Este objeto derivado de document se refiere a un formulario. Puede ser útil para
verificarlos antes de enviarlos.
submit
Nombre.submit()
Envía el formulario llamando Nombre.
text
Contiene el texto contenido en un campo de edición de un formulario.
Objeto date
Este es un objeto de propósito general que permite trabajar con fechas y horas
Objeto math
Este otro objeto de propósito general incluye las diversas funciones matemáticas
más comunes, como abs o sin o el valor PI.
Objeto navigator
A través de este objeto podremos averiguar varias características del navegador
que usamos. Por ejemplo:
o
navigator.appName: Nombre del navegador.
o
navigator.appVer: Número principal de versión.
o
navigator.language: Idioma del mismo.
o
navigator.platform: Plataforma donde esta ejecutándose.
No podemos sobreescribir estos atributos, pero sí leerlos.
Objeto screen
Con este objeto podremos averiguar la configuración de la pantalla. Al igual que en
el anterior, todos sus atributos son de sólo lectura.
o
screen.height: Altura..
o
screen.width: Anchura.
o
screen.pixelDepth: Número de bits por pixel.
Norbert Wiener
101
Manual del Alumno
Eventos
Un evento, como su mismo nombre indica, es algo que ocurre. Para que una rutina
nuestra se ejecute sólo cuando suceda algo extraño deberemos llamarla desde un
controlador de eventos. Estos controladores se asocian a un elemento HTML y se
incluyen así:
<A HREF="http://home.netscape.com" onMouseOver="MiFuncion()">
Lista de Eventos
Aquí se expone una pequeña guía de eventos definidos en JavaScript :
Evento
Descripción
onLoad
Terminar de cargarse una página
onUnLoad
Salir de una página (descargarla)
Elementos que lo admiten
<BODY...>
<FRAMESET...>
<LAYER...>
<BODY...><FRAMESET...>
<LAYER...>
onMouseOver Pasar el ratón por encima
<A HREF..>
<AREA...>
<LAYER...>
onMouseOut Que el ratón deje de estar encima
<A HREF..>
<AREA...>
<LAYER...>
onSubmit
Enviar un formulario
<FORM...>
onClick
Pulsar un elemento
<INPUT TYPE="button, checkbox, link,
radio"...>
onBlur
Perder el cursor
<INPUT TYPE="text"...>
<TEXTAREA...>
<LAYER...>
onChange
Cambiar de contenido o perder el
cursor
<TEXTAREA...>
onFocus
Conseguir el cursor
<TEXTAREA...>
<LAYER...>
onSelect
Seleccionar texto
<TEXTAREA...>
Un ejemplo
Como ejemplo, vamos a hacer que una ventana aparezca automáticamente en
cuanto pasemos un cursor por encima de un elemento <A> (e impidiendo, de paso,
que quien esté viendo la página pueda hacer uso del mismo).
<HTML>
<HEAD>
<SCRIPT LANGUAGE="JavaScript">

</SCRIPT>
</HEAD>
<BODY>
<A HREF="eventos.html" onMouseOver="Alarma()">
Pasa por aquí encima
</A>
</BODY>
</HTML>
Objeto event
Este objeto permite la identificación de un evento con el atributo type y su
localizacion con x e y, entre otras cosas. Así, por ejemplo, podríamos hacer:
<A HREF="http://home.netscape.com" onMouseOut='alert("Hubo un evento
"+event.type+" en el enlace.")'>
Pasa por aquí encima y cuando te vayas saldrá la ventanita
</A>
Su importancia radica en el hecho de que se puede usar para capturar toda clase
de eventos por medio de la función captureEvents(e). El argumento de esta
función es una propiedad del objeto event que indica el tipo de eventos que
desees capturas de este modo:
captureEvents(event.CLICK | event.MOUSEOVER | event.BLUR)
que permitiría la captura de todos los eventos onLoad, onMouseOver y onBlur.
El único uso que le he encontrado a estas posibilidades está en la creación de
objetos nuevos, que de este modo tendrían un control de eventos propio.
Norbert Wiener
Semana 16 :
103
Manual del Alumno
HTML Dinámico.
DHTML
DHTML no es precisamente un lenguaje de programación. Más bien se trata de una
nueva capacidad de la que disponen los navegadores modernos, por la cual se
puede tener un mayor control sobre la página que antes.
Cualquier página que responde a las actividades del usuario y realiza efectos y
funcionalidades se puede englobar dentro del DHTML, pero en este caso nos
referimos más a efectos en el navegador por los cuales se pueden mostrar y ocultar
elementos de la página, se puede modificar su posición, dimensiones, color, etc.
DHTML nos da más control sobre la página, gracias a que los navegadores
modernos incluyen una nueva estructura para visualizar en páginas web
denominada capa. Las capas se pueden ocultar, mostrar, desplazar, etc.
Para realizar las acciones sobre la página, como modificar la apariencia de una
capa, seguimos necesitando un lenguaje de programación del lado del cliente como
Javascript o VBScript.
Dentro del concepto de DHTML se engloban también las Hojas de Estilo en
Cascada o CSS (Cascade Style Sheets), que veremos a continuación.
Qué es CSS
CSS, es una tecnología que nos permite crear páginas web de una manera más
exacta. Gracias a las CSS somos mucho más dueños de los resultados finales de la
página, pudiendo hacer muchas cosas que no se podía hacer utilizando solamente
HTML, como incluir márgenes, tipos de letra, fondos, colores...
CSS son las siglas de Cascading Style Sheets, en español Hojas de estilo en
Cascada. En este reportaje vamos a ver algunos de los efectos que se pueden crear
con las CSS sin necesidad de conocer la tecnología entera.
Para empezar
Las Hojas de Estilo en Cascada se escriben dentro del código HTML de la página
web, solo en casos avanzados se pueden escribir en un archivo a parte y enlazar la
página con ese archivo. En un principio vamos a utilizar la manera más directa de
aplicar estilos a los elementos de la página, mas adelante veremos la declaración
en archivos externos. Para ello, y esto es la primera lección de este artículo, vamos
a conocer un nuevo atributo que se puede utilizar en casi todas las etiquetas HTML:
style.
Ejemplo:
<p
style="color:green;font-weight:bold">El
párrafo
saldrá
con
color
verde
y
en
negrita</p>
Dentro del atributo style se deben indicar los atributos de estilos CSS separados por
punto y coma (;). Durante este artículo vamos a conocer muchos atributos de CSS,
los dos primeros que hemos visto aquí son:
Norbert Wiener
104
Manual del Alumno
Color: indica el color del contenido la etiqueta donde estemos utilizándolo,
generalmente indica el color del texto.
Font-weight: indica el grosor del texto. Bold sirve para poner en negrita.
Color en los enlaces
Con HTML definimos el color de los enlaces en la etiqueta <body>, con lo atributos
link, vlink y alink. Esto nos permite cambiar el color de los enlaces para todo el
documento, pero ¿Y si queremos cambiar el color de un enlace en concreto, para
que tenga otro color que el definido en la etiqueta <body>?
Para hacer esto utilizaremos el atributo style dentro del enlace:
<a href="mienlace.html" style="color:red">
Así saldrá el enlace en color rojo, independientemente de lo definido para todo el
documento.
Espaciado entre líneas
Con CSS podemos definir el espacio que hay entre cada línea del documento,
utilizando el atributo line-height. Por ejemplo, podemos definir que para todo un
párrafo el espacio entre cada una de sus líneas sea 25 pixels:
<p style="line-height: 25px;">
Un párrafo normal en el que cada una de las líneas está separada 25 pixels de la otra. Hay que poner
suficiente texto como para que se vean 2 líneas, así saldrán separadas
</p>
Espaciado entre caracteres
Se puede definir también el espacio entre cada carácter. Esto se hace con el
atributo de CSS letter-spacing. Veamos un ejemplo:
<p style="letter-spacing:12cm">
Este párrafo tiene las letras espaciadas por 1 centímetro.
</p>
Este atributo, al igual que ocurre con muchos otros de CSS, no está soportado por
todos los navegadores. En concreto Netscape, en su versión 4 todavía no lo incluye.
Enlaces sin subrayado
Uno de los efectos más significativos y fáciles de realizar con CSS es eliminar el
subrayado de los enlaces de una página web. Existe un atributo que sirve para
definir la decoración de un texto, si está subrayado, tachado, o si no tiene ninguna
de estas "decoraciones". Es el atributo text-decoration, en este caso indicaremos en
un enlace que no queremos decoración:
<a href="mipagina.html" style="text-decoration:none">
Incluir estilos para todo un sitio web
Una de las características más potentes de la programación con hojas de estilo
105
Norbert Wiener
Manual del Alumno
consiste en definir los estilos de todo un sitio web. Esto se consigue creando un
archivo donde tan sólo colocamos las declaraciones de estilos de la página y
enlazando todas las páginas del sitio con ese archivo. De este modo, todas las
páginas comparten una misma declaración de estilos y, por tanto, si la cambiamos,
cambiarán todas las páginas.
Veamos ahora todo el proceso para incluir estilos con un fichero externo.
1- Creamos el fichero con la declaración de estilos
Es un fichero de texto normal, que puede tener cualquier extensión, aunque le
podemos asignar la extensión .css para aclararnos qué tipo de archivo es. El texto
que debemos incluir debe ser escrito exclusivamente en sintaxis CSS, es un poco
distinta que la sintaxis que utilizamos dentro del atributo style. Sería erróneo incluir
código HTML en este archivo: etiquetas y demás. Podemos ver un ejemplo a
continuación.
P{
font-size : 12pt;
font-family : arial,helvetica;
font-weight : normal;
}
H1 {
font-size : 36pt;
font-family : verdana,arial;
text-decoration : underline;
text-align : center;
background-color : Teal;
}
BODY {
background-color : #006600;
font-family : arial;
color : White;
}
2- Enlazamos la página web con la hoja de estilos
Para ello vamos a colocar la etiqueta <LINK> con los atributos
rel="STYLESHEET" indicando que el enlace es con una hoja de estilo.
type="text/css" porque el archivo es de texto, en sintaxis CSS.
href="estilos.css" indica el nombre del fichero fuente de los estilos.
Veamos una página web entera que enlaza con la declaración de estilos anterior:
<html>
<head>
<link rel="STYLESHEET" type="text/css" href="estilos.css">
<title>Página que lee estilos</title>
</head>
<body>
<h1>Página que lee estilos</h1>
<p>
Esta página tiene en la cabecera la etiqueta necesaria para enlazar con la hoja de estilos. Es muy fácil.
</p>
</body>
</html>
Las CSS tienen mucho más jugo
Las Hojas de Estilo en Cascada son un estándar muy amplio, con unas
especificaciones y posibilidades muy grandes. En este artículo hemos visto unos
cuantos efectos interesantes que realizar aunque no tengamos ningún conocimiento
previo. Sin embargo, lo mejor para trabajar con esta tecnología es conocerla bien,
gracias a ello, los resultados serán mucho más sorprendentes.
Norbert Wiener
Semana 17 :
106
Manual del Alumno
JavaScript : Animación.
ANIMACIONES
La animación en JavaScript puede ser de texto, imágenes o ambas cosas
interactuando. En todos los casos para conseguirla se trabaja del mismo modo.
Lo primero que tendremos que hacer es preparar las etiquetas del texto o de la
imagen dandoles un nombre (con los mismos requisitos que las variables) por
medio del atributo name en caso de las imágenes e id en caso de texto. De esta
manera podremos hacer referencia al elemento deseado desde la función
encargada de ejecutar la animación.
A continuación, añadiremos el evento con la llamada a la función (si es necesario,
en muchas ocasiones se llama a la función por medio del método setTimeout que
veremos en un momento).
El último cambio que afecta a las etiquetas del texto o de la imagen afecta a los
estilos. Por tanto tendremos que añadir obligatoriamente el atributo style con todos
aquellos estilos que intervengan en la animación. De entre todos los estilos que
existen, podemos destacar los que hay en la siguiente tabla.
ESTILOS
SINTAXIS
DESCRIPCIÓN
Posibilita el
style="Position:absolute;top:pos;left:pos" cambio de
posición.
style="color:nombre_color"
Posibilita el
cambio de
color.
style="visibility:hidden o visible"
Posibilita
mostrar y
ocultar.
Recordar que si trabajamos con varios estilos todos se incluyen dentro de un
atributo style.
Una vez construida y modificada la o las etiquetas, las variaciones que sufran sus
etilos o cualquier otro de sus atributos se realizarán en la función que tengamos
preparada para ello. Para todos los cambios que realicemos la sintaxis a seguir es:
SINTAXIS:
nombre_etiqueta.style.estilo=valor;
nombre_etiqueta.atributo=valor;
Si nuestra animación avanza según un intervalo de tiempo, debemos utilizar el
método setTimeout() para establecer el intervalo de tiempo y la llamada a la
función. Este método se puede utilizar en cualquier parte del código, pero
normalmente se encuentra al principio del código y dentro de la función donde se
realiza cada uno de los pasos de nuestra animación. La sintaxis del método es
(recordar respetar mayúsculas y minúsculas):
Norbert Wiener
107
Manual del Alumno
SINTAXIS:
setTimeout("nombre_función()",intervalo milisegundos);
EJEMPLOS
EJEMPLO 1: Texto con movimiento en horizontal.
<html>
<head>
<script>
var horizontal=12;
setTimeout("mueve()",500);
function mueve()
{
horizontal+=10;
TEXTO1.style.left=horizontal;
if(horizontal>=200)
horizontal=12;
setTimeout("mueve()",500);
}
</script>
</head>
<body>
<p id="TEXTO1" style="position:absolute; top:16; left:12">
TEXTO
</p>
</body>
</html>
EJEMPLO 2: Texto que aparece y desaparece.
<html>
<head>
<script>
var estado=true;
setTimeout("ver()",500);
function ver()
{
estado=!estado;
if(estado==true)
TEXTO1.style.visibility="visible";
else
TEXTO1.style.visibility="hidden";
setTimeout("ver()",500);
}
</script>
</head>
<body>
<p id="TEXTO1" style="visibility:visible">TEXTO</p>
</body>
</html>
EJEMPLO 3: Imagen que cambia cuando entra y sale el ratón.
<html>
<head>
Norbert Wiener
108
Manual del Alumno
<script>
function pasa(valor)
{
if(valor==1)
img.src="ten1.gif"
else
img.src="ten2.gif"
}
</script>
</head>
<body>
<img name="img" src="ten2.gif" onMouseOver=pasa(1); onMouseOut=pasa(2);>
</body>
</html>
EJEMPLO 4: Imágenes que van cambiando solas.
<html>
<head>
<script>
var estado=true;
setTimeout("cambio()",500);
function cambio()
{
estado=!estado;
if(estado==true)
img.src="tenista1.gif"
else
setTimeout("cambio()",500);
}
</script>
</head>
<body>
<img name="img" src="tenista1.gif">
</body>
</html>
EJEMPLO 5: Cambiamos la imagen según situemos el ratón en un texto o
en otro.
<html>
<head>
<script>
function imag(valor)
{
if(valor==1)
else
}
</script>
</head>
<body>
<table border="1" width="15%">
<tr>
<td width="100%"><p onMouseOver=imag(1);>IMAGEN 1</td>
</tr>
Norbert Wiener
109
Manual del Alumno
<tr>
<td width="100%"><p onMouseOver=imag(2);>IMAGEN 2</td>
</tr>
</table>
<br>
</body>
</html>
EJEMPLO 6: Cambiar la imagen por medio de un control. En este caso una
lista (select). Es igual que en el caso anterior. Lo único que cambia es el
evento que gestiona la llamada a la función.
<html>
<head>
<script>
function cambio(valor)
{
if(valor=="imagen1")
else
}
</script>
</head>
<body>
<select size="3" name="lista" onChange=cambio(value);>
<option value="imagen1">Imagen 1</option>
<option value="imagen2">Imagen 2</option>
</select>
<br>
</body>
</html>
EJEMPLO 7: Una imagen moviéndose en vertical automáticamente.
<html>
<head>
<script>
var vertical=35;
var ida=true;
setTimeout("mover()",200);
function mover()
{
if(vertical<=200 && ida==true)
vertical+=10;
else
{
vertical-=10;
ida=false;
if(vertical<=35)
ida=true;
}
img.style.top=vertical;
setTimeout("mover()",200);
}
</script>
</head>
<body>
<img name="img" src="pic.gif"
style="position:absolute; left:12; top:35">
</body>
</html>
Norbert Wiener
Semana 18 :
110
Manual del Alumno
Aplicación Web.
Cookies
Parece más que necesario definir algo que lleva el absurdo nombre de galletita o
cookie. Una galleta es un elemento de una lista que se guarda en el fichero
cookies.txt en el ordenador del visitante. Cada elemento de esa lista tiene dos
campos obligatorios: el nombre y su valor; y uno opcional: la fecha de caducidad.
Este último campo sirve para establecer la fecha en la que se borrará la galleta.
Tiene este formato:
nombre=valor;[expires=caducidad;]
Sólo el servidor que ha enviado al usuario una determinada cookie puede
consultarla. Cada galleta tiene un tamaño máximo de 4 Kb y puede haber un
máximo de 300 cookies en el disco duro. Cada servidor podrá almacenar como
mucho 20 galletas en el fichero cookies.txt (en el caso de usar Netscape) o en el
directorio cookies (si utilizamos Explorer) del usuario. Si no especificamos la fecha
de caducidad la galleta se borrará del disco duro del usuario en cuanto éste cierre
el navegador.
Funciones básicas
Para poder hacer algo con cookies deberemos programar dos funciones: una que se
encargue de mandar una galleta al usuario y otra que consulte su contenido.
function mandarGalleta(nombre, valor, caducidad) {
document.cookie = nombre + "=" + escape(valor)
+ ((caducidad == null) ? "" : ("; expires=" + caducidad.toGMTString()))
}
Con esta función mandamos una galleta. Vemos que el valor es codificado por
medio de la función escape y que la caducidad (en caso de decidir ponerla) debe
ser convertida a formato GMT. Esto se hace mediante el metodo toGMTString() del
objeto Date.
function consultarGalleta(nombre) {
var buscamos = nombre + "=";
if (document.cookie.length > 0) {
i = document.cookie.indexOf(buscamos);
if (i != -1) {
i += buscamos.length;
j = document.cookie.indexOf(";", i);
if (j == -1)
j = document.cookie.length;
return unescape(document.cookie.substring(i,j));
}
}
}
111
Norbert Wiener
Manual del Alumno
Declaramos la variable buscamos que contiene el nombre de la galleta que
queremos buscar más el igual que se escribe justo después de cada nombre, para
que así no encontremos por error un valor o una subcadena de otro nombre que
sea igual al nombre de la galleta que buscamos. Una vez encontrada extraemos la
subcadena que hay entre el igual que separa el nombre y el valor y el punto y coma
con que termina dicho valor.
Un ejemplo
Vamos
a
ver
un
ejemplo.
Utilizaremos
una
galleta
llamada
VisitasAlCursoDeJavaScript para guardar el número de veces que has visitado este
curso:
<HTML>
<HEAD>

</SCRIPT>
</HEAD>
<BODY>
Por lo que veo,
<!-Contador();
// -->
</SCRIPT>
</BODY>
</HTML>
La función consulta el valor de la galleta incrementandolo y, si no existe, lo pone a
uno. Luego escribe en el documento el número de veces que has visitado el curso
Semana 19 :
Semana 20 :
(Examen Final).
(Examen Sustitutorio).

aplicativos v (visual script y javascript)

Transcripción

Documentos relacionados

Nuevos horarios de entrada y salida para el año escolar 2016-17

funciones lógicas

Actividades Operacionales en todo el pais