Tutorial de Jscript (página 2)

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 unaExpresion= "3 * (4 / 5)";

var unaSegundaExpresion = "Math.PI * radio *
2";

var unaTerceraExpresion = unaSegundaExpresion + "%" +
unaExpresion;

var unaCuartaExpresion = "(" + unaSegundaExpresion + ")
% (" + unaExpresion + ")";

Variables de
JScript

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.

Si declara una variable sin asignarla un valor, la
variable existirá, pero será no
definida.

var godot;

var esperarA= 1 * godot; // Asigna el valor NaN a
esperarA, ya que godot no está definida.

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.
3. Dado que los valores
   de ambos lados del operador + son cadenas, se realiza
   una concatenación de ellas. El resultado es
   "110"
4. 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.
5. Como ahora hay cadenas a ambos lados del operador +=,
   se realiza una concatenación de cadenas. El resultado es
   "0110".
6. 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.

Tipos de datos de
JScript

¿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 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 // Un entero hexadecimal, equivalente a
14287.

0x3e7 // Un entero hexadecimal, equivalente a
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 son true 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)

Para obtener más información acerca de las comparaciones,
vea Controlar el flujo del programa.

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.

Operadores de JScript

JScript tiene un amplio conjunto de operadores,
incluidos aritméticos, lógicos, de bits y de
asignación. También existen algunos operadores
variados.

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.

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.
3. Lo siguiente es la multiplicación: Se
   multiplican 78 y 144, dando como resultado un valor igual a
   11232.
4. Por último se realiza la asignación: Se
   asigna 11232 a z.

Controlar el
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>");

}

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.";

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.

