Código JavaScript
Sentencias
Comentarios
Asignación
Expresiones
Variables
Declaración de variables
Nombres de variables
Tipos de datos
Tipo String
Tipo Number
Tipo Boolean
Tipo Undefined
Tipo Null
Conversión de Tipos. Coerción
Conversión explícita de String a
Number: parseInt(), parseFloat()
Conversión explícita de Number a
String: toString()
Copia, comparación y paso de datos
Control del flujo del programa
if-else
Bucles for
Bucles for-in
Bucles while y do-while
Sentencias break y continue
Sentencia switch-case
Objetos
Prototipo de un objeto
Cláusula with
Operaciones matemáticas. El objeto Math
Cadenas de texto. El objeto String
Fechas y horas. El objeto Date
Funciones con un número variable de argumentos. Objeto Function
JavaScript es la implementación de Microsoft del lenguaje JavaScript. Este lenguaje se usa fundamentalmente para añadir contenidos a las páginas de Internet (páginas htm o html), pero puede utilizarse para manipulación y personalización de otras aplicaciones (como Microsoft Office), para la realización de procesos en servidores de Internet, para administrar el sistema, etc.
Es un lenguaje interpretado. El código JavaScript, almacenado en un archivo de texto, ha de ser traducido por un interprete para poder ser ejecutado. Es decir, los programas JavaScript no pueden ser compilados para obtener una aplicación independiente.
Cuando el código JavaScript forma parte de una página Web, se incluye en el archivo HTML entre las etiquetas <SCRIPT LANGUAGE = "JavaScript"> y </SCRIPT>. Este código será interpretado por el navegador de Internet cuando se descarga la página desde el servidor. Podrá ser también ejecutado en el servidor Web, necesitando igualmente un interprete.
Las versiones del sistema operativo Windows 98 y posteriores incluyen Windows Script Host, un controlador para los motores interpretes de scripts. Hay dos versiones: Wscript.exe, que utiliza una hoja de propiedades para establecer las propiedades del script; y Cscript.exe, que utiliza parámetros en la línea de comandos para establecer las propiedades del script.
Windows Script Host utiliza las extensiones de archivos (.vbs para VBScript y .js para JavaScript) para identificar el script y pasarlo al motor correspondiente. No requiere de las etiquetas HTML para interpretar el código JavaScript.
JavaScript es un lenguaje de programación orientado a objetos (POO). Proporciona una colección de objetos y permite definir tipos de objetos personalizados que tienen entidad propia y pueden ser reutilizados.
La OOP permite establecer una comparación entre el mundo físico y el del software. En la realidad casi todos los objetos están constituidos por objetos más pequeños, que tienen características y funcionalidad propia e independiente del conjunto al que pertenecen.
En OOP las clases definen las características o propiedades y la funcionalidad o métodos que determinan un ente. Se crearán objetos o instancias de una clase determinada asignando valores a sus propiedades e implementando los métodos concretos.
Los objetos software especializados permiten escribir el código una sola vez reutilizándolo tal cual o adaptándolo a las necesidades particulares modificando ciertas propiedades o métodos de los objetos.
El código JavaScript se escribe en formato de texto, está organizado en sentencias, grupos de sentencias relacionadas constituyendo un bloque, y comentarios. En las sentencias pueden utilizarse variables, constantes y expresiones.
Una sentencia consiste en uno o más items y símbolos en una línea, una nueva línea indicará una nueva sentencia, sin embargo es conveniente terminar las sentencias explícitamente utilizando el punto y coma (;), que es el carácter de terminación de la sentencia.
Un bloque es un grupo de sentencias entre llaves ({}). Se utilizan bloques en la definición de funciones, en las estructuras de control de flujo.
Los comentarios son líneas de código que no se interpretan, se emplean para incluir notas aclaratorias o para eliminar temporalmente líneas de código que no se quieren ejecutar.
Un comentario de una única línea se precederá por dos barras inclinadas a la derecha (//). Un comentario multilínea comienza por una barra inclinada a la derecha seguida de un asterisco (/*) y finaliza con estos mismos caracteres en orden inverso (*/).
El signo igual (=) es utilizado, como en el resto de los lenguajes de programación, para asignar un valor. Es decir, una sentencia como miNum = 8; significa asignar el valor 8 a la variable miNum. Cuando se quiere comparar dos valores para saber si son iguales, se utilizan dos signos de igualdad (==).
Expresiones son un conjunto de símbolos y palabras, cualquier combinación de variables, constantes y operadores que resulta en un valor Booleano (verdadero o falso) o en una expresión numérica.
Las variables se utilizan para almacenar valores permitiendo recuperar y manipular dichos valores utilizando nombres. Los nombres de variables deben ser descriptivos para que constituyan una ayuda en la comprensión del programa.
Las variables de declaran con la sentencia var. Únicamente es necesario declarar las variables cuando se trata de variables locales a una función, aunque es conveniente declarar siempre las variables antes de utilizarlas.
var miVariable;
var miNumero = 123;
var b = true;
var nombre1 = "CARLOS LOPEZ SANCHEZ"
Las tres últimas sentencias declaran e inicializan la variable asignándole un valor.
Se pueden declarar varias variables en una única sentencia var separando los nombres de las variables por comas:
var miVariable, miNumero = 123;
Si se quiere declarar una variable e inicializarla, pero no se quiere asignar ningún valor en particular, puede asignarse el valor especial null.
Se puede declarar una variable implícitamente, sin utilizar la sentencia var, simplemente asignándole un valor.
miNumero = 123; // variable declarada implícitamente
Sin embargo, no se puede utilizar una variable que nunca ha sido declarada, ya que genera un error en tiempo de ejecución.
JavaScript diferencia entre mayúsculas y minúsculas. La variable miVariable se considerará distinta de MiVariable. Los nombres de variable pueden tener cualquier longitud y deben seguir las siguientes reglas:
Cuando se declara una variable sin inicializarla no pertenece a ningún tipo y tiene un valor indefinido (undefined). Es cuando se inicializa cuando pasa a ser del tipo equivalente al valor que contienen.
Se puede conocer el tipo de dato que contienen una variable utilizando la función typeof que reotrna una cadena indicando el tipo de dato.
Hay seis tipos de datos en JavaScript: cadenas de caracteres (String), números (Number), objetos (Object) y Booleanos (Boolean). Los otros dos tipos son null y undefined.
En realidad String, Number y Boolean son objetos intrínseco de JavaScript que tienen sus propiedades y métodos. Aunque resulte transparente para el programador cuando inicializa una variable con un número esta creando un objeto tipo Number.
Los Strings se delimitan por comillas simples o dobles. Se utilizan comillas simples cuando el texto contiene dobles comillas y viceversa. Cuando se asigna a una variable una cadena de caracteres la variable será de tipo String.
var miNombre = "Carlos López Sánchez";
Un string puede contener cero o más caracteres Unicode. Cuando contiene cero caracteres se dice que es un string de longitud cero o vacio ("").
Caracteres Unicode son los establecidos por la organización internacional para la normalización ISO, ampliando los 256 códigos ASCII a 65.536 códigos. Ocupando cada carácter 2 bytes de memoria en lugar de 1. Para averiguar el código correspondiente a un carácter determinado puede utilizarse el Mapa de caracteres que se incluye con el sistema operativo Windows.
El simbódo "\" actúa como carácter de control para introducir otros caracteres en una cadena. En la siguiente tabla se incluyen los más comunes de estos caracteres especiales:
\n Salto de línea
\r Retorno de carro
\f Salto de página
\t Tabulador
\\ El propio carácter \
\' Comilla simple
\" Comilla doble
\b Carácter anterior
Los objetos String creados implícitamente se denominan strings estándar y son tratados de forma diferente a los objetos String creados explícitamente, ya que todos los string estándar comparten un objeto común global.
Las variables tipo Number pueden contener tanto un entero como un número de coma flotante de cualquier tamaño, tanto positivos como negativos.
var miNumero = 12345;
var miNumero1 = -382;
var miNumero2 = -3,14159;
miNumero = 6,023e+23;
pueden especificarse potencias de 10 en notación científica utilizando la letra "e", tanto en mayúsculas como en minúsculas.
Hay ciertos valores numéricos que son especiales: NaN (Not a Number) indica que no es un número, Infinity (Infinito positivo y negativo).
Los números enteros pueden estar representados en base 10 (decimal), base 8 (octal), y base 16 (hexadecimal).
Los números octales se especifican precediendo el número por un cero (0), pudiendo contener dígitos entre 0 y 7. Si un número está precedido por un cero pero contiene el dígito 8 o 9, se considera un número decimal. Un número que pudiendo ser octal contenga la letra "e" (o "E") genera un error.
Los enteros hexadecimales se especifican precediéndoles por "0x", la "x" puede ser mayúscula o minúscula, y puede contener dígitos de 0 a 9 y letras de la A a la F, tanto en mayúsculas como en minúsculas. La letra "e" puede figurar en los enteros hexadecimales pero no tiene el significado de número exponencial. Las letras de la A a la F son usadas para representar los números comprendidos del 10 al 15 en notación decimal. Es decir, 0xC equivale al 12, y 0x10 equivale al 16 en base decimal.
Los números octales y hexadecimales pueden ser negativos, pero no pueden ser faccionarios. Un número que empieza con un "0" y contienen decimales se considerará un número de coma flotante en base 10.
var NumHex = 0xFF32; // número hexadecimal = 65330 en
notación decimal
var NumOctal = 012345; // número octal = 5349 en decimal
Como hemos mencionado, en todos estos casos estamos creando una instancia de la clase Number.
Las variables de tipo Boolean pueden contener dos valores posibles: true (verdadero) y false (falso) que se escriben en minúsculas. En una comparación, una expresión que se evalúa a 0 toma el valor false, y y si se evalúa a cualquier otro número distinto de cero toma el valor true.
Por ejemplo, la expresión false == 0 se evalúa como true o verdadero.
Es el valor que se asigna a una variable después de haber sido declarada, pero antes de asignarle un valor.
Cuando una variable no contiene ningún valor su contenido es nulo.
var miVar = null;
En determinadas circunstancias se produce una conversión implícita o coerción automática de tipos.
var var1 = "75";
var var2 = 25;
var3 = var1 + var2;
El símbolo + se utiliza tanto como operador aritmético de suma como para enlazar o concatenar cadenas de caracteres. En este caso la variable numérica var2 se convierte en string de forma que var3 será un string igual a "7525".
Los números pueden ser fácilmente convertidos en string. Para convertir un string a un tipo number se utilizan las funciones parseFloat() y parseInt().
parseFloat(numstring) retorna un valor numérico igual al número contenido en numstring, si numstring no puede convertirse a un número retornará NaN (Not a Number).
parseFloat ("3,43ABC"); //
retorna 3,43
parseFloat ("BCD");
// retorna NaN
Puede chequearse el valor NaN con la función isNaN(valornumero) retorna true si valornumero es NaN y false en caso contrario.
parseInt(numstring, [base]) retorna un valor entero igual al número contenido en numstring. El argumento opcional base es un valor entre 2 y 36 que indica la base del número contenido en numstring, Si no se especifica, los strings precedidos por "0x" se consideran hexadecimales y los que tienen el prefijo "0" octales, cualquier otro string se considerará decimal.
var var1 = "75";
var var2 = 25;
var3 = parseInt(var1) + var2; // var3 será tipo number
conteniendo el valor 100
El método toString() forma parte de todos los objetos propios de JavaScript. Este método se llama automáticamente cuando se requiere una conversión textual del objeto. Por ejemplo cuando se concatena un Number a un String.
var var1 = 5678;
var1.toString(); // retorna "5678"
var2 = true;
var2.toString(); // retorna "true"
En el caso de los números, toString() tiene un argumento opcional para especificar la base de numeración del valor retornado.
(15).toString(16); // retorna F que es la notación
hexadecimal del número 15
(13).toString(2); // retorna 1101 que es la notación en base
dos de 13
Las funciones permiten agrupar sentencias bajo un nombre. Se escribe el grupo de sentencias, se asigna un nombre, y se ejecuta el grupo entero simplemente referenciando su nombre y pasando la información que requieran.
Para definir una función se emplea la palabra reservada function seguida del nombre de la función. Los nombres de funciones siguen las mismas reglas que los nombre de variables.
Si la función tiene que recibir información esta irá encerrada entre paréntesis después del nombre de la función, esta información se conoce como argumentos o parámetros. Algunas funciones no requieren argumentos; otras necesitan uno; otras varios argumentos que se separarán con comas (,). Hay incluso funciones para las cuales el número de argumentos depende de como se está usando la función.
Las sentencias de la función se encierran entre llaves ({}) a continuación de la declaración de argumentos.
Las funciones pueden retorna resultados mediante la sentencia return.
function Calcular (a, b, c)
{
return a*b*c
}
var = Calcular (3, 2, 4) // var será igual a 24
En el tutorial de JavaScript suministrado por Microsoft se encuentra el siguiente ejemplo:
var epsilon = 0.0000000000001; // Un número muy pequeño para evaluar
var triplet = false;
function integerCheck(a, b, c)
{ // función de chequeo de enteros
if ( (a*a) == ((b*b) + (c*c)) )
{
triplet = true;
}
}
function floatCheck(a, b, c)
{ // Función de chequeo para números de coma flotante
var theCheck = ((a*a) - ((b*b) + (c*c)))
if (theCheck < 0)
{ // El chequeo requiere valores absolutos, invierte theCheck
si es negativo.
theCheck *= -1;
}
if (epsilon > theCheck)
{
triplet = true;
}
}
function checkTriplet(a, b, c)
{ // Mueve el lado más largo a la posición a
var d = 0;
if (c > b)
{ // If c > b, los intercambia.
d = c;
c = b;
b = d;
}
if (b > a)
{ // If b > a, los intercambia
d = b;
b = a;
a = d;
}
// El lado a es ahora la hipotenusa, si es que existe una
hipotenusa.
if (((a%1) == 0) && ((b%1) == 0) && ((c%1) == 0))
{ // Comprueba si los tres valores son enteros
integerCheck(a, b, c);
}
else floatCheck(a, b, c); // Si no los son busca una
aproximación
}
var sideA = 5;
var sideB = 5;
var sideC = 7,0710678118654755; // = raiz cuadrada de 50
checkTriplet(sideA, sideB, sideC); // triplet será
true
La función checkTriplet recibe como argumentos la longitud de los lados de un triángulo, y determina si el triángulo es un triángulo rectángulo chequeando si los tres números cumplen el teorema de Pitágoras, es decir, el cuadrado de la longitud de la hipotenusa es igual a la suma de los cuadrados de la longitud de los otros dos lados.
Se utiliza un número muy pequeño para chequear en el caso de números de coma flotante, ya que como consecuencia del redondeo el chequeo puede resultar falso.
Las variables pueden ser globales o locales. Si se declara una variable fuera de la definición de una función, será una variable global, y su valor es accesible y modificable a través de todo el programa. Si se declara una variable dentro de una función será una variable local, estas variables se crean y se destruyen cada vez que se ejecuta la función y no son accesibles fuera de la función.
Una variable local puede tener el mismo nombre que una variable global, pero siguen siendo enteramente distintas. Al cambiar el valor de una de ellas no cambiará el valor de la otra. Dentro de la función en la cual la variable local es declarada, sólo esta variable tendrá significado.
No existe posibilidad de declarar variables estáticas como ocurren en otros lenguajes. Estas son variables que mantienen su valor entre las sucesivas llamadas a la función en que se a definido.
Un valor se copia o se pasa a una función por valor, cuando se ubica para él un nuevo espacio de memoria y se coloca en este espacio el valor original. Si se cambia el original, la copia no se verá afectada y viceversa, ya que se trata de entidades independientes.
Cuando se copia o se pasa un valor por referencia, se crea un puntero al ítem original y se utiliza el puntero como copia. Si se cambia el original, cambiarán ambos original y copia (y viceversa). Hay una única entidad, la copia no es realmente una copia, es otra referencia a un mismo dato.
Datos tipo Number y Boolean por defecto son copiados, pasados y comparados por valor. Objetos, Arrays y funciones son copiados, pasados y comparados por referencia.
Por último, Strings son copiados y pasados por referencia, pero son comparados por valor.
Cuando se pasa un parámetro a una función por valor, se hace una copia separada del parámetro, una copia que existe solamente dentro de la función, puede cambiarse el valor del parámetro dentro de la función sin que cambie su valor fuera de ella. Si se pasa el parámetro por referencia y la función cambia el valor de dicho parámetro, quedará cambiado el original en cualquier parte del script.
| Aritméticos | Lógicos | Bit a Bit | Asignación | Otros | |||||
|---|---|---|---|---|---|---|---|---|---|
| Cambio de signo | - | Negación | ! | Negación | ~ | Asignación | = | borrar | delete |
| Incremento | ++ | Menor que | < | Rotación izquierda | << | Con adición | += | tipo | typeof |
| Decremento | -- | Mayor que | > | Rotación derecha | >> | Con sustracción | -= | obviar valor | void |
| Multiplicación | * | Menor o igual que | <= | Rotación derecha sin signo | >>> | Con multiplicación | *= | ||
| División | / | Mayor o igual que | >= | AND | & | Con división | /= | ||
| Módulo | % | Igual a | == | XOR | ^ | Con módulo | %= | ||
| Suma | + | Distinto a | != | OR | | | Con op. bit a bit | <<=,>>=, etc. | ||
| Resta | - | AND | && | ||||||
| OR | || | ||||||||
| Condicional | ?: | ||||||||
| Coma | , | ||||||||
| Igualdad estricta | === | ||||||||
| Desigualdad estricta | !== |
Si al evaluar una expresión matemática alguno de los operandos es nulo (null) el resultado será nulo.
JavaScript proporciona los operadores de incremento ++ y decremento --, también disponibles en C/C++. La expresión a++; es equivalente a la expresión a = a + 1; aumentando en una unidad la variable a. En este caso el operador es un post-incremento. Su acción es aumentar el valor de la variable y luego devolver dicho valor. También puede utilizarse precediendo al nombre de la variable, sería un pre-incremento.
var n1 = 1, n2, n3;
n2 = ++n1;
n3 = n1++;
Como resultado de las anteriores sentencias n1 tendrá el valor 3 por haber incrementado dos veces su valor inicial 1, n2 y n3 valdrán 2, ya que en la última sentencia se asigna el valor 2 de n1 a n3 y a continuación se incrementa n1.
Los operadores lógicos se utilizan para evaluar expresiones y poder tomar decisiones dependiendo de que el resultado sea verdadero o falso:
| Operador | Operando1Operando2 | Resultado | |
| AND (&&) | false | false | false |
| false | true | false | |
| true | false | false | |
| true | true | true | |
| OR (||) | false | false | false |
| false | true | true | |
| true | false | true | |
| true | true | true | |
| NOT (!) | false | true | |
| true | false |
Los operadores bit a bit: AND (&), OR (|), XOR (^) y NOT (~) actúan a nivel binario haciendo una comparación bit a bit según la siguiente tabla:
| Operador | Primer_Bit | Segundo_Bit | Resultado |
| AND (&) | 0 | 0 | 0 |
| 1 | 0 | 0 | |
| 0 | 1 | 0 | |
| 1 | 1 | 1 | |
| OR (|) | 0 | 0 | 0 |
| 1 | 0 | 1 | |
| 0 | 1 | 1 | |
| 1 | 1 | 1 | |
| XOR (^) | 0 | 0 | 0 |
| 1 | 0 | 1 | |
| 0 | 1 | 1 | |
| 1 | 1 | 0 | |
| NOT (~) | 0 | 1 | |
| 1 | 0 |
Por ejemplo 15^5 se evalúa a 10 al comparar bit a bit la representación binaria de 15 (1111) y 5 (0101) resulta 1010 que corresponde a la representación binaria del número 10 en decimal.
Veamos el siguiente ejemplo del operador de negación:
var num = 0, num2;
num2 = ~num;
como resultado cabría esperar que num2 tuviera el valor 1, sin embargo el resultado es -1. Para entender esto hay que conocer la representación interna que JavaScript hace de los números.
Los números enteros son almacenados en 2 bytes (16 bits) reservando el primero de ellos para el signo. Por tanto, podemos utilizar números enteros en el rango -32.768 - 32.768.
Esta representación se conoce como complemento a dos, para representar un número negativo se aplica el operador lógico NOT a los 15 bits del número positivo, se coloca un 1 en el bit menos significativo (el de la izquierda correspondiente al signo) y se suma 1 al resultado.
Según esto para negar el número de 16 bits que representa al 1 habría que hacer lo siguiente:
0000 0000 0000 0001 se niegan los 15 bits finales
0111 1111 1111 1110 se coloca un 1 en el bit de la izquierda
1111 1111 1111 1110 se suma 1 al resultado
1111 1111 1111 1111 para obtener el número 1 cambiado de
signo, o se -1
Si al número 0 de 16 bits le aplicamos el operados NOT (~) obtenemos 1111 1111 1111 1111 que como acabamos de ver es realmente el -1.
Los operadores de desplazamiento de bits requieren dos argumentos: el número entero en el que se produce el desplazamiento de bits a izquierda o derecha, y un segundo entero indicando el número de posiciones a desplazar. Por ejemplo, 43 << 3 resulta 344.
0000 0000 0010 1011 << 3 = 0000 0001 0101 1000
Estos operadores, al contrario que en C/C++, mantienen el bit del signo desplazando únicamente los 15 bits correspondientes al número. Sin embargo el operador >>> desplaza los bits a la derecha incluido el bit de signo.
Los operadores de asignación compuestos actúan como sigue:
num += 2; // equivale a num = num + 2
num -= 2; // equivale a num = num - 2
num *= 2; // equivale a num = num * 2
num /= 2; // equivale a num = num / 2
etc.
La siguiente tabla muestra los operadores en orden de mayor a menor precedencia. Los operadores que se encuentran el la misma fila de la tabla se evalúan de izquierda a derecha.
| Operador | Descripción |
| . [] () | Acceso a miembro, indice de array, llamada a función |
| ++ -- - ~ ! typeof new void delete | Operadores unuarios, tipo de dato, constructor, valores indefinidos |
| * / % | Multiplicación, división, módulo |
| + - + | Adición, sustracción, concatenación de cadenas |
| << >> >>> | Desplazamiento de bits |
| < <= > >= | Menor que, menor o igual que, mayor que, mayor o igual que |
| == != === !== | Igualdad, desigualdad, igualdad estricta, desigualdad estricta |
| & | AND |
| ^ | XOR |
| | | OR |
| && | AND lógico |
| || | OR lógico |
| ?: | Condicional |
| = OP= | asignación, asignación con operación |
| , | Múltiple evaluación |
Los paréntesis son utilizados para alterar el orden de evaluación. La expresión dentro del paréntesis es completamente avaluada antes de que su valor sea usado en el resto de la sentencia.
x = a * (b + c + d)
Hay cinco operadores en esta expresión: =, *, (), +, y +. Serán evaluados en el siguiente orden según la tabla de precedencias: (), *, +, +, =. Primeramente se evalúa la expresión dentro del paréntesis: hay dos operadores de suma que tienen igual precedencia: se sumarán b y c y al resultado se sumará d. El resultado de esta suma se multiplicará por a. Por último se asignará el resultado a x.
Estas sentencias proporcionan a los programas la capacidad de decisión y la de realizar procesos repetitivos
Esta sentencia permite evaluar una expresión booleana y ejecutar una sentencia o bloque de sentencias en el caso de que el resultado de evaluar la expresión sea true. Opcionalmente puede especificarse, bajo la cláusula else, un grupo de sentencias a ejecutar cuando el resultado sea false.
if (condición)
{
sentencias
}
[else
{
sentencias
}]
Cuando se ejecuta una única sentencia no es necesario utilizar las llaves.
if (num > 0 && num< 100)
num +=1;
if (num > 0 && num< 100)
{
num += 1;
total = num;
}
else
num = 1;
Pueden anidarse las sentencias if-else cuando se requiera.
if (pesoreal < pesoideal)
txt = "Está usted delgado";
else
if (pesoreal == pesoideal)
txt = "Su peso es idoneo";
else
txt = "Sufre sobrepeso";
JavaScript también soporta una forma condicional implicita:
hora += (laHora >= 12) ? " PM" : " AM";
Cuando se tienen que evaluar varias condiciones, se puede acelerar la ejecución del programa colocándolas en un orden determinado. Por ejemplo, si tres condiciones están conectadas por el operador AND (&&) y la segunda se evalúa a false, la tercera condición no se evaluará. Análogamente, si varias condiciones están unidas por el operador OR (||) la evaluación parará cuando se encuentre la primera de ellas que sea true.
Permite ejecutar una sentencia o bloque de sentencias repetitivamente mientras se cumpla una determinada condición. Especifica una variable contador, un condición a evaluar, y una acción que actualiza el contador. Justo antes de cada ejecución del bucle (paso o iteración del bucle), la condición es evaluada. Después de que el bucle es ejecutado, la variable contador es actualizada justo antes del comienzo de la siguiente iteración.
Si la condición nunca se alcanza, el bucle no se ejecutará. Si la condición es siempre verdadera (true), resultará un bucle inifinito.
var s = 1, t;
for (var i = 0; i <= 100; i++)
{
s += i;
t = s;
}
La variable i se declara como variable contador con un valor inicial 0, a continuación se evalúa la condición i <= 100 y si es verdadera se ejecuta el bloque de sentencias (sentencias entre llaves), por último se verá incrementada la variable contador en una unidad. Cuando el bloque se ha ejecutado 100 veces se detendrá el bucle. La variable i así declarada sólo es válida dentro del bucle.
Es posible establecer un salto variable para el contador del bucle. El siguiente ejemplo muestra una función que cuenta el número de bits necesarios para representar en base dos un número decimal n.
function numbits (n)
{
var paso = 1;
var t = 0;
for (var i = 1; i <= n; i++)
{
t++;
paso = i;
}
return t;
}
num = numbits (15); // retorna 4
Los bucles for se pueden anidar. Es decir se puede ejecutar un bucle dentro de otro.
var t = "";
for (i = 0; i <= 9; i++)
for (j=0; j <= 9; j++)
t = t + i + j + " ";
t += "\n";
La variable t contendrá una cadena con los números 00 01 02 03... al 99. En cada iteración del bucle exterior, se añade a la cadena un retorno de carro, formándose 10 líneas.
Ejecuta el cuerpo del bucle tantas veces como miembros tenga una colección de objetos o una matriz sin necesidad de conocer su número exacto. Supongamos un objeto Biblioteca con una propiedad llamada Libro que devuelve una cadena de texto con cada uno de los títulos de los libros de esa biblioteca. Para obtener una lista completa de los libros escribimos:
var libro = "";
var lista = "";
for (libro in Biblioteca.Libro)
lista = lista + libro + "\n"
Ejecutarán un bloque de sentencias hasta que una determinada condición sea falsa (false). La sintaxis para los bucles while es:
while (condición)
{
bloque_de_sentencias
}
y para los bucles do-while
do
{
bloque_de_sentencias
}while (condición)
En el primer caso se evalúa la condición antes de comenzar la ejecución del bucle, en el segundo se realiza después de la ejecución del bloque de sentencias. Por tanto, los bucles do-while se ejecutan al menos una vez, mientras que los bucles while no se ejecutarán nunca si la condición es falsa ya inicialmente.
A diferencia de los bucles for, se desconoce de antemano el número de veces que se ejecutará el bucle, por lo que se llaman bucles indeterminados.
La sentencia break se utiliza para detener la ejecución del bucle y continuar ejecutando la sentencia inmediatamente posterior al bucle.
La sentencia continue se utiliza para hacer que el bucle inicie la siguiente iteración, saltando el resto del bloque de código pero actualizando la variable contador si procede. Únicamente se utiliza en los bucles while, do-while, for, y for-in.
El siguiente ejemplo muestra una función que retorna una cadena conteniendo los números, separados por blancos, comprendidos en un intervalo dado n1::n2 excepto los que son múltiplos de 5:
function NoMult5 (n1, n2)
{
var txt = "";
for (i=n1; i<=n2; i++)
{
if (i % 5 == 0)
continue;
txt += txt +" ";
}
return txt;
}
Permite la ejecución de un bloque de sentencias cuando una el valor de una expresión coincide con una etiqueta.
switch (expresión)
{
case etiqueta1:
bloque 1
case etiqueta2:
bloque 2
...
default:
bloque n
}
La cláusula default indica el bloque de sentencias a ejecutar en el caso de que ninguno de los valores de las etiquetas coincida con la expresión.
Primeramente se evalúa la expresión y se busca, en orden, una etiqueta que coincida con ella. Si el valor de una etiqueta es igual a la expresión se ejecuta el bloque de sentencias que la siguen, continuando la ejecución hasta encontrar una sentencia break o hasta que finaliza la sentencia switch.
Cuando se quiere ejecutar el mismo código para varios valores de la expresión, se especifican varias etiquetas separadas por comas. Veamos un ejemplo:
switch (Nota)
{
case 0, 1, 2, 3, 4:
txt = "Suspenso";
break;
case 5, 6:
txt = "Aprobado";
break;
case 7, 8:
txt = "Notable";
break;
case 9, 10:
txt = "Sobresaliente";
break;
default:
txt = "Indeterminada";
}
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 grupo de valores (en forma de objeto array) que es miembro de un objeto.
JavaScript soporta tres tipos de objetos: objetos intrínsecos, objetos creados por el programador, y objetos del navegador.
Hay nueve objetos intrínsecos o incorporados: Array, Boolean, Date, Function, Global, Math, Number, Object, y String.
Para crear instancias de un objeto se utiliza la palabra reservada new seguida del nombre del objeto, por ejemplo:
var fecha = new Date (2001, 1, 12);
Con ello llamamos a un método especial del objeto denominado constructor. El constructor recibe unos parámetros y los asigna a ciertas propiedades particularizando la instancia del objeto frente a las demás.
Para crear instancias de un objeto propio hay que escribir un constructor para dicho objeto. El siguiente ejemplo define las propiedades del objeto Ciudad y su constructor:
// Constructor de Ciudad
function Ciudad (nombre, habitantes, pais)
{
this.Nombre = nombre;
this.Habitantes = habitantes;
this.Pais = pais;
}
var Madrid = new Ciudad ("Madrid", 3800000, "España"); // crea un objeto
Ciudad
La palabra clave this es utilizada para referenciar el objeto actual.
Para referenciar cualquier miembro de un objeto (propiedades o métodos) se escribe el nombre del objeto seguido de un punto y del nombre de la propiedad.
var h = Madrid.Habitantes; // asigna a h 3.800.000
JavaScript tiene la particularidad de que los objetos y las matrices o arrays se manejan de forma idéntica, ya que el objeto es en realidad una lista o array de propiedades y métodos. Se pueden referencias los miembros de un objeto por su nombre, como acabamos de ver, y también por su índice. La numeración de índices comienza por cero. Las siguientes sentencias son equivalentes:
var h = Madrid.Habitantes;
var h = Madrid[1];
var h = Madrid["Habitantes"];
Una vez creado el objeto puede cambiarse el valor de cualquiera de sus propiedades.
Madrid.Habitantes = 4000000;
Para definir los métodos miembro de un objeto se define una función y se asigna al método del objeto en su constructor. Supongamos que la clase Ciudad tiene un método llamado Resumen que retorna una cadena de texto con el resumen de las propiedades del objeto. Se define primero la función:
function ciudad_resumen ()
{
return "Nombre: " + this.Nombre + "\nHabitantes: " +
this.Habitantes + "\nPais: " + this.Pais + "\n";
}
se asigna como método de la clase en su constructor:
function Ciudad (nombre, habitantes, pais)
{
this.Nombre = nombre;
this.Habitantes = habitantes;
this.Pais = pais;
this.Resumen = ciudad_resumen;
}
En la función se utiliza la palabra clave this que hace referencia a la instancia concreta que llame al método en cada ocasión.
var Huelva = new Ciudad ("Huelva", 500000, "España);
var txt = Huelva.Resumen(); // equivale a
Huelva["Resumen"]();
Puede cambiarse el comportamiento del objeto en tiempo de ejecución reasignando sus métodos para cada instancia concreta. Por ejemplo en el resumen de Huelva no queremos que incluya el país.
function ciudad_resumen_breve ()
{
return "Nombre: " + this.Nombre + "\nHabitantes: " +
this.Habitantes + "\n";
}
Huelva.Resumen = ciudad_resumen_breve;
Pueden definirse nuevas propiedades y métodos para un objeto una vez creado. Para ello basta con asignar un valor a la nueva propiedad o método:
Madrid.Capital = true; // la propiedad Capital es ahora miembro del objeto Madrid
Ahora bien, estas nuevas propiedades o métodos son miembros únicamente del objeto para el que se definen (en este caso sólo de Madrid) y no de la clase Ciudad.
Tampoco se pueden reasignar los métodos para la clase en tiempo de ejecución. Por ejemplo la siguiente sentencia
Ciudad.Resumen = ciudad_resumen_breve;
no generará ningún error, pero la asignación no funcionará, y todos los objetos se comportarán igual que antes.
JavaScript suministra una propiedad llamada prototype que permite crear nuevas propiedades y métodos que serán comunes a todos los objetos de la clase. Estas propiedades son copiadas por referencia en cada objeto de la clase, por lo que tendrán el mismo valor para todos ellos. Sin embargo, se pude cambiar el valor de un miembro prototype en un objeto, y el nuevo valor sobreescribe el valor de defecto únicamente en esa instancia. Otros objetos pertenecientes a la misma clase no se verán afectados por el cambio.
Ciudad.prototype.Capital = false;
Ciudad.prototype.Resumem_breve = ciudad_resumen_breve;
Ahora la propiedad Capital el método Resumen_breve forman parte del prototipo de la clase. Para referenciarles no es necesario incluir la palabra prototype.
var c = Huelva.Capital; // será false mientras que
Madrid.Capital será true
txt = Madrid.Resumen_breve;
Es posible incluso, definir nuevas propiedades para los objetos intrínsecos de JavaScript, ya que todos ellos tienen la propiedad prototype. Por ejemplo, la clase Number tiene una serie de propiedades que representan constantes (MAX_VALUE, MIN_VALUE, NaN, NEGATIVE_INFINITY y PODITIVE_INFINITY), MIN_VALUE es el número más próximo a cero que puede representarse en JavaScript, aproximadamente igual a 2,22e-308.
Number.prototype.MIN_VALUE = 0;
Puede obtenerse una relación de las propiedades y métodos de un objeto creado por el programador con la siguiente función:
function ResumenObjeto (obj)
{
var propiedad;
var txt "";
for (propiedad in obj)
txt += pripiedad + ": " + obj[prop] +
"<br>";
return txt;
}
La palabra clave with permite designar un objeto como predeterminado en un bloque de sentencias, de forma que puedan referenciarse sus métodos y propiedades sin necesidad de precederlos con el nombre del objeto. Por ejemplo la definición de la función ciudad_resumen puede simplificarse como sigue:
function ciudad_resumen ()
{
with (this)
return "Nombre: " + Nombre +
"\nHabitantes: " + Habitantes + "\nPais: " + Pais + "\n";
}
Es el objeto JavaScript que proporciona la funcionalidad matemática. Este objeto no puede ser creado usando el operador new, dando un error cuando se intenta utilizar. Es creado por el motor interprete del script en el momento en que se carga el motor.
Métodos:
Math.abs(n) - Retorna el valor absoluto del número o expresión numérica n que recibe como argumento
Math.acos(n) - Retorna el arco coseno de la n
Math.asin(n) - Retorna el arco seno de n
Math.atan(n) - Retorna el arco tangente de n
Math.atan2(y, x) - Retorna el ángulo en radianes desde el eje X a el punto (y, x) que recibe como argumento
Math.ceil(n) - Retorna el entero más pequeño que sea menor o igual que n
Math.cos(n) - Retorna el coseno de n
Math.exp(n) - Retorna el número e elevado a n, siendo e la constante de Euler cuyo valor aproximado es 2,718282
Math.floor(n) - Retorna el mayor entero que sea mayor o igual que n
Math.log(n) - Retorna el logaritmo neperiano de n
Math.max(n1, n2) - Retorna el máximo entre n1 y n2, n1 es una expresión numérica y n2 un valor numérico
Math.min(n1,n2) - Retorna el mínimo entre n1 y n2, n1 es una expresión numérica y n2 un valor numérico
Math.pow(b, e) - Retorna b elevado a la potencia e
Math.random() - Retorna un número aleatorio entre 0 y 1 ambos incluidos. El número generador del número aleatorio (semilla) es suministrado automáticamente cuando se carga el interprete JavaScript.
Math.round(n) - Retorna el número entero más próximo a n, si la parte decimal del número es 0,5 o mayor, el valor retornado es igual a menor entero mayor que n. En caso contrario retorna el mayor entero menor o igual que n.
Math.sin(n) - Retorna el seno de n
Math.sqrt(n) - Retorna la raíz cuadrada de n
Math.tan(n) - Retorna la tangente de n
Propiedades y constantes:
E - Número de Euler, base de los logaritmos neperianos. Aproximadamente 2,718282
LN2 - Logaritmo neperiano de 2, aproximadamente 0,693
LN10 - Logaritmo neperiano de 10, aproximadamente 2,302
PI - Relación entre la longitud de la circunferencia y su diámetro. Aproximadamente 3,14159
LOG2E - Logaritmo en base 2 de e, aproximadamente 1,442
LOG10E - Logaritmo natural o en base 10 de e, aproximadamente 0,434
SQRT2 - Retorna la raíz cuadrada de 2, aproximadamente 1,414
SQRT1_2 - Sirve para obtener la inversa de la raíz cuadrada de 2 o raíz cuadrada de 0,5, muy usada en trogonometría, aproximadamente 0,707
Ejemplos:
Math.sqrt (25); // retorna 5
Math.pow (5, 3);
/* retorna 5 elevado a 3 = 125. No se puede hacer 5^3 ya que ^ el el operados
XOR a nivel de bits */
Math.floor (3.14); // retorna 3
Math.floor (-3.14); // retorna -4
Math.ceil (3.14); // retorna 4
Maht.ceil (-3.14); // retorna -3
Math.round (3.14); //retorna 3
Maht.round (3.64); // retorna 4
Math.roung (3.4); // retorna 4
/* La siguiente función recibe un n y un entero ndec y retorna el número n
redondado con ndec decimales */
function xround (num, ndec)
{
var factor = 1;
for (i=1; i<=ndec; i++)
factor *= 10;
return Math.round (num * fact) / fact;
}
var n;
n = xround (2.345, 2); // retorna 2.34
n = xround (2.368, 1); // retorna 2.4
n = xround (2.368); // retorna 2
/* La siguiente función genera un número aleatorio comprendido entre los
números LInferiror y LSuperior que recibe como argumento */
function NAleatorio (LInferior, LSuperior)
{
return Math.round (LSuperior - LInferior) * Math.random() +
LInferior;
}
Math.max (20, 80); // retorna 80
Math.min (20, 80); // retorna 20
/* La siguiente función recibe un número n retornado un 1 si el número es
positivo, un -1 si es negativo y un 0 si el número es 0 */
function sgn (n)
{
if (n != 0)
return n / Math.abs(n);
else
return 0;
}
Una matriz es un conjunto de elementos colocados de forma adyacente en la vemoria de manera que se pueden referenciar por un nombre común y un índice
La clase Array permite definir y manejar matrices.
var Proveedores = new Array ();
// define una matriz de tamaño indeterminado
var Proveedores = new Array (20); // define una matriz de 20
elementos
Los elementos se pueden direccionar escribiendo el nombre del objeto array seguido del indice del elemento entre corchetes. Los indices han de ser números enteros positivos, comenzando con el 0:
Proveedores[0] = "Teleline";
Proveedores[1] = "Arrakis";
Proveedores[2] = "CTV-Jet";
Proveedores[3] = "Alehop";
Proveedores[20] = "Arsys";
El tamaño o número de elementos puede variar en tiempo de ejecución del script. Es decir, los arrays son dinámicos. Los índices no tienen que ser necesariamente consecutivos, en el ejemplo anterior los elementos del 4 al 19 no se han inicializado y tendrán el valor undefined.
La propiedad length del objeto Array almacena automáticamente el número de elementos de la matriz. En el ejemplo anterior la propiedad length valdrá 21 y no 5.
Se puede definir la matriz y sus elementos simultáneamente en al llamada al constructor:
var Proveedores = new Array ("Teleline", "Arrakis", "CTV-Jet", "Alehop", "Arsys");
JavaScript no soporta de forma directa las matrices multidimensionales. Para manejar este tipo de matrices definimos una matriz que a su vez contiene otras matrices. Así, para definir una matriz de dos dimensiones con 5 elementos por cada dimensión (25 en total):
var M = new Array (5);
for (i=0; i<=4; i++)
M[i] = new Array (5);
Se crea un array M de 5 elementos cada uno de los cuales es, a su vez, un array. Si hay que crear más dimensiones se repite el proceso anterior para cada elemento de las sucesivas matrices. Una vez definido el array multidimensional, se accede a sus elementos escribiendo los índices correspondientes entre corchetes
M [0][0] = "Primer elemento de la matriz";
El siguiente ejemplo crea una tabla de multiplicar desde 0x0 al 16x16:
var tabla = new Array (17);
for (var i = 0; i < tabla.length; i++)
{
var fila = new Array (17);
for (var j=0; j< fila.length; j++)
fila[j] = i + " x " + j + " = "
+ i*j;
tabla [i] = fila + "<br>";
}
var m3x7 = tabla[3][7];
Métodos:
array1.concat(array1) - retorna una objeto Array resultado de concatenar array1 y array2.
array.join(separador) - retorna una cadena de texto conteniendo los elementos del array separados por el string separador, si no se especifica este string se utilizará el string vacio "".
array.reverse() - invierte el orden de los elementos del array.
array.slice(inicio, [fin]) - retorna un nuevo array conteniendo los elementos de array comprendidos entre los índices inicio y fin que recibe como argumento, incluyendo el primero de ellos pero no el último. Si se omite fin la extracción se realizará hasta el final del array incluyendo el último elemento. Si fin es un número negativo indicará un desplazamiento desde el final del array.
array.sort([funcionsort]) - ordena los elementos del array. Si se omite la función de ordenación, los elementos se ordenan ascendentemente según su código ASCII. La función de ordenación debe retornar un valor negativo cuando el valor de su primer argumento es menor que el del segundo, un cero cuando los dos argumentos son equivalentes, y un valor positivo si el primer argumento es mayor que el segundo.
array.toString() - este método, que forma parte de todos los objetos intrínsecos de JavaScript, es llamado automáticamente cuando el array tiene que convertirse en string. Cada elemento es convertido a string y todos ellos se concatenan separados por comas.
array.valueOf() - igual a toString.
Ejemplos:
var a = new Array (0, 1, 2, 3, 4);
var b = new Array (5, 6, 7, 8, 9);
var c = a.concat (b); // c será un
array con los elementos 0, 1, 2 , 3, 4, 5, 6, 7, 8 ,9
var txt = c.join ("--"); // txt será 0--1--2--3--4--5--6--7--8--9
a.reverse(); // a contendrá los elementos 4, 3, 2, 1, 0
var d = c.slice(5, 8); // d
será un array con los elementos 5, 6, 7
var e = c.slice(4, -2); // e será un
array con los elementos 4, 5, 6, 7. No incluye los dos últimos
/* El siguiente ejemplo ilustra como añadir un método al objeto Array que
retorne el valor del mayor de sus elementos */
function array_max ()
{
var i, max = this[0];
for (i=1; i < this.length; i++)
if (max < this[i])
max =
this[i];
return max;
}
Array.prototype.max = array_max;
var x = new Array (1, 2, 3, 4, 5, 6);
var y = x.max();
// y valdrá 6 que es el máximo elemento de x
Cuando se declara en JavaScript una variable de string o se utilizan literales, se crea un objeto String. Los objetos String creados implícitamente son tratados de forma algo diferente a los creados explícitamente con el operador new. Todos los strings implícitos comparte un único objeto, de forma que si se añade una propiedad a uno de ellos, la propiedad se añadirá al resto de los string implícitos.
var a, b;
a = "Esto es un string estándar";
b = "Esto es otro string estándar";
a.test = 10;
En este caso, la propiedad test se define para a y para todos los literales utilizados en el resto de script. Sin embargo, en el siguiente ejemplo:
var a, b;
a = new String("Esto es un objeto String");
b = new String("Esto es otro objeto String");
a.test = 10;
la propiedad test no queda definida para b ni para el resto de los string del script. Esta es la única diferencia entre los objetos string creados con new y los string literales.
Métodos:
Algunos de los métodos del objeto String facilitan la inclusión de etiquetas HTML en las cadenas de texto. No tendremos en cuenta estos métodos, ya que la creación de páginas Web no es el objeto de este documento. En los métodos siguientes string puede ser un objeto String o un literal.
string.charAt(índice) - retorna el carácter en la posición especificada por índice. El índice esta en el rango de 0 a string.length
string.charCodeAt(índice) - retorna el código Unicode correspondiente al carácter que se encuentra en la posición especificada por índice.
string1.concat(string2) - retorna un objeto String igual a la concatenación de string1 y string2.
String.fromCharCode (code1, code2, code2,...) - crea un string desde los códigos Unicode que recibe
string.indexOf(substring, [índice]) - encuentra la primera ocurrencia del substring en string comenzando la búsqueda en la posición índice. Si no se especifica un índice se comenzará la búsqueda en el primer carácter. Retorna un entero indicando la posición de comienzo de substring dentro del objeto string. Si el substring no se encuentra retorna -1.
string.lastindexOf(substring, [índice]) - es idéntico al método indexOf exceptuando que la búsqueda se realiza de derecha a izquierda en vez de izquierda a derecha, retornando la posición de la última ocurrencia del substring en string.
string.slice(inicio, [fin]) - crea un objeto String conteniendo los caracteres de string comprendidos entre las posiciones inicio y fin. Si fin es negativo indica un desplazamiento desde el final de string.
string.split(separador) - crea un array en que cada elemento es un string conteniendo los caracteres que resultan de dividir string en cada punto donde contiene el carácter separador.
string.substr(inicio, [longitud]) - retorna un string conteniendo los caracteres de string desde la posición inicio y con la longitud especificada. Si no se especifica la longitud retornará hasta el último carácter.
string.substring(inicio, [fin]) - retorna un substring de string conteniendo los caracteres entre las posiciones inicio y fin.
string.toLowerCase() - convierte los caracteres de string a minúsculas.
string.toUpperCase() - convierte los caracteres de string a mayúsculas.
string.toString() - retorna el valor de string.
string.valueOf() - retorna el valor de string.
Ejemplos:
var s = "ABCDEFG".charAt(3); // s valdrá D
var n = "ABCDEFG".charCodeAt(3); // n valdrá 68 que es el
código Unicode del carácter D
var str1 = "ABCDEFGHIJKLM"
var str2 = "NOPQRSTUVWXYZ";
var s = str1.concat(str2); // s valdrá
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
var s = String.fromCharCode (68); // s valdrá "D"
var n = "ABCDEFG".indexOf ("CDE"); // n valdrá 2
var s = "ABCDEFGH".slice (2, 4); // s valdrá "CD"
/* En el siguiente ejemplo, la variable a será un array con los elementos
a[0] = "El", a[1] = "perro", ...
var a = "El perro de San Roque no tiene rabo".split(" ");
var s = "ABCDEF".substr (2, 3); // s valdrá "CDE"
La funcionalidad relacionada con unidades temporales de fecha y hora son suministradas por el objeto Date de JavaScript.
Una variable que contenga una fecha, o sea un objeto de tipo Date, almacena un valor numérico que expresa el número de milisegundos (miles de segundos) transcurridos desde medianoche (00:00:00) del día 1 de enero de 1970 (1/1/1970). Las diferencias temporales se expresan igualmente en esta unidad, de forma que un día tiene 86.400.000 milisegundos.
El rango de fechas que puede ser representado por un objeto Date es aproximadamente de 285.616 años anteriores o posteriores al uno de enero de 1970.
JavaScript proporciona la funcionalidad para manejar las unidades temporales estándar llamadas Uneversal Coordinated Time, UTC. Mas conocido como Greenwich Meridian Time, GMT. Teniendo por tanto en cuenta la diferencia horaria de los distintos sistemas que ejecutan el script.
El constructor del objeto Date admite tres sintaxis distintas:
var fecha = newDate();
La variable fecha tendrá un valor que representa la fecha y hora local
en el momento de ser creada. Si en el momento de crear la variable son las
20:53:22 del viernes 3 de agosto del 2001 la representación textual de
fecha, retornada por el método toString, será Fri Aug 3 20:53:22 UTC+0200
2001.
var fecha = newDate(ValordeFecha);
Siendo ValordeFecha un valor numérico, representando el valor en
milisegundos en UTC entre la fecha especificada y el 1/1/1970 a las 00:00:00.
También puede ser un string que será analizado por el método parse que se
explica a continuación.
var fecha = newDate(año, mes, día, [horas,[minutos,
[segundos, [milisegundos]]]]);
El año se expresará con cuatro dígitos, el mes será un
entero entre 0 y 11 correspondiendo el 0 a enero y el 11 a diciembre, el
día es un entero entre 1 y 31, la horas es un entero de 0 a 23 (de
medianoche a 11 pm), los minutos y segundos se expresan como un
entero de 0 a 59, los milisegundos como un entero de 0 a 999.
El objeto Date tiene dos métodos estáticos que pueden ser llamados sin necesidad de crear un objeto Date. Estos son: parse y UTC.
El método parse analiza un string que contiene una fecha, y retorna el número de milisegundos entre dicha fecha y el 1/1/1970 a las 00:00:00.
Date.parse (ValordeFecha);
El método UTC retorna el número de milisegundos entre el 1/1/1970 a las 00:00:00 UTC y la fecha que recibe como argumento.
Date.UTC (año, mes, día, [horas,[minutos, [segundos, [milisegundos]]]]);
El valor retornado puede ser utilizado como argumento para el constructor de un objeto Date y en el método setTime.
Métodos:
fecha.getDate() - retorna el día del mes almacenado en el objeto fecha según la hora local.
fecha.getDay() - retorna el día de la semana almacenado en el objeto fecha según la hora local. El valor retornado es un entero de 0 a 6 correspondiendo a los días de la semana del domingo al sabado.
fecha.getFullYear() - retorna el año almacenado en el objeto fecha según la hora local.
fecha.getHours() - retorna un entero entre 0 y 23 indicando el número de horas desde la medianoche almacenadas en el objeto fecha según la hora local.
fecha.getMilliseconds() - retorna un entero entre 0 y 999 indicando el número de milisegundos almacenados en el objeto fecha según la hora local.
fecha.getMinutes() - retorna un entero entre 0 y 59 indicando el número de minutos almacenados en el objeto fecha según la hora local.
fecha.getMonth() - retorna un entero entre 0 y 11 indicando el mes almacenado en el objeto fecha según la hora local.
fecha.getSeconds() - retorna un entero entre 0 y 59 indicando los segundos almacenados en el objeto fecha según la hora local.
fecha.getTime() - retorna un entero representando el número de milisegundos entre las 00:00:00 del 1 de enero de 1970 y la fecha y hora almacenada en el objeto fecha. El rango es aproximadamente de 285.616 años anteriores y posteriores al 1/1/1970. Los números negativos indican fechas anteriores a 1970.
fecha.getTimezoneOffset() - retorna un entero representando el número de minutos entre la hora en la máquina en la que se ejecuta y la hora UTC.
fecha.getUTCDate() - retorna el día del mes almacenado en el objeto fecha según la hora UTC
fecha.getUTCDay() - retorna el día de la semana almacenado en el objeto fecha según la hora UTC.
fecha.getUTCFullYear() - retorna el año almacenado en el objeto fecha según la hora UTC.
fecha.getUTCHours() - retorna un entero entre 0 y 23 indicando el número de horas desde la medianoche almacenadas en el objeto fecha según hora UTC.
fecha.getUTCMilliseconds() - retorna un entero entre 0 y 999 indicando el número de milisegundos almacenados en el objeto fecha según la hora UTC.
fecha.getUTCMinutes() - retorna un entero entre 0 y 59 indicando el número de minutos almacenados en el objeto fecha según la hora UTC.
fecha.getUTCMonth() - retorna un entero entre 0 y 11 indicando el mes almacenado en el objeto fecha según la hora UTC.
fecha.getUTCSeconds() - retorna un entero entre 0 y 59 indicando los segundos almacenados en el objeto fecha según la hora UTC.
fecha.setDate(día) - asigna un nuevo día del mes a la fecha almacenada en fecha según la hora local.
fecha.setFullYear(año, [ mes, [ día]]) - asigna un nuevo año a la fecha almacenada en fecha, opcionalmente se puede establecer un mes y un día del mes según la hora local.
fecha.setHours(horas, [ minutos, [ segundos, [milsegundos]]]) - asigna un hora a la fecha almacenada en fecha, según la hora local, opcionalmente se pueden establecer los minutos, segundos, y milisegundos.
fecha.setMilliseconds(milsegundos) - asigna milisegundos a la hora almacenada en fecha, según la hora local.
fecha.setMinutes( minutos, [ segundos, [milsegundos]]) - asigna minutos a la hora almacenada en fecha, según la hora local, opcionalmente se pueden establecer los segundos, y milisegundos.
fecha.setMonth( mes, [ valordefecha]) - asigna el mes a la fecha almacenada en fecha, según la hora local, opcionalmente se pueden establecer un varordefecha. El valor del mes estará comprendido entre 0 y 11.
fecha.setSeconds(segundos, [milsegundos]) - asigna el número de segundos a la hora almacenada en fecha, según la hora local, opcionalmente se pueden establecer los milisegundos.
fecha.setTime(milsegundos) - asigna una fecha y hora al objeto fecha, milisegundos expresa el número de milisegundos desde medianoche del 1/1/1970. Es independiente de la zona horaria.
Los métodos setUTCDate, setUTCFullYear, setUTCHours, setUTCMilliseconds, setUTCMinutes, setUTCMonth, setUTCSeconds son equivalentes a los vistos anteriormente pero utilizan la hora UTC en vez de la hora local.
fecha.toUTCString() - convierte la hora a un string en coordenadas UTC.
Ejemplos:
/* El siguiente ejemplo ilustra es uso del método getTimezoneOffset */
function TZDemo()
{
var d, tz, s = "La hora local actual es ";
d = new Date();
tz = d.getTimezoneOffset();
if (tz < 0)
s += tz / 60 + " horas anteriores
GMT";
else if (tz == 0)
s += "GMT";
else
s += tz / 60 + " horas posteriores
GMT";
return(s);
}
var fecha = new Date(2001, 8, 6); // 6/8/2001
fecha.setDate(33); // almacenará 2
de septiembre en fecha
Existen dos sintaxis para definir funciones:
function functionname( [argname1 [, ... argnameN]] )
{
body
}
var functionname = new Function( [argname1, [... argnameN,]] body );
La primera sintaxis crea una función que será convertida a un objeto Function cuando sea necesario. La segunda sintaxis crea un objeto Function que será convertido en un valor de función en el momento que la función es llamada. Esta segunda sintaxis crea el objeto Function explícitamente.
El objeto Function tiene una propiedad en su prototipo llamada arguments. Se trata de una matriz que permite conocer los argumentos pasados a la función. De este modo es posible crear funciones polimórficas que permiten responder de distinta forma ante los distintos argumentos que recibe.
Veamos una función que permite sumar los números que recibe como argumentos, independientemente del número de ellos que reciba:
function Suma ()
{
var suma=0;
for (i=0; i < Suma.arguments.length; i++)
suma += Suma.aguments[i];
return suma;
}
Otra propiedad del objeto Function es caller, que contiene una referencia a la función que ha llamado a la actual. Si la función es llamada desde el primer nivel del script, caller será null, pero en caso de ser llamada desde otra función, caller contendrá una referencia a dicha función.
Es un objeto intrínseco de JavaScript que almacena los métodos globales. Este objeto no se utiliza nunca directamente, y no puede crearse usando el operador new. Se crea automáticamente, igual que el objeto Math, el inicializar el motor interprete del script, por los que sus métodos y propiedades están siempre disponibles.
Métodos:
eval (códigostring) - el argumento códigostring es un objeto String que contienen sentencias de código JavaScript. Este string es analizado y ejecutado en el mismo contexto que la llamada a eval.
isFinite (número) - determina si número tiene un valor finito, retorna true si número es cualquier valor distinto de NaN, de infinito negativo, e infinito positivo. En estos tres casos retorna false.
isNaN (número) - retorna true si número contiene el valor reservado NaN (not a number) y false en caso contrario. Alternativamente podría compararse número consigo mismo, se no es igual significa que su valor es NaN, esto es así porque NaN es el único valor que no es igual a sí mismo.
parseFloat(stringnúmero) y parseInt(stringnúmero) - convierten el string que reciben como argumento en un número de coma flotante o entero respectivamente.
Ejemplos:
/* el siguiente ejemplo crea un objeto Date llamado mifecha, conteniendo la
fecha y hora local del sistema en el momento de ser creada */
eval ("var mifecha = new Date ();");
parseFloat ("abc"); // retorna NaN
parseFloat ("1.2abc"); // retorna 1,2