Horario del curso

Introducción a JavaScript

• Tutoriales avanzados de JavaScript
• Historia de JavaScript
• Implementación de JavaScript

Fundamentos ECMAScript

• Sintaxis ECMAScript
• Variables ECMAScript
• Palabras clave ECMAScript
• Palabras reservadas ECMAScript
• Valores ECMAScript
• Tipos primitivos ECMAScript
• Conversión de tipos ECMAScript
• Tipos de referencia ECMAScript

Operadores ECMAScript

• Operador unario
• Operador de bits
• Operador lógico
• Operador multiplicativo
• Operador aditivo
• Operador de relación
• Operador de igualdad
• Operador de condición
• Operador de asignación
• Operador de coma

Sentencias ECMAScript

• Sentencia if
• Sentencia iterativa
• Sentencia etiquetada
• Sentencia break
• Sentencia continue
• Sentencia with
• Sentencia switch

Funciones ECMAScript

• Resumen de funciones
• Objeto arguments
• Objeto Function
• Cierre (closure)

Objeto ECMAScript

• Programación orientada a objetos
• Aplicación de objetos
• Tipo de objetos
• Escopo de objetos
• Definición de clases o objetos
• Modificación de objetos

Herencia ECMAScript

• Ejemplo de mecanismo de herencia
• Implementación del mecanismo de herencia

Ejemplo JS

• Ejemplo JS
• DOM HTML JS
• Entrada HTML JS
• Objeto HTML JS
• Eventos HTML JS
• Navegador JS
• Examen JS

Manual de referencia JS

• Objeto JavaScript
• Objeto HTML DOM

Cursos optativos

Recomendaciones de cursos:

• CodeW3C.com Caja de Herramientas

ECMAScript tiene 5 tipos primitivos (primitive type), es decir, Undefined, Null, Boolean, Number y String.

Operador typeof

El operador typeof tiene un parámetro, es decir, la variable o valor que se debe verificar. Por ejemplo:

var sTemp = "test string";
alert (typeof sTemp);    // Sale "string"
alert (typeof 86);    // Sale "number"

Llamar al operador typeof sobre una variable o valor devolverá uno de los siguientes valores:

• undefined - Si la variable es de tipo Undefined
• boolean - Si la variable es de tipo Boolean
• number - Si la variable es de tipo Number
• string - Si la variable es de tipo String
• object - Si la variable es de un tipo de referencia o de tipo Null

Nota:Quizás te preguntes por qué el operador typeof devuelve "Object" para valores null. Esto es en realidad un error en la implementación inicial de JavaScript, que fue adoptado por ECMAScript. Ahora, null se considera un marcador de posición para objetos, lo que explica esta contradicción, aunque técnicamente sigue siendo un valor primitivo.

Tipo Undefined

Como se mencionó anteriormente, el tipo Undefined tiene solo un valor, es decir, undefined. Cuando una variable declarada no se inicializa, el valor predeterminado de esa variable es undefined.

var oTemp;

La línea de código anterior declara la variable oTemp sin valor inicial. Esta variable se asignará el valor undefined, es decir, el literal del tipo undefined. Se puede probar si el valor de esta variable es igual a undefined con el siguiente código segmento:}}

var oTemp;
alert(oTemp == undefined);

Este código muestra "true", lo que indica que estos dos valores son realmente iguales. También se puede usar el operador typeof para mostrar que el valor de la variable es undefined:

var oTemp;
alert(typeof oTemp); // Sale "undefined"

Consejo:El valor undefined es diferente del valor no definido. Sin embargo, el operador typeof no distingue verdaderamente entre estos dos valores. Considera el siguiente código:

var oTemp;
alert(typeof oTemp);  // Sale "undefined"
alert(typeof oTemp2);  // Sale "undefined"

El código anterior sale "undefined" para los dos variables, incluso si solo la variable oTemp2 no ha sido declarada. Si se utiliza otro operador además de typeof con oTemp2, se producirá un error, ya que otros operadores solo se pueden usar con variables declaradas.

Por ejemplo, el siguiente código generará un error:

var oTemp;
alert(oTemp2 == undefined);

Cuando una función no tiene un valor de retorno explícito, también retorna el valor "undefined", como se muestra a continuación:

function testFunc() {
{}
alert(testFunc() == undefined);  // Sale "true"

El tipo Null

Otro tipo que tiene solo un valor es Null, que tiene un valor especial null, es decir, su literal.

alert(null == undefined);  // Sale "true"

A pesar de que estos dos valores son iguales, su significado es diferente. undefined es el valor asignado a una variable declarada pero no inicializada, mientras que null se utiliza para representar un objeto que aún no existe (se ha presentado brevemente en el contexto del operador typeof). Si una función o método debe retornar un objeto y no se encuentra ese objeto, generalmente se retorna null.

El tipo Boolean

El tipo Boolean es uno de los tipos más utilizados en ECMAScript. Tiene dos valores: true y false (es decir, dos literales Boolean).

即使 false 不等于 0，0 也可以在必要时被转换成 false，这样在 Boolean 语句中使用两者都是安全的。

var bFound = true;
var bLost = false;

Number 类型

ECMA-262 中定义的最特殊的类型是 Number 类型。这种类型既可以表示 32 位的整数，还可以表示 64 位的浮点数。

直接输入的（而不是从另一个变量访问的）任何数字都被看做 Number 类型的字面量。例如，下面的代码声明了存放整数值的变量，它的值由字面量 86 定义：

var iNum = 86;

八进制数和十六进制数

整数也可以被表示为八进制（以 8 为底）或十六进制（以 16 为底）的字面量。八进制字面量的首数字必须是 0，其后的数字可以是任何八进制数字（0-7），如下面的代码所示：

var iNum = 070;  //070 等于十进制的 56

要创建十六进制的字面量，首位数字必须为 0，后面接字母 x，然后是任意的十六进制数字（0 到 9 和 A 到 F）。这些字母可以是大写的，也可以是小写的。例如：

var iNum = 0x1f;  //0x1f 等于十进制的 31
var iNum = 0xAB;  //0xAB 等于十进制的 171

Consejo:尽管所有整数都可以表示为八进制或十六进制的字面量，但所有数学运算返回的都是十进制结果。

浮点数

要定义浮点值，必须包括小数点和小数点后的一位数字（例如，用 1.0 而不是 1）。这被看作浮点数字面量。例如：

var fNum = 5.0;

对于浮点字面量的有趣之处在于，用它进行计算前，真正存储的是字符串。

科学计数法

对于非常大或非常小的数，可以用科学计数法表示浮点数，可以把一个数表示为数字（包括十进制数字）加 e（或 E），后面加乘以 10 的倍数。例如：

var fNum = 5.618e7

该符号表示的是数 56180000。把科学计数法转化成计算式就可以得到该值：5.618 x 10⁷。

也可以用科学计数法表示非常小的数，例如 0.00000000000000008 可以表示为 8-e¹⁷(Aquí, 10 se eleva al -17 poder, lo que significa que debe dividirse por 10 17 veces). ECMAScript convierte por defecto los números de coma flotante con 6 o más ceros precedentes en notación científica.

Consejo:También se pueden almacenar valores de punto flotante en forma de 64 bits IEEE 754, lo que significa que el valor decimal puede tener hasta 17 dígitos decimales. Los dígitos decimales posteriores se truncan, lo que puede causar algunos errores matemáticos pequeños.

Valores especiales de Number

Varios valores especiales también se definen como tipo Number. Los dos primeros son Number.MAX_VALUE y Number.MIN_VALUE, que definen los límites externos del conjunto de valores Number. Todos los números ECMAScript deben estar entre estos dos valores. Sin embargo, los resultados de cálculo generados no necesariamente deben estar entre estos dos valores.

Cuando el número calculado es mayor que Number.MAX_VALUE, se le asigna el valor Number.POSITIVE_INFINITY, lo que significa que ya no hay valores numéricos. Del mismo modo, si el valor calculado es menor que Number.MIN_VALUE, también se le asigna el valor Number.NEGATIVE_INFINITY, lo que significa que ya no hay valores numéricos. Si el cálculo devuelve un valor infinito, el resultado generado ya no se puede usar en otros cálculos.

De hecho, hay valores especiales que representan el infinito, como puedes adivinar, es decir, Infinity. El valor de Number.POSITIVE_INFINITY es Infinity. El valor de Number.NEGATIVE_INFINITY es -Infinity.

Dado que el número infinito puede ser positivo o negativo, se puede usar un método para determinar si un número es finito (en lugar de probar cada número infinito por separado). Se puede llamar al método isFinite() para cualquier número para asegurarse de que no es infinito. Por ejemplo:

var iResult = iNum * some_really_large_number;
if (isFinite(iResult)) {
    alert("finite");
{}
else {
    alert("infinite");
{}

El último valor especial es NaN, que representa 'No un número' (Not a Number). NaN es un valor especial curioso. Generalmente, este tipo de situación ocurre cuando falla la conversión de tipo (Cadena, Booleano, etc.). Por ejemplo, al intentar convertir la palabra 'blue' a un número fallará, ya que no hay un número equivalente. Al igual que el infinito, NaN no se puede usar en cálculos aritméticos. Otra peculiaridad de NaN es que no es igual a sí mismo, lo que significa que el siguiente código devolverá false:

alert(NaN == NaN);  //Salida "false"

Por esta razón, no se recomienda usar el valor NaN en sí mismo. La función isNaN() hace un buen trabajo:

alert(isNaN("blue"));  //Salida "true"
alert(isNaN("666"));  //Salida "false"

Tipo de cadena

Lo que es único del tipo de cadena es que es el único tipo primitivo sin tamaño fijo. Se puede almacenar 0 o más caracteres Unicode en una cadena, representados por enteros de 16 bits (Unicode es un conjunto de caracteres internacionales, que se discutirá en el tutorial posterior).

Cada carácter en una cadena tiene una posición específica, el primer carácter comienza en la posición 0, el segundo carácter en la posición 1, y así sucesivamente. Esto significa que la posición del último carácter en la cadena es siempre la longitud de la cadena menos 1:

Los literales de cadena se declaran mediante comillas dobles (" ) o comillas simples ( ' ). Java declara las cadenas con comillas dobles y los caracteres con comillas simples. Sin embargo, dado que ECMAScript no tiene un tipo de caracteres, se puede usar cualquier una de estas dos notaciones. Por ejemplo, las dos líneas de código siguientes son válidas:

var sColor1 = "red";
var sColor2 = 'red';

El tipo de cadena también incluye varios literales de caracteres, los desarrolladores de Java, C y Perl deben estar muy familiarizados con ellos.

A continuación se enumeran los literales de caracteres de ECMAScript:

Caixa de ferramentas

Manual de referencia de JavaScript y HTML DOM

Ejemplo de JavaScript

Pruebas de JavaScript

Tutoriales de JavaScript

Enlaces de patrocinadores