/*

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ó";

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 elComentario = "";

var elResto = 0;

var laSalida = 3;

var comprobar = 27;

for (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ó";

Funciones de
JScript

¿Qué es una
función?

Las funciones de Microsoft JScript realizan acciones.
También pueden devolver resultados. A veces son los
resultados de cálculos o comparaciones.

Las funciones combinan varias operaciones bajo
un único nombre. Esto le permite simplificar su
código. Puede escribir un conjunto de instrucciones,
asignarle un nombre y ejecutarlo en cualquier momento, tan solo
con llamarlo y pasarle la información que
necesite.

Para pasar información a una función hay
que encerrar la información entre paréntesis
después del nombre de la función. Los elementos de
información que se pasan a una función se llaman
argumentos o parámetros. Algunas funciones no utilizan
ningún argumento, otras sólo utilizan uno, otras
utilizan varios. Incluso existen algunas funciones para las que
el número de argumentos depende de cómo se utilice
la función.

JScript admite dos tipos de funciones: las que
están incorporadas en el lenguaje y
las creadas por el propio usuario.

Funciones especiales incorporadas

El lenguaje JScript incluye varias funciones
incorporadas. Algunas permiten controlar expresiones y caracteres
especiales, así como convertir cadenas en valores
numéricos.

Por ejemplo, escape()
y unescape() se utilizan
para convertir caracteres que tienen un significado especial en
el código HTML, caracteres
que no se pueden incluir directamente en el texto. Por
ejemplo, los símbolos de menor y mayor, "<" y ">",
delimitan las marcas
HTML.

La función escape toma como argumento
cualquiera de estos caracteres especiales y devuelve el
código de escape correspondiente. Cada código de
escape está compuesto por un signo de porcentaje (%)
seguido por un número de dos dígitos. La
función unescape es exactamente la inversa. Recibe
como argumento una cadena compuesta por un signo de porcentaje y
un número de dos dígitos y devuelve un
carácter.

Otra función incorporada que resulta útil
es eval(), que evalúa
cualquier expresión matemática
válida que se presente en forma de cadena. La
función eval() recibe un argumento: la
expresión a evaluar.

var unaExpresion = "6 * 9 % 7";

var total = eval(unaExpresion); // Asigna el valor 5 a
la variable total.

var otraExpresionMas = "6 * (9 % 7)";

total = eval(otraExpresionMas) // Asigna el valor 12 a
la variable total.

var totalidad = eval("…rodeado por hectáreas de
olivares."); // Genera un error.

Consulte la referencia del lenguaje para obtener
más información acerca de estas y otras funciones
incorporadas.

Crear sus propias funciones

Puede crear sus propias funciones y utilizarlas cuando
las necesite. La definición de una función
está formada por una instrucción function y un
bloque de instrucciones de JScript.

La función compruebaTripleta del siguiente
ejemplo usa como argumentos las longitudes de los lados de un
triángulo y calcula con ellas si el triángulo es
correcto comprobando si los tres números constituyen una
tripleta de Pitágoras. (El cuadrado de la longitud de la
hipotenusa de un triángulo es igual a la suma de los
cuadrados de los otros dos lados.) La función
compruebaTripleta llama a una función de entre otras dos
para realizar el cálculo
real.

Observe el uso de un número muy pequeño
("epsilon") como variable de prueba en la versión en coma
flotante de la comprobación. Debido a las incertidumbres y
a los errores de redondeo en los cálculos de coma
flotante, no resulta práctico realizar una prueba directa
de si el cuadrado de la hipotenusa es igual a la suma de los
cuadrados de los otros dos lados a menos que se sepa que los
valores en cuestión serán números enteros.
Como es más preciso realizar una prueba directa, el
código de este ejemplo determina si este método es
apropiado y, si lo es, lo utiliza.

var epsilon = 0.0000000000001; // Algún
número muy pequeño contra el cual se hace la
comprobación.

var tripleta = false;

function compruebaEnteros (a, b, c) { // La
función de comprobación para los
enteros.

if ( (a*a) == ((b*b) + (c*c)) ) { // La
comprobación.

tripleta = true;

}

} // Fin de la función de comprobación de
enteros.

function compruebaFlotante (a, b, c) { // La
función de comprobación para los números de
coma flotante.

var laPrueba= ((a*a) – ((b*b) + (c*c))) // Obtiene el
número de la prueba.

if (laPrueba< 0) { // La comprobación necesita
el valor absoluto, por lo que invierte laPrueba si su valor es
negativo.

laPrueba*= -1;

}

if (epsilon > laPrueba) { // Si son tan aproximados,
¡son muy aproximados!

tripleta = true;

}

} // Fin de la función de comprobación de
coma flotante.

function compruebaTripleta(a, b, c) { // La
comprobación. Primero pasa el lado mayor a la
posición "a".

var d = 0; // Crea un depósito
temporal.

if (c > b) { // Si c > b, los
intercambia.

d = c;

c = b;

b = d;

} // Si no, ignorarlos.

if (b > a) { // Si b > a, los
intercambia.

d = b;

b = a;

a = d;

} // Si no, ignorarlos.

// Ahora, el lado "a" es la hipotenusa, si es que hay
una.

if (((a%1) == 0) && ((b%1) == 0) &&
((c%1) == 0)) { // Comprueba los tres valores. ¿Son
enteros?

compruebaEnteros (a, b, c); // Si lo son se utiliza la
comprobación precisa.

}

else

compruebaFlotante (a, b, c); // Si no lo son se obtienen
los valores más próximos.

} // Fin de la función de comprobación de
la tripleta.

// Las tres próximas instrucciones asignan
valores de prueba para realizar una
comprobación.

var ladoA = 5;

var ladoB = 5;

var ladoC = Math.sqrt(50);

compruebaTripleta(ladoA, ladoB, ladoC); // Llama a la
función. Después de la llamada, tripleta contiene
el resultado.

Objetos de
JScript

¿Qué son los objetos?

En Microsoft JScript, los objetos son, esencialmente,
colecciones de propiedades y métodos.
Un método es una función que es miembro de un
objeto y una propiedad es
un valor o un conjunto de valores (en forma de matriz o de
objeto) que es miembro de un objeto. JScript admite tres tipos de
objetos: objetos intrínsecos, objetos creados por el
usuario, y objetos del explorador, de los que hablaremos en otra
sección.

Objetos como matrices

En JScript, los objetos y las matrices se manipulan de
forma idéntica. Puede hacer referencia a cualquiera de los
miembros de un objeto (sus propiedades y métodos) bien por
su nombre (usando el nombre del objeto, seguido por un punto y el
nombre de la propiedad) o bien por su subíndice en la
matriz. La numeración de los subíndices en JScript
comienza desde 0. Por comodidad, también se puede hacer
referencia al subíndice por su nombre.

Así, puede hacer referencia a una propiedad de
varias formas. Todas las instrucciones que aparecen a
continuación son equivalentes.

laAnchura= spaghetti.width;

laAnchura= spaghetti[3]; // [3] es el índice de
"anchura".

laAnchura = spaghetti["anchura"];

Aunque se pueden utilizar paréntesis para hacer
referencia a una propiedad por su índice numérico,
no es posible utilizar el punto (.) con los números de
índice. La siguiente instrucción genera un
error.

laAnchura= spaghetti.3;

Cuando un objeto tiene otro objeto como propiedad, la
convención de asignación de nombres se extiende de
forma sencilla.

var init4 = listaCompras.paraHoy [3].substring(0,1); //
listaCompras, una matriz, es una propiedad de paraHoy.

El hecho de que los objetos puedan tener otros objetos
como propiedades permite generar matrices con más de un
subíndice, que no sean directamente compatibles con el
lenguaje. El siguiente código crea una tabla de
multiplicación para los valores que van desde 0 veces 0
hasta 16 veces 16.

var tablaMult = new Array(17); // Crea el entorno que se
convertirá en la tabla.

for (var j = 0; j < tablaMult.length; j++) { // Se
prepara para rellenarla con filas.

var unaFila = new Array(17); // Crea una
fila.

for (var i = 0; i < unaFila.length; i++) { // Se
prepara para rellenar la fila.

unaFila [i] = (i + " veces " + j + " = " + i*j); // Crea
y coloca un valor.

}

tablaMult [j] = unaFila; // Coloca en la tabla la fila
ya completa.

}

Para hacer referencia a uno de los elementos de una
matriz de este tipo se utilizan varios conjuntos de
llaves.

var multiplica3x7 = tablaMult [3][7];

La siguiente instrucción genera un
error.

var multiplica3x7 = tablaMult [3, 7];

JScript tiene varias palabras clave reservadas. Estas
palabras pueden ser de tres tipos diferentes: Palabras clave
reservadas de JScript, palabras reservadas para el futuro y
palabras que se deben evitar.

Las palabras que se deben evitar serán
cualesquiera que ya sean un nombre de un objeto o una
función intrínseca de JScript. Palabras como
String o parseInt se incluyen en esta
categoría.

Si utiliza cualquiera de las palabras clave de las dos
primeras categorías se produce un error de
compilación la primera vez que se carga la secuencia de
comandos. Si utiliza una de las palabras clave del tercer
grupo se
pueden producir problemas de
comportamiento
extraño si intenta utilizar, en la misma secuencia de
comandos, la variable y la entidad original que tiene el mismo
nombre. Por ejemplo, la siguiente secuencia de comandos en
realidad no hace lo que se supone que debería
hacer:

var String;

var texto = new String("Este es un objeto
String");

En este caso obtendrá un error indicando que
String no es un objeto. En muchas ocasiones, el uso de un
identificador ya existente no resulta tan obvio.

Recursividad

La recursividad es una técnica de programación importante. Se utiliza para
realizar una llamada a una función desde la misma
función. Como ejemplo útil se puede presentar el
cálculo de números factoriales. Los factoriales de
0 y 1 son, por definición, 1. Los factoriales de
números mayores se calculan multiplicando 1 * 2 * …,
incrementando el número de 1 en 1 hasta llegar al
número para el que se está calculando el
factorial.

El siguiente párrafo
muestra una función, definida en palabras, que calcula un
factorial.

"Si el número es menor que cero,
recházalo. Si no es un entero, redondéalo al
siguiente entero. Si el número es cero o uno, su factorial
es uno. Si el número es mayor que uno, multiplícalo
por el factorial del número menor inmediato."

Para calcular el factorial de cualquier número
mayor que 1 hay que calcular como mínimo el factorial de
otro número. La función que se utiliza para hacerlo
es la función en la que se encuentra en estos momentos,
esta función debe llamarse a sí misma para el
número menor inmediato, antes de poder
ejecutarse en el número actual. Esto es un ejemplo de
recursividad.

Claramente, aquí existe un modo de meterse en
problemas. Es fácil crear un función recursiva que
no llegue a devolver nunca un resultado definitivo y no pueda
llegar a un punto de finalización. Este tipo de
recursividad hace que el sistema ejecute
lo que se conoce como bucle "infinito". El siguiente es un
ejemplo: omita la primera regla (la de los números
negativos) de la descripción verbal del cálculo de un
factorial e intente calcular el factorial de un número
negativo. Se produce un fallo, ya que para poder calcular el
factorial de, por ejemplo, -24, primero hay que calcular el
factorial de -25, pero para hacerlo primero hay que calcular el
factorial de -26, y así sucesivamente. Obviamente, el
bucle nunca se detendrá.

Por tanto, es muy importante tener mucho cuidado al
diseñar las funciones recursivas. Si en alguna
ocasión sospecha que existe la posibilidad de que se
produzca un bucle infinito, puede hacer que la función
cuente el número de veces que se llama a sí misma.
Si la función se llama a sí misma demasiadas veces,
algo que deberá decidir usted, se detiene
automáticamente.

Aquí está de nuevo la función del
factorial, pero esta vez escrita en JScript.

function factorial(unNumero) {

unNumero = Math.floor(unNumero); // Si el número
no es un entero, lo redondea.

if (unNumero < 0) { // Si el número es menor
que cero, lo rechaza.

return " no se ha definido una cantidad ";

}

if ((unNumero == 0) || (unNumero == 1)) { // Si el
número es 0 o 1, su factorial es 1.

return 1;

}

else return (unNumero * factorial(unNumero – 1)); // De
lo contrario, la función recurre hasta
terminar.

}

Alcance de
variables

Microsoft JScript tiene dos alcances: global y local. Si
declara una variable fuera de una definición de una
función, será una variable global y tendrá
acceso a su valor y podrá modificarlo desde todo su
programa. Si declara una variable dentro de una definición
de una función, esa variable será local. Se crea y
se destruye cada vez que se ejecuta la función, no se
tiene acceso a ella desde fuera de la función.

Una variable local puede tener el mismo nombre que una
variable global, pero es totalmente distinta e independiente. En
consecuencia, si se modifica el valor de una variable no se
producirá efecto alguno sobre la otra. Dentro de la
función en la que se define la variable local sólo
tiene significado la versión local.

var unCentauro = "un caballo con jinete,"; //
Definición global de unCentauro.

// Código de JScript, omitido por razones de
brevedad.

function antiguedades() // En esta función se
define una variable local unCentauro.

{

// Código de JScript, omitido por razones de
brevedad.

var unCentauro = "Un centauro, probablemente será
un guerrero Escita a caballo";

// Código de JScript, omitido por razones de
brevedad.

unCentauro += ", mal informado; es decir, "; // Se
agrega a la variable local.

// Código de JScript, omitido por razones de
brevedad.

} // Fin de la función.

var nadaenparticular = antiguedades();

unCentauro += " tal y como es visto a cierta distancia
por una persona inocente.";

/*

Dentro de la función, la variable contiene "Un
centauro es probablemente un guerrero Escita a
caballo,

mal informado, es decir "; fuera de la función,
la variable contiene el resto de la frase:

"un caballo con jinete, tal y como es visto a cierta
distancia por una persona inocente."

*/

