Guía JavaScript 1.5:Características generales del lenguaje

De MDC

Tabla de contenidos 1 Valores 1.1 Conversión de tipos de datos 2 Variables 2.1 Declaración de variables 2.2 Evaluación de variables 2.3 Dominio de variables 2.4 Variables globales 3 Constantes 4 Literales 4.1 Arreglos de literales 4.2 Literales lógicos booleans 4.3 Literales enteros 4.4 Literales de coma flotante 4.5 Literales de objetos 4.6 Literales de cadenas de caracteres (string) 4.6.1 Uso de caracteres especiales en cadenas de caracteres 4.6.2 Caracteres de escape 5 Unicode 5.1 Compatibilidad de Unicode con ASCII e ISO 5.2 Secuencias de escape unicode 5.3 Caracteres Unicode en archivos JavaScript 5.4 Desplegando caracteres con unicode

[editar] Valores

JavaScript reconoce los siguientes tipos de valores:

• Números, como 42 o 3.14159.
• Valores Lógicos (Booleanos), tanto true como false.
• Cadenas, como "Hola!".
• null, una palabra especial que denota un valor nulo; null es además un valor primitivo. Debido a que JavaScript discrimina mayúsculas y minúsculas [case-sensitive], no es lo mismo null que Null, NULL, o cualquier otra variación.
• undefined: una propiedad de alto nivel cuyo valor es indefinido; undefined es también un valor primitivo.

Este relativamente pequeño grupo de tipos de valores, o tipos de datos, le permite realizar útiles funciones con sus aplicaciones. No existe una diferencia explicita entre números enteros y reales. Ni hay implícitamente un tipo de dato de fecha en JavaScript. Sin embargo, usted puede usar el objeto Date y sus métodos para manejar fechas. Objetos y funciones son los otros elementos fundamentales en el lenguaje. Usted puede pensar en los objetos como si fueran contenedores (de valores) con nombre, y en las funciones como los procedimientos que sus aplicaciones pueden realizar.

[editar] Conversión de tipos de datos

JavaScript es un lenguaje del tipo dinámico. Esto significa que no es necesario especificar el tipo de dato de una variable cuando esta es declarada y que las variables son convertidas automáticamente cuando sea necesario durante la ejecución del script. Así, por ejemplo, puede definir una variable como sigue a continuación:

 
var respuesta = 42

Y luego, asignar a la misma variable un valor de cadena, por ejemplo:

respuesta = "Gracias por todo el pescado..."

Ya que JavaScript asigna tipos dinámicamente, esta asignación no provoca un mensaje de error.

En expresiones que incluyen valores numéricos y de cadena con el operador '+', JavaScript convierte los valores numéricos a cadena. Por ejemplo, considere las siguientes sentencias:

x = "La respuesta es " + 42 // devuelve "La respuesta es 42"
y = 42 + " es la respuesta" // devuelve "42 es la respuesta"

En sentencias que incluyen otros operadores, JavaScript no convierte los valores numéricos a cadena. Por ejemplo:

"37" - 7 // devuelve 30
y
"37" + 7 // devuelve "377"

[editar] Variables

Las variables se utilizan como nombres simbólicos para los valores en su aplicación. Los nombres de las variables, llamados identificadores, se ajustan a ciertas reglas.

Un identificador JavaScript debe empezar con una letra, guión bajo [underscore] (_), o el signo de dólar [dollar sign] ($); los caracteres subsecuentes tambien pueden ser dígitos (0-9). Debido a que JavaScript es [case sensitive], la letras incluyen los caracteres desde la "A" hasta la "Z" (Mayúsculas) y los caracteres desde la "a" hasta la "z" (minúsculas).

Comenzando por JavaScript 1.5, usted puede utilizar en los identificadores las letras ISO 8859-1 o Unicode tales como å y ü. Usted también puede utilizar las secuencias de escape Unicode \uXXXX listadas en la página Secuencias de escape Unicode como caracteres en los identificadores.

Algunos ejemplos de nombres legales son Número_de_hits, temp99 y _nombre entre otros.

