Introducción

Un programa es un conjunto de instrucciones que al ser ejecutadas por un computador permiten que éste lleve a cabo ciertas tareas: como pueden ser la de llevar a cabo ciertos cálculos numéricos por nosotros, imprimir un informe de gastos anual o darnos un mensaje de bienvenida al encender el sistema.

Los programas se escriben mediante lenguajes de programación. Los lenguajes de programación son muy parecidos (por lo que respecta a las reglas sintácticas, no a su uso) a nuestras propias lenguas. Como ellas constan: 1) de un alfabeto, que especifica con todo rigor cuales son los símbolos admitidos por el lenguaje; 2) y de una serie de reglas de construcción de instrucciones o sintaxis, que determinan que concatenaciones y cuales no constituyen una instrucción del lenguaje. La diferencia pues, entre nuestras lenguas y los lenguajes de programación (por lo que respecta a las reglas de construcción sintácticas) es la precisión y el rigor de estos últimos con respecto a los primeros. Mientras que en los lenguajes que empleamos para comunicarnos y expresarnos, día a día, nos podemos permitir ciertas libertades estilísticas (puesto que una de sus principales funciones, junto a la comunicación, es la propia expresividad), y lejos está de ser una cuestión resoluble la de poder determinar que sea o no una oración de forma concluyente, en una instrucción de un lenguaje de programación no nos podemos permitir ninguna concesión de estilo, puesto que el resultado será un error de interpretación por parte del computador. Los lenguajes de programación responden a un fin: dotarnos de un entorno familiar desde el cual poder dar órdenes al computador para que lleve a cabo ciertas tareas.

Se distinguen lenguajes de alto nivel y de bajo nivel. Los lenguajes de bajo nivel pueden ser procesados directamente por la máquina puesto que están escritos directamente en su idioma: el denominado código máquina ¡plagado de ceros y unos! Frente a la complejidad de éste tipo de lenguajes (a pesar de lo que pudiera sugerir la denominación de bajo nivel, quizás sería más conveniente llamarlos de nivel profundo y de nivel superficial) se encuentran los lenguajes de alto nivel que utilizan términos y símbolos conocidos por todos: +, -, for, break, etc. Ahora bien, a diferencia de los anteriores deben ser traducidos a código máquina, si queremos que el computador pueda procesarlos: la llamada compilación. La compilación no es pues más que la traducción de las oraciones escritas con estos lenguajes a instrucciones que el ordenador entienda.

Cada programa escrito con un lenguaje de alto nivel debe ser compilado para la plataforma correspondiente: PC, Applet, etc. Ahora bien, si lo que buscamos es código multiplataforma, código independiente de ésta, tendremos que compilar el programa en tiempo de ejecución en el sistema correspondiente. Es decir, a medida que el programa en cuestión se va ejecutando.   

¡Y esto es justamente lo que ocurre con Java Script y VBScript!  Java Script y VBScript (desde ahora respectivamente JS y VBS) son lenguajes de script, de guiones, que se insertan en las páginas web mediante la etiqueta <Script>. Una vez que el navegador descarga una página que contiene un script se encarga de interpretarlo y de ejecutarlo. Así se consigue la independencia del script frente a la plataforma. ¡Lo único que necesitamos pues es un navegador que interprete scripts! E Internet Explorer 4.0 interpreta scripts de ambos lenguajes.

La etiqueta <Script>

La etiqueta <Script> puede insertarse  en cualquier parte de la página, aunque frecuentemente se sitúa en la sección de cabecera. Mediante el atributo language se debe indicar si se trata de un script de Java Script o VBScript (si no se indica se sobreentiende que es un script de Java Script):

<Script language="JavaScript">
<!--
  código
-->
</Script>

<Script language="VBScript">
<!--
  código
-->
</Script>

Los símbolos <!-- y --> evitan que los navegadores que no puedan interpretar scripts interpreten el código de éstos como parte del contenido de la página. Para facilitar la lectura del código no incluiré tales símbolos en los ejemplos subsiguientes.

Una página web puede contener más de un script. Su orden de ejecución corresponde a su orden de aparición en la página. Si bien hay scripts que no son ejecutados hasta que el usuario lleve a cabo alguna acción (como los manejadores de eventos) o el estado de la página cambie por algún motivo (por ejemplo, porque se acaba de procesar todo el documento). Pero no te preocupes ahora demasiado por estas cuestiones, a medida que avancemos iremos viendo distintos ejemplos de ellas.

Sentencias, bloques y comentarios

En un script nos podemos encontrar con tres tipos de instrucciones: sentencias, bloques y comentarios. Las sentencias son instrucciones que llevan a cabo alguna tarea. Por ejemplo la siguiente sentencia, al ser ejecutada por el navegador, muestra una ventana con el mensaje Bienvenido al curso de Java Script y VBScript:

alert("Bienvenido al curso de Java Script y VBScript")