Es importante tener en cuenta que las variables
actúan como si estuvieran declarados al principio de
cualquier alcance en el que existan. Por este motivo en ocasiones
se producen resultados inesperados.

var unNumero = 100;

var conSuma = 0;

conSuma += unNumero; // conSuma ahora vale
100.

tweak();

conSuma += unNumero; // conSuma ahora vale
200.

function tweak() {

var nuevoElemento = 0; // Declaración
explícita de la variable nuevoElemento.

// La siguiente instrucción, si no estuviera
comentada, generaría un error.

// nuevoElemento = unNumero;

// La siguiente instrucción asigna el valor 42 a
la variable local unNumero, declarándola de forma
implícita.

unNumero = 42;

if (false) {

var unNumero; // Esta instrucción nunca se
ejecuta.

unNumero= "¡Hola!"; // Esta instrucción
nuca se ejecuta.

} // Fin de la condición.

} // Fin de la definición de la
función.

La instrucción que se incluye como comentario
intenta asignar el valor de la variable local unNumero a
la variable local nuevoElemento. Produce un error, a pesar
de que dentro de la función está definida una
variable local unNumero, por lo que existe en ella. La
variable unNumero no tiene ningún valor asignado
cuando esta instrucción aparece en el código, por
lo que su valor es no definido.