[editar] Declaración de variables

Una variable puede ser declarada de dos maneras:

• Con la palabra clave: var. Por ejemplo, var x = 42. Esta sintaxis se puede usar para declarar variables locales y globales.
• Simplemente asignándole un valor. Por ejemplo, x = 42. Esto siempre declara una variable global y genera una advertencia estricta [strict warning] de JavaScript. No debería utilizar esta variante.

[editar] Evaluación de variables

Una variable declarada usando la sentencia var sin un valor inicial especificado tiene el valor de indefinido.

Un intento de acceso a una variable no declarada dará como resultado el lanzamiento de la excepción ReferenceError (Error de referencia):

var a;
print("El valor de a es " + a); // imprime: "El valor de a es indefinido"
print("El valor de b es " + b); // lanza la excepción ReferenceError

Puede utilizar el valor undefined para determinar si una variable posee un valor. En el código siguiente, a la variable entrada no se asigna un valor y la sentencia if la evalúa como verdadera true.

var entrada;
if(entrada === undefined){
   hagaEsto();
} else {
   hagaAquello();
}

El valor undefined se comporta como false cuando es usado en un contexto lógico [boolean]. Por ejemplo, el siguiente código ejecuta la función miFunción porque el elemento miArreglo no está definido:

miArreglo=new Array()
if (!miArreglo[0])
   miFunción();

Cuando evalúe una variable nula, el valor null se comporta como 0 en un contexto numérico y como falso en un contexto lógico [boolean]. Por ejemplo:

var n = null;
n * 32; //devuelve "0"

[editar] Dominio de variables

Cuando se declara una variable fuera de cualquier función, se le llama variable global, porque está disponible para cualquier sección del código en el documento. Cuando se declara una variable dentro’’ de una función, se le llamada variable local, porque está disponible sólo dentro de esa función.

JavaScript no tiene dominio de bloque de sentencias; más bien, una variable será considerada local para el código donde ésta reside. Por ejemplo el código siguiente imprimirá '0' en lugar de saltar si la condición es false:

if (condición) {
  var x = 5;
}
print(x ? x : 0);

Otra cosa inusual acerca de variables en JavaScript es que se puede hacer referencia a una variable declarada posteriormente, sin obtenerse una excepción.

print(x === undefined); // imprime: "true"
var x = 3;

[editar] Variables globales

Las variables globales son en realidad las propiedades del objeto global. En la páginas Web, el objeto global es la ventana, de tal forma que usted puede configurar y acceder a las variables globales usando la sintaxis siguiente window.variable.

En consecuencia, usted puede acceder a las variables globales declaradas en una ventana o frame desde otra ventana o frame especificando el nombre de la ventana o frame. Por ejemplo, si una variable llamada NúmeroTelefónico es declarada en un documento FRAMESET, usted puede referirse a esta variable desde un frame hijo como parent.NúmeroTelefónico.

[editar] Constantes

Puede crear constantes con nombre sólo de lectura con la palabra clave const. La sintaxis de un identificador de constante es la misma que la de un identificador de variable: debe empezar con una letra o un guión bajo "_" [underscore] y puede contener caracteres alfanuméricos y/o guiones bajos.

const prefijo = '212'; 

Una constante no puede cambiar el valor mediante una asignación o ser re-declarada mientras el script está en ejecución.

Las reglas de ámbito [scope] para constantes son las mismas que para las variables, excepto que la palabra clave const es siempre requerida, incluso para constantes globales. Si la palabra clave es omitida, se asume que el identificador representa a una variable.

No se puede declarar una constante con el mismo nombre de una función o de una variable en el mismo ámbito [scope]. Por ejemplo:

//ESTO CAUSA UN ERROR
function f() {};
  const f = 5;

//ESTO CAUSARÍA TAMBIÉN UN ERROR
function f() {
  const g = 5;
  var g;

  //grupo de sentencias

}

[editar] Literales

Se utilizan los literales para representar valores en JavaScript. Estos son valores fijados, no variables, que usted literalmente proporciona en su script. Esta sección describe los siguientes tipos de literales:

• Arreglos de literales
• Literales lógicos [booleans]
• Literales de punto flotante
• Literales enteros
• Objetos literales
• Cadenas literales (string)

[editar] Arreglos de literales

Un arreglo literal es una lista de cero o más expresiones, cada una de las cuales representa un elemento del arreglo, delimitada por corchetes ([]). Cuando crea un arreglo usando un arreglo literal, aquel será inicializado con los valores especificados como sus elementos y su longitud será el número de argumentos especificados.

El siguiente ejemplo crea un arreglo de cafés con tres elementos y una longitud de tres:

cafés = ["Tueste francés", "Colombiano", "Kona"]

Nota Un arreglo literal es un tipo de objeto iniciador. Véase: el uso de objetos iniciadores.

Si un arreglo es creado usando un literal en un script de alto nivel, JavaScript interpreta el arreglo cada vez que es evaluada la expresión que contiene el arreglo literal. Adicionalmente, un literal utilizado en una función es creado cada vez que la función es invocada.

Los arreglos literales también son un arreglo de objetos. Véase: el objeto array para más detalles.

Comas extra en Arreglos Literales

No tiene que especificar todos los elementos dentro de un arreglo literal. Si pone dos comas en una fila, el arreglo es creado con espacios para los elementos no especificados. El siguiente ejemplo crea el arreglo pez:

pez = ["León", , "Angel"]

Este arreglo posee dos elementos con los valores establecidos y un elemento vacío (pez[0] es "León", pez[1] es undefined y pez[2] es "Angel").

Si incluye una coma al final de la lista de elementos, esta coma es ignorada. En el siguiente ejemplo, la longitud del arreglo es tres. No existe miLista[3]. Todas las otras comas en la lista indican a un nuevo elemento.

miLista = ['casa', , 'escuela', ];

En el siguiente ejemplo, la longitud del arreglo es cuatro y miLista[0] y miLista[2] están vacíos.

miLista = [ , 'casa', , 'escuela'];

En el siguiente ejemplo, la longitud del arreglo es cuatro y miLista[1] y miLista[3] están vacíos. Sólo la última coma es ignorada.

miLista = ['casa', , 'escuela', , ];

[editar] Literales lógicos booleans

El tipo Boolean posee dos valores literales: true y false.

No debe confundirse los valores primitivos Boolean true y false con los valores verdadero [true] y falso [false] del objeto Boolean. El objeto Boolean es un contenedor [wrapper] de los tipos de datos primitivos Boolean. Véase: el objeto boolean para más información.

[editar] Literales enteros

Los enteros pueden ser expresados en decimales (base 10), hexadecimales (base 16) y octales (base 8). Un literal entero decimal consiste de una secuencia de dígitos sin un 0 (cero) por delante. Un 0 (cero) por delante en un literal entero indica que este es un octal; Un 0x (o 0X) por delante indica que es un hexadecimal. Un entero hexadecimal puede incluir los dígitos (0-9) y las letras a-f y A-F. Los enteros octales pueden incluir sólamente los dígitos 0-7.

Los literales enteros octales están obsoletos y han sido removidos del estandar de la ECMA-262, Edición 3. JavaScript 1.5 mantiene un soporte para ellos sólo por compatibilidad con versiones anteriores.

Algunos ejemplos de literales enteros son:

0, 117 y -345 (decimales, base 10)
015, 0001 y -077 (octales, base 8) 
0x1123, 0x00111 y -0xF1A7 (hexadecimales, "hex" o base 16)

[editar] Literales de coma flotante

Un literal de coma flotante puede contener las siguientes partes:

• Un entero decimal el cual puede tener signo (precedido por "+" o "-"),
• Un punto decimal ("."),
• Una fracción (otro número decimal),
• Un exponente.

La parte exponencial es una "e" o "E" seguida de un entero, el cual puede tener signo (precedido por "+" o "-"). Un literal de coma flotante debe tener al menos un dígito y, o un punto decimal o una "e" (o "E").