Observa que éste código se ejecuta cuando pulsamos sobre el botón. No se ejecuta al cargarse la página. Si nuestra intención fuera esta tendríamos que incluirlo (por ejemplo en la sección de cabecera) de la manera siguiente:

<Script>
  alert("Bienvenido al curso de Java Script y VBScript")
</Script>

Se pueden escribir en una misma línea más de una sentencia de código. Para indicar entonces al intérprete donde acaba cada sentencia se utiliza el símbolo ; para JS o : para VBS (de hecho se pueden incluir tales símbolos aunque la línea de código sólo contenga una sentencia):

<Script language="JavaScript">
  alert("Esto es un mensaje");alert("Y este, otro")
</Script>

El código correspondiente para VBS:

<Script language="VBScript">
  alert("Esto es un mensaje"):alert("Y este, otro")
</Script>

Los bloques no son más que conjuntos de sentencias agrupadas que llevan a cabo una acción específica dentro del código. En JS las sentencias se agrupan mediante los símbolos { y }. El siguiente código te preguntará por tu nombre. Si escribes Alicia obtendrá dos mensajes. ¡No te preocupe por entender todo el código! Simplemente fíjate en las dos sentencias incluidas entre llaves:

<Script language="JavaScript">
nombre = prompt("Introduzca su nombre por favor", "")
if(nombre == "Alicia"){
  alert("Hola " + nombre)
  alert("Hoy hace un día soleado")
}
</Script>

El código correspondiente en VBS sería:

<Script language="VBScript">
nombre = prompt("Introduzca su nombre por favor", "")
If nombre = "Alicia" Then
  alert("Hola " & nombre)
  alert("Hoy hace un día soleado")
End If
</Script>

En este caso las sentencias del ejemplo anterior van situadas entre las palabras claves If y End IF. Aunque también podrían ir entre las palabras Sub y End Sub o Function y End Function, etc. Como siempre no te preocupes por el significado de tales palabras. Lo importante ahora es que entiendas que se están definiendo bloques de sentencias que se ejecutarán bajo determinadas circunstancias (como que sea Alicia y no otra persona la que accede al sistema).

Nota 1: Las palabras clave de un lenguaje de programación son las palabras pertenecientes al propio lenguaje.

Por último mediante los comentarios podemos hacer explícito a otros (o a nosotros mismos en un futuro) las tareas llevadas a cabo por nuestro código. JS utiliza el símbolo // para especificar un comentario. VBS utiliza el símbolo '. Los comentarios no son interpretados por el navegador:

//La siguiente sentencia le desea unos "buenos días"
alert("Buenos días")

O en VBS:

'La siguiente sentencia le desea "buenas tardes"
alert("Buenos tardes")

También se suelen situar a la derecha del código:

alert("Buenas noches")	//Le desea "buenas noches"

Variables

Las variables son una de las piezas clave de todo lenguaje de programación. Piense en un programa como en una receta de cocina, y en el computador que sigue las instrucciones del programa como en el cocinero que lleva a acabo la receta. El cocinero necesita una serie de ingredientes con los que llevar a cabo una serie de procesos tras los cuales de por concluida su receta. Igualmente el computador necesita de datos para llevar a cabo sus tareas. Y aquí es donde entran en juego las variables. Las variables nos permiten almacenar y manipular datos mediante nombres.

Generalmente antes de usar una variable se la suele declarar. Declarar una variable no es más que reservar una región de la memoria de trabajo del ordenador: la llamada memoria RAM. La memoria de trabajo del ordenador es la memoria donde, entre otras cosas, el ordenador va almacenando los datos iniciales y el resultado de las diferentes operaciones llevadas a cabo con tales datos. Fíjate en la hoja de calculo mostrada parcialmente en la  fig.1:

fig.1

Podemos imaginarnos la memoria RAM del ordenador organizada en parcelas como el conjunto de celdas de una hoja de cálculo. Cada parcela tiene una dirección que se representa mediante un número hexadecimal y que en la hoja de cálculo se representa mediante una letra de columna y un número de fila (por ejemplo B3). Cuando declaramos una variable lo que estamos haciendo no es más que reservando espacio de antemano en una de estas parcelas para su uso posterior. La siguiente sentencia declara una variable denominada cadena en JS mediante la palabra reservada var y en VBS mediante la palabra dim:

var cadena	

dim cadena	

Nota 1: Los nombres de las variables pueden contener letras, números y el símbolo _. No se puede utilizar un número como primer carácter del nombre de una variable.

Por ahora sólo habríamos reservado espacio en memoria para ambos casos. Aún no habríamos asignado ningún valor a tales parcelas. Si te fijas de nuevo en la fig.1 observa que la celda B3 contiene el valor alfanumérico "Alicia". Si quisieras asignar tal valor a las variables anteriormente declaradas tendrías que escribir los siguientes códigos:

var cadena			//declara la variable
cadena = "Alicia"		//asigna el valor "Alicia"

dim cadena			//declara la variable
cadena = "Alicia"     	//asigna el valor "Alicia"

En ambos casos hemos declarado primeramente las variables y posteriormente les hemos asignado mediante el operador de asignación = el valor alfanumérico Alicia (fíjate que va entrecomillado).

Nota 2: Las declaraciones anteriormente expuestas reciben el nombre de declaraciones explícitas. Pero tanto JS como VBS aceptan también la declaración implícita de sus variables:

cadena = "Alicia"

cadena = "Alicia"

La diferencia estriba en que se asigna directamente el valor a la variable sin incluir las palabras var y dim. Generalmente la ejecución de un programa es más rápida cuando se reserva espacio con antelación para sus variables. Pero nos encontraremos con ejemplos de código que utilicen este modo de declaración.

Nota 3: JS a diferencia de VBS es sensible a las mayúsculas. Fíjate en el siguiente código:

var cadena
cadena = "Lewis"
Cadena = "Alicia"
alert(cadena)

dim cadena
cadena = "Lewis"
Cadena = "Alicia"
alert(cadena)

Aparentemente en ambos códigos primero se declara la variable cadena, luego se asigna el valor Lewis a la variable cadena y luego se reasigna el valor Alicia a la variable Cadena. Con lo cual cabría esperar que el valor resultante en ambos casos fuera Alicia que es el último valor asignado. Pero mientras que esto es a sí, en el caso de VBS, en el caso de JS no, debido a que para éste lenguaje de script las variables cadena y Cadena no son la misma (dicho sea de paso fíjate que esta vez no hemos utilizado las comillas dentro de los paréntesis de la sentencia alert. Esto se debe a que la sentencia alert está mostrando el valor de una variable, no un valor concreto como "Alicia").

Los valores que pueden ser asignados a una variable son básicamente los siguientes:

• Numéricos: comprenden los números enteros (como 3, 456, -8767, etc) y en coma flotante (como 3.5, 0.5689, etc).
• Alfanuméricos: también denominados cadenas que comprenden cualquier secuencia de signos entre comillas. Por ejemplo: "Alicia", "091", "Los caballeros de la mesa redonda" o inclusive "" (denominada cadena vacía).
• Booleanos: comprende los valores true y false (verdadero y falso) que nos van a permitir sobre todo evaluar expresiones condicionales.
• Referencias a objetos: los objetos son colecciones de propiedades y métodos que estudiaremos más adelante.

En función del tipo de valor asignado a una variable diremos que la variable es de tipo number, string, boolean, object, etc. Veamos un ejemplo:

numeroEntero = 4
numeroCFlotante = 0.5
cadena = "Alicia"
booleano = true
referenciaObjeto = window

numeroEntero = 4
numeroCFlotante = 0.5
cadena = "Alicia"
booleano = true
set referenciaObjeto = window

Como se puede apreciar para VBS la variable numeroEntero es de tipo integer y la variable numeroCFlotante de tipo float, mientras que en JS ambas variables son de tipo number. Además VBS utiliza la palabra reservada set cuando la variable contiene una referencia a objeto e indica la categoría a la que pertenece el objeto: en éste caso HTML.

Quizás te estés preguntando qué valores contienen las variables que aún no han sido inicializadas (es decir, que sólo han sido declaradas) y a que tipos pertenecen. En el caso de JS una variable que no ha sido inicializada es de tipo undefined y contiene el valor especial null. En el caso de VBS la variable sería de tipo empty y contendría la cadena vacía, "", o un cero, 0:

var nombre
alert(nombre)

dim nombre
alert(nombre)

Como puedes comprobar la sentencia alert arroja el tipo de la variable para JS y la cadena vacía para VBS.

Por último hay que decir que VBS incluye también, entre otros, el tipos date que JS trata como un objeto.

Procedimientos, funciones y objetos

Los procedimientos y  las funciones nos van a permitir llevar a cabo diferentes tareas. Por ahora sólo hemos visto como declarar y asignar valores (si bien la sentencia alert es en realidad un método del objeto window, como veremos más adelante). La diferencia entre los procedimientos y las funciones es que éstas últimas además de llevar a cabo una tarea devuelven un valor. Veamos primeramente un ejemplo de un procedimiento:

<Script language="JavaScript">
function buenosDias1() {
  alert("Bienvenido")
}

buenosDias()
</Script>

<Script language="VBScript">
Sub buenosDias2()
  alert("Bienvenido")
End Sub

buenosDias
</Script>

JS utiliza la palabra reservada function mientras que VBS utiliza la palabra Sub. Los dos utilizan las mismas normas para nombrar a los procedimientos y paréntesis para sus argumentos. Si no hay argumentos simplemente aparecerán los paréntesis. El cuerpo de la función se sitúa en JS entre llaves, y entre las sentencias Sub y End Sub en VBS. La única sentencia del cuerpo en el ejemplo es alert("Bienvenido"). La última sentencia se limita a llamar al procedimiento por su nombre. Obsérvese que JS incluye paréntesis después del nombre del procedimiento.