Copiar, pasar y
comparar datos

En Microsoft JScript, la forma como se controlan los
datos depende del tipo de datos.

Por valor o por referencia

Los valores numéricos o Boolean (true y
false) se copian, pasan y comparan por valor. Al
copiar o pasar por valor, se asigna un espacio en la memoria de
su equipo y se coloca el valor del original en ese espacio. Si
después cambia el original, la copia no se modifica (y
viceversa), porque son entidades separadas.

Los objetos, matrices y funciones se copian, pasan y
comparan por referencia bajo la mayoría de las
circunstancias. Al copiar o pasar por referencia,
básicamente crea un puntero al elemento original y
utilizar el puntero como si fuera una copia. Si cambia el
original, modifica el original y la copia (y viceversa). En
realidad, sólo hay una entidad; la "copia" realmente no es
una copia, es sólo otra referencia a los datos.

Por último, las cadenas se copian y pasan por
referencia, pero se comparan por valor.

Pasar parámetros a funciones

Al pasar un parámetro a una función por
valor, está haciendo una copia separada del
parámetro, una copia que sólo existe dentro de la
función. Si, por otro lado, pasa un parámetro por
referencia y la función cambia el valor del
parámetro, se cambia en toda la secuencia de
comandos.

Verificar datos

Al realizar una verificación por valor, se
comparan dos elementos distintos para comprobar si son iguales.
Normalmente, esta comparación se realiza byte por byte. Al
verificar por referencia, está comprobando si dos
elementos son punteros un solo elemento original. Si es
así, entonces el resultado es que son iguales; si no,
aunque contengan los mismos valores exactos, byte por byte, el
resultado es que no son iguales.