Algunos ejemplos de literales de coma flotante son: 3.1415, -3.1E12, .1e12 y 2E-12.

De forma breve, la sintaxis es: [dígitos][.dígitos][(E|e)[(+|-)]dígitos]

Por ejemplo:

3.14 2345.789 .3333333333333333333

[editar] Literales de objetos

Un literal de objeto es una lista de cero o más pares de nombres de propiedades y valores asociados a dicho objeto, delimitada por llaves ({}). Usted no debe utilizar un literal de objeto al inicio de una sentencia. Esto provocaría un error o un comportamiento inesperado, debido a que una { será interpretada como el comienzo de un bloque.

El siguiente es un ejemplo de un literal de objeto. El primer elemento del objeto automovil define una propiedad, miAuto; el segundo elemento, la propiedad obtenerAuto invoca a la función (TipoAuto("Honda")); el tercer elemento, la propiedad especial usa una variable existente (Ventas).

var Ventas = "Toyota";

function TipoAuto(nombre) {
   if(nombre == "Honda")
      return nombre;
   else
      return "Lo siento, no vendemos " + nombre + ".";
}

automovil = {miAuto: "Saturn", obtenerAuto: TipoAuto("Honda"), especial: Ventas}

document.write(automovil.miAuto); // Saturn
document.write(automovil.obtenerAuto); // Honda
document.write(automovil.especial); // Toyota

Adicionalmente, usted puede usar literales de cadena o numéricos para el nombre de una propiedad o para anidar un objeto dentro de otro. El siguiente ejemplo utiliza estas opciones.

car = {manyCars: {a: "Saab", b: "Jeep"}, 7: "Mazda"}

document.write(car.manyCars.b); // Jeep
document.write(car[7]); // Mazda

Por favor, tenga en cuenta lo siguiente:

foo = {a: "alpha", 2: "two"}
document.write (foo.a)    // alpha
document.write (foo[2])   // two
//document.write (foo.2)  // Error: nos e encuentra ) después de la lista de argumentos
//document.write (foo[a]) // Error: a no ha sido definido
document.write (foo["a"]) // alpha
document.write (foo["2"]) // two

[editar] Literales de cadenas de caracteres (string)

Una cadena literal tiene cero o más caracteres encerrados entre comillas dobles (") o simples ('). Una cadena debe estar delimitada por comillas del mismo tipo, es decir, tanto las comillas simples como dobles al inicio y al final de la cadena. Los siguientes ejemplos son cadenas literales:

• "blah"
• 'blah'
• "1234"
• "una línea \n otra línea"
• "El gato de John"

Usted puede invocar cualquiera de los métodos del objeto String (cadena) en un valor literal de cadena—JavaScript automáticamente la convierte de una cadena literal a un objeto String temporal, mediante la invocación del método, luego descarta el objeto String temporal. También se puede usar la propiedad String.length con una cadena literal:

• "El gato de John".length

Debe usarse una cadena literal a menos que desee específicamente utilizar un objeto String. Véase:Objeto String para más detalles.

[editar] Uso de caracteres especiales en cadenas de caracteres

Además de los caracteres ordinarios, se puede también incluir caracteres especiales en las cadenas, tal como se muestra en el siguiente ejemplo.

"una línea \n otra línea"

La siguiente tabla lista los caracteres especiales que pueden usarse en cadenas JavaScript.

Caracter	Significado
\b	Retroceso [Backspace]
\f	[Form feed]
\n	Nueva línea
\r	Retorno de carro [Carriage return]
\t	Tabulador [Tab]
\v	Tabulador vertical
\'	Apóstrofe o comilla simple
\"	Doble comilla
\\	Caracter Backslash (\).
\XXX	El caracter de codificación Latin-1 especificado por tres dígitos octales XXX entre 0 y 377. Por ejemplo, \251 es una secuencia octal para el símbolo de derechos de copia [copyright] .
\xXX	El caracter de codificación Latin-1 especificado por dos dígitos hexadecimales XX entre 00 y FF. Por ejemplo, \xA9 es una secuencia hexadecimal para el símbolo de copyright.
\uXXXX	El caracter Unicode especificado por cuatro dígitos hexadecimales XXXX. por ejemplo, \u00A9 es una secuencia Unicode para el símbolo de copyright. Véase Secuencia de escape Unicode.

Tabla 2.1: Caracteres especiales de JavaScript

[editar] Caracteres de escape

Para caracteres no listados en la Tabla 2.1, la contrabarra [backslash] precedente es ignorada, pero su uso está obsoleto y debería ser abandonado.

Se puede insertar una comilla dentro de una cadena precediéndola por una contrabarra [backslash]. Esto se conoce como escapar la comilla. Por ejemplo:

var texto = "El lee \"La Incineración de Sam McGee\" de R.W. Service."
document.write(texto)

El resultado de ello sería:

El lee "La Incineración de Sam McGee" de R.W. Service.

Para incluir el literal correspondiente a la contrabarra [backslash] dentro de una cadena, deberá escapar el caracter de contrabarra [backslash]. Por ejemplo, para asignar la ruta de un archivo c:\temp a una cadena, use lo siguiente:

var home = "c:\\temp"

[editar] Unicode

Unicode es un estandar universal para la codificación de caracteres para el intercambio y despliegue de los principales lenguajes escritos. Cubre los lenguajes de las Américas, Europa, Medio Este, África, India, Asia y el Pacífico, así como para escritos históricos y símbolos técnicos. El Unicode permite el intercambio, procesamiento y despliegue de textos multilingües, al igual para el uso de símbolos técnicos comunes y matemáticos. Unicode espera resolver los problemas de internacionalización para el cómputo multilingüe, tales como los diferentes estándares nacionales de caracteres. Sin embargo, no todas las escrituras modernas o arcaicas son soportadas actualmente.

El conjunto de caracteres Unicode puede ser usado por todas las codificaciones conocidas. Unicode es modelado después del conjunto de caracteres ASCII (Código estandar americano para el intercambio de información [American Standard Code for Information Interchange]). Utiliza para cada caracter nombres y valores numéricos. La codificación de caracteres especifica la identidad de los caracteres y sus valores numéricos (posición del código) así como la representación de estos valores en bits. El valor numérico de 16-bits (valor del código) está definido por números hexadecimales y un prefijo U, por ejemplo: U+0041 representa A. El nombre único para este valor es LA LETRA LATINA EN MAYÚSCULA A.

Unicode no es soportado por versiones anteriores a JavaScript 1.3.

[editar] Compatibilidad de Unicode con ASCII e ISO

Unicode es totalmente compatible con el estandar internacional ISO/IEC 10646-1; 1993, el cual es un subconjunto del estandar ISO 10646.

Varias codificaciones estandar (incluyendo UTF-8, UTF-16 y la ISO UCS-2) son usadas para representar físicamente los bits actuales como Unicode.

La codificación UTF-8 de Unicode es compatible con los caracteres ASCII y es soportada por muchos programas. Los primeros 128 caracteres Unicode corresponden a los caracteres ASCII y tienen el mismo valor en bytes. Los caracteres Unicode U+0020 hasta U+007E son equivalentes a los caracteres ASCII 0x20 hasta 0x7E. A diferencia de la ASCII, la cual soporta el alfabeto Latino que utiliza un conjunto de caracteres de 7-bit, UTF-8 utiliza entre uno y cuatro octetos para cada caracter. (Un "Octeto" significa un byte, u 8 bits.) Esto permite la representación de millones de caracteres. Una codificación alternativa estandar, UTF-16, utiliza dos octetos para representar los caracteres Unicode. Una sequencia de escape permite a la UTF-16 representar el rango total Unicode usando cuatro octetos. La ISO UCS-2 (Conjunto de caracteres universales [Universal Character Set]) utiliza dos octetos.

JavaScript y Navigator soportan UTF-8/Unicode lo cual significa que puede usar caracteres no-Latinos, internacionales y localizados, más símbolos técnicos especiales en los programas JavaScript. Unicode provee una manera estandar para codificar textos multilingües. Desde la codificación UTF-8 de Unicode es posible la compatibilidad con ASCII, los programas pueden utilizar los caracteres ASCII. Puede utilizar caracteres no-ASCII Unicode en los comentarios, cadenas literales, identificadores y expresiones regulares de JavaScript.

[editar] Secuencias de escape unicode

Usted puede utilizar las secuencias de escape Unicode en cadenas literales, expresiones regulares e identificadores. La secuencia de escape consiste en seis caracteres ASCII: \u y un número hexadecimal de cuatro dígitos. Por ejemplo: \u00A9 representa el símbolo de copyright. Cada secuencia de escape Unicode en JavaScript es interpretada como un caracter más.

El código siguiente retorna el símbolo de copyright y una cadena "Centro de desarrollo Mozilla".

x="\u00A9 Centro de desarrollo Mozilla"

La siguiente tabla lista los caracteres especiales utilizados frecuentemente y su valor Unicode.

Categoría	Valor Unicode	Nombre	Nombre del Formato
Valores de espacios en blanco	\u0009	Tab	<TAB>
	\u000B	Tab Vertical	<VT>
	\u000C	Form Feed	<FF>
	\u0020	Espacio	<SP>
Valores terminales de Línea	\u000A	Avance de línea	<LF>
	\u000D	Retorno del carro	<CR>
Valores adicionales de secuencias de escape Unicode	\u0008	Retroceso	<BS>
	\u0009	Tab Horizontal	<HT>
	\u0022	Comilla doble	"
	\u0027	Comilla simple	'
	\u005C	Contrabarra [Backslash]	\

Tabla 2.2: Valores Unicode para caracteres especiales

JavaScript utiliza la secuencia de escape Unicode en forma diferente a Java. En JavaScript, la secuencia de escape nunca es interpretada como un primer caracter especial. Por ejemplo: una secuencia de escape de terminal de línea dentro de una cadena no termina la cadena antes de ser interpretada por la función. JavaScript ignora cualquier secuencia de escape si ésta es utilizada en comentarios. En Java, si una secuencia de escape es utilizada en una línea simple de comentario, ésta es interpretada como un caracter Unicode. Para cadenas literales, el compilador de Java interpreta primero la secuencia de escape. Por ejemplo: si un caracter de escape de terminal de línea (e.g., \u000A) es utilizado en Java, este termina la cadena literal. En Java, esto acarrea un error, debido a que los terminadores de línea no son permitidos en cadenas literales. Usted debe usar \n para un avance de línea en una cadena literal. En JavaScript, la secuencia de escape trabaja de la misma manera que \n.

[editar] Caracteres Unicode en archivos JavaScript

Las primeras versiones de Gecko asumían la codificación de caracteres Latin-1 para archivos JavaScript cargados desde XUL. A partir de Gecko 1.8, la codificación de caracteres es inferida desde la codificación de archivos XUL. Véase: Caracteres internacionales en XUL JavaScript para más información.

[editar] Desplegando caracteres con unicode

Puede utilizar Unicode para desplegar caracteres en lenguajes diferentes o símbolos técnicos. Para que los caracteres sean desplegados apropiadamente, un cliente como Mozilla Firefox o Netscape necesitan soportar Unicode. Más aún, un tipo de letra [font] Unicode apropiado debe estar disponible para el cliente y la plataforma del cliente debe soportar Unicode. A menudo, los fonts Unicode no despliegan todos los caracteres Unicode. Algunas plataformas, tales como Windows 95, proveen soporte parcial para Unicode.

Para recibir como entrada caracteres no-ASCII, el cliente necesita enviar la entrada como Unicode. Utilizando un teclado estándar extendido, el cliente no puede fácilmente ingresar como entrada caracteres adicionales soportados por Unicode. Algunas veces, la única forma de utilizar como entrada caracteres Unicode es mediante el uso de secuencias de escape Unicode.

Para más información acerca de Unicode, véase la Página inicial de Unicode y el estandar Unicode, Versión 2.0, publicado por Addison-Wesley, 1996.