Si incluimos cualquiera de estos dos scripts en una página web obtendremos el mensaje de buenos días correspondiente. Si bien, para esto, sería más fácil incluir simplemente la sentencia alert apropiada. Ahora bien, imagina que el código correspondiente a los procedimientos sólo se ejecute cuando el usuario pulse sobre un determinado botón de la página (como en los ejemplos de ésta página):

<Script language="JavaScript">
function buenosDias1() {
  alert("Buenos días")
}
</Script>

<Script language="VBScript">
Sub buenosDias2()
  alert("Buenos días")
End Sub
</Script>

El código HTML para cada uno de los botones sería:

<P><Input type="button" value="Púlsame" language="javascript" onclick="buenosDias1()"></P>
<P><Input type="button" value="Púlsame" language="vbscript" onclick="buenosDias2"></P>

El atributo language indica al navegador el lenguaje de script a utilizar. Y el atributo onclick ejecuta el código que tenga asignado cuando el usuario pulse sobre el botón.

Cuando hablamos sobre la etiqueta <Script> mencionamos que algunos scripts no son ejecutados hasta que el usuario lleve a cabo alguna acción. Los casos anteriores son una muestra de ello.

Veamos ahora un ejemplo de función:

<Script language="JavaScript">
function suma1(a, b) {
  c = a + b
  return c
}

total = suma1(3, 2)
alert(total)
</Script>

<Script language="VBScript">
Function suma2(a, b)
  c = a + b
  suma2 = c
End Function

total = suma2(3, 2)
alert(total)
</Script>

Esta vez tanto JS como VBS utilizan la palabra clave function. Como antes utilizan las mismas normas para nombrar funciones y paréntesis para sus argumentos. A diferencia del ejemplo anterior, en este las funciones tienen dos argumentos, a y b, que recibirán los valores 3 y 2 cuando sean llamadas mediante las expresiones suma1(3, 2) y suma2(3, 2) respectivamente. Posteriormente en el cuerpo de la primera función se asigna a c el resultado de sumar los valores a y b, tras lo cual se devuelve el resultado de c mediante la sentencia return a la variable total. En el caso de la segunda función ocurre lo mismo, si bien el resultado es devuelto a la variable total asignando el valor de c al nombre de la función. Por último las sentencias siguientes son las encargadas de pasar los valores a la función, recibir el resultado de la operación de ésta y finalmente mostrar el resultado mediante una sentencia alert.

Al igual que antes, podemos llamar a estas funciones mediante botones. Pero esta vez vamos a complicar un poco más las cosas. Vamos a pedir al usuario que introduzca los dos números a ser sumados:

<Script language="JavaScript">
function suma3() {
  uno = prompt("introduzca un número", "")
  dos = prompt("introduzca otro número", "")
  c = uno + dos
  return c
}
</Script>

<Script language="VBScript">
Function suma4()
  uno = prompt("introduzca un número", "")
  dos = prompt("introduzca otro número", "")
  c = uno + dos
  suma4 = c
End Function
</Script>

La función prompt(), al igual que la sentencia alert, es un método del objeto window que nos permite mostrar una petición al usuario. Debe incluirse la cadena vacía como segundo argumento para evitar que aparezca la cadena undefined en el cuadro de texto donde el usuario debe introducir los datos. 

Seguramente te habrás percatado de que las funciones anteriores no realizan la adición de los valores introducidos, como era de esperar, sino que se limitan a concatenar tales valores. Esto se debe a que prompt() devuelve una cadena no un valor numérico y a que el operador + concatena cadenas cuando alguno de sus operandos es una cadena. Para evitar esto se deben convertir los valores devueltos por prompt() a valores numéricos mediante las funciones parseInt() y cInt() de JS y VBS de la manera siguiente:  

<Script language="JavaScript">
function suma5() {
  uno = prompt("introduzca un número", "")
  dos = prompt("introduzca otro número", "")
  c = parseInt(uno) + parseInt(dos)
  return c
}
</Script>

<Script language="VBScript">
Function suma6()
  uno = prompt("introduzca un número", "")
  dos = prompt("introduzca otro número", "")
  c = cInt(uno) + cInt(dos)
  suma6 = c
End Function
</Script>

Las funciones como parseInt() o cInt() nos ahorran trabajo en la elaboración de nuestro código. JS y VBS cuentan con un gran número de funciones de éste tipo para llevar a cabo operaciones relacionadas con el tipo de las variables, las cadenas, las fechas y ciertos cálculos matemáticos. Si bien, el enfoque conceptual de ambos lenguajes es diferente. Mientras que en VBS todas estas funciones son tratadas como funciones, en JS las operaciones concernientes a cadenas, fechas y operaciones matemáticas son tratadas como métodos de objetos.