Copiar y pasar cadena por referencia ahorra memoria; pero
como no puede cambiar cadenas una vez creadas, es posible
compararlas por valor. Esto le permite verificar si dos cadenas
tienen el mismo contenido aunque una se haya generado totalmente
aparte de la otra.

Usar
matrices

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 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. Puesto que se puede tener acceso a los
miembros de cualquier objeto JScript utilizando la
notación de matriz, se puede utilizar un objeto JScript
como una matriz asociativa.

El código siguiente crea e inicializa la forma
más común de matriz:

var miMatriz = new Array("Atenas", "Belgrado",
"Cairo");

Se direcciona a cada elemento de esta matriz utilizando
su número de elemento; en este caso 0, 1 ó 2. Si se
utiliza la instrucción for…in, se puede iterar en
la matriz empezando en 0 y terminando en 2. Por
ejemplo:

for (clave in miMAtriz)

response.write("El valor del elemento es" +
MiMatriz[clave] + "<BR>);

El código siguiente crea e inicializa una matriz
asociativa que contiene tres elementos:

var MiMatriz = {"a" : "Atenas", "b" : "Belgrado", "c" :
"Cairo" };

En esta matriz, se direcciona a los elementos con las
cadenas clave("a", "b" o "c") en vez de un número de
elemento de matriz (0, 1 ó 2). Esto permite crear y
utilizar matrices con patrones de direccionamiento más
intuitivos. El mismo código de instrucción
for…in que se muestra arriba se puede utilizar para
iterar en esta matriz.