Nota 1: Las funciones parseFloat() y cDbl() acometen la misma tarea para valores en coma flotante.

En programación un objeto no es más que una colección de propiedades y métodos. Las propiedades son variables en las que se reflejan las características esenciales del objeto, como pueden ser el alto, color y estado (abierta o cerrada) de una puerta:

tamaño = 2
color = "rojo"
estado = true

Estas tres variables podrían caracterizar una puerta roja de 2 metros abierta. Por supuesto entendemos que cualquier otro objeto puerta tendrá las mismas propiedades, si bien seguramente poseerá valores distintos para algunas de sus variables. Ahora bien, necesitamos expresar notacionalmente que tales variables son en realidad propiedades de un objeto puerta en concreto. Esto se consigue mediante la siguiente notación:

puerta1.tamaño = 2
puerta1.color = "rojo"
puerta1.estado = false

Aquí sabemos que las variables tamaño, color y estado son en realidad propiedades del objeto puerta puerta1. El siguiente código correspondería a otro objeto puerta distinto:

puerta2.tamaño = 1.5
puerta2.color = "azul"
puerta2.estado = false

Para crear un objeto puerta nuevo JS utiliza la palabra clave new:

puerta3 = new Puerta()

De esta manera la variable puerta3 contiene ahora una referencia a un nuevo objeto puerta.

Los métodos son procedimientos o funciones del objeto cuyo objetivo es dotar a éste de comportamiento. Por ejemplo, el siguiente código implementaría el comportamiento de apertura de una puerta (la palabra clave this hace referencia al objeto que llama al método):

function abrir(){
  this.estado = true
}  

Cuando un objeto puerta como puerta1 llamara a este método se asignaría el valor true a su propiedad estado:

puerta1.abrir()		//Llama al método abrir
alert(puerta1.estado)	//Muestra el valor true

Mientras que JS es un lenguaje de script claramente orientado a objetos en todos sus aspectos, VBS está más bien pensado para trabajar con objetos ajenos a él. Debido nos vamos a encontrar con una serie de funciones en VBS que son tratadas como métodos de objetos en JS:

Funciones matemáticas

Para capturar el valor devuelto por cualquiera de estas funciones no tenemos más que asignar el resultado de la función a una variable. Por ejemplo la siguiente sentencia asigna el valor 2 a la variable resultado:

resultado = Sqr(4)

Veamos ahora los correspondientes métodos del objeto Math de JS:

Como puedes ver, salvo ligeras diferencias, los métodos del objeto Math permiten llevar a cabo las misma operaciones matemáticas que las funciones expuestas arriba. Al igual que antes si quisieras capturar el valor devuelto por algunos de estos métodos no tendrías más que asignárselo a una variable:

resultado = Math.sqrt(4)

A parte de los métodos mencionados (y algunos otros más relacionados sobre todo con operaciones trigonométricas), el objeto Math dispone de una serie de propiedades como E y Pi que corresponden a constantes matemáticas. Una constante no es más que una variable que no cambia de valor. En VBS podemos obtener constantes declarando las variables mediante la palabra reservada Const

<Script language="JavaScript">
alert(Math.PI)
</Script>
 

<Script language = "VBScript">
Const PI = 3.141592653589793
alert(PI)
</Script>

El objeto Math es un objeto intrínseco al lenguaje y no puede ser creado.

Funciones con cadenas

A continuación veremos una serie de funciones de VBS destinadas a facilitarnos el trabajo con las cadenas:

Los correspondientes métodos para el objeto String de JS son:

Hay que hacer ciertas matizaciones con respecto a las cadenas. Habrás observado que a parte del primer método en el cual se usa el objeto String, el resto de métodos se han utilizado sobre cadenas normales. Esto se debe a que en JS las cadenas pueden ser tratadas de la manera habitual o como objetos:

s = new String("Alicia")
alert(s)

También habrás observado que para los mismos valores de algunos ejemplos, los métodos arrojan resultados diferentes a los de las funciones de VBS. Esto se debe a que en VBS el primer carácter de una cadena ocupa la posición uno, mientras que en JS ocupa la posición cero. Por último decirte que length es una propiedad, no un método del objeto String.

Funciones con fechas

Veamos ahora las funciones de VBS relacionadas con las fechas:

En JS debemos crear un objeto Date para poder utilizar alguno de los métodos correspondientes a las funciones vistas con anterioridad:

fecha = new Date()	// Devuelve la fecha y hora del sistema.
alert(fecha)			//'Wed Oct 21 17:51:28 UTC + 0200 1998'

Mediante el método toLocaleString() obtendremos un formato de fecha más acorde con nuestro sistema:

fecha = new Date()		// Devuelve la fecha y hora del sistema.
alert(fecha.toLocaleString())	//'10/21/1998 17:51:28'

La palabra que acompaña a new en la sentencia de creación de un objeto se denomina constructor. Un constructor no es más que un método especial en el cual se definen las propiedades y métodos de los objetos pertenecientes a cierto tipo. El objeto Date acepta también los siguientes constructores:

fecha1 = new Date("mes/día/año horas:minutos:segundos")
fecha2 = new Date(año, mes, día, horas, minutos, segundos)

Veamos sendos ejemplos de ambos constructores:

fecha1 = new Date("10/21/1998 17:51:28")
fecha2 = new Date(1998, 9, 21, 17, 51, 28)

Observa que JS considera enero como el mes 0, por lo cual el 9 del segundo constructor representa a octubre, no a septiembre. Cualquiera de los objetos Date creados hasta el momento tiene una serie de métodos que sirven, como las funciones expuestas arriba de VBS, para obtener sus diferentes partes. Veámoslos para el objeto denominado fecha:

Nota 2: Mediante las funciones typeof() y TypeName() de JS y VBS podemos determinar a que tipo pertenece una variable:

nombre = "Alicia"
alert(typeof(nombre))

nombre ="Alicia"
alert(TypeName(nombre))

Nota 3: Las variables declaradas en el ámbito de una función o procedimiento reciben el nombre de variables locales. Cada vez que se llama a una función o procedimiento que contenga una declaración de una variable local esta es cargada en la memoria del ordenador hasta que se sale de la función o procedimiento. Deben ser declaradas explícitamente: 

function local(){
  var nombre
  nombre = "Alicia"
  alert(nombre)
}
local()
alert(nombre)

Sub local()
  dim nombre
  nombre = "Alicia"
  alert(nombre)
End Sub
local
alert(nombre)

En ambos lenguajes de script una vez que se llame a los correspondientes procedimientos se mostrará el contenido de la variable nombre. Ahora bien, una vez se sale del procedimiento éste se descarga de memoria produciendo un error en tiempo de ejecución en JS y la consideración por parte de VBS de que se trata de una nueva variable sin inicializar.

Las variables declaradas fuera del ámbito de una función reciben el nombre de globales. A diferencia de las anteriores se encuentran disponibles en memoria durante toda la ejecución del programa:

var numero
numero = 5
function global(){
  numero = 3
}
global1()
alert(numero)

dim numero
numero = 5
Sub global()
  nuero = 3
End Sub
global
alert(numero)

En ambos casos se obtiene 3, puesto que la variable numero es global.

Nota 4: Mientras que en JS las variables se pasan a las funciones por valor, en VBS se pasan por referencia:

var numero
numero = 5
function valor(n){
  n = n - 3
}
valor(numero)
alert(numero)

dim numero
numero = 5
Sub referencia(n)
  n = n - 3
End Sub
referencia numero
alert(numero)

En JS la sentencia valor(numero) pasa el valor de numero, es decir un 5, al argumento n del procedimiento. Por lo tanto la variable numero no se ve afectada por las operaciones llevadas a cabo por el procedimiento. En el segundo caso en cambio, se pasa a n, no un 5, sino una referencia a la variable número. Por lo cual las operaciones realizadas en el procedimiento con n apuntan realmente a número.

Nota 5: En cualquier momento podemos salir de un procedimiento o función mediante la sentencia return en JS y mediante las sentencias Exit Sub y Exit Function en VBS.

Operadores

Hasta ahora, exceptuando algunas sencillas operaciones, nos hemos limitado a asignar valores directamente a las variables. Pero hemos visto algunos casos como  n = n - 3 o c = parseInt(uno) + parseInt(dos), en los cuales el valor asignado a las variables es el resultado de llevar a cabo una serie de operaciones previas. Los símbolos encargados de llevar a cabo estas operaciones reciben el nombre de operadores y los fragmentos de código en los cuales aparecen se denominan expresiones. Las dos expresiones anteriores son numéricas, porque el valor resultante de llevar a cabo las operaciones que las integran es de tipo numérico en ambos casos. Pero también hay expresiones de tipo cadena, booleanas o condicionales, etc. Veremos a continuación los diferentes tipos de operadores más usados en ambos lenguajes:

Aritméticos 

JS posee dos operadores adicionales ++ y -- que permiten incrementar o decrementar a la variable a la que acompaña:

a = 5		//Asigna 5 a 'a'
b = ++a	//a y b valen 6.
a = 10	//asigno 10 a 'a'
b = a++	//¡b vale 10 no 11! a vale 11

Observa que el comportamiento del operador es diferente según su posición con respecto a la variable. Si antecede a la variable primero añade una unidad a ésta y luego se asigna el valor resultante a b. Si por el contrario precede a la variable, primero se efectúa la asignación del valor de a a b (por eso b vale 10) y después se suma un 1 a a. El operador -- funciona de la misma manera.

Comparación

No se debe confundir en el caso de VBS el operador de asignación con el operador de identidad, aunque para ambos se utilice el mismo símbolo. El operador de asignación asigna un valor a una variable, mientras que el operador de identidad efectúa una comparación cuyo resultado es true o false.

JS incluye un operador especial de asignación op= que permite a cualquier operador aritmético binario (de dos operandos) escribir el código de la siguiente manera:

a = 5
b = 4
b += a	//Es equivalente a 'b = b + a
b -= a	//Es equivalente a 'b = b - a
b *= a	//Es equivalente a 'b = b * a
b /= a	//Es equivalente a 'b = b / a

Lógicos

JS incluye además el operador ?: cuya sintaxis es la siguiente expresiónCondicional? valor1: valor2. Este operador evalúa primeramente la expresiónCondicional, si es verdadera ejecuta la sentencia1, si es falsa la sentencia2. Como veremos a continuación su comportamiento es similar al de las estructuras de decisión condicionales.

Estructuras de control de flujo

Las estructuras de control de flujo se dividen en:

1. Estructuras de decisión condicional
2. Bucles

Las estructuras de decisión condicional nos permiten decidir mediante expresiones condicionales que sentencias de nuestro código han de ser ejecutadas. Los bucles nos permiten repetir un número determinado o indeterminado de veces una serie de sentencias de nuestro código. Pasaremos a continuación a tratar primeramente las estructuras de decisión condicional.

Estructuras de decisión condicional

La estructura de decisión condicional principal en ambos lenguajes es if:

if(expresión condicional){
  código1
}
[else{
  código2
}]

If expresión condicional Then
  código1
[Else
  código2]
End If
 

En ambos casos se evalúa la expresión condicional. Si es true se ejecuta el código1. Si es falsa se ejecuta el código2. El código situado entre corchetes es opcional. Veamos de nuevo uno de nuestros primeros ejemplos ligeramente modificado:

<Script language="JavaScript">
nombre = prompt("Introduzca su nombre por favor", "")
if(nombre == "Alicia"){
  alert("Hola " + nombre)
  alert("Hoy hace un día soleado")
}
else{
  alert("Hola " + nombre + ". ¿Has visto a Alicia?")
}
</Script>

Cuando el código llega a la sentencia if comprueba si el valor introducido es realmente 'Alicia' o no. Si es 'Alicia' recibiremos los mensajes pertinentes. En otro caso se nos preguntará por Alicia. ¡Te dejo como ejercicio el correspondiente código en VBS!

En el caso de VBS se admite también la siguiente estructura de decisión condicional en la que se pueden testar condiciones adicionales. Veámoslo mediante un ejemplo:

nombre = prompt("Introduzca su nombre por favor", "")
If nombre = "Alicia" Then
  alert("Hola " & nombre)
ElseIf nombre = "Lewis" Then
  alert("Hola " & nombre)
Else
  alert("Hola " & nombre & ". ¿Has visto a Alicia o a Lewis?")
End If

Ahora bien, para este tipo de estructuras condicionales tanto VBS como JS cuentan con estructuras más especializadas:

switch(expresión){
case valor1:
  código1
  break
case valor2:
  código2
  break
.
.
default:
  código
}

Select Case expresión
Case valor1
  código1

Case valor2:
  código2

.
.
Case Else
  código
End Select

En ambos tipos de estructuras se ejecuta el código correspondiente al caso cuya comparación de identidad entre su valor y la expresión arroje como resultado true. Veamos un ejemplo:

nombre = prompt("Introduzca su nombre por favor", "")
switch(nombre){
case "Alicia":
  alert("Hola Alicia")
  break
case "Lewis":
  alert("Hola Lewis")
  break
default:
  alert("Hola " + nombre)
}

nombre = prompt("Introduzca su nombre por favor", "")
Select Case nombre
Case "Alicia"
  alert("Hola Alicia")
  
Case "Lewis"
  alert("Hola Lewis")
  
Case Else
  alert("Hola " + nombre)
End Select

Bucles

Como ya hemos dicho los bucles nos permiten repetir un número determinado o indeterminado de veces ciertas sentencias de nuestro código. For es el bucle determinado por excelencia en ambos lenguajes:

for(i = inicio; expresión condicional; i++){
  código
}

For i = inicio To fin [Step paso]
  código
Next

En un bucle for primeramente se inicializa una variable que recibe el nombre de contador representada comúnmente con la letra i. A continuación en JS se comprueba la expresión condicional. Si es true se ejecuta el código correspondiente, se añade una unidad a la variable contador y se vuelve a evaluar la expresión condicional, a ejecutar el código, etc hasta que la expresión condicional devuelva false. En VBS simplemente se ejecuta el código y se añade una unidad a la variable contador, se vuelve a ejecutar el código, se vuelve a añadir una unidad a la variable contador, etc hasta que la variable contador alcance el valor fin. Veamos unos ejemplos:

var m
m = ""
for(i = 0; i < 5; i++){
  m += "vuelta " + i + "\n"
}
alert(m)
alert(i)

dim m
m = ""
For i = 0 To 4
  m = m & "vuelta " & i & chr(13)
Next
alert(m)
alert(i)

Si ejecutas el código observa que ambos bucles ejecutan el cuerpo del bucle un total de 5 veces. Fíjate en el valor final de la variable contador. La secuencia de escape '\n' permite introducir un salto de carro en el cuadro de diálogo alert. En VBS la función chr(13) se encarga de la misma tarea.

En VBS se puede especificar un paso distinto a 1: 

dim m
m = ""
For i = 0 To 4 Step 2
  m = m & "vuelta " & i & chr(13)
Next
alert(m)
alert(i)

Por último los bucles indeterminados de ambos lenguajes son:

while(expresión condicional){
  código
}

Do While | Until expresión condicional
  código
Loop

En JS se ejecuta el cuerpo del bucle mientras que la expresión condicional sea true. En VBS existen dos posibilidades. Si la expresión condicional va precedida de la palabra clave While el comportamiento es el mismo que en JS. Si va precedida de Until el cuerpo del bucle se ejecuta hasta que la expresión condicional sea true. Veamos un ejemplo de ambos:

i = 0
while(i < 5){
  alert(i)
  i++
}

i = 0
Do while i <> 5
  alert(i)
  i = i + 1
Loop

También se aceptan las siguientes variantes de los bucles indeterminados:

Do{
  código
}while(expresión condicional)

Do
  código
Loop While | Until expresión condicional

La diferencia estriba en que mientras que los primeros pueden no llegar a ejecutarse, los segundos siempre ejecutaran el cuerpo del bucle al menos una vez.

En cualquier momento se puede salir de un bucle de JS mediante la palabra clave break. En VBS podemos utilizar las sentencias Exit For y Exit Do. Además en JS podemos pasar a la siguiente vuelta de un bucle mediante la palabra clave continue.

Arrays

Un array es una colección de variables generalmente del mismo tipo. JS dispone de los siguientes constructores para crear arrays:

lista = new Array()			//Crea un array denominado lista
lista1 = new Array(n)			//Crea un array de n elementos
lista2 = new Array(e1, e2, ...,en)	//Crea un array cuyos elementos son e1, e2, ...,en

En el caso de VBS podemos crear un array mediante alguna de las siguientes sentencias:

Dim lista()				//Crea un array denominado lista
Dim lista1(n)			//Crea un array de n + 1 elementos
lista2 = Array(e1, e2, ...,en)	//Crea un array cuyos elementos son e1, e2, ...,en

Para asignar un valor a un elemento del array se utiliza la siguiente notación:

lista[i] = valor

lista(i) = valor

Estas sentencias quieren decir que se asigna un valor, del tipo que sea, al i-ésimo elemento del array. Hay que observar que tanto en JS como en VBS el primer índice de un array es el 0.

El siguiente código nos devuelve la longitud de un array en ambos lenguajes:

lista.length

Ubound(lista) + 1

En el primer caso length es una propiedad del array (JS trata a los arrays como objetos) que devuelve la longitud del array. En el segundo caso la función Ubound() de VBS nos devuelve el índice mayor del array. Puesto que como hemos dicho el primer índice de un array es el cero le añadimos una unidad para obtener el número de elementos correcto.

Mediante el código siguiente se demuestra como convertir una cadena en un array y como llevar a cabo la operación inversa:

m = "Alicia en el país de las maravillas".split(" ")
s = m.join(" ")

m = Split("Alicia en el país de las maravillas")
s = join(m)

Cuando declaramos en VBS un array sin indicar su número de elementos deberemos utilizar el siguiente código para indicar tal dato:

Dim lista()		//Declara un array
Redim lista(9)	//Declara un array de 10 elementos	

Si se redimensiona un array cuyos valores originales no queremos perder deberemos usar la palabra reservada Private.

En el caso de que queramos eliminar de memoria un array en VBS debemos utilizar la siguiente sentencia:

Erase lista

En VBS es muy fácil declarar una matriz:

Dim matriz(n, m)

En JS se debe crear un array de arrays mediante bucles for.

Por último veamos un ejemplo que nos muestra una a una cada letra de nuestro nombre:

var m = new Array()
var s
s = prompt("Su nombre ", "")
 
for(i = 0; i < s.length; i++){
  m[i] = s.substr(i, 1)
}
for(i = 0; i < m.length; i++){
  alert(m[i])
}

dim m()
dim s
var s = prompt("Su nombre ", "")
Redim m(len(s)-1)
For i = 1 To len(s)
  m(i-1) = Mid(s, i, 1)
Next
For i = 0 To Ubound(m)
  alert(m(i))
Next

Última actualización: 09/11/2010
© 1998 D. Ordiales