JavaScript.

La guía definitiva
PDF
David Flanagan
 JavaScript. La guía definitiva
Domina JavaScript con la Guía de Referencia
Definitiva.
Escrito por Bookey
Consulta más sobre el resumen de JavaScript. La guía
definitiva
Escuchar JavaScript. La guía definitiva Audiolibro
Sobre el libro
"JavaScript. La guía definitiva", ahora en su séptima edición,
es la referencia definitiva para desarrolladores web y
programadores que desean aprovechar al máximo el potencial
de JavaScript. Con actualizaciones importantes que incluyen
nuevo material sobre ECMAScript 2017 (ES8) y capítulos
adicionales que exploran características clave del lenguaje,
esta guía más vendida es perfecta para desarrolladores
experimentados que buscan profundizar su comprensión del
lenguaje de programación de la web, así como para aquellos
que desean mejorar sus habilidades existentes en JavaScript.
Sobre el autor
David Flanagan es un autor muy respetado y experto en el
campo de la programación informática, conocido
principalmente por sus obras influyentes sobre JavaScript y el
ecosistema más amplio del desarrollo web. Con una formación
en ingeniería de software y una pasión por la enseñanza,
Flanagan ha escrito numerosos libros que son recursos
esenciales tanto para programadores principiantes como
avanzados. Su estilo de escritura claro y sus explicaciones
detalladas han hecho que temas complejos sean más
accesibles, ganándose el reconocimiento como una voz de
confianza en la comunidad tecnológica. Como defensor del
software y estándares de código abierto, Flanagan sigue
contribuyendo al avance de las prácticas de programación,
consolidando su reputación como una figura clave en el
desarrollo de las tecnologías web modernas.
Lista de contenido del resumen
Capítulo 1 : Sección 1.1. Sintaxis

Capítulo 2 : Sección 1.3. Tipos de Datos

Capítulo 3 : Sección 1.4. Expresiones y Operadores

Capítulo 4 : Sección 1.5. Sentencias

Capítulo 5 : Sección 1.6. JavaScript orientado a objetos

Capítulo 6 : Sección 1.7. Expresiones Regulares

Capítulo 7 : Sección 1.8. Versiones de JavaScript

Capítulo 8 : Sección 2.1. JavaScript en HTML

Capítulo 9 : Sección 2.2. El objeto Window

Capítulo 10 : Sección 2.3. El Objeto Documento

Capítulo 11 : Sección 2.4. El DOM Legado

Capítulo 12 : Sección 2.5. El W3C DOM

Capítulo 13 : Sección 2.6. DOM de IE 4

Capítulo 14 : Sección 2.7. DHTML: Programación de estilos

CSS
Capítulo 15 : Sección 2.8. Eventos y Manejo de Eventos

Capítulo 16 : Sección 2.9. Restricciones de Seguridad en

JavaScript

Capítulo 17 : Array

Capítulo 18 : Fecha

Capítulo 19 : Documento

Capítulo 20 : Elemento

Capítulo 21 : Evento

Capítulo 22 : Global

Capítulo 23 : Input

Capítulo 24 : Capa

Capítulo 25 : Enlace

Capítulo 26 : Math

Capítulo 27 : Navegador

Capítulo 28 : Nodo

Capítulo 29 : Número
Capítulo 30 : Objeto

Capítulo 31 : RegExp

Capítulo 32 : Select

Capítulo 33 : Cadena

Capítulo 34 : Estilo

Capítulo 35 : Window
 Capítulo 1 Resumen : Sección 1.1.
Sintaxis

Sección Descripción

1. Sintaxis La sintaxis de JavaScript es similar a la de Java, lo que ayuda a los programadores familiarizados
con C, C++ o Java a aprenderlo fácilmente.

1.1 Sensibilidad a JavaScript es sensible a las mayúsculas, lo que requiere una capitalización consistente para
mayúsculas y minúsculas palabras clave, variables y nombres de funciones.

1.2 Espacios en blanco Los caracteres de espacio en blanco son ignorados, lo que permite un formato e indentación
flexibles para una mejor legibilidad.

1.3 Puntos y coma Las declaraciones suelen terminar con puntos y coma, pero se pueden omitir si son seguidas por
una nueva línea, con reglas específicas sobre los saltos de línea.

1.4 Comentarios Soporta comentarios al estilo C/C++: comentarios de una sola línea con `//`, y comentarios de
varias líneas con `/* ... */`.

1.5 Identificadores Los identificadores pueden incluir letras, dígitos, guiones bajos (_) y signos de dólar ($), pero no
pueden comenzar con un dígito.

1.6 Palabras clave Las palabras clave reservadas incluyen aquellas con significados especiales, como break, if,
return, etc. También se enumeran palabras clave de uso futuro.

1. Sintaxis

La sintaxis de JavaScript se asemeja de cerca a la de Java,

que a su vez se deriva de C y C++. Esta familiaridad facilita
que los programadores con experiencia en C, C++ o Java
aprendan JavaScript.

1.1 Sensibilidad a Mayúsculas y Minúsculas

JavaScript es sensible a mayúsculas y minúsculas. Todas las

palabras clave están en minúsculas, y es esencial mantener
una capitalización consistente para las variables, nombres de
funciones e identificadores.

1.2 Espacios en Blanco

Los caracteres de espacio en blanco, como espacios,

tabulaciones y saltos de línea, son ignorados por JavaScript,
lo que permite un formato e indentación flexibles en el
código para mejorar la legibilidad.

1.3 Punto y Coma

Las declaraciones en JavaScript se terminan típicamente con

punto y coma. Sin embargo, cuando están seguidas de un
salto de línea, los puntos y coma pueden omitirse, con
restricciones sobre dónde se pueden dividir las declaraciones
en varias líneas.

1.4 Comentarios

JavaScript permite comentarios al estilo de C y C++:

- Los comentarios de una sola línea comienzan con `//`.
- Los comentarios de varias líneas están encerrados entre `/*`
y `*/`.

1.5 Identificadores

Los identificadores en JavaScript pueden incluir letras,

dígitos, guiones bajos (_) y signos de dólar ($). El primer
carácter no puede ser un dígito. Ejemplos de identificadores
válidos incluyen:
-i
- mi_nombre_variable
- v13
- $str

1.6 Palabras Clave

JavaScript tiene un conjunto de palabras clave reservadas que

tienen un significado especial y no pueden usarse como
identificadores:
- Palabras clave comunes: break, do, if, switch, typeof, case,
else, in, this, var, catch, false, instanceof, throw, void,
continue, finally, new, true, while, default, for, null, try, with,
delete, function, return.
- Palabras reservadas adicionales para uso futuro incluyen:
abstract, enum, int, short, boolean, export, interface, static,
byte, extends, long, super, char, final, native, synchronized,
class, float, package, throws, const, goto, private, transient,
debugger, implements, protected, volatile, double, import,
public.
Los desarrolladores también deben evitar nombrar variables
con los nombres de propiedades y funciones globales, y no
deben usar `arguments` como nombre de variable local.
Ejemplo
Punto clave:Sensibilidad a mayúsculas y minúsculas
en JavaScript
Ejemplo:En JavaScript, nombres de variables como
'myVariable' y 'myvariable' son completamente
diferentes; recuerda esto para evitar errores.
Pensamiento crítico
Punto clave:La familiaridad de la sintaxis de
JavaScript con C, C++ y Java es una simplificación
excesiva.
Interpretación crítica:Si bien es cierto que la sintaxis de
JavaScript comparte similitudes con esos lenguajes,
insinuar que esto hace que JavaScript sea más fácil para
todos los programadores pasa por alto las considerables
diferencias en los paradigmas, como la herencia
prototípica en JavaScript frente a los modelos basados
en clases en Java. Esta consideración es crucial porque
puede engañar a los recién llegados a subestimar la
singularidad y complejidad de JavaScript,
particularmente en la programación asíncrona y las
arquitecturas basadas en eventos. Autores como
Douglas Crockford en 'JavaScript: Los buenos partes' y
Kyle Simpson en 'You Don’t Know JS' profundizan en
estas complejas distinciones, proporcionando un
contexto más amplio que podría contrarrestar la
perspectiva de Flanagan.
 Capítulo 2 Resumen : Sección 1.3. Tipos
de Datos

Sección Contenido

1.3 Tipos de JavaScript soporta tres tipos de datos primitivos (números, booleanos, cadenas) y dos tipos compuestos
Datos (objetos, arreglos), incluyendo tipos especializados como funciones y fechas.

1.3.1 Números Formato de punto flotante de 64 bits. Los literales numéricos incluyen decimal, hexadecimal y valores
especiales (infinito, NaN). Funciones: isNaN(), constantes numéricas, métodos de Math.

1.3.2 Dos valores: verdadero y falso, que representan la verdad y la falsedad.

Booleanos

1.3.3 Cadenas Secuencias de caracteres, representadas entre comillas. Secuencias de escape especiales modifican caracteres.
Las cadenas tienen métodos y una propiedad de longitud, son inmutables.

1.3.4 Objetos Tipos de datos compuestos con propiedades nombradas accedidas a través del operador . o notación de
corchetes. Se crean utilizando el operador new o literales de objeto.

1.3.5 Arreglos Objetos numerados accedidos a través de índices, pueden contener tipos mixtos. Se crean utilizando el
constructor Array o la sintaxis de literal de arreglo.

1.3.6 Bloques de código reutilizables. Los métodos son funciones en objetos (palabra clave this). Los argumentos
Funciones y se acceden a través del arreglo de argumentos.
Métodos

1.3.7 Nulo y Null indica ausencia de valor; undefined representa variables no inicializadas/propiedades faltantes. Similar
No Definido con == pero diferente con ===.

1.3 Tipos de Datos en JavaScript. La guía definitiva

JavaScript admite tres tipos de datos primitivos: números,
booleanos y cadenas; y dos tipos de datos compuestos:
objetos y arreglos. También define tipos de objeto
especializados, como funciones, expresiones regulares y
fechas.

1.3.1 Números

- Los números se representan en formato de punto flotante de

64 bits sin diferenciación entre números enteros y de punto
flotante.
- Los literales numéricos pueden estar en decimal,
hexadecimal (por ejemplo, 0xFF para 255), y pueden
representar valores especiales: infinito positivo/negativo y
NaN (not-a-number).
- La función `isNaN()` prueba si el valor es NaN.
- El objeto `Number` proporciona constantes, mientras que el
objeto `Math` ofrece varias funciones matemáticas.

1.3.2 Booleanos

- El tipo booleano tiene dos valores: `true` y `false`, que

denotan verdad y falsedad.
1.3.3 Cadenas

- Las cadenas son secuencias de caracteres, representadas

entre comillas (simples o dobles).
- Secuencias de escape especiales modifican caracteres
dentro de las cadenas (por ejemplo, `\n` para nueva línea, `\'`
para apóstrofo).
- Las cadenas tienen métodos para operaciones, la propiedad
`length`, y son inmutables, lo que significa que las
modificaciones devuelven nuevas cadenas en lugar de alterar
la original.

1.3.4 Objetos

- Los objetos son tipos de datos compuestos con propiedades

nombradas.
- Accede a las propiedades con el operador `.` (por ejemplo,
`o.x = 1`) o notación de corchetes (por ejemplo, `o["x"] = 1`).
- Los objetos se pueden crear utilizando el operador `new` o
literales de objeto (por ejemplo, `var o = {x:1, y:2}`).

1.3.5 Arreglos
- Los arreglos son objetos numerados que se acceden
mediante índices (por ejemplo, `a[0]` para el primer
elemento).
- Los arreglos pueden contener tipos mixtos y tienen una
propiedad de longitud.
- Usa el constructor `Array` o la sintaxis de literal de arreglo
(por ejemplo, `var a = [1,2,3]`) para crear arreglos.

1.3.6 Funciones y Métodos

- Las funciones son bloques reutilizables de código definidos

una vez y llamados varias veces (por ejemplo, `function
sum(x, y) { return x + y; }`).
- Los métodos son funciones asignadas a propiedades de
objeto, con `this` refiriéndose al objeto contenedor.
- Usa el arreglo `arguments` para acceder a todos los
argumentos pasados a una función.

1.3.7 Null y Undefined

- `null` indica "sin valor" y significa una ausencia de datos

válidos.
- `undefined` representa variables no inicializadas o
propiedades de objeto faltantes.
- `null` y `undefined` se tratan de manera similar con el
operador `==` pero difieren al usar `===`.
Ejemplo
Punto clave:Entender los tipos de datos primitivos y
compuestos es crucial para una codificación efectiva
en JavaScript.
Ejemplo:Imagina que estás programando una simple
aplicación web. Necesitas almacenar la edad de un
usuario — un número, quizás, como 28. Ahora, también
quieres verificar si es un adulto. Aquí, un booleano
(verdadero o falso) te ayudará. ¿Y si necesitas
representar el nombre del usuario? Utilizarás cadenas de
texto. Al agregar varios usuarios, agruparás sus datos en
un array, lo que te permitirá gestionar una colección
fácilmente. Reconocer cómo funcionan e interactúan
estos tipos de datos es vital para construir aplicaciones
dinámicas y responsivas en JavaScript.
Pensamiento crítico
Punto clave:Tipos de datos primitivos vs. compuestos
Interpretación crítica:Un punto clave en este capítulo es
la distinción entre los tipos de datos primitivos y
compuestos en JavaScript. El autor los presenta como
conocimientos fundamentales para entender el lenguaje.
Si bien Flanagan enfatiza la simplicidad de los tipos de
datos primitivos de JavaScript—números, booleanos y
cadenas—en comparación con las estructuras más
complejas de objetos y matrices, es esencial criticar esta
simplificación. Por ejemplo, el manejo de números a
través de un sistema de punto flotante puede llevar a
errores de precisión inesperados, como lo destaca el
estándar de punto flotante IEEE ([IEEE
754]([Link] Esto
plantea la cuestión de si los principiantes podrían
sobreestimar la claridad y fiabilidad de estos tipos sin
una comprensión más profunda de sus implicaciones.
Los críticos podrían argumentar que la presentación del
autor no prepara adecuadamente a los estudiantes para
los desafíos que pueden enfrentar cuando estos tipos de
datos interactúan en escenarios prácticos.
 Capítulo 3 Resumen : Sección 1.4.
Expresiones y Operadores
Categoría Descripción P A Operador Operación

Expresiones y Las expresiones de JavaScript combinan valores

operadores utilizando operadores, con paréntesis para agrupar.

Precedencia Determina el orden de las operaciones.

de operadores

Asociatividad Describe cómo se agrupan los operadores de la

de operadores misma precedencia (de izquierda a derecha o de
derecha a izquierda).

Visión 15 L . Acceder a una

general de propiedad de
operadores objeto

P
A
Operador
Operación

[Link] a una propiedad de objeto

15L[ ]Acceder a un elemento de arreglo
15L( )Llamar a una función
14RnewCrear un nuevo objeto
14R++Incrementar (unario)
14R--Decrementar (unario)
14R-Menos unario
14R+Más unario
14R~Complemento a nivel de bits
14R!Complemento lógico
14RdeleteEliminar una propiedad
14RtypeofDevolver tipo de dato
14RvoidDevolver indefinido
13L*, /, %Multiplicación, división, resto
12L+, -Sumar, restar; Concatenar cadenas
11L<<, >>, >>>Desplazamientos a nivel de
bits
10L<, <=, >, >=Operadores relacionales
9L==, !=, ===, !==Comprobaciones de
igualdad e identidad
8L&Y lógico a nivel de bits
7L^XOR a nivel de bits
6L|O lógico a nivel de bits
5L&&Y lógico
4L||O lógico
3R?:Operador condicional
2R=Asignación
2R*=, +=, -=, [Link]ón con operación
1L,Evaluación múltiple
Categoría Descripción P A Operador Operación

15 L . Acceder a una
propiedad de
objeto

15 L [] Acceder a un
elemento de
arreglo

15 L () Llamar a una
función

14 R new Crear un nuevo

objeto

14 R ++ Incrementar
(unario)

14 R -- Decrementar
(unario)

14 R - Menos unario

14 R + Más unario

14 R ~ Complemento a
nivel de bits

14 R ! Complemento
lógico

14 R delete Eliminar una

propiedad

14 R typeof Devolver tipo de

dato

14 R void Devolver
indefinido

13 L *, /, % Multiplicación,
división, resto

12 L +, - Sumar, restar;
Concatenar
cadenas

11 L <<, Desplazamientos
>>, a nivel de bits
>>>

10 L <, <=, Operadores

>, >= relacionales

9 L ==, Comprobaciones
!=, de igualdad e
===, identidad
!==
Categoría Descripción P A Operador Operación

8 L & Y lógico a nivel

de bits

7 L ^ XOR a nivel de
bits

6 L | O lógico a nivel
de bits

5 L && Y lógico

4 L || O lógico

3 R ?: Operador
condicional

2 R = Asignación

2 R *=, Asignación con

+=, operación
-=,
etc.

1 L , Evaluación
múltiple

Expresiones y Operadores en JavaScript. La guía

definitiva

Las expresiones en JavaScript combinan diversos valores

utilizando operadores, con paréntesis que se usan para
agrupar y alterar el orden de evaluación.

Prioridad de los Operadores y Asociatividad

JavaScript presenta una amplia gama de operadores similares

a los de C, C++ y Java. Los operadores se clasifican por
prioridad y asociatividad:
-
Prioridad (P)
: Determina el orden de las operaciones.
-
Asociatividad (A)
: Describe cómo se agrupan los operadores de la misma
prioridad (ya sea de izquierda a derecha o de derecha a
izquierda).

Resumen de los Operadores

| P | A | Operador | Operación realizada |

|-----|---|-----------|---------------------------------------------|
| 15 | L | . | Acceder a una propiedad de un objeto |
| 15 | L | [ ] | Acceder a un elemento de un arreglo |
| 15 | L | ( ) | Invocar una función |
| 14 | R | new | Crear un nuevo objeto |
| 14 | R | ++ | Incremento pre- o post- (unario) |
| 14 | R | -- | Decremento pre- o post- (unario) |
| 14 | R | - | Negativo unario (negación) |
| Instalar
14 | R | + la aplicación Bookey
| Positivo unario para desbloquear
(no-op) |
| 14 | R | ~ |texto completo
Complemento y audio
a nivel de bits (unario) |
| 14 | R | ! | Complemento lógico (unario) |
 Capítulo 4 Resumen : Sección 1.5.
Sentencias
Sección Descripción Sintaxis

Programa de Consiste en una secuencia de sentencias que se asemejan a No aplica

JavaScript C, C++ y Java

Sentencias de Cada expresión puede estar sola como una sentencia Ejemplos: s = "hello world";, x =
Expresión [Link](4);, x++;

Sentencias Un agrupamiento de sentencias dentro de llaves No aplica

Compuestas

Sentencias Vacías Una sentencia que no hace nada ;

Sentencias Sentencias etiquetadas para su uso con break y continue label: statement;
Etiquetadas

break Saliendo del bucle más cercano break; o break label;

case Etiqueta una condición dentro de las sentencias switch No aplica

continue Salta a la siguiente iteración de un bucle continue; o continue label;

default Actúa como un respaldo en sentencias switch No aplica

do/while Ejecuta un bloque mientras una condición sea verdadera do statement while (expression);

for Un bucle que combina inicialización, condición y for (initialize; test; update) statement;
actualización

for/in Recorre las propiedades de un objeto for (variable in object) statement;

function Declara una función function funcname(args) { statements }

if/else Ejecución condicional de sentencias if (expression) statement;else statement2;

return Saliendo de una función y opcionalmente retornando un return; o return expression;

valor

switch Ramas múltiples basadas en una expresión

switch(expression) {
case constant-expression: statements
...
default: statements
}

throw Señala un error, transfiriendo el control al manejador de throw expression;

excepciones

try/catch/finally Mecanismo para el manejo de excepciones

try { statements }
catch (argument) { statements }
Sección Descripción Sintaxis

finally { statements }

var Declara e inicializa variables var name [= value] [, name2 [= value2]

...];

while Un bucle que continúa mientras una condición sea while (expression) statement;
verdadera

with Agrega un objeto a la cadena de alcance; su uso no es with (object) statement;

recomendado

Descripción General de las Sentencias JavaScript

Un programa en JavaScript consiste en una secuencia de

sentencias, cuya sintaxis se asemeja en gran medida a la de
C, C++ y Java.

Sentencias de Expresión

- Cada expresión en JavaScript puede ser una sentencia

independiente.
- Ejemplos incluyen asignaciones (por ejemplo, `s = "hola
mundo"`), llamadas a métodos (por ejemplo, `x =
[Link](4)`), y operaciones de incremento/decremento (por
ejemplo, `x++`).

Sentencias Compuestas
- Un agrupamiento de sentencias dentro de llaves forma una
sentencia compuesta.
- Útil para múltiples sentencias en construcciones como
bucles o condicionales.

Sentencias Vacías

- Una sentencia vacía se representa únicamente por un punto

y coma (`;`) y no realiza ninguna acción.
- Es útil para bucles que requieren un cuerpo vacío.

Sentencias Etiquetadas

- Se pueden asignar etiquetas a las sentencias para su uso con

break y continue.
- Sintaxis: `label: statement`.

Sentencias Comunes de JavaScript

-
break
: Sale del bucle más cercano.
- Sintaxis: `break;` o `break label;`
-
case
: Se utiliza dentro de sentencias switch; etiqueta una
condición.

-
continue
: Salta a la siguiente iteración de un bucle.
- Sintaxis: `continue;` o `continue label;`

-
default
: Actúa como una opción de reserva en las sentencias switch.
-
do/while
: Ejecuta un bloque mientras una condición sea verdadera.
- Sintaxis: `do statement while (expression);`

-
for
: Un bucle que combina inicialización, condición y
actualización en una línea.
- Sintaxis: `for (initialize; test; update) statement;`
-
for/in
: Recorre las propiedades de un objeto.
- Sintaxis: `for (variable in object) statement;`
-
function
: Declara una función.
- Sintaxis: `function funcname(args) { statements }`
-
if/else
: Ejecución condicional de sentencias.
- Sintaxis: `if (expression) statement;` y `else statement2;`
-
return
: Sale de una función y opcionalmente devuelve un valor.
- Sintaxis: `return;` o `return expression;`
-
switch
: Ramificación múltiples basada en una expresión.
- Sintaxis:
```
switch(expression) {
case constant-expression: statements
...
 default: statements
}
```
-
throw
: Señala un error, transfiriendo el control al manejador de
excepciones más cercano.
- Sintaxis: `throw expression;`
-
try/catch/finally
: Mecanismo de manejo de excepciones.
- Sintaxis:
```
try { statements }
catch (argument) { statements }
finally { statements }
```
-
var
: Declara e inicializa variables.
- Sintaxis: `var name [= value] [, name2 [= value2] ...];`
-
while
: Un bucle que continúa mientras una condición sea
verdadera.
- Sintaxis: `while (expression) statement;`
-
with
: Agrega un objeto a la cadena de ámbito; su uso es
desaconsejado debido a su complejidad.
- Sintaxis: `with (object) statement;`
Ejemplo
Punto clave:Entender las declaraciones de
JavaScript es crucial para secuenciar tu lógica de
manera efectiva.
Ejemplo:Cuando escribes un programa en JavaScript,
piensa en tus declaraciones como ingredientes en una
receta; cada uno tiene un papel específico que
desempeñar. Por ejemplo, cuando te das cuenta de que
`let result = [Link](2, 3);` no es solo una expresión,
sino una declaración independiente que aporta claridad a
tu código, ves cómo cada pieza de sintaxis encaja para
crear una lógica funcional. ¡Si te olvidas de colocar un
punto y coma, tu postre podría arruinarse! Cada
declaración puede afectar el control del flujo, como usar
un bucle `for` para iterar sobre datos que te permite
manipular colecciones sin problemas, reforzando que
cada declaración es esencial para una correcta ejecución.
Pensamiento crítico
Punto clave:La similitud de la sintaxis con C, C++ y
Java
Interpretación crítica:Si bien Flanagan destaca la
semejanza de la sintaxis de JavaScript con C, C++ y
Java, es esencial abordar esta perspectiva de manera
crítica. El autor sugiere que tales similitudes ayudan a
suavizar la curva de aprendizaje para los programadores
familiarizados con estos lenguajes. Sin embargo, este
punto de vista podría simplificar en exceso las
diferencias fundamentales en los paradigmas y la
ejecución: JavaScript es principalmente basado en
eventos y asíncrono, lo que se desvía significativamente
de la naturaleza sincrónica de C/C++. Comprender estas
distinciones es crucial para dominar JavaScript, ya que
los lenguajes de programación no pueden entenderse
solo a través de la sintaxis. Aquellos interesados en
exploraciones más profundas sobre los paradigmas de
lenguaje deberían consultar fuentes como
"Programming JavaScript Applications" de Eric Elliott,
que enfatiza los aspectos únicos de JavaScript más allá
de la mera sintaxis.
 Capítulo 5 Resumen : Sección 1.6.
JavaScript orientado a objetos
Tema Resumen

JavaScript orientado a JavaScript admite programación orientada a objetos a través de objetos, herencia y clases.
objetos

Objetos en JavaScript Los objetos son arreglos asociativos que vinculan valores con propiedades nombradas y admiten
herencia.

Definiendo una clase Una clase se define utilizando una función constructora, inicializada con el operador `new` y la
palabra clave `this`.

Propiedad Prototype La propiedad `prototype` de un constructor permite métodos y propiedades compartidos entre
instancias de la clase.

Métodos de ejemplo Se pueden definir métodos en el prototipo para realizar operaciones como calcular distancias y
convertir a cadenas.

Métodos y propiedades Los métodos/properties estáticas se adjuntan directamente al constructor, como definir un punto
estáticas constante.

Creando y usando objetos Para crear un objeto, utiliza el constructor y llama a sus métodos para realizar operaciones.

JavaScript orientado a objetos

Objetos en JavaScript

Los objetos en JavaScript son arreglos asociativos que

vinculan valores con propiedades nombradas. Soportan un
mecanismo de herencia simple y permiten la creación de
nuevas clases de objetos.
Definiendo una clase

Para definir una nueva clase, se crea una función

constructora. El constructor se invoca con el operador `new`
y utiliza la palabra clave `this` para inicializar el objeto
recién creado. Por ejemplo, un constructor `Point` inicializa
las coordenadas x e y:
```javascript
function Point(x, y) {
this.x = x;
this.y = y;
}
```

Propiedad Prototype

Cada función constructora tiene una propiedad `prototype`

que apunta a un objeto prototipo especial para la clase
asociada. Las propiedades definidas en este prototipo son
heredadas por todos los objetos creados con el constructor.
Esto se utiliza típicamente para definir métodos para las
instancias de la clase.

Métodos de ejemplo
Definir métodos en el prototipo permite que las instancias
realicen operaciones, como calcular la distancia entre dos
puntos y convertirlos a cadenas:
```javascript
[Link] = function(that) {
var dx = this.x - that.x;
var dy = this.y - that.y;
return [Link](dx * dx + dy * dy);
}
[Link] = function() {
return '(' + this.x + ',' + this.y + ')';
}
```

Métodos y propiedades estáticas

Los métodos o propiedades estáticas se asignan directamente

a la función constructora. Por ejemplo, una constante
comúnmente utilizada se puede definir de la siguiente
manera:
```javascript
[Link] = new Point(0, 0);
```
Creando y usando objetos

Para utilizar la clase `Point`, se puede crear un nuevo objeto

y llamar a los métodos como se muestra:
```javascript
var p = new Point(3, 4);
var d = [Link]([Link]);
var msg = "La distancia a " + p + " es " + d;
```
Ejemplo
Punto clave:Entender la propiedad prototype mejora
tu programación orientada a objetos en JavaScript.
Ejemplo:Al trabajar con JavaScript, imagina crear una
aplicación robusta donde defines una clase 'Persona'
para gestionar usuarios. Al establecer métodos como
'calcularEdad' en el prototype, permites que cada objeto
de persona pueda calcular su edad fácilmente sin
duplicar código, ilustrando el poder de los prototypes
para proporcionar funcionalidad compartida a todas las
instancias.
Pensamiento crítico
Punto clave:La explicación del autor sobre los
principios de la programación orientada a objetos en
JavaScript enfatiza la encapsulación y la herencia a
través de la encadenación de prototipos.
Interpretación crítica:Aunque Flanagan presenta estos
conceptos como fundamentales para el diseño de
JavaScript, es importante señalar que no todos los
desarrolladores coinciden en la superioridad o
simplicidad de este enfoque. Algunos argumentan que la
herencia basada en prototipos de JavaScript puede llevar
a complicaciones, especialmente para aquellos que están
haciendo la transición desde lenguajes basados en
clases. Esta perspectiva se explora en recursos como
'You Don’t Know JS' de Kyle Simpson, que destaca las
posibles trampas de depender únicamente de la herencia
por prototipos, sugiriendo que se necesita una
comprensión más matizada de la flexibilidad y
peculiaridades de JavaScript para una programación
efectiva.
 Capítulo 6 Resumen : Sección 1.7.
Expresiones Regulares
Sección Descripción

1.7 Expresiones Regulares JavaScript admite expresiones regulares para la coincidencia de patrones, similar a la sintaxis
de Perl.

1.7.1 Caracteres Literales La mayoría de los caracteres se representan a sí mismos, con significados especiales para
ciertos signos de puntuación y secuencias de escape.

Secuencias de Escape Representan caracteres literales (p. ej., `\n`, `\r`, `\t`) y signos de puntuación (p. ej., `\\`, `\/`).

Caracteres Hexadecimales y Se representan como `\xnn` y `\uxxxx`.

Unicode

1.7.2 Clases de Caracteres Se definen utilizando corchetes, permitiendo coincidencias en conjuntos de caracteres
específicos.

Escapes de Clases de `[...]`, `[^...]`, `.`, `\w`, `\W`, `\s`, `\S`, `\d`, `\D` para diversas coincidencias de caracteres.
Caracteres Comunes

1.7.3 Repetición Controla cuántas veces un patrón puede coincidir dentro de una cadena.

Operadores de Repetición `?`, `+`, `*`, `{n}`, `{n,}`, `{n,m}` y coincidencia no codiciosa con `?`.

1.7.4 Agrupación y Utiliza paréntesis para agrupar subexpresiones y separar alternativas.

Alternancia

Coindicencias de Grupo Se refieren a subexpresiones con `$n` para el texto coincidente.

1.7.5 Anclaje de la Posición Define posiciones para coincidencias en una cadena.

de Coincidencia

Sintaxis de Anclaje `^`, `$`, `\b`, `\B`, `(?=p)`, `(?!p)` para coincidir en diversas posiciones de cadena y
afirmaciones.

1.7 Expresiones Regulares

JavaScript utiliza expresiones regulares para la coincidencia

de patrones, empleando una sintaxis similar a Perl.
JavaScript 1.2 soporta expresiones Perl 4, mientras que
JavaScript 1.5 mejora esto con algunas características de Perl
5. Las expresiones regulares se pueden expresar literalmente
usando delimitadores de barra (/) o como objetos RegExp
creados con el constructor RegExp().

1.7.1 Caracteres Literales

La mayoría de los caracteres en una expresión regular

representan a sí mismos. Cierta puntuación y secuencias de
escape tienen significados especiales, incluyendo:
-
Secuencias de escape
: Representan caracteres literales (por ejemplo, `\n`, `\r`, `\t`)
y puntuación (por ejemplo, `\\`, `\/`).
-
Caracteres Hexadecimales y Unicode
: Representados como `\xnn` y `\uxxxx`, respectivamente.

1.7.2 Clases de Caracteres

Los corchetes definen clases de caracteres, con secuencias de

Instalar
escape la aplicación
específicas Bookey
para conjuntos para desbloquear
comunes:
- `[...]`: Coincidetexto completo
con cualquier y audio
carácter dentro de los
corchetes.
Capítulo 7 Resumen : Sección 1.8.
Versiones de JavaScript

1.8 Versiones de JavaScript

Netscape ha desarrollado múltiples versiones de JavaScript,

mientras que Microsoft introdujo versiones compatibles
llamadas JScript. El organismo de estándares ECMA ha
publicado tres ediciones del estándar ECMAScript. A
continuación se describen las diversas versiones y su
relación:
-
JavaScript 1.0:
La versión original con errores, implementada en Netscape 2
y ahora obsoleta.
-
JavaScript 1.1:
Introdujo verdaderos objetos Array y resolvió muchos
errores; implementada por Netscape 3.
-
JavaScript 1.2:
Añadió la instrucción switch, expresiones regulares y otras
características; casi compatible con ECMA v1.
-
JavaScript 1.3:
Corregió incompatibilidades y se ajustó a ECMA v1;
implementada en Netscape 4.5.
-
JavaScript 1.4:
Solo usada en productos del servidor de Netscape.
-
JavaScript 1.5:
Introdujo manejo de excepciones y se ajustó a ECMA v3;
implementada por Mozilla y Netscape 6.

Versiones de JScript:

-
JScript 1.0:
Equivalente a JavaScript 1.0 para versiones tempranas de IE
3.
-
JScript 2.0:
Equivalente a JavaScript 1.1 para versiones posteriores de IE
3.
-
JScript 3.0:
Comparable a JavaScript 1.3 y conforme a ECMA v1;
implementada por IE 4.
-
JScript 5.0:
Soportaba el manejo de excepciones; parcialmente conforme
a ECMA v3; utilizada en IE 5.
-
JScript 5.5:
Equivalente a JavaScript 1.5 y totalmente conforme a
ECMA v3; vista en IE 5.5 e IE 6.

Versiones de ECMA:

-
ECMA v1:
Estandarizó características de JavaScript 1.1, pero excluyó la
instrucción switch y el soporte para expresiones regulares;
las implementaciones conformantes son JavaScript 1.3 y
JScript 3.0.
-
ECMA v2:
Una versión de mantenimiento con aclaraciones y sin nuevas
características.
-
ECMA v3:
Estandarizó las instrucciones switch, las expresiones
regulares y el manejo de excepciones; cumplimiento
alcanzado por JavaScript 1.5 y JScript 5.5.

Capítulo 1: El lenguaje JavaScript

JavaScript es un lenguaje de scripting ligero optimizado para

ser embebido dentro de páginas HTML, cubriendo aspectos
fundamentales y del lado del cliente de JavaScript.

2.1 JavaScript en HTML

JavaScript puede incluirse en HTML a través de scripts,

manejadores de eventos y URLs:
-
<script> Etiqueta:
La mayor parte del código JavaScript se inserta entre
etiquetas <script>. Con JavaScript 1.1 y versiones
posteriores, se pueden incluir scripts externos usando el
atributo `src`.
-
Manejadores de Eventos:
 JS puede aparecer en atributos de manejadores de eventos de
etiquetas HTML, activándose mediante eventos específicos
(por ejemplo, `onclick`).
-
URLs de JavaScript:
Aplicados usando el pseudo-protocolo `javascript:` para
ejecutar código JS directamente.

2.2 El objeto Window

El objeto Window representa una ventana del navegador,

actuando como un ámbito global para propiedades y
métodos. Las características clave incluyen:
-
Diálogos Simples:
Métodos como `alert()`, `confirm()`, y `prompt()` para
interacciones con el usuario.
-
Gestión de la Línea de Estado:
Configuración de texto en el área de estado a través de la
propiedad `status`.
-
Temporizadores:
Usando `setTimeout()` y `setInterval()` para programar la
ejecución de funciones.
-
Información del Sistema:
Accediendo a las propiedades `navigator` y `screen` para
detalles del navegador y del sistema.
-
Navegación en el Navegador:
Utilizando las propiedades `location` y `history` para
manipular el flujo de navegación y desplazarse.
-
Control de Ventanas:
Métodos para mover, redimensionar y abrir/cerrar ventanas
del navegador.
-
Múltiples Ventanas y Marcos:
Tratando cada marco como un objeto Window separado y
accediendo a ellos en consecuencia.

2.3 El objeto Document

El objeto Document es integral, representando el documento

HTML cargado.

DOM Heredado:
Proporciona acceso al contenido y propiedades del
documento, pero es limitado en capacidad.

2.5 DOM W3C:

Mejora el DOM heredado, permitiendo el acceso a cualquier

elemento del documento mediante métodos como
`getElementById()` y métodos para manipular atributos de
nodos y estructura.

2.6 DOM IE 4:

Introducido por Internet Explorer 4, soporta funcionalidades

similares al W3C pero carece de cierta estandarización.

2.7 DHTML: Scripting de Estilos CSS

HTML dinámico combina HTML, CSS y JavaScript para

páginas web visualmente dinámicas. La propiedad `style`
permite la manipulación directa de atributos CSS.

2.8 Eventos y Manejo de Eventos

JavaScript puede manejar eventos utilizando atributos
estándar precedidos por "on". Los eventos pueden asociarse
con etiquetas HTML, siendo los problemas de
compatibilidad entre diferentes navegadores un factor que
afecta el manejo avanzado de eventos.

2.9 Restricciones de Seguridad en JavaScript

JavaScript impone varias restricciones por razones de

seguridad, incluyendo:
- Limitaciones en la política de origen cruzado.
- Prevención de la gestión de archivos en máquinas locales.
- Confirmación del usuario requerida para acciones sensibles.
Este capítulo proporciona una base sobre la evolución,
estructura y funcionalidad de JavaScript, destacando tanto su
poder como las limitaciones impuestas por razones de
seguridad.
Pensamiento crítico
Punto clave:La evolución de JavaScript a través de
diversas versiones ilustra las complejidades y
inconsistencias en los estándares de desarrollo web.
Interpretación crítica:Mientras que David Flanagan
describe la evolución de JavaScript y sus distintas
versiones, los lectores podrían cuestionar la fiabilidad
de esta rápida transformación, que podría sugerir
inestabilidad en una tecnología fundamental para la
web. El hecho de que múltiples iteraciones y estándares
de compatibilidad variables (como JScript frente a
ECMAScript) hayan surgido para abordar errores
anteriores indica no solo progreso, sino también una
confusión potencial para los desarrolladores que se
adaptan a los cambios. Esto plantea la cuestión de que
confiar únicamente en la interpretación de un solo autor,
tal como se presenta en el resumen de Flanagan, puede
pasar por alto perspectivas más amplias y críticas sobre
los problemas de estandarización en los lenguajes de
programación. Para obtener perspectivas más profundas,
referencias como 'JavaScript. Los buenos partes' de
Douglas Crockford y la serie 'You Don’t Know JS' de
Kyle Simpson ofrecen visiones contrastantes sobre la
evolución y los desafíos de JavaScript.
 Capítulo 8 Resumen : Sección 2.1.
JavaScript en HTML
Sección Contenido

JavaScript en HTML Integración a través de scripts, controladores de eventos y URLs de JavaScript.

La etiqueta <script>

Incrustada entre las etiquetas <script> y </script>.

Archivos externos referenciados usando el atributo src: <script src="[Link]">.
Los archivos normalmente tienen la extensión .js; </script> es obligatorio incluso con src.
El atributo language está en desuso; usa el atributo type configurado como text/javascript.

Controladores de
Eventos
Se ejecutan a través de atributos de etiquetas HTML que comienzan con 'on'.
Ejemplo: <input type="button" value="Press Me" onclick="alert('¡Hola Mundo!');"> activa la
alerta al hacer clic.

URLs de JavaScript

Se ejecutan usando el pseudo-protocolo javascript:.

Usa el operador void para ejecutar JavaScript sin cambiar el documento: <form
action="javascript:void validate()">.

JavaScript en HTML

JavaScript se puede integrar en archivos HTML a través de

scripts, controladores de eventos y URLs de JavaScript.

La etiqueta <script>
- JavaScript generalmente se incluye entre las etiquetas
`<script>` y `</script>`.
- Puedes referenciar archivos JavaScript externos utilizando
el atributo `src`: `<script src="[Link]"></script>`.
- Los archivos suelen tener una extensión `.js`, y la etiqueta
`</script>` sigue siendo necesaria incluso con el atributo
`src`.
- El atributo `language` especifica el lenguaje de scripting,
pero su uso está siendo descontinuado a favor del atributo
`type`, que debe configurarse como `text/javascript`.

Controladores de Eventos

- JavaScript también se puede ejecutar a través de atributos

de controladores de eventos en etiquetas HTML, que
comienzan con 'on'.
- Por ejemplo: `<input type="button" value="Presióname"
onclick="alert('¡Hola Mundo!');">` activa una alerta de
JavaScript al hacer clic en el botón.

URLs de JavaScript

- El código JavaScript también se puede ejecutar a través de

URLs que utilizan el pseudo-protocolo `javascript:`.
- Para ejecutar JavaScript sin alterar el documento actual,
utiliza el operador `void`: `<form action="javascript:void
validate()">`.
Pensamiento crítico
Punto clave:Integración de JavaScript en HTML
Interpretación crítica:Mientras David Flanagan enfatiza
la integración sencilla de JavaScript en HTML, se
podría argumentar que esta dependencia de incrustar el
script directamente en HTML puede conducir a posibles
problemas en cuanto a mantenibilidad y separación de
preocupaciones. Al acoplar los scripts estrechamente
con el marcado, los desarrolladores podrían crear
involuntariamente complejidades en la depuración y las
actualizaciones, lo cual va en contra de las prácticas
modernas promovidas por frameworks como React o
Angular, que fomentan una clara separación entre la
estructura (HTML) y el comportamiento (JavaScript).
Es importante considerar que las ideas de Flanagan son
valiosas, pero deben verse a través del prisma de las
mejores prácticas en evolución en el desarrollo web,
como lo apoyan fuentes como 'Clean Code' de Robert C.
Martin. Esto resalta la importancia de evaluar las
opiniones del autor en el contexto de las metodologías
emergentes.
 Capítulo 9 Resumen : Sección 2.2. El
objeto Window
Sección Detalles

El objeto Window El objeto Window representa una ventana de navegador web y sirve como el objeto global en
JavaScript del lado del cliente.

Propiedades y Define propiedades/métodos globales de nivel superior, accesibles sin prefijos. Propiedad notable:
Métodos Globales document.

Cuadros de Diálogo Métodos:

Simples
alert() para mensajes.
confirm() para preguntas de sí/no.
prompt() para entrada de texto del usuario.

La Línea de Estado Muestra la URL y otra información. Establece el texto de estado usando status y el predeterminado
usando defaultStatus.

Temporizadores Ejecuta código después de intervalos:

setTimeout() para ejecuciones únicas.

setInterval() para ejecuciones repetidas.

Identificadores de cancelación devueltos por clearTimeout() y clearInterval().

Información del Las propiedades navigator y screen proporcionan detalles del sistema, ayudando en el código específico
Sistema del navegador.

Navegación del Gestiona la URL con location (leyendo la URL actual, estableciendo para navegar). La propiedad
Navegador history permite la navegación por el historial.

Control de Ventanas Los métodos para la manipulación de ventanas incluyen open() para nuevas ventanas y close() para
cerrar ventanas creadas por scripts.

Múltiples Ventanas Cada ventana/marco tiene un objeto Window separado. Las interacciones requieren referencias
y Marcos explícitas. Los marcos HTML son objetos Window independientes.

El objeto Window

El objeto Window representa una ventana del navegador web

y actúa como el objeto global en JavaScript del lado del
cliente.

Propiedades y métodos globales

- El objeto Window define propiedades y métodos globales

de alto nivel, accesibles sin prefijos.
- Una propiedad importante es `document`, que se refiere al
objeto Document que se muestra en el navegador.

Cuadros de diálogo simples

- Tres métodos para mostrar cuadros de diálogo:

- `alert()` para mensajes.
- `confirm()` para preguntas de sí/no.
- `prompt()` para la entrada de texto del usuario.

La línea de estado

- La línea de estado muestra destinos de URL y otra

información.
-Instalar la aplicación
Puedes establecer Bookey
el texto de para desbloquear
estado usando la propiedad
`status` y el valortexto completousando
predeterminado y audio
`defaultStatus`.
Capítulo 10 Resumen : Sección 2.3. El
Objeto Documento

El Objeto Documento

Cada objeto Window tiene una propiedad document que hace

referencia a un objeto Document, que es fundamental ya que
representa el documento HTML que se muestra en la ventana
del navegador.

El Modelo de Objetos del Documento (DOM)

El DOM describe cómo se accede y se modifica el contenido

del documento, y existen varios tipos de DOM:

DOM Heredado

El DOM heredado original evolucionó con las primeras

versiones de JavaScript, permitiendo el acceso a partes clave
del documento como formularios e imágenes. Está bien
soportado en todos los navegadores.
DOM W3C

Este modelo proporciona acceso completo a todo el

contenido del documento y está estandarizado por el World
Wide Web Consortium (W3C). Soportado por navegadores
modernos, difiere del DOM de IE 4 pero estandariza muchas
características heredadas. El libro se centra en las
características básicas relevantes para los programadores de
JavaScript.

DOM IE 4

Desarrollado por Microsoft, este DOM amplió el DOM

heredado, ofreciendo potentes características para la
manipulación del contenido del documento. Estas
características no fueron estandarizadas, pero tuvieron cierto
apoyo en navegadores que no son de Microsoft.

Conclusión

Las secciones siguientes detallarán cada tipo de DOM y sus

funcionalidades para acceder y modificar el contenido del
documento.
Ejemplo
Punto clave:Entender el objeto Document es esencial
para una programación efectiva en JavaScript.
Ejemplo:Imagina que estás creando una página web que
actualiza dinámicamente el contenido según la
interacción del usuario. El objeto Document, que
representa tu documento HTML, te permite acceder y
manipular elementos como párrafos y botones. Por
ejemplo, si deseas cambiar el texto de un párrafo cuando
un usuario hace clic en un botón, utilizarías JavaScript
para interactuar con el objeto Document. Al entender
cómo navegar por el DOM, puedes crear aplicaciones
web receptivas e interactivas que reaccionen a la entrada
del usuario, enriqueciendo significativamente la
experiencia del usuario.
Pensamiento crítico
Punto clave:La importancia del Modelo de Objetos
del Documento (DOM) en el desarrollo web.
Interpretación crítica:El autor enfatiza el papel crítico
del DOM como la interfaz entre los documentos web y
JavaScript, lo que permite la manipulación dinámica del
contenido. Sin embargo, aunque el DOM del W3C es
ampliamente aceptado como el estándar, los
desarrolladores deben mantenerse alerta sobre la
compatibilidad entre navegadores y los modelos
alternativos, como el DOM de IE 4. La suposición de
que todos los navegadores soportarán de forma
uniforme el modelo del W3C puede llevar a pasar por
alto aspectos en aplicaciones prácticas, como lo
evidencian numerosos testimonios de desarrolladores
que encuentran comportamientos inconsistentes en
diferentes plataformas. Recursos como Can I use
([Link]) pueden proporcionar información sobre la
compatibilidad de navegadores y problemas potenciales.
Capítulo 11 Resumen : Sección 2.4. El
DOM Legado

El DOM Legado

El DOM Legado se refiere al modelo original del Document

Object Model (DOM) de JavaScript del lado del cliente, que
permite el acceso a varias propiedades y contenidos del
documento.

Propiedades del Objeto Documento

- El objeto Documento proporciona varias propiedades de

solo lectura, incluyendo:
-
título:
Título del documento
-
URL:
URL del documento
-
últimaModificación:
 Fecha de la última modificación del documento
- También incluye arrays que hacen referencia a tipos
específicos de contenido del documento:
-
formularios[]:
Array de objetos Form
-
imágenes[]:
Array de objetos Image
-
applets[]:
Array de objetos de applets de Java incrustados
-
enlaces[]:
Array de objetos Link
-
anclas[]:
Array de objetos Anchor

Referencias Nombradas

Las referencias nombradas se pueden crear utilizando el

atributo name de HTML, permitiendo que los scripts accedan
a los elementos del documento por nombre, junto con la
notación de array.

Objetos Formulario

El objeto Form contiene:

-
elementos[]:
Un array de elementos de entrada dentro del formulario que
se pueden acceder en orden o por su nombre.

Limitaciones del DOM Legado

El DOM Legado está limitado a tipos específicos de

contenido (formularios, imágenes, etc.) y carece de métodos
para interactuar directamente con otras etiquetas u obtener
texto del documento.

Documentos Generados Dinámicamente

- El método `write()` del objeto Documento permite la

generación de contenido dinámico durante la fase de carga
del documento.
- Precaución: Usar `[Link]()` después de que el
documento se haya cargado sobrescribirá el documento
actual.

Formularios Dinámicos

- Los elementos de entrada se pueden actualizar

dinámicamente utilizando sus propiedades, como `value`.
- Ejemplo de establecer la hora local actual en un campo de
formulario de manera dinámica.

Validación de Formularios

- La etiqueta `<form>` admite un controlador de eventos

`onsubmit` para validar las presentaciones de formularios al
verificar los campos de entrada.

Efectos de Imágenes

- Los efectos de imágenes se pueden implementar utilizando

el array de imágenes y cambiando la propiedad `src` en
eventos del ratón (por ejemplo, `onmouseover`,
`onmouseout`).

Trabajo con Cookies

- La propiedad cookie permite establecer y consultar cookies
asociadas con el documento.
- Las cookies deben seguir un formato específico para los
pares nombre/valor, con fechas de expiración y
especificaciones de ruta opcionales.
- Se proporciona una función de ejemplo para recuperar el
valor de una cookie específica.
Capítulo 12 Resumen : Sección 2.5. El
W3C DOM

El W3C DOM

El estándar W3C DOM estandariza características del DOM

heredadas e introduce nuevas, permitiendo que los scripts
accedan y manipulen varios elementos del documento más
allá de formularios e imágenes.

Encontrando Elementos por ID

- Utiliza un atributo `id` único para elementos especiales.

- Accede a los elementos con el método `getElementById()`.

Ejemplo:
```javascript
var t = [Link]("title");
```

Encontrando Elementos por Nombre de Etiqueta

- Accede a los elementos mediante su nombre de etiqueta
usando `getElementsByTagName()`, que devuelve un array
de elementos que coinciden.

Ejemplo:
```javascript
var lists = [Link]("ul");
var item = lists[1].getElementsByTagName("li")[2];
```

Recorriendo un Árbol de Documentos

- El W3C DOM representa un documento como un árbol de

nodos (etiquetas HTML, texto, comentarios).
- Usa propiedades como `parentNode`, `firstChild`,
`nextSibling` y `lastChild` para navegar por el árbol.
Ejemplo:
```javascript
var p = [Link];
var c0 = [Link];
```
Instalar la aplicación Bookey para desbloquear
Tipos de Nodostexto completo y audio
Capítulo 13 Resumen : Sección 2.6. DOM
de IE 4

Visión general del DOM de IE 4

El DOM de IE 4, Introducido con Internet Explorer 4, es un

modelo de objeto de documento potente pero no estándar.
Aunque IE 5 y versiones posteriores admiten la mayoría de
las características del DOM de W3C, este modelo más
antiguo sigue siendo relevante debido a su uso.

Acceso a los elementos del documento

A diferencia del DOM de W3C, el DOM de IE 4 no utiliza el

método getElementById(). En cambio, los elementos se
pueden acceder a través del array all[] del objeto documento,
ya sea utilizando una ID de cadena o haciendo referencia a
ella directamente. El método tags() en el array all[] se utiliza
para obtener elementos por nombre de etiqueta, necessitando
nombres de etiquetas en mayúsculas.

Recorriendo el árbol del documento

El recorrido en el DOM de IE 4 se asemeja al del DOM de
W3C pero utiliza nombres de propiedades diferentes:
`children[]` reemplaza a `childNodes[]`, y `parentElement`
reemplaza a `parentNode`. Cabe destacar que los comentarios
y el texto del documento están excluidos del árbol, siendo el
texto accesible a través de las propiedades innerHTML e
innerText.

Modificando el contenido y la estructura del

documento

Los objetos de elemento en el DOM de IE 4 pueden tener sus

propiedades configuradas y consultadas de manera similar a
los elementos del DOM de W3C. La propiedad innerText
cambia el contenido textual de un elemento, mientras que la
propiedad innerHTML permite reemplazar el contenido de
un elemento con una cadena HTML, aunque de manera
menos eficiente. La propiedad outerHTML y los métodos
insertAdjacentHTML() son formas adicionales, aunque
menos comunes, de manipular elementos.

Compatibilidad del DOM

Para asegurar la compatibilidad entre diferentes
implementaciones del DOM, los scripts pueden comprobar la
existencia de métodos o propiedades. Esto permite que la
funcionalidad diseñada para el DOM de W3C vuelva al
DOM de IE 4 si es necesario, proporcionando una solución
de scripting robusta para varios navegadores.
Capítulo 14 Resumen : Sección 2.7.
DHTML: Programación de estilos CSS

DHTML: Programación de estilos CSS

Resumen de DHTML

HTML dinámico (DHTML) integra HTML, CSS y

JavaScript, permitiendo la modificación dinámica de estilos,
incluyendo la posición y visibilidad de los elementos del
documento.

Propiedad de estilo

- Cada elemento del documento tiene una propiedad de estilo

vinculada a sus estilos en línea.
- La propiedad de estilo se refiere a un objeto de estilo con
propiedades que corresponden a los atributos CSS.
- Por ejemplo, para acceder al atributo de color:
`[Link]` y para establecer el color de fondo:
`[Link]`.
- Los atributos CSS con guiones utilizan nombres en
mayúsculas y minúsculas en JavaScript (por ejemplo,
`background-color` se convierte en `backgroundColor`).

Caso especial

- El atributo `float` es una palabra reservada en JavaScript; se

le conoce como `cssFloat`.

Propiedades CSS y scripting dinámico

- El estándar CSS incluye propiedades para mejorar la

apariencia visual, particularmente en lo que respecta a la
posición y visibilidad:
-
Posición
: Valores - absoluto, relativo, fijo, estático.
-
Izquierda/Arriba
: Coordenadas X/Y.
-
Ancho/Alto
: Dimensiones del elemento.
-
Índice Z
: Orden de apilamiento; valores más altos están en la parte
superior.
-
Display
: Valores - bloque, en línea, ninguno.
-
Visibilidad
: Puede establecerse como oculto o visible; se asigna espacio
para elementos ocultos.
-
Desbordamiento
: Cómo manejar el contenido que excede el tamaño del
elemento (visible, oculto, desplazamiento, automático).
-
Clip
: Porción del contenido que se muestra (sintaxis: `rect(arriba
derecha abajo izquierda)`).

Ejemplo de animación DHTML

- Demuestra una animación simple de mover un elemento.

- Código para animar un elemento moviéndolo 10 píxeles a
la derecha cada 50 milisegundos hasta que se haya movido
20 veces, momento en el cual se vuelve invisible.
```html
<h1 id='title'>Animación DHTML</h1>
<script>
var e = [Link]("title");
[Link] = "absolute";
var frame = 0;
function nextFrame() {
if (frame++ < 20) {
[Link] = (10 * frame) + "px";
setTimeout("nextFrame()", 50);
} else [Link] = "hidden";
}
nextFrame();
</script>
```
Capítulo 15 Resumen : Sección 2.8.
Eventos y Manejo de Eventos

2.8 Eventos y Manejo de Eventos

Esta sección aborda cómo implementar JavaScript del lado

del cliente en documentos HTML a través de atributos de
controladores de eventos.

Atributos de Controladores de Eventos Estándares

Una tabla resume los controladores de eventos estándar que

comienzan con "on" y sus correspondientes etiquetas HTML.
Los controladores clave incluyen:
-
onabort
: Se activa cuando se aborta la carga de una imagen.
-
onclick
: Se ejecuta al presionar y soltar el mouse.
-
onfocus
: Se activa cuando un elemento obtiene el foco del teclado.
-
onload
: Se dispara una vez que un documento o imagen se carga por
completo.
-
onsubmit
: Relacionado con la presentación de formularios, permite
prevenir la presentación a través de una declaración de
retorno falso.
Se pueden prevenir las acciones predeterminadas de ciertos
eventos retornando falso, excepto en el caso de onmouseover,
donde retornar verdadero detiene la visualización de la URL
en la línea de estado.

2.8.1 Controladores de Eventos como Funciones de

JavaScript

Los controladores de eventos en HTML corresponden a

funciones de JavaScript. Por ejemplo:
```javascript
Instalar la aplicación Bookey
[Link][0].onsubmit para desbloquear
= validate;
``` texto completo y audio
Esto asigna una función de validación al evento de envío de
Capítulo 16 Resumen : Sección 2.9.
Restricciones de Seguridad en JavaScript

Restricciones de Seguridad en JavaScript

Descripción General

Las implementaciones de JavaScript en el lado del cliente

imponen diversas restricciones de seguridad para prevenir
acciones peligrosas, proteger la privacidad del usuario y
mejorar la experiencia general del usuario. Estas restricciones
no están estandarizadas, pero muchas son comunes en
diferentes navegadores.

Principales Restricciones

-
Política de Origen Único
: Los scripts solo pueden acceder a las propiedades de las
ventanas y documentos del mismo servidor web, limitando la
programación cruzada entre ventanas.
-
Restricciones de Carga de Archivos
: Los scripts no pueden manipular la propiedad de valor del
elemento de formulario FileUpload.
-
Envío de Correos y Noticias
: Se prohíbe a los scripts enviar formularios a URLs mailto: o
news: sin la confirmación del usuario.
-
Gestión de Ventanas
: Los scripts solo pueden cerrar ventanas que han creado, a
menos que se obtenga confirmación del usuario.
-
Acceso a la Caché
: Los scripts no pueden cargar URLs como about:cache.
-
Creación de Ventanas
: Los scripts no pueden crear ventanas fuera de la pantalla o
pequeñas, ni ventanas sin barras de título.

Restricciones Evolutivas

Debido al mal uso de JavaScript para acciones no deseadas,

los navegadores más recientes permiten a los usuarios
configurar ajustes de seguridad para bloquear anuncios
emergentes y manipular el tamaño o la posición de las
ventanas.

JavaScript en el Lado del Cliente

Definición y Funcionalidad

JavaScript de lado del cliente se refiere al código incrustado

en archivos HTML, ejecutado por los navegadores web.
Proporciona acceso a los objetos del navegador y del
documento, y a menudo está basado en eventos,
reaccionando a las interacciones del usuario.

Implicaciones del Marco y la Seguridad

Las potentes capacidades de JavaScript del lado del cliente

pueden introducir vulnerabilidades de seguridad
significativas, lo que lleva a los navegadores a imponer
restricciones sobre las acciones de los scripts. Esta sección se
centra en la inclusión de JavaScript en HTML, la
introducción de objetos de JavaScript, el manejo de eventos y
la descripción de las medidas de seguridad.
Pensamiento crítico
Punto clave:La ausencia de estandarización en las
restricciones de seguridad de JavaScript genera
preocupaciones sobre la privacidad y la seguridad de
los usuarios.
Interpretación crítica:Aunque el autor destaca la
importancia de varias restricciones de seguridad en
JavaScript del lado del cliente, es fundamental evaluar
críticamente su efectividad y consistencia entre
navegadores. La falta de un estándar universal significa
que las medidas de seguridad pueden variar
significativamente, lo que potencialmente deja a los
usuarios vulnerables dependiendo del navegador que
utilicen. Esta inconsistencia socava la fiabilidad de
JavaScript como tecnología y sugiere que el punto de
vista del autor podría sobreestimar la naturaleza
protectora de estas medidas. De hecho, investigaciones
de expertos en seguridad como Michal Zalewski han
encendido alarmas sobre la seguridad de los
navegadores, enfatizando la necesidad de un enfoque
más estandarizado y sólido para la seguridad en
JavaScript (fuente: "JavaScript. La guía definitiva"). Se
anima a los lectores a buscar fuentes externas para
comprender mejor las complejidades y deficiencias de
las prácticas de seguridad en JavaScript.
Capítulo 17 Resumen : Array

Creación y Manipulación de Arrays en JavaScript

Métodos Constructores

-
new Array()
: Crea un array vacío.
-
new Array(n)
: Crea un array con `n` elementos indefinidos.
-
new Array(e0, e1,...)
: Inicializa un array con los elementos especificados.

Sintaxis Literal

- Los arrays se pueden crear usando corchetes cuadrados con

valores separados por comas, por ejemplo, `var a = [1, true,
'abc'];`.
Propiedades del Array

-
length
: Un número entero de lectura/escritura que indica el número
de elementos en el array. Se puede modificar para truncar o
ampliar el array.

Métodos del Array

-
concat(value, ...)
: Combina arrays y valores en un nuevo array.
-
join(separator)
: Convierte cada elemento a una cadena y los concatena con
un separador especificado.
-
pop()
: Elimina y devuelve el último elemento, alterando la
longitud del array.
-
push(value, ...)
: Agrega valores al final y devuelve la nueva longitud.
-
reverse()
: Invierte el orden del array.
-
shift()
: Elimina y devuelve el primer elemento, ajustando la
longitud.
-
slice(start, end)
: Crea un nuevo array con elementos desde el índice de inicio
hasta, pero sin incluir, el índice final.
-
sort(orderfunc)
: Ordena los elementos en su lugar según una función de
ordenación opcional.
-
splice(start, deleteCount, value,...)
: Elimina elementos especificados e inserta nuevos en el
índice definido, devolviendo los elementos eliminados.
-
toLocaleString()
: Devuelve una representación de cadena localizada del array.
-
toString()
: Convierte el array a una cadena.
-
unshift(value, ...)
: Agrega nuevos elementos al principio, moviendo los
elementos existentes y devolviendo la nueva longitud.
Capítulo 18 Resumen : Fecha

Objeto Date en JavaScript. La guía definitiva

El objeto Date en JavaScript se utiliza para trabajar con

fechas y horas, y se puede crear utilizando varios formatos.

Variantes del Constructor

- `new Date();` - Crea un objeto Date para la fecha y hora

actuales.
- `new Date(milliseconds);` - Inicializa a partir de una marca
de tiempo (milisegundos).
- `new Date(datestring);` - Analiza una cadena de fecha
proporcionada.
- `new Date(year, month, day, hours, minutes, seconds, ms);`
- Define campos individuales de fecha y hora, siendo los dos
primeros argumentos (año y mes) obligatorios.

Métodos del Objeto Date

El objeto Date opera sin propiedades y se basa en varios

métodos:
-
Métodos Get:

- `get[UTC]Date()`: Devuelve el día del mes (1-31).

- `get[UTC]Day()`: Devuelve el día de la semana (0-6).
- `get[UTC]FullYear()`: Devuelve el año completo.
- `get[UTC]Hours()`: Devuelve las horas (0-23).
- `get[UTC]Milliseconds()`: Devuelve los milisegundos.
- `get[UTC]Minutes()`: Devuelve los minutos (0-59).
- `get[UTC]Month()`: Devuelve el mes (0-11).
- `get[UTC]Seconds()`: Devuelve los segundos (0-59).
- `getTime()`: Devuelve los milisegundos desde el 1 de
enero de 1970.
- `getTimezoneOffset()`: Devuelve la diferencia en minutos
respecto a UTC.
- `getYear()`: Devuelve el año menos 1900 (obsoleto).
-
Métodos Set:

- `set[UTC]Date(day_of_month)`: Establece el día del mes.

- `set[UTC]FullYear(year, month, day)`: Establece el año (y
Instalar la aplicación
opcionalmente Bookey para desbloquear
el mes y el día).
texto completo
- `set[UTC]Hours(hours, y audio
mins, secs, ms)`: Establece las
horas, con opciones para minutos, segundos y milisegundos.
Capítulo 19 Resumen : Documento

Objeto Document en JavaScript del lado del cliente

Descripción general

El objeto Document representa un documento HTML y es un

componente clave en JavaScript del lado del cliente,
introducido en JavaScript 1.0, con mejoras posteriores en
JavaScript 1.1. Tanto Netscape como Internet Explorer han
añadido características no estándar al objeto Document,
mientras que el estándar W3C DOM proporciona
especificaciones adicionales.

Propiedades comunes

-
alinkColor
: Color de los enlaces activados (obsoleto).
-
anchors[]
: Array de objetos Anchor en el documento.
-
applets[]
: Array de objetos Applet en el documento.
-
bgColor
: Color de fondo (obsoleto).
-
cookie
: Gestiona las cookies asociadas con el documento.
-
domain
: Especifica el dominio de Internet del documento por
razones de seguridad.
-
embeds[]
: Objetos que representan datos incrustados a través de la
etiqueta `<embed>`.
-
fgColor
: Color de texto predeterminado (obsoleto).
-
forms[]
: Array de objetos Form en el documento.
-
images[]
: Array de objetos Image en el documento.
-
lastModified
: Fecha del último cambio en el documento.
-
linkColor
: Color de los enlaces no visitados (obsoleto).
-
links[]
: Array de objetos Link en el documento.
-
location
: URL del documento (obsoleto).
-
plugins[]
: Sinónimo de embeds[].
-
referrer
: URL del documento que enlazó al actual.
-
title
: Contenido de texto de la etiqueta `<title>`.
-
URL
: URL del documento.
-
vlinkColor
: Color de los enlaces visitados (obsoleto).

Propiedades del W3C DOM

-
body
: Referencia a la etiqueta `<body>` del documento.
-
defaultView
: La ventana en la que aparece el documento.
-
documentElement
: Referencia a la etiqueta `<html>` del documento.
-
implementation
: La implementación que creó el documento.

Propiedades de Internet Explorer 4

-
activeElement
: Se refiere al elemento de entrada actualmente activo.
-
all[]
: Array de todos los objetos Element en el documento.
-
charset
: Conjunto de caracteres del documento.
-
children[]
: Hijos directos del documento como un array.
-
defaultCharset
: Conjunto de caracteres predeterminado del documento.
-
expando
: Previene la expansión de objetos del lado del cliente.
-
parentWindow
: La ventana que contiene el documento.
-
readyState
: Estados de carga del documento (no inicializado, cargando,
interactivo, completo).
Propiedades de Netscape 4

-
height
: Altura del documento en píxeles.
-
layers[]
: Array de objetos Layer en el documento (obsoleto).
-
width
: Ancho del documento en píxeles.

Métodos comunes

-
clear()
: Borra el contenido del documento (obsoleto).
-
close()
: Cierra un flujo de documento.
-
open()
: Abre un flujo para nuevo contenido del documento.
-
write(value...)
: Inserta cadenas en el documento.
-
writeln(value...)
: Inserta cadenas con un salto de línea en el documento.

Métodos del W3C DOM

-
createAttribute(name)
: Crea un nodo de atributo.
-
createComment(text)
: Devuelve un nuevo nodo de Comentario.
-
createDocumentFragment()
: Devuelve un nodo DocumentFragment vacío.
-
createElement(tagName)
: Crea un nuevo nodo Element.
-
createTextNode(text)
: Crea un nodo de Texto con el texto especificado.
-
getElementById(id)
: Recupera un Elemento por su id.
-
getElementsByName(name)
: Recupera elementos por su nombre.
-
getElementsByTagName(tagname)
: Recupera elementos por su nombre de etiqueta.
-
importNode(importedNode, deep)
: Copia un nodo de otro documento.

Métodos de Netscape 4

-
getSelection()
: Devuelve el texto seleccionado del documento sin etiquetas
HTML.

Métodos de Internet Explorer 4

-
elementFromPoint(x,y)
: Recupera el Elemento ubicado en las coordenadas
especificadas.

Controladores de eventos

El objeto Document soporta controladores de eventos

genéricos, similares al objeto Element. Controladores de
eventos como onload y onunload son propiedades del objeto
Window.

Temas relacionados

Anchor, Applet, Element, Form, Image, Layer, Link,

Window.
Ejemplo
Punto clave:Comprendiendo la importancia del
objeto Document en JavaScript
Ejemplo:El objeto Document sirve como tu interfaz
principal para manipular e interactuar con páginas web a
través de JavaScript, permitiéndote modificar
dinámicamente los elementos HTML según las acciones
o eventos del usuario.
Capítulo 20 Resumen : Elemento

Objeto Elemento en el DOM

Descripción general

El objeto Elemento representa un elemento o etiqueta HTML

en un documento, heredando propiedades del objeto Nodo
según lo definido en el DOM Nivel 1. Varios navegadores,
incluyendo IE 4 y posteriores, soportan el acceso a los
elementos del documento pero con diferencias en sus
implementaciones del DOM.

Propiedades del DOM W3C

-
Nombres de propiedades
: Corresponden a atributos HTML; las palabras reservadas
requieren un nombramiento especial (por ejemplo,
className para class).
-
Propiedades comunes
:
-
className
: Cadena del atributo de clase.
-
style
: Objeto que representa estilos CSS en línea.
-
tagName
: Nombre de la etiqueta del elemento, de solo lectura.

Propiedades del DOM IE

- Definidas a partir de IE 4, distintas de los estándares W3C.

-
Propiedades clave
:
-
all[]
: Array de objetos Elemento descendientes.
-
children[]
: Array de objetos Elemento hijos directos.
-
innerHTML
: Texto HTML dentro del elemento.
-
offsetHeight/Width
: Dimensiones del elemento.
-
outerHTML
: Representación HTML completa incluyendo etiquetas.

Métodos del DOM W3C

- Incluyen métodos para manipular atributos y elementos:

-
getAttribute(nombre)
: Recupera el valor de un atributo.
-
setAttribute(nombre, valor)
: Establece un atributo nombrado.
-
removeAttribute(nombre)
: Elimina un atributo nombrado.

Métodos del DOM IE

- Métodos no estándar presentes en IE:
-
contains(objetivo)
: Verifica si el elemento contiene otro elemento.
-
insertAdjacentHTML(donde, texto)
: Inserta HTML en la posición especificada.
-
scrollIntoView(arriba)
: Desplaza la vista para hacer visible el elemento.

Manejadores de eventos

- Los elementos responden a diversas acciones del usuario a

través de manejadores de eventos:
-
onclick
: Al hacer clic del usuario.
-
ondblclick
: Al hacer doble clic.
-
onkeydown/onkeyup
: Al realizar actividad en el teclado.
 -
onmousemove/onmouseout
: Al mover el ratón sobre/fuera del elemento.

Conceptos relacionados

Referencias a objetos adicionales que comparten interacción

con el objeto Elemento incluyen Formulario, Entrada, Nodo,
Seleccionar y Textarea.
Capítulo 21 Resumen : Evento

Descripción General del Objeto Evento

El objeto Evento proporciona detalles sobre un evento y

controla su propagación a través de diferentes entornos de
navegador. Existen diferentes estándares e implementaciones
en varios navegadores como DOM Nivel 2, Internet Explorer
(IE) y Netscape.

Objeto Evento DOM Nivel 2

-
Tipos de Evento
: El objeto Evento se utiliza en los modelos de eventos de
DOM y Netscape, pasándolo como un argumento a los
manejadores de eventos. En contraste, el modelo de IE
accede al evento a través de la propiedad evento del objeto
Window.
-
Constantes de Fase del Evento
:
-
Event.CAPTURING_PHASE
=1
-
Event.AT_TARGET
=2
-
Event.BUBBLING_PHASE
=3

Propiedades del DOM

Todas las propiedades son de solo lectura:

-
altKey
: Indica si la tecla Alt estaba presionada durante el evento.
-
bubbles
: Indica si el evento puede burbujear.
-
button
: Identifica qué estado del botón del mouse cambió.
-Instalar la aplicación Bookey para desbloquear
cancelable texto completo y audio
: Indica si la acción predeterminada del evento puede ser
Capítulo 22 Resumen : Global

Visión General de JavaScript Global

El objeto Global en JavaScript contiene un conjunto de

propiedades y funciones globales que pueden ser accedidas
directamente sin referencia a otro objeto. Cualquier variable
y función creada a nivel superior en tu código se considera
una propiedad del objeto Global. En JavaScript del lado del
cliente, este objeto Global está representado por el objeto
Window, que también incluye métodos y propiedades
adicionales.

Propiedades Globales

-
Infinity
: Representa infinito positivo.
-
NaN
: Representa un valor no numérico.

Funciones Globales
-
decodeURI(uri)
: Devuelve una versión decodificada de la URI
proporcionada, reemplazando las secuencias de escape en
hexadecimal con sus caracteres correspondientes.
-
decodeURIComponent(s)
: Similar a decodeURI pero funciona específicamente en las
partes componente de una URI.
-
encodeURI(uri)
: Codifica una URI, reemplazando ciertos caracteres con
secuencias de escape en hexadecimal, dejando los
separadores como #, ?, y @ sin codificar.
-
encodeURIComponent(s)
: Similar a encodeURI pero codifica todos los caracteres de
puntuación.
-
escape(s)
: Devuelve una copia codificada de la cadena con ciertos
caracteres reemplazados (obsoleto en favor de encodeURI y
encodeURIComponent).
-
eval(code)
: Evalúa una cadena que contiene código JavaScript y
devuelve el resultado.
-
isFinite(n)
: Verifica si n es un número finito, devolviendo verdadero o
falso.
-
isNaN(x)
: Verifica si x no es un número, devolviendo verdadero o
falso.
-
parseFloat(s)
: Convierte una cadena a un número y lo devuelve.
-
parseInt(s, radix)
: Convierte una cadena a un entero con un argumento radial
opcional que especifica la base (de 2 a 36).
-
unescape(s)
: Decodifica una cadena previamente codificada con escape
(obsoleto en favor de decodeURI y decodeURIComponent).
Ver También

-
Window
: El objeto que representa la ventana del navegador y sirve
como contexto global para JavaScript del lado del cliente.
Capítulo 23 Resumen : Input

JavaScript del lado del cliente 1.0

Descripción del objeto Input

El objeto Input representa los elementos HTML `<input>` y

proporciona propiedades para sus atributos.

Propiedades

-
checked
: Indica si un checkbox o un radio está marcado.
-
defaultChecked
: Muestra si el checkbox o radio estaba marcado
inicialmente.
-
defaultValue
: Texto inicial para inputs de texto/contraseña; no aplicable a
inputs de archivo.
-
form
: Referencia de solo lectura al objeto Form que contiene.
-
name
: El atributo nombre del elemento de entrada.
-
type
: Especifica el tipo de entrada como una cadena (por ejemplo,
"texto," "checkbox," etc.).

Valores legales para Type

- Incluye valores como "button," "checkbox," "file,"

"hidden," "image," "password," "radio," "reset," "text," y
"submit."
-
value
: Representa el valor de cadena enviado con el formulario,
varía según el tipo de entrada.

Métodos
-
blur()
: Quita el foco del elemento de entrada.
-
click()
: Simula un clic del mouse en la entrada.
-
focus()
: Establece el foco del teclado en la entrada.
-
select()
: Selecciona texto en la entrada (aplicable para "texto,"
"contraseña," y "archivo").

Controladores de eventos

-
onblur
: Se activa cuando el elemento pierde el foco.
-
onchange
: Se activa cuando se cambia el texto y se aleja el foco.
-
onclick
: Se activa al hacer clic en botones; puede prevenir el envío
del formulario.
-
onfocus
: Se activa cuando el elemento gana el foco.

Referencias a objetos relacionados

Incluye asociaciones con los objetos Form, Option, Select y

Textarea.
Capítulo 24 Resumen : Capa

Capa Solo del lado del cliente en Netscape 4

Sinopsis

- Proporciona una visión general del objeto Capa, que es una

característica no estándar exclusiva de Netscape 4 para
manejar objetos posicionados dinámicamente.

Construcción del objeto Capa

- `[Link][i]`, `[Link][nombre_capa]` y
`new Layer(ancho, capa_padre)` se pueden utilizar para
referenciar o crear capas.

Descripción

- Las capas se representan mediante elementos HTML con

posicionamiento CSS absoluto y se pueden crear utilizando
ya sea la etiqueta `<layer>` o el constructor Layer. Esta
característica se descontinuó en Netscape 6.
Propiedades

-
above
: Referencia de solo lectura a la capa superior.
-
background
: Imagen de fondo de la capa.
-
below
: Referencia de solo lectura a la capa inferior.
-
bgColor
: Color de fondo de la capa.
-
clip
: Propiedades que definen los límites y dimensiones del área
de recorte (inferior, altura, izquierda, derecha, superior,
ancho).
-
Instalar la aplicación Bookey para desbloquear
document
texto
: Referencia de solo completo
lectura al objetoyDocument
audio contenido.
-
Capítulo 25 Resumen : Enlace

Enlace JavaScript del lado del cliente 1.0

Herencia y Descripción General

- El objeto Link hereda de la clase Element. Representa

elementos `<a>` o `<area>` en HTML.

Propiedades del Objeto Link

- El objeto Link incluye varias propiedades que representan

diferentes partes de una URL. A continuación se presentan
descripciones y ejemplos basados en una URL ficticia: `http:/
/[Link]/catalog/[Link]?q=JavaScript&
m=10#results`.
-
hash
: Una cadena que representa la parte del ancla de la URL (por
ejemplo, `#result`).

-
host
: Una cadena que representa el nombre del host y el puerto
(por ejemplo, `[Link]`).

-
hostname
: Una cadena solo para el nombre del host (por ejemplo,
`[Link]`).

-
href
: La URL completa como una cadena.

-
pathname
: La porción del pathname de la URL (por ejemplo,
`/catalog/[Link]`).

-
port
: Una cadena que representa el puerto (por ejemplo, `1234`).

-
protocol
: Una cadena para el protocolo de la URL, incluyendo los dos
puntos (por ejemplo, `http:`).

-
search
: Una cadena para la parte de consulta de la URL, incluyendo
el signo de interrogación (por ejemplo,
`?q=JavaScript&m=10`).

-
target
: Una cadena que especifica el nombre del objeto Window
donde se abrirá el documento vinculado. Esto incluye
atributos estándar de destino de HTML (_blank, _top,
_parent y _self).

Manejadores de Eventos para el Objeto Link

-
onclick
: Se activa cuando se hace clic en el enlace. Puede devolver
falso en JavaScript 1.1 para evitar seguir el enlace.

-
onmouseout
: Se activa cuando el mouse sale del enlace, disponible en
JavaScript 1.1.

-
onmouseover
: Se activa cuando el mouse pasa sobre el enlace. Puede
modificar la propiedad de estado de la ventana y devolver
verdadero para suprimir la visualización de la URL en la
línea de estado.

Conceptos Relacionados

- Incluye referencias a objetos Anchor y Location para una

mejor comprensión del comportamiento y las propiedades de
los enlaces.
Capítulo 26 Resumen : Math

Objeto Math en JavaScript.

El objeto Math es una característica fundamental en

JavaScript que organiza constantes y funciones matemáticas.
A diferencia de otros objetos como Date y String, no tiene un
constructor y sus funciones son independientes, no métodos
de un objeto.

Constantes

-
Math.E
: Base del logaritmo natural.
-
Math.LN10
: Logaritmo natural de 10.
-
Math.LN2
: Logaritmo natural de 2.
-
Math.LOG10E
: Logaritmo base 10 de e.
-
Math.LOG2E
: Logaritmo base 2 de e.
-
[Link]
: Constante À.
-
Math.SQRT1_2
: 1 dividido por la raíz cuadrada de 2.
-
Math.SQRT2
: Raíz cuadrada de 2.

Funciones

-
[Link](x)
: Valor absoluto de x.
-
[Link](x)
: Arcocoseno de x (0 a À radianes).
-
[Link](x)
: Arcoseno de x (-À/2 a À/2 radianes).
-
[Link](x)
: Arcotangente de x (-À/2 a À/2 radianes).
-
Math.atan2(y, x)
: Ángulo en sentido antihorario entre el eje X positivo y el
punto (x, y).
-
[Link](x)
: Entero más cercano mayor o igual a x.
-
[Link](x)
: Coseno de x.
-
[Link](x)
: e elevado a la potencia de x.
-
[Link](x)
: Entero más cercano menor o igual a x.
-
[Link](x)
: Logaritmo natural de x.
-
[Link](args...)
: Mayor de los argumentos especificados; devuelve -Infinity
si no hay argumentos o NaN si la entrada no es numérica.
-
[Link](args...)
: Menor de los argumentos especificados; devuelve Infinity si
no hay argumentos o NaN si la entrada no es numérica.
-
[Link](x, y)
: x elevado a la potencia de y.
-
[Link]()
: Número pseudoaleatorio entre 0.0 y 1.0.
-
[Link](x)
: Entero más cercano a x.
-
[Link](x)
: Seno de x.
-
[Link](x)
: Raíz cuadrada de x (devuelve NaN si x < 0).
-
[Link](x)
: Tangente de x.

Tema Relacionado

-
Número
: Para más detalles sobre operaciones y comportamientos
numéricos en JavaScript.
Capítulo 27 Resumen : Navegador

Información sobre el Navegador y JavaScript del

Lado del Cliente 1.0

Síntesis

Esta sección proporciona propiedades y métodos esenciales

del objeto `navigator` utilizado en JavaScript para obtener
información sobre el navegador que se está utilizando.

Propiedades

-
appCodeName
: Una cadena que indica el apodo del navegador, típicamente
"Mozilla" tanto para navegadores de Netscape como de
Microsoft.
-
appName
: Una cadena que especifica el nombre del navegador,
"Netscape" para los navegadores de Netscape y "Microsoft
Internet Explorer" para IE.
-
appVersion
: Una cadena que indica la versión del navegador y la
plataforma. El número de versión se puede extraer usando
`parseInt()` o `parseFloat()`.
-
cookieEnabled
: Un valor booleano que es verdadero si las cookies están
habilitadas en el navegador.
-
language
: Una cadena que especifica el idioma predeterminado del
navegador utilizando códigos estándar de dos letras.
-
platform
: Una cadena que indica el sistema operativo o la plataforma
de hardware, como "Win32" o "Linux i586".
-
systemLanguage
: Una cadena que denota el idioma predeterminado del
Instalar
sistema la aplicación Bookey para desbloquear
operativo.
- texto completo y audio
userAgent
Capítulo 28 Resumen : Nodo

Nodo DOM Nivel 1

Definición

Un Nodo en un árbol de documentos es una instancia de una

de varias subclases, incluyendo Attr, Comment, Document,
DocumentFragment, Element y Text. Cada objeto Nodo tiene
una propiedad `nodeType` que indica su subclase específica.

Constantes de Tipo de Nodo

Las siguientes constantes definen valores legales para

`nodeType`:
- `Node.ELEMENT_NODE = 1` (Elemento)
- `Node.ATTRIBUTE_NODE = 2` (Attr)
- `Node.TEXT_NODE = 3` (Texto)
- `Node.COMMENT_NODE = 8` (Comentario)
- `Node.DOCUMENT_NODE = 9` (Documento)
- `Node.DOCUMENT_FRAGMENT_NODE = 11`
(DocumentFragment)
Propiedades del Nodo

- `attributes[]`: Array de sólo lectura de objetos Attr para

nodos Element.
- `childNodes[]`: Array de sólo lectura de objetos Nodo hijos.
- `firstChild`: El primer Nodo hijo o null si no existe.
- `lastChild`: El último Nodo hijo o null si no existe.
- `nextSibling`: El siguiente Nodo hermano o null si no
existe.
- `nodeName`: El nombre del nodo, varía según el tipo de
nodo.
- `nodeType`: Especifica el tipo del nodo.
- `nodeValue`: Contiene el valor de cadena, lectura/escritura
para nodos Texto y Comentario.
- `ownerDocument`: El objeto Documento que contiene este
Nodo o null para nodos Documento.
- `parentNode`: El nodo contenedor o null para nodos sin
padre.
- `previousSibling`: El Nodo hermano anterior o null si no
existe.

Métodos del Nodo

- `addEventListener(type, listener, useCapture)`: Registra un
listener de eventos.
- `appendChild(newChild)`: Agrega un nuevo Nodo hijo al
árbol de documentos.
- `cloneNode(deep)`: Devuelve una copia del nodo,
opcionalmente incluyendo descendientes.
- `hasAttributes()`: Verifica si hay atributos en un nodo
Element.
- `hasChildNodes()`: Verifica si el nodo tiene hijos.
- `insertBefore(newChild, refChild)`: Inserta un nuevo hijo
antes de un hijo de referencia especificado.
- `isSupported(feature, version)`: Verifica el soporte para una
versión de una característica.
- `normalize()`: Consolida nodos de Texto adyacentes y
elimina nodos de Texto vacíos.
- `removeChild(oldChild)`: Elimina un Nodo hijo
especificado.
- `removeEventListener(type, listener, useCapture)`: Elimina
un listener de eventos.
- `replaceChild(newChild, oldChild)`: Reemplaza un Nodo
hijo viejo con un nuevo Nodo hijo.

Subclases Relacionadas
Incluye Attr, Comment, Document, DocumentFragment,
Element y Text.
Capítulo 29 Resumen : Número

Resumen del Capítulo 29: Números en JavaScript

Constructor Number

- El constructor `Number` puede ser utilizado con el operador

`new` para crear un nuevo objeto `Number`. Sin `new`,
funciona como una función de conversión, devolviendo un
valor numérico.

Constantes

-
Number.MAX_VALUE
: El número representable más grande (~1.79E+308).
-
Number.MIN_VALUE
: El número representable más pequeño (~5E-324).
-
[Link]
: Representa 'No es un número'.
-
Number.NEGATIVE_INFINITY
: Valor infinito negativo.
-
Number.POSITIVE_INFINITY
: Valor infinito positivo.

Métodos

-
toExponential(dígitos)
: Devuelve una cadena en notación exponencial con un
número específico de dígitos después del punto decimal
(0-20).
-
toFixed(dígitos)
: Devuelve una cadena con exactamente el número
especificado de dígitos decimales (0-20) sin notación
exponencial.
-
toLocaleString()
: Devuelve una representación de cadena del número
dependiente de la localidad.
-
toPrecision(precisión)
: Devuelve una representación de cadena que contiene un
número específico de dígitos significativos (1-21).
-
toString(base)
: Convierte un número a una cadena en una base especificada
(2-36); por defecto se utiliza la base 10 si se omite.

Referencia Relacionada

- Se puede encontrar información adicional en la

documentación del objeto Math.
Capítulo 30 Resumen : Objeto

Objeto en JavaScript

Constructor

- El constructor `new Object();` crea un objeto vacío al que

se le pueden añadir propiedades arbitrarias.

Propiedades de los Objetos en JavaScript

-
constructor
: Una referencia a la función que creó el objeto (JS 1.1;
JScript 2.0; ECMA v1).

Métodos de los Objetos en JavaScript

1.
hasOwnProperty(propname)
:
- Devuelve `true` si el objeto tiene una propiedad no
heredada con el nombre especificado, de lo contrario
devuelve `false` (JS 1.5; JScript 5.5; ECMA v3).

2.
isPrototypeOf(o)
:
- Devuelve `true` si el objeto es el prototipo de `o`, de lo
contrario devuelve `false` (JS 1.5; JScript 5.5; ECMA v3).

3.
propertyIsEnumerable(propname)
:
- Devuelve `true` si el objeto tiene una propiedad
enumerable no heredada con el nombre especificado (JS 1.5;
JScript 5.5; ECMA v3).

4.
toLocaleString()
:
- Devuelve una representación de cadena del objeto
localizada. Típicamente llama a `toString()`, pero las
Instalarpueden
subclases la aplicación Bookey
sobreescribir esto (JSpara desbloquear
1.5; JScript 5.5;
ECMA v3). texto completo y audio
Capítulo 31 Resumen : RegExp

RegExp en JavaScript

Descripción general

Las expresiones regulares (RegExp) se utilizan en JavaScript

para la búsqueda de patrones. Pueden definirse utilizando
sintaxis literal o mediante un constructor.

Sintaxis

-
Sintaxis literal
: `/patrón/atributos`
-
Constructor
: `new RegExp(patrón, atributos)`

Propiedades de instancia

-
global
: Indica si el RegExp tiene el atributo 'g' para coincidencias
globales (booleano de solo lectura).
-
ignoreCase
: Indica si el RegExp tiene el atributo 'i' para coincidencias
insensibles a mayúsculas (booleano de solo lectura).
-
lastIndex
: Para objetos globales, esta propiedad (lectura/escritura)
muestra la posición después de la última coincidencia para la
siguiente búsqueda.
-
multiline
: Indica si el RegExp tiene el atributo 'm' para coincidencias
en múltiples líneas (booleano de solo lectura).
-
source
: Cadena de solo lectura que contiene el patrón de la
expresión regular sin barras y atributos.

Métodos

-
exec(cadena)
: Coincide una cadena contra el RegExp y devuelve un
arreglo de resultados de coincidencia o null si no se
encuentra ninguna coincidencia. El arreglo incluye el texto
coincidente y cualquier coincidencia de subexpresiones,
junto con una propiedad de índice que indica la posición de
inicio de la coincidencia.
-
test(cadena)
: Devuelve verdadero si la cadena contiene una coincidencia
para el RegExp; de lo contrario, devuelve falso.

Métodos relacionados

- [Link]()
- [Link]()
- [Link]()
Capítulo 32 Resumen : Select

JavaScript del lado del cliente 1.0: Descripción del

objeto Select

Herencia

- Hereda del objeto Elemento.

Sinopsis

- Accedido a través de:

- `[Link][i]`
- `[Link][nombre_elemento]`
- `form.nombre_elemento`

Propiedades

-
form
: El objeto Form que contiene (solo lectura).
-
length
: La cantidad de elementos en el array de opciones (solo
lectura).
-
options[]
: Array de objetos Opción; se puede manipular modificando
`[Link]` o estableciendo elementos individuales en
null.
-
selectedIndex
: Entero de lectura/escritura para el índice de la opción
seleccionada; -1 si no hay ninguna seleccionada.
Deselecciona todas si se establece en -1.
-
type
: Cadena de solo lectura que indica el tipo de selección
("select-one" para una sola opción, "select-multiple" para
múltiples).

Métodos

-
add(nuevo, viejo)
: Inserta un nuevo objeto Opción antes del viejo en el array
de opciones; agrega al final si el viejo es null.
-
blur()
: Libera el foco del teclado.
-
focus()
: Obtiene el foco del teclado.
-
remove(n)
: Elimina el enésimo elemento del array de opciones.

Manejadores de eventos

-
onblur
: Se activa cuando se pierde el foco.
-
onchange
: Se activa cuando se selecciona/deselecciona un elemento.
-
onfocus
: Se activa cuando se obtiene el foco.

Conceptos relacionados
- Consulta los objetos Form, Input y Option para más
contexto.
Capítulo 33 Resumen : Cadena

Cadena en JavaScript

Descripción general

- La manipulación de cadenas es una característica clave en

JavaScript, introducida en JavaScript 1.0, JScript 1.0 y
estandarizada en ECMA v1.
- El tipo `String` hereda del objeto base `Object`.

Constructor

- `String(s)` - Sin el operador `new`, convierte su argumento

en una cadena. Con `new`, crea un objeto String.

Propiedades

- `length` - Una propiedad de solo lectura que representa el

número de caracteres en la cadena.

Métodos
1.
Acceso a caracteres

- `charAt(n)` - Devuelve el carácter en la posición `n`.

- `charCodeAt(n)` - Devuelve la codificación Unicode del
carácter en la posición `n`.
2.
Manipulación de cadenas

- `concat(valor...)` - Concatena cadenas.

- `indexOf(subcadena, inicio)` - Devuelve la posición de la
primera ocurrencia de `subcadena` después de `inicio` o -1 si
no se encuentra.
- `lastIndexOf(subcadena, inicio)` - Devuelve la posición
de la última ocurrencia antes de `inicio` o -1 si no se
encuentra.
3.
Coincidencia de patrones

- `match(expresionRegular)` - Compara la cadena contra un

Instalar
patrón regexlay aplicación Bookey para
devuelve los resultados desbloquear
de coincidencia.
texto completo
- `replace(expresionRegular, y audio
reemplazo)` - Reemplaza el
texto que coincide con una regex por un `reemplazo`
Capítulo 34 Resumen : Estilo

Estilo DOM Nivel 2: Propiedades CSS en línea en IE

4

Sinopsis

El objeto Style en JavaScript se utiliza para manipular las

propiedades CSS en línea de un elemento. Comprende
propiedades que corresponden a los atributos CSS definidos
por la especificación CSS2. La nomenclatura de estas
propiedades imita de cerca sus contrapartes CSS, con
modificaciones para garantizar la compatibilidad con
JavaScript, como eliminar guiones y capitalizar las palabras
subsiguientes.

Propiedades Clave

- Los atributos compuestos como `font-family` se reescriben

como `fontFamily`.
- La propiedad `float` se renombra a `cssFloat` debido a
conflictos con palabras reservadas en JavaScript.
Notas Importantes

- Todas las propiedades se representan como cadenas. Para

propiedades con valores numéricos, es esencial utilizar
`parseFloat()` para convertir cadenas a números al
consultarlas y convertir números nuevamente a cadenas al
establecer propiedades (normalmente añadiendo unidades
como "px").
- No todas las propiedades son implementadas por los
navegadores actuales, por lo que es recomendable consultar
referencias CSS para significados y valores válidos.

Lista de Propiedades CSS Visuales

- background, backgroundColor, backgroundImage,

backgroundPosition, backgroundRepeat
- border (varias sub-propiedades), borderCollapse,
borderColor, borderStyle, borderWidth
- color, cursor, display, direction
- font (varias sub-propiedades), fontSize, fontWeight,
fontStyle
- height, left, right, top, width
- margin (varias sub-propiedades), padding (varias
sub-propiedades)
- overflow, position, visibility, zIndex
Estas propiedades permiten una manipulación detallada de la
presentación de un elemento en el desarrollo web. Para una
guía completa, consulta referencias CSS específicas.
Capítulo 35 Resumen : Window

Resumen del Capítulo 35: Objeto Window y

JavaScript del lado del cliente

Sinopsis

Este capítulo abarca el objeto Window en JavaScript del lado

del cliente, detallando sus propiedades, métodos, manejo de
eventos y sus implicaciones en la programación dentro de los
navegadores web.

Propiedades del Objeto Window

-
Propiedades Básicas:

- `closed`: Booleano que indica si la ventana está cerrada.

- `defaultStatus`: Mensaje de estado mostrado cuando no se
muestra ningún otro mensaje.
- `document`: Referencia al objeto Document en la ventana.
- `frames[]`: Arreglo de objetos Window que representan
cada marco dentro de la ventana.
- `location`: Objeto de ubicación que representa la URL
actual de la ventana.
- `navigator`: Referencia al objeto Navigator que
proporciona información del navegador.
-
Propiedades Específicas de Netscape 4:

- `innerHeight`, `innerWidth`: Dimensiones del área de

visualización del documento.
- `outerHeight`, `outerWidth`: Dimensiones totales de la
ventana.
- `pageXOffset`, `pageYOffset`: Posiciones de
desplazamiento.
-
Propiedades Específicas de Internet Explorer 4:

- `clientInformation`: Alias para navigator.

- `event`: Referencia al objeto de evento más reciente.

Métodos del Objeto Window

-
Métodos Comunes:
 - `alert()`: Muestra un mensaje en un cuadro de diálogo.
- `confirm()`: Muestra un diálogo de sí/no y devuelve la
elección del usuario.
- `prompt()`: Solicita la entrada del usuario con un valor
predeterminado.
- `setTimeout()` y `setInterval()`: Programan acciones
después de intervalos de tiempo especificados.
- `open()`: Abre una nueva ventana con la URL y
características especificadas.

Manejadores de Eventos

Estos se definen utilizando atributos dentro de las etiquetas

HTML, como `onload`, `onresize` y `onclick`, que
desencadenan funciones de JavaScript ante eventos
específicos.

Restricciones de Seguridad en JavaScript

Las medidas de seguridad limitan las capacidades de los

scripts del lado del cliente, como prevenir el acceso a
diferentes dominios y controlar las funcionalidades de carga
de archivos.
Conclusión

El objeto Window sirve como la base para JavaScript del

lado del cliente, permitiendo la interacción con páginas web
a través de métodos y propiedades que influyen en el
comportamiento del navegador y la presentación del
contenido.
Ejemplo
Punto clave:Entender el objeto Window es esencial
para un desarrollo efectivo de JavaScript del lado del
cliente.
Ejemplo:A medida que te adentras en JavaScript del
lado del cliente, imagina que estás creando una
aplicación web dinámica. Podrías usar el método
`alert()` para notificar a los usuarios sobre
actualizaciones importantes, instándolos a prestar
atención. Al manipular la propiedad `location`, imagina
que estás redirigiendo a los usuarios a una experiencia
más adaptada en tu sitio, mejorando su viaje. Al definir
controladores de eventos con atributos como `onclick`,
piensa en hacer un botón que realmente responda a los
clics de los usuarios, ofreciendo retroalimentación o
acciones instantáneas. Cada interacción depende de tu
comprensión del objeto Window, ya que rige todas estas
funciones esenciales, haciendo que tus scripts sean no
solo interactivos, sino también intuitivos y fáciles de
usar.
Mejores frases del JavaScript. La guía
definitiva por David Flanagan con
números de página
Ver en el sitio web de Bookey y generar imágenes de citas hermosas

Capítulo 1 | Frases de las páginas 14-17

[Link]. La guía definitiva es un lenguaje
sensible a mayúsculas.
[Link] ignora los espacios en blanco entre tokens.
[Link] instrucciones de JavaScript se terminan con puntos y
comas.
[Link] nombres de variables, funciones y etiquetas son
identificadores de JavaScript.
[Link] siguientes palabras clave son parte del lenguaje
JavaScript y tienen un significado especial para el
intérprete de JavaScript.
Capítulo 2 | Frases de las páginas 20-27
[Link] números en JavaScript se representan en
formato de punto flotante de 64 bits.
[Link] cadena de JavaScript es una secuencia de letras
 arbitrarias, dígitos y otros caracteres del conjunto de
caracteres Unicode de 16 bits.
[Link] objeto es un tipo de dato compuesto que contiene
cualquier número de propiedades.
[Link] primer elemento de un array de JavaScript es el
elemento 0.
[Link] función es un fragmento de código JavaScript que se
define una vez y puede ser ejecutado múltiples veces por
un programa.
Capítulo 3 | Frases de las páginas 28-32
[Link] expresiones de JavaScript se forman
combinando valores mediante los operadores de
JavaScript.
[Link] paréntesis se pueden utilizar en una expresión para
agrupar subexpresiones y alterar el orden predeterminado
de evaluación.
[Link] define un conjunto completo de operadores, la
mayoría de los cuales deberían ser familiares para los
programadores de C, C++ y Java.
[Link] operador de identidad, ===, es más estricto: solo evalúa
a verdadero si sus operandos son idénticos.
[Link] operadores relacionales <, <=, >, y >= comparan
cadenas basado en el orden alfabético.
Capítulo 4 | Frases de las páginas 33-40
[Link] una secuencia de instrucciones de
JavaScript está encerrada entre llaves, se
considera una única instrucción compuesta.
[Link] instrucción return hace que la función actualmente en
ejecución se detenga y regrese a su llamador.
[Link] instrucción try/catch/finally es el mecanismo de manejo
de excepciones de JavaScript.
[Link] instrucción for es un bucle fácil de usar que combina las
expresiones de inicialización e incremento con la expresión
de condición del bucle.
[Link] instrucción puede ser etiquetada con un nombre.
Capítulo 5 | Frases de las páginas 41-43
[Link] objetos en JavaScript son arreglos asociativos
que vinculan valores con propiedades nombradas.
[Link] definir una nueva clase, comienza por escribir una
función constructora.
[Link] función de JavaScript utilizada como constructora
tiene una propiedad llamada prototype.
[Link] un método llamado toString permite que las
instancias de tu clase sean convertidas a cadenas.
[Link] deseas definir métodos o propiedades estáticas (o de
clase), puedes asignarlos directamente a la función
constructora.
[Link] fragmentos de código anteriores definen una clase Point
simple que podemos usar con código como este
Capítulo 6 | Frases de las páginas 44-48
[Link]. La guía definitiva soporta expresiones
regulares para la coincidencia de patrones con la
misma sintaxis que el lenguaje de programación
Perl.
[Link] expresión regular se especifica literalmente en un
programa de JavaScript como una secuencia de caracteres
entre caracteres de barra diagonal (/).
[Link] JavaScript 1.5, cualquiera de los caracteres de
repetición puede ser seguido por un signo de interrogación
para hacerlos no codiciosos, lo que significa que coinciden
con la menor cantidad de repeticiones posible mientras aún
 permiten que el patrón completo coincida.
[Link] expresiones regulares utilizan paréntesis para agrupar
subexpresiones, al igual que lo hacen las expresiones
matemáticas.
[Link] ancla en una expresión regular coincide con una
posición en una cadena sin coincidir con ninguno de los
caracteres de una cadena.
Capítulo 7 | Frases de las páginas 49-90
[Link]. La guía definitiva es un lenguaje de
secuencias de comandos ligero y orientado a
objetos que se puede incrustar en páginas HTML.
[Link] código JavaScript también puede aparecer como el valor
de un atributo de manejador de eventos de una etiqueta
HTML.
[Link] embargo, al hacer esto, debes escribir el contenido
completo del nuevo documento y recordar llamar al método
[Link]() cuando hayas terminado.
[Link] objeto Window representa una ventana del navegador
web.
[Link] trata cada marco como un objeto Window
separado, y los scripts en diferentes marcos se ejecutan
independientemente unos de otros.
[Link], o HTML dinámico, es el resultado de combinar
HTML, CSS y JavaScript: utiliza scripts para modificar
dinámicamente el estilo, que puede incluir la posición y
visibilidad de los elementos del documento.
[Link] razones de seguridad, las implementaciones de
JavaScript del lado del cliente suelen imponer restricciones
a las tareas que los scripts pueden realizar.
Capítulo 8 | Frases de las páginas 93-96
[Link] JavaScript 1.1 y versiones posteriores, puedes
usar el atributo src de la etiqueta <script> para
especificar la URL de un script externo que se
cargará y ejecutará.
[Link] permite escribir scripts en lenguajes distintos a
JavaScript, y algunos navegadores, como Internet Explorer,
soportan lenguajes como VBScript.
[Link] JavaScript, establece este atributo al tipo MIME
"text/javascript": <script src="[Link]"
language="JavaScript1.5" type="text/javascript"></script>
[Link] nombres de los atributos de los manejadores de
eventos siempre comienzan con "on". El código
especificado por uno de estos atributos se ejecuta cuando
ocurre el evento nombrado.
Capítulo 9 | Frases de las páginas 97-105
[Link] objeto Window representa una ventana del
navegador web.
[Link] propiedad más importante del objeto Window es
document.
[Link]( ) te permite mostrar un mensaje al usuario, confirm( )
te permite hacer una pregunta de sí o no, y prompt( ) te
permite pedir al usuario que introduzca una línea de texto.
[Link]én puedes usar temporizadores para especificar
código que se ejecute cuando haya transcurrido un número
específico de milisegundos.
[Link] propiedad history del objeto Window se refiere al objeto
History de la ventana del navegador.
6.Más importantes que estos métodos que manipulan una
ventana existente son el método open( ) que crea una nueva
ventana del navegador y el método close( ) que cierra una
ventana creada por un script.
[Link] trata cada marco como un objeto Window
independiente, y los scripts en diferentes marcos se
ejecutan de forma independiente entre sí.
Capítulo 10 | Frases de las páginas 106-108
[Link] objeto Document es, sin duda, más importante
que el objeto Window: mientras que Window
representa la ventana del navegador, el objeto
Document representa el documento HTML que se
muestra en esa ventana.
[Link] forma en que se accede y se modifica el contenido del
documento se llama modelo de objeto del documento, o
DOM.
[Link] DOM de W3C no es completamente compatible con el
DOM de IE 4, pero sí estandariza muchas de las
características heredadas del DOM original.
Capítulo 11 | Frases de las páginas 109-117
[Link] DOM heredado no proporciona ninguna
manera de referirse al contenido del documento
más allá de formularios, elementos de formulario,
imágenes, applets, enlaces y anclas.
[Link] método write( ) solo se puede usar desde una etiqueta
<script> mientras un documento aún se está cargando.
[Link] el controlador onsubmit devuelve false, el formulario no
se envía.
[Link] cambiar la imagen que se muestra, simplemente
establece esta propiedad a una nueva URL.
[Link] cookie con el nombre y valor especificados para este
documento.
Capítulo 12 | Frases de las páginas 118-124
[Link] W3C DOM estandariza la mayoría de las
características del DOM heredado, pero también
añade importantes novedades.
[Link] W3C DOM representa cada documento como un árbol.
[Link] forma sencilla de manipular documentos HTML con el
W3C DOM es simplemente establecer las propiedades que
corresponden a los atributos HTML.
[Link] W3C DOM te permite alterar la estructura del árbol del
documento mismo.
Capítulo 13 | Frases de las páginas 125-129
[Link] DOM de IE 4 no soporta el método
getElementById().
[Link] recorrer un árbol de documentos de IE 4... en lugar
de childNodes[], IE 4 utiliza children[], y en lugar de
parentNode, IE 4 utiliza parentElement.
[Link] DOM de IE 4 no tiene métodos para crear, insertar,
eliminar o reemplazar explícitamente nodos del árbol del
documento.
[Link] embargo, sí admite la muy importante propiedad
innerHTML, que te permite reemplazar el contenido de
cualquier elemento del documento con una cadena
arbitraria de HTML.
Capítulo 14 | Frases de las páginas 130-134
[Link], o HTML dinámico, es el resultado de
combinar HTML, CSS y JavaScript: utiliza scripts
para modificar dinámicamente el estilo...
[Link] propiedades de posicionamiento y visibilidad son
especialmente relevantes para la programación dinámica.
[Link] en cuenta que los valores de todas las propiedades
de estilo son siempre cadenas, incluso para propiedades
como left y width que representan números.
[Link] vez que se llama, la función nextFrame( ) mueve un
elemento 10 píxeles a la derecha...
[Link]és de 20 invocaciones, la función utiliza la propiedad
de visibilidad para ocultar el elemento y deja de llamarse a
sí misma.
Capítulo 15 | Frases de las páginas 135-141
1.Típicamente, si un manejador de eventos retorna
falso, la acción por defecto (como seguir un
hipervínculo o enviar un formulario) no se realiza.
[Link] mismo es cierto para los manejadores de eventos. Si tu
documento HTML incluye una única etiqueta <form> con
un atributo onsubmit, ese manejador de eventos está
disponible como: [Link][0].onsubmit
[Link] manejadores de eventos son activados solo por el
elemento del documento en el que ocurrió el evento.
[Link] los modelos avanzados, los eventos pueden propagarse
 hacia arriba y/o hacia abajo en la jerarquía de elementos y
ser gestionados por uno o más manejadores de eventos.
[Link] permite a aplicaciones avanzadas registrar más de un
manejador para el mismo tipo de evento.
Capítulo 16 | Frases de las páginas 142-145
1.'Los scripts solo pueden leer propiedades de
ventanas y documentos que se cargaron desde el
mismo servidor web.'
2.'Los scripts no pueden establecer el valor de la propiedad
del elemento de formulario FileUpload.'
3.'Un script solo puede cerrar ventanas del navegador que él
mismo creó, a menos que obtenga la confirmación del
usuario.'
4.'A medida que el uso de JavaScript ha crecido, los
anunciantes y personajes poco recomendables han
comenzado a hacer cosas molestas con él.'
5.'Navegadores más recientes, como Mozilla 1.0, permiten
restricciones de seguridad configurables por el usuario que
pueden evitar que los scripts abran nuevas ventanas.'
Capítulo 17 | Frases de las páginas 156-159
[Link] ejemplo: var a = [1, true, 'abc'];
[Link] el valor de esta propiedad trunca o extiende el
arreglo.
[Link] la cadena que resulta de convertir cada elemento
de un arreglo a una cadena y luego concatenar las cadenas
juntas, con la cadena separadora entre elementos.
[Link] y devuelve el último elemento del arreglo,
disminuyendo la longitud del arreglo.
[Link] los elementos de un arreglo y devuelve una
referencia al arreglo.
[Link] el argumento o los argumentos como nuevos
elementos al principio de un arreglo, desplazando los
elementos existentes del arreglo hacia arriba para hacer
espacio.
Capítulo 18 | Frases de las páginas 171-177
[Link] argumentos, el constructor Date( ) crea un
objeto Date configurado con la fecha y hora
actuales.
[Link] se llama como una función sin el operador new,
Date( ) ignora cualquier argumento que se le pase y
devuelve una representación en cadena de la fecha y hora
actuales.
[Link] el número de milisegundos entre la medianoche
(UTC) del 1 de enero de 1970 y la fecha y hora
representadas por el objeto Date.
[Link] una cadena que representa la parte de la fecha de
la fecha, expresada en la zona horaria local.
[Link] la representación interna de la fecha en
milisegundos. Devuelve el argumento de milisegundos.
Capítulo 19 | Frases de las páginas 178-186
[Link] objeto Document representa un documento
HTML y es uno de los objetos más importantes en
JavaScript del lado del cliente.
[Link] Comunes Todas las implementaciones del
objeto Document son compatibles con las siguientes
propiedades.
[Link] API depende del control específico.
[Link] propiedad puede ser particularmente útil para los
programadores que están cambiando a JavaScript después
de acostumbrarse a lenguajes insensibles a las mayúsculas.
[Link] Especifica el estado de carga de un documento.
Capítulo 20 | Frases de las páginas 189-197
1.... todos los elementos de un documento HTML
tienen propiedades que corresponden a sus
atributos HTML...
[Link], los métodos y propiedades definidos
por el DOM de IE 4 no son los mismos que los métodos y
propiedades definidos por el estándar DOM de W3C.
[Link] esta propiedad reemplaza el contenido del
elemento.
[Link] propiedades de este objeto cambia el estilo de
presentación del elemento.
[Link] HTML contenido dentro del elemento, sin incluir las
etiquetas de apertura y cierre del propio elemento.
Capítulo 21 | Frases de las páginas 200-208
[Link] objeto Event proporciona tanto detalles sobre
un evento como control sobre la propagación de
un evento.
[Link] nivel 2 del DOM define un objeto Event estándar, pero
Internet Explorer 4, 5 y 6 utilizan un objeto propietario en
su lugar.
[Link] objeto Event se pasa como argumento al controlador de
eventos.
[Link] fase actual de la propagación del evento está
representada por la propiedad eventPhase.
[Link] al navegador web que no realice la acción
predeterminada asociada a este evento.
[Link] el evento de propagarse aún más a través de las
fases de captura, objetivo o burbujeo de la propagación del
evento.
Capítulo 22 | Frases de las páginas 215-218
[Link] objeto global no tiene nombre, pero puedes
referirte a él en el código de nivel superior (es
decir, fuera de los métodos) con la palabra clave
this.
[Link]: Un valor numérico que representa la infinitud
positiva.
[Link]: El valor no es un número.
[Link](código) Evalúa una cadena de código JavaScript y
devuelve el resultado.
[Link](n): Devuelve verdadero si n es (o puede ser
convertido a) un número finito.
[Link](s, radix): Convierte la cadena s (o un prefijo de s)
en un entero y devuelve ese entero.
Capítulo 23 | Frases de las páginas 224-228
[Link] objeto Input define propiedades para cada uno
de los atributos de la etiqueta HTML <input>.
[Link] Un booleano de lectura/escritura que especifica si
un elemento de entrada de tipo 'checkbox' o 'radio' está
 marcado (true) o no (false).
[Link] Una cadena que especifica el texto que
aparece en un elemento de entrada de tipo 'text' o
'password' cuando se crea por primera vez o cuando se
restablece a su estado inicial.
[Link] El valor de texto que se envía cuando se envía el
formulario.
[Link]( ) Simula un clic del ratón en el elemento del
formulario y no devuelve nada.
[Link] Para elementos de entrada de texto de tipo 'text',
'password' y 'file', este controlador de evento se invoca
cuando el usuario cambia el texto mostrado y luego
transfiere el enfoque del teclado fuera del elemento.
[Link] de Eventos onblur Invocado cuando el
elemento pierde el enfoque del teclado.
Capítulo 24 | Frases de las páginas 229-233
[Link] objeto Layer solo es compatible con Netscape 4
y fue descontinuado en Netscape 6.
[Link] elemento HTML con un atributo de posición
 CSS de absoluto se representa por un objeto Layer en
JavaScript.
[Link] dos capas se superponen, la que tiene un zIndex
más alto aparece en la parte superior y oculta la que tiene
un zIndex más bajo.
[Link] esta propiedad también establece el valor de
[Link].
[Link] una capa sobre otra y no devuelve nada.
Capítulo 25 | Frases de las páginas 234-236
[Link] propiedad de cadena de lectura/escritura que
especifica la parte del ancla de la URL del enlace,
incluyendo el signo de almohadilla (#) al principio.
[Link] ejemplo: "[Link]".
[Link] nombres especiales "_blank", "_top", "_parent" y
"_self" están permitidos.
[Link] JavaScript. La guía definitiva, este handler de eventos
puede evitar que se siga el enlace al retornar falso.
[Link] propiedad de estado de la ventana actual puede
establecerse aquí.
Capítulo 26 | Frases de las páginas 239-242
[Link] objeto Math es un lugar para agrupar
constantes y funciones matemáticas.
[Link](x) Devuelve el valor absoluto de x.
[Link](args...) Devuelve el mayor de los argumentos.
[Link]() Devuelve un número pseudoaleatorio entre
0.0 y 1.0.
[Link](x) Devuelve la raíz cuadrada de x.
Capítulo 27 | Frases de las páginas 243-246
[Link] Una cadena de solo lectura que
especifica un apodo para el navegador. En todos
los navegadores de Netscape, este es 'Mozilla'.
[Link] Un booleano de solo lectura que es
verdadero si el navegador tiene cookies habilitadas, y falso
si están deshabilitadas.
[Link] Una cadena de solo lectura que especifica el
valor que el navegador utiliza para el encabezado de agente
de usuario en las solicitudes HTTP.
Capítulo 28 | Frases de las páginas 247-252
[Link] los nodos en un documento HTML son
instancias de una de las subclases de Node
mencionadas anteriormente.
[Link] objeto Node tiene una propiedad nodeType que
especifica de cuál de las subclases es una instancia.
[Link](newChild) Agrega el nodo newChild al árbol
del documento al anexarlo al array childNodes[] de este
nodo.
[Link](oldChild) Elimina el nodo oldChild del árbol
del documento.
[Link]() Normaliza todos los nodos de texto
descendientes de este nodo eliminando los nodos de texto
vacíos y fusionando nodos de texto adyacentes.
Capítulo 29 | Frases de las páginas 253-255
[Link].MAX_VALUE El número más grande que
se puede representar. Aproximadamente
1.79E+308.
[Link].MIN_VALUE El número más pequeño que se
 puede representar. Aproximadamente 5E-324.
[Link] Valor no numérico. Igual que el NaN global.
[Link].NEGATIVE_INFINITY Valor infinito negativo.
[Link].POSITIVE_INFINITY Valor infinito. Igual que el
infinito global.
Capítulo 30 | Frases de las páginas 256-258
[Link] constructor crea un objeto vacío al que
puedes agregar propiedades arbitrarias.
[Link] verdadero si el objeto tiene una propiedad no
heredada con el nombre especificado.
[Link] verdadero si este objeto es el prototipo de o.
[Link] verdadero si este objeto tiene una propiedad
enumerable no heredada con el nombre especificado.
[Link] una representación de cadena localizada del
objeto.
[Link] implementación de este método proporcionado por la
clase Object es bastante genérica y no proporciona mucha
información útil.
Capítulo 31 | Frases de las páginas 261-263
1./pattern/attributes
[Link] RegExp(pattern, attributes)
[Link] Un booleano de solo lectura que especifica si el
RegExp tiene el atributo g y, por lo tanto, realiza
coincidencias globales.
[Link] Un booleano de solo lectura que especifica si el
RegExp tiene el atributo i y, por lo tanto, realiza
coincidencias sin distinción de mayúsculas y minúsculas.
[Link] Para objetos RegExp globales, esta propiedad de
lectura/escritura especifica la posición del carácter
inmediatamente después de la última coincidencia; este es
el primer carácter examinado para la siguiente
coincidencia.
[Link]( string) Coincide la cadena con este RegExp y
devuelve un array que contiene los resultados de la
coincidencia, o null si no se encontró ninguna coincidencia.
Capítulo 32 | Frases de las páginas 266-269
[Link] objeto Select define propiedades para cada uno
 de los atributos de la etiqueta HTML <select>,
como deshabilitado, múltiple, nombre y tamaño.
[Link] eliminar opciones individuales estableciendo un
elemento del array en null; esto desplaza los elementos por
encima hacia abajo, acortando el array.
[Link] esta propiedad hace que todas las demás
opciones queden deseleccionadas. Establecerla en -1
provoca que todas las opciones sean deseleccionadas.
[Link] el objeto Select solo permite una única selección (es
decir, si el atributo múltiple no aparece en la definición
HTML del objeto), esta propiedad es 'select-one'.
Capítulo 33 | Frases de las páginas 270-274
[Link] el operador new, la función String() convierte
su argumento en una cadena.
[Link] una nueva cadena que resulta de convertir cada
uno de los argumentos en una cadena y concatenar las
cadenas resultantes.
[Link] la posición de la primera aparición del substring
dentro de esta cadena que aparece en o después de la
 posición inicial o -1 si no se encuentra tal ocurrencia.
[Link] una nueva cadena, con el texto que coincide con
regexp reemplazado por el reemplazo.
[Link] un array de cadenas, creado al dividir la cadena
en substrings en los límites especificados por el
delimitador.
[Link] una copia de la cadena, con todas las letras
mayúsculas convertidas a su equivalente en minúsculas.
Capítulo 34 | Frases de las páginas 275-278
[Link] objeto Style define un gran número de
propiedades: una propiedad para cada atributo
CSS definido por la especificación CSS2.
[Link] atributos de varias palabras que contienen guiones,
como font-family, se escriben sin guiones en JavaScript, y
cada palabra después de la primera se escribe con
mayúscula: fontFamily.
[Link] en cuenta que los navegadores actuales no
implementan todas estas propiedades.
[Link] las propiedades son cadenas, y se requiere cuidado al
trabajar con propiedades que tienen valores numéricos.
Capítulo 35 | Frases de las páginas 285-366
[Link] objeto Window es el objeto global para
JavaScript del lado del cliente.
[Link] es un lenguaje de scripting ligero y basado en
objetos que puede ser embebido en páginas HTML.
[Link] expresiones en JavaScript se forman combinando
valores usando operadores de JavaScript.
[Link] soporta tres tipos de datos primitivos: números,
booleanos y cadenas; y dos tipos de datos compuestos:
objetos y arreglos.
[Link] objetos se crean con el operador new.
[Link] instrucción for/in itera a través de las propiedades de un
objeto especificado.
[Link] es un lenguaje que distingue entre mayúsculas y
minúsculas.
[Link] no tiene un alcance de bloque.
[Link] palabra clave this se refiere al objeto para el cual la
función es una propiedad.
[Link] gestión de errores en JavaScript se realiza mediante la
instrucción try/catch/finally.
JavaScript. La guía definitiva Preguntas
Ver en el sitio web de Bookey

Capítulo 1 | Sección 1.1. Sintaxis| Preguntas y

respuestas
[Link]
¿Cuál es la importancia de la sensibilidad a mayúsculas y
minúsculas en JavaScript?
Respuesta:Que JavaScript sea sensible a mayúsculas
significa que el lenguaje trata los identificadores con
diferentes capitalizaciones como entidades distintas.
Por ejemplo, 'variable', 'Variable' y 'VARIABLE' se
considerarían entidades diferentes. Esto es
importante para prevenir conflictos de nombres y
mejorar la claridad del código, ya que fomenta a los
desarrolladores a adherirse de manera consistente a
sus convenciones de nomenclatura.

[Link]
¿Cómo afecta el espacio en blanco al código de
JavaScript?
Respuesta:El espacio en blanco en JavaScript es ignorado
entre los tokens, lo que da a los programadores la libertad de
formatear su código de manera legible y organizada. Esta
flexibilidad permite una mejor estructuración del código, lo
cual ayuda no solo en la comprensión personal sino también
en la colaboración con otros, ya que el código se vuelve más
fácil de leer y mantener.

[Link]
¿Por qué son importantes los puntos y comas, y cuándo
pueden omitirse en JavaScript?
Respuesta:Los puntos y comas se utilizan para terminar
declaraciones en JavaScript, lo que ayuda al intérprete a
entender dónde termina una declaración y comienza otra.
Pueden omitirse cuando una declaración termina con un salto
de línea; sin embargo, esto podría provocar errores si la
primera línea puede permanecer sola como una declaración
válida. Esta característica enfatiza la necesidad de un
formateo cuidadoso para prevenir consecuencias no deseadas
en la ejecución del código.

[Link]
¿Cuál es la función de los comentarios en JavaScript?
Respuesta:Los comentarios en JavaScript son cruciales para
la documentación y para mejorar la legibilidad del código.
Permiten a los desarrolladores dejar notas, explicaciones o
recordatorios dentro del código, lo cual puede ayudar a otros
programadores (o a ellos mismos en un momento posterior) a
entender la lógica y el propósito detrás de secciones
específicas del código. Por ejemplo, un comentario podría
explicar la razón de una elección de algoritmo en particular o
anotar una característica planificada para futuras
actualizaciones.

[Link]
¿Qué deben tener en cuenta los desarrolladores al
nombrar identificadores en JavaScript?
Respuesta:Los desarrolladores deben seguir reglas
específicas al nombrar identificadores en JavaScript. Los
identificadores pueden incluir letras, dígitos, guiones bajos y
signos de dólar, pero no deben comenzar con un dígito.
Además, deben evitar palabras clave reservadas y no utilizar
los mismos nombres que propiedades y métodos globales
para prevenir conflictos y asegurar la claridad del código.

[Link]
¿Cuáles son las palabras clave reservadas en JavaScript y
por qué deben evitarse como identificadores?
Respuesta:Las palabras clave reservadas en JavaScript tienen
significados y funciones predefinidas dentro del lenguaje,
como 'if', 'for' y 'return'. No pueden ser utilizadas como
identificadores porque pueden llevar a complicaciones en el
código y confusión respecto a la estructura del lenguaje. Es
esencial respetar estas palabras reservadas para mantener la
lógica y el flujo de los scripts.

[Link]
¿Cómo puede un estilo de programación afectar la
calidad del código en JavaScript?
Respuesta:Un estilo de programación consistente, que
incluya un uso adecuado de mayúsculas para palabras clave y
nombres de funciones, un uso apropiado del espacio en
blanco y comentarios reflexivos, impacta enormemente la
mantenibilidad y legibilidad del código en JavaScript. Un
código bien estilizado es más fácil de navegar, entender y
depurar, especialmente en entornos de equipo.
Capítulo 2 | Sección 1.3. Tipos de Datos| Preguntas y
respuestas
[Link]
¿Cuáles son los principales tipos de datos primitivos que
soporta JavaScript?
Respuesta:JavaScript soporta tres tipos de datos
primitivos: números, booleanos y cadenas.

[Link]
¿Cómo se representan los números en JavaScript?
Respuesta:Los números se representan en JavaScript
utilizando el formato de punto flotante de 64 bits, y no hay
distinción entre enteros y números de punto flotante.

[Link]
¿Qué valores especiales puede devolver una operación
numérica cuando ocurre un error?
Respuesta:Cuando una operación numérica se desborda,
devuelve infinito positivo o negativo; cuando se
subdesborda, devuelve cero; y si una operación resulta en un
error (como calcular la raíz cuadrada de un número
negativo), devuelve NaN (no es un número).

[Link]
¿Puedes dar un ejemplo de cómo definir una cadena en
JavaScript?
Respuesta:Una cadena se puede definir utilizando comillas
simples o dobles, por ejemplo: 'Hola Mundo' o "¡JavaScript
es divertido!".

[Link]
¿Qué significa que las cadenas de JavaScript son
inmutables?
Respuesta:Significa que una vez que se crea una cadena, su
contenido no puede ser cambiado. Cualquier operación que
parezca modificar la cadena en realidad devolverá una nueva
cadena modificada.

[Link]
¿Cómo se crea un nuevo objeto en JavaScript?
Respuesta:Puedes crear un nuevo objeto utilizando el
operador new, así: var o = new Object(); o utilizando la
sintaxis de literal de objeto: var o = {x: 1, y: 2};.

[Link]
¿Qué es un array en JavaScript?
Respuesta:Un array es un tipo de objeto especializado que
contiene valores numerados (elementos) y puede almacenar
cualquier tipo de valor, incluyendo otros objetos y arrays.

[Link]
¿Cuál es el propósito de las funciones en JavaScript?
Respuesta:Las funciones son bloques de código reutilizables
que pueden definirse una vez y ejecutarse múltiples veces, lo
que ayuda a organizar y encapsular la lógica del código.

[Link]
¿Puedes explicar la diferencia entre null y undefined en
JavaScript?
Respuesta:Null es un valor especial que indica 'sin valor'
explícitamente, mientras que undefined es un tipo de variable
que ha sido declarada pero aún no se le ha asignado un valor.

[Link]
¿Cuál es la importancia de la palabra clave 'this' dentro
de un método en JavaScript?
Respuesta:En el contexto de un método, la palabra clave 'this'
se refiere al objeto para el cual el método es una propiedad,
lo que permite acceder a las propiedades de ese objeto.
Capítulo 3 | Sección 1.4. Expresiones y Operadores|
Preguntas y respuestas
[Link]
¿Qué son las expresiones de JavaScript y cómo se
construyen?
Respuesta:Las expresiones de JavaScript se crean al
combinar valores mediante operadores, que pueden
incluir literales, variables, propiedades de objetos,
elementos de arrays y llamadas a funciones. Se
pueden utilizar paréntesis para agrupar
subexpresiones y ajustar el orden de evaluación por
defecto.

[Link]
¿Cuál es el propósito de los operadores en JavaScript y
puedes dar ejemplos de sus categorías?
Respuesta:Los operadores en JavaScript realizan una
variedad de operaciones como aritmética, comparación y
manipulación de objetos. Ejemplos de categorías incluyen
operadores aritméticos (como +, -, *, /), operadores de
comparación (como ==, ===, <, >) y operadores lógicos
(como &&, ||).

[Link]
¿En qué se diferencia el operador de igualdad '==' del
operador de identidad '===' en JavaScript?
Respuesta:El operador de igualdad '==' realiza una
comparación flexible, permitiendo la conversión de tipos, así
que 3 == '3' devuelve verdadero. Por otro lado, el operador de
identidad '===' verifica tanto el valor como el tipo, lo que
significa que 3 === '3' devuelve falso porque son de
diferentes tipos.

[Link]
¿Por qué es importante el operador 'typeof' en JavaScript
y qué devuelve?
Respuesta:El operador 'typeof' es crucial para determinar el
tipo de datos de un operando dado, devolviendo cadenas
como 'number', 'string', 'boolean', 'object', entre otros. Esto
ayuda en la verificación adecuada de tipos y en el manejo de
errores en los scripts.

[Link]
¿Qué hace el operador 'delete' en JavaScript?
Respuesta:El operador 'delete' elimina una propiedad de un
objeto. A diferencia de establecer la propiedad en null,
realmente elimina la propiedad misma del objeto y devolverá
falso si la propiedad no era configurable o no se pudo
eliminar.

[Link]
¿Cómo funcionan los operadores relacionales con cadenas
en JavaScript?
Respuesta:Los operadores relacionales como <, <=, > y >=
comparan cadenas en función de su orden alfabético, lo que
significa que 'banana' < 'apple' se evaluaría como falso, ya
que 'b' viene después de 'a' en la secuencia alfabética.

[Link]
¿Puedes explicar cómo funcionan los operadores de
asignación en JavaScript?
Respuesta:Los operadores de asignación en JavaScript
asignan valores a variables y también pueden realizar
operaciones. Por ejemplo, 'x += 2' suma 2 a x, mientras que
'y *= 3' multiplicaría y por 3. Son una forma abreviada de
realizar una operación seguida de una asignación.

[Link]
¿Cuál es un ejemplo de usar paréntesis en una expresión
de JavaScript?
Respuesta:Considera la expresión (1 + 2) * 3. Aquí, se
utilizan paréntesis para asegurar que la suma se realice
primero, resultando en 3 * 3, que es igual a 9. Sin los
paréntesis, las operaciones seguirían su precedencia por
defecto, llevando a un resultado diferente.

[Link]
¿Cómo funciona el operador 'instanceof' en JavaScript?
Respuesta:El operador 'instanceof' verifica si un objeto fue
creado a partir de una función constructora especificada. Por
ejemplo, si obj fue creado por el constructor Date, entonces
obj instanceof Date se evalúa como verdadero. Esto es útil
para comprobar tipos de objetos.
Capítulo 4 | Sección 1.5. Sentencias| Preguntas y
respuestas
[Link]
¿De qué se compone un programa de JavaScript?
Respuesta:Un programa de JavaScript es una
secuencia de declaraciones de JavaScript.

[Link]
¿Cómo funciona una expresión como declaración en
JavaScript?
Respuesta:Cada expresión en JavaScript puede funcionar
como una declaración independiente, como asignaciones o
llamadas a métodos, por ejemplo, 's = "hello world";' o 'x =
[Link](4);'.

[Link]
¿Qué es una declaración compuesta y cuándo se utiliza?
Respuesta:Una declaración compuesta consiste en varias
declaraciones encerradas en llaves. Es útil cuando un bucle o
una condición necesita ejecutar más de una declaración.

[Link]
¿Cuál es el propósito de la declaración vacía en
JavaScript?
Respuesta:La declaración vacía, representada por un sólo
punto y coma, no hace nada, pero se puede usar para definir
cuerpos vacíos de bucle.

[Link]
¿Qué son las declaraciones etiquetadas y cómo se
utilizan?
Respuesta:Las declaraciones etiquetadas te permiten
etiquetar cualquier declaración, habilitando el uso de 'break' o
'continue' para controlar el flujo en bucles anidados.

[Link]
¿Puedes explicar la diferencia entre las declaraciones
'break' y 'continue'?
Respuesta:La declaración 'break' sale del bucle más interno,
mientras que 'continue' salta la iteración actual y procede a la
siguiente.

[Link]
¿Cuál es la importancia del bucle 'do/while'?
Respuesta:El bucle 'do/while' garantiza que el cuerpo se
ejecute al menos una vez, ya que la condición se verifica
después del cuerpo del bucle.

[Link]
¿Cómo funciona un bucle 'for' en JavaScript?
Respuesta:Un bucle 'for' combina inicialización, condición
de prueba y actualización en una sola línea, ejecutando la
declaración repetidamente mientras la condición de prueba
sea verdadera.

[Link]
¿Qué hace la declaración 'for/in'?
Respuesta:El bucle 'for/in' itera sobre las propiedades de un
objeto, asignando el nombre de cada propiedad a una variable
especificada.

[Link]
¿Cuál es el papel de la declaración 'function'?
Respuesta:La declaración 'function' define una función
nombrada con parámetros específicos y un cuerpo de código
ejecutable.

[Link]
Describe la funcionalidad de la declaración 'if/else'.
Respuesta:La declaración 'if' ejecuta un bloque de código si
la condición es verdadera; de lo contrario, puede ejecutar un
bloque alternativo de código usando 'else'.

[Link]
¿En qué se diferencia la declaración 'switch' de las
condicionales estándar?
Respuesta:La declaración 'switch' evalúa una expresión y
salta al caso que coincida con la expresión, facilitando
ramificaciones múltiples.

[Link]
¿Cuál es el propósito del manejo de excepciones en
JavaScript?
Respuesta:La estructura 'try/catch/finally' te permite manejar
errores de forma elegante ejecutando código cuando ocurren
excepciones y asegurando que se realicen acciones de
limpieza después.

[Link]
¿Cuál es la importancia de la declaración 'var'?
Respuesta:La declaración 'var' se utiliza para declarar
variables en JavaScript, lo cual es particularmente importante
para declarar variables locales dentro de funciones.
[Link]
¿Por qué se desaconseja la declaración 'with'?
Respuesta:La declaración 'with' puede provocar efectos
secundarios complejos y poco intuitivos, haciendo que el
código sea menos legible y predecible.
Capítulo 5 | Sección 1.6. JavaScript orientado a
objetos| Preguntas y respuestas
[Link]
¿Cuál es el propósito de una función constructora en
JavaScript?
Respuesta:Una función constructora se utiliza para
crear nuevos objetos e inicializar sus propiedades.
Se invoca con el operador 'new' y utiliza 'this' para
hacer referencia al nuevo objeto que se está creando.

[Link]
¿Cómo funciona la herencia en los objetos de JavaScript?
Respuesta:JavaScript utiliza un mecanismo de herencia
simple donde los objetos heredan propiedades y métodos de
un objeto prototipo asociado con su constructor. Cualquier
propiedad o método definido en el prototipo es accesible para
todas las instancias del objeto.

[Link]
¿Puedes explicar la importancia de la propiedad
prototype en los constructores?
Respuesta:La propiedad prototype permite la definición de
métodos que son compartidos entre todas las instancias de
una clase, reduciendo el uso de memoria y haciendo el
código más eficiente. Por ejemplo, al definir 'distanceTo' en
[Link], todas las instancias de Point pueden utilizar
este método sin que cada una tenga su propia copia.

[Link]
¿Qué es un método estático en JavaScript y cómo se
define?
Respuesta:Un método estático se define directamente en una
función constructora, en lugar de en su prototipo. Esto
significa que está asociado con la clase misma en lugar de
cualquier instancia de esa clase. Por ejemplo, '[Link]'
es una propiedad estática definida en el constructor de Point.

[Link]
¿Cómo puedes explicar el valor de retorno del método
toString en la clase Point?
Respuesta:El método toString está definido para convertir un
objeto Point en un formato de cadena de texto legible.
Retorna una representación en cadena de las coordenadas del
objeto, facilitando su inclusión en mensajes o registros, como
'(3,4)' para un Point con x=3 y y=4.

[Link]
Da un ejemplo de cómo crear un nuevo objeto Point y
utilizar sus métodos.
Respuesta:Puedes crear un nuevo objeto Point con 'var p =
new Point(3, 4);'. Luego, puedes calcular la distancia desde
este punto hasta el origen con 'var d =
[Link]([Link]);'. Esto te permite utilizar
dinámicamente los métodos del objeto en escenarios en
tiempo real.

[Link]
¿Por qué es beneficiosa la programación orientada a
objetos en JavaScript?
Respuesta:La programación orientada a objetos (OOP) en
JavaScript permite una mejor organización del código,
promueve la reutilización a través de la herencia y modela las
entidades del mundo real de manera más efectiva. Esto
conduce a un desarrollo de software más manejable y
escalable.
Capítulo 6 | Sección 1.7. Expresiones Regulares|
Preguntas y respuestas
[Link]
¿Qué son las expresiones regulares y cómo se utilizan en
JavaScript?
Respuesta:Las expresiones regulares son secuencias
de caracteres que definen patrones de búsqueda,
utilizadas principalmente para la coincidencia de
cadenas en JavaScript. Utilizan la misma sintaxis
que Perl, lo que permite a los desarrolladores
realizar operaciones complejas sobre cadenas de
manera eficiente. En JavaScript, se pueden escribir
usando la notación literal (encerradas entre barras)
o con el constructor RegExp.

[Link]
¿Puedes explicar qué son las clases de caracteres en el
contexto de las expresiones regulares?
Respuesta:Las clases de caracteres en las expresiones
regulares te permiten definir un conjunto de caracteres para
coincidir. Por ejemplo, [abc] coincide con cualquier carácter
'a', 'b' o 'c'. También puedes negar una clase con [^abc], que
coincide con cualquier carácter que no sea 'a', 'b' o 'c'. Esta
característica mejora considerablemente la flexibilidad de la
coincidencia de patrones.

[Link]
¿Cuál es la importancia de la repetición en las
expresiones regulares?
Respuesta:La repetición te permite definir cuántas veces debe
aparecer un patrón en el texto. Por ejemplo, el carácter '*'
indica que el elemento anterior puede aparecer cero o más
veces, mientras que '+' indica una o más veces. Esto permite
capacidades de coincidencia poderosas, como validar la
entrada del usuario o analizar datos estructurados.

[Link]
¿Qué significa el agrupamiento en las expresiones
regulares y por qué es importante?
Respuesta:El agrupamiento en las expresiones regulares se
realiza utilizando paréntesis para combinar múltiples
elementos en una sola unidad. Esto es importante porque
permite aplicar cuantificadores a frases enteras en lugar de
caracteres individuales. Por ejemplo, (abc)+ coincidiría con
'abc', 'abcabc', etc., tratando todo el grupo como una sola
entidad.

[Link]
¿Cómo afectan los anclajes a la coincidencia de patrones
en las expresiones regulares?
Respuesta:Los anclajes restringen la coincidencia de patrones
a una ubicación específica dentro de una cadena. Por
ejemplo, '^' significa el inicio y '$' el final, por lo que /^Hola/
solo coincidiría con 'Hola' si aparece al principio de una
cadena. Esto es crucial para garantizar que los patrones
coincidan solo en ubicaciones prescritas, mejorando la
precisión en las operaciones de búsqueda.
[Link]
¿Qué son las afirmaciones de anticipación y cómo pueden
ser útiles en las expresiones regulares?
Respuesta:Las afirmaciones de anticipación son
características avanzadas que te permiten coincidir con un
patrón solo si se cumplen ciertas condiciones después del
patrón, sin incluir esas condiciones en la coincidencia en sí.
Por ejemplo, '(?=abc)' coincidiría con cualquier cosa si 'abc'
lo sigue, pero no consumiría 'abc' como parte de la
coincidencia. Esto es útil en escenarios donde la presencia o
ausencia de ciertos patrones afecta lo que intentas coincidir.

[Link]
¿Qué desafíos pueden enfrentar los desarrolladores al
usar expresiones regulares en JavaScript?
Respuesta:Los desarrolladores pueden encontrar dificultades
debido a la complejidad y la sintaxis matizada de las
expresiones regulares. Por ejemplo, crear una expresión
regular que interprete correctamente varios patrones o
escapar caracteres especiales requiere atención cuidadosa al
detalle. Además, las expresiones excesivamente complejas
pueden llevar a problemas de rendimiento o coincidencias no
deseadas, lo que hace que las pruebas y la depuración sean
esenciales.
Capítulo 7 | Sección 1.8. Versiones de JavaScript|
Preguntas y respuestas
[Link]
¿Cuál es la importancia de las versiones de JavaScript y
cómo se relacionan con el desarrollo web?
Respuesta:Las versiones de JavaScript son cruciales
para entender la evolución del lenguaje y sus
capacidades. Desde JavaScript 1.0, que era buggy y
limitado, hasta JavaScript 1.5 que introdujo el
manejo de excepciones conforme a ECMA v3, cada
versión añadió características esenciales que
mejoraron la robustez y funcionalidad. Esta
evolución es vital para los desarrolladores web, ya
que les informa sobre las características disponibles,
asegura la compatibilidad entre diferentes
navegadores y guía la elección de versiones de
JavaScript para varios proyectos.

[Link]
¿Cómo se integra JavaScript en HTML y por qué es
importante esta integración?
Respuesta:JavaScript se integra en HTML utilizando la
etiqueta <script>, controladores de eventos y URL de
JavaScript. Esta integración permite a los desarrolladores
crear páginas web interactivas y dinámicas, mejorando la
experiencia del usuario. Por ejemplo, el uso de <script>
permite la generación de contenido dinámico, mientras que
los controladores de eventos permiten interacciones en
tiempo real como clics y envíos de formularios. Esta
integración sin problemas es vital para el desarrollo web
moderno, ya que transforma HTML estático en aplicaciones
dinámicas.

[Link]
Explica el papel del objeto Window en JavaScript del
lado del cliente.
Respuesta:El objeto Window representa la ventana del
navegador en JavaScript del lado del cliente, sirviendo como
el objeto global para acceder y manipular documentos web.
Define propiedades y métodos globales, como document, que
apunta al objeto Document que representa el contenido que
se está mostrando. Entender el objeto Window permite a los
desarrolladores controlar aspectos del navegador, como la
navegación y los eventos de tiempo, mejorando así la
interactividad y gestionando eficazmente la experiencia del
usuario.

[Link]
¿Cuáles son las funcionalidades clave que ofrece el objeto
Document?
Respuesta:El objeto Document es esencial ya que representa
el documento HTML mostrado en el navegador. Permite el
acceso a elementos dentro del documento a través de
propiedades como forms, images y links. Los desarrolladores
pueden manipular contenido, manejar eventos y generar
HTML dinámicamente a través de métodos como
getElementById() y write(). Dominar el objeto Document
facilita aplicaciones web poderosas que reaccionan a las
entradas del usuario y se adaptan dinámicamente.

[Link]
¿Qué ventajas ofrecen el DOM del W3C y el DOM de IE
4 a los desarrolladores de JavaScript?
Respuesta:El DOM del W3C proporciona un método
estandarizado para acceder y modificar todos los elementos
del documento, promoviendo la compatibilidad entre
navegadores modernos. Permite a los desarrolladores recorrer
el árbol de documentos y manipular varias estructuras HTML
de manera sistemática. En contraste, el DOM de IE 4, aunque
no estándar, ofrece características únicas como innerHTML
para actualizaciones rápidas de contenido. Comprender
ambos ayuda a los desarrolladores a escribir scripts
compatibles entre diferentes navegadores y a utilizar
características específicas de cada navegador de manera
efectiva.

[Link]
¿Cómo puede JavaScript mejorar la interacción del
usuario a través de eventos, y por qué es crucial esta
funcionalidad?
Respuesta:JavaScript mejora la interacción del usuario a
través del manejo de eventos, permitiendo que los scripts
respondan a acciones del usuario como clics, pulsaciones de
teclas y movimientos del mouse. Esta interactividad es
crucial para las aplicaciones web modernas que requieren
retroalimentación en tiempo real y cambios dinámicos de
contenido, mejorando el compromiso y la satisfacción del
usuario. Por ejemplo, la validación de formularios utilizando
eventos onsubmit asegura la integridad de los datos al
prevenir envíos incorrectos antes de que ocurran.

[Link]
¿Qué restricciones de seguridad se imponen en
JavaScript del lado del cliente y por qué son importantes?
Respuesta:Las restricciones de seguridad en JavaScript del
lado del cliente, como la política de mismo origen y
limitaciones al acceso a archivos, son vitales para proteger la
privacidad del usuario y prevenir actividades maliciosas.
Estas restricciones aseguran que los scripts solo puedan
interactuar con documentos servidos desde el mismo
dominio, mitigando amenazas como el scripting entre sitios
(XSS). Entender estas limitaciones permite a los
desarrolladores escribir aplicaciones seguras que protegen los
datos del usuario y mantienen la confianza.
Capítulo 8 | Sección 2.1. JavaScript en HTML|
Preguntas y respuestas
[Link]
¿Cuál es el propósito principal de la etiqueta <script> en
HTML?
Respuesta:La etiqueta <script> se utiliza para
incrustar código JavaScript dentro de los
documentos HTML, permitiendo ejecutar
JavaScript directamente o mediante un archivo
externo.

[Link]
¿Cómo pueden los controladores de eventos mejorar la
interacción del usuario en una aplicación web?
Respuesta:Los controladores de eventos permiten que el
código JavaScript se ejecute en respuesta a acciones
específicas del usuario, como clics o eventos del teclado. Por
ejemplo, utilizar un evento onclick para mostrar '¡Hola
Mundo!' cuando se hace clic en un botón demuestra cómo la
programación orientada a eventos puede hacer que las
páginas web sean interactivas.

[Link]
¿Cuál es la importancia de usar el atributo type en la
etiqueta <script>?
Respuesta:El atributo type especifica el lenguaje de scripting
del código incluido. Para JavaScript, debe establecerse en
'text/javascript' para garantizar la compatibilidad,
especialmente en entornos donde se pueden utilizar múltiples
lenguajes de scripting.

[Link]
¿Cómo funciona el esquema de URL javascript: en los
formularios HTML?
Respuesta:El esquema de URL javascript: permite ejecutar
código JavaScript cuando se envía un formulario sin recargar
la página. Al usar este esquema junto con el operador void,
puedes ejecutar funciones sin alterar el contenido del
documento.

[Link]
¿Por qué podría ser necesario especificar la versión de
JavaScript en la etiqueta <script>?
Respuesta:Especificar la versión de JavaScript usando
atributos como language o type asegura que los navegadores
interpreten el código correctamente. Ayuda a mantener la
compatibilidad con diferentes versiones de navegadores que
pueden solo soportar características específicas de
JavaScript.

[Link]
¿Puedes proporcionar un ejemplo de uso de un
controlador de eventos para mejorar la funcionalidad en
una página web?
Respuesta:¡Por supuesto! Por ejemplo, un cuadro de entrada
podría utilizar el controlador de eventos onfocus para
cambiar su color de fondo, indicando a los usuarios que está
listo para recibir input. Esta retroalimentación visual mejora
la experiencia del usuario al hacer que la interacción sea más
fluida.

[Link]
¿Qué papel juega el operador void en las URL de
JavaScript?
Respuesta:El operador void se utiliza en las URL de
JavaScript para evitar que el navegador navegue a una nueva
página o modifique el documento actual. Permite la
ejecución de scripts sin ningún efecto visible en la página
web, lo cual es útil en acciones de formularios.

[Link]
¿Cómo acomoda la etiqueta <script> diferentes lenguajes
de scripting?
Respuesta:La etiqueta <script> permite la inclusión de varios
lenguajes de scripting especificando el tipo MIME apropiado
o el atributo language. Aunque JavaScript es el más común,
HTML soporta otros scripts como VBScript, lo que lo hace
versátil para los desarrolladores que pueden trabajar en
entornos multilingües.
Capítulo 9 | Sección 2.2. El objeto Window|
Preguntas y respuestas
[Link]
¿Cuál es la importancia del objeto Window en JavaScript
del lado del cliente?
Respuesta:El objeto Window representa el contexto
global para JavaScript del lado del cliente y abarca
todas las propiedades y métodos de primer nivel
disponibles en el navegador. Sirve como un espacio
de nombres para funciones globales y permite a los
desarrolladores controlar aspectos del entorno del
navegador, como mostrar diálogos, rastrear
interacciones del usuario y navegar a través del
historial del navegador.

[Link]
¿Cómo se crea y muestra un cuadro de diálogo utilizando
el objeto Window? ¿Puedes dar un ejemplo?
Respuesta:Se pueden crear cuadros de diálogo utilizando
métodos como alert(), confirm() y prompt(). Por ejemplo,
alert('¡Bienvenido a mi página de inicio!') mostrará un cuadro
de alerta simple. Para solicitar al usuario que ingrese
información, utiliza prompt('Ingresa tu nombre'); esto abrirá
un cuadro de diálogo que permite al usuario ingresar una
línea de texto.

[Link]
¿Qué métodos permiten manipular la línea de estado en
un navegador web?
Respuesta:Puedes manipular la línea de estado utilizando las
propiedades status y defaultStatus del objeto Window. Por
ejemplo, establecer [Link] = 'Cargando...' cambiará el
texto de la línea de estado a 'Cargando...' hasta que se
establezca otro estado.

[Link]
¿Puedes explicar cómo funcionan los temporizadores en
JavaScript utilizando el objeto Window?
Respuesta:Los temporizadores en JavaScript se crean
utilizando setTimeout() y setInterval(). setTimeout() ejecuta
una función una vez después de un retraso especificado,
mientras que setInterval() ejecuta repetidamente una función
en los intervalos definidos. Por ejemplo, var timer =
setInterval(function() { [Link]('Tic'); }, 1000) registrará
'Tic' en la consola cada segundo.

[Link]
¿Cuál es la propiedad navigator del objeto Window y
cómo se utiliza?
Respuesta:La propiedad navigator proporciona información
sobre el navegador y el sistema operativo del usuario.
Retorna un objeto Navigator que contiene propiedades como
appName, appVersion y userAgent. Esta información puede
utilizarse para adaptar funcionalidades según el navegador,
como if ([Link] == 'Netscape') { // Código
específico para Netscape }.

[Link]
¿Cómo afecta la propiedad location a la navegación en el
navegador?
Respuesta:La propiedad location representa la URL actual
que se muestra en la barra de direcciones del navegador.
Puedes leerla para obtener la URL actual o establecerla para
navegar a una página web diferente. Por ejemplo, establecer
[Link] = '[Link] llevará al navegador a la
página web indicada.

[Link]
¿Qué métodos están disponibles para controlar el tamaño
y la posición de la ventana del navegador?
Respuesta:Los métodos para controlar la ventana del
navegador incluyen moveTo(), moveBy(), resizeTo() y
resizeBy(). Estos permiten a los desarrolladores cambiar la
posición y el tamaño de una ventana programáticamente. Por
ejemplo, resizeTo(800, 600) cambiaría el tamaño de la
ventana a un ancho de 800 píxeles y una altura de 600
píxeles.

[Link]
¿Cuál es el propósito de utilizar múltiples ventanas y
marcos en JavaScript?
Respuesta:Múltiples ventanas y marcos permiten a los
desarrolladores crear aplicaciones web complejas donde
diferentes conjuntos de información pueden mostrarse
simultáneamente de una manera amigable para el usuario.
Cada ventana o marco opera con su propio contexto de
ejecución, lo que significa que las variables y funciones
pueden estar limitadas a sus respectivas ventanas,
promoviendo un diseño de código modular.

[Link]
¿Cómo puede un script en un marco anidado acceder a
funciones definidas en la ventana de nivel superior?
Respuesta:Un script que se ejecuta en un marco anidado
puede acceder a funciones y variables definidas en la ventana
de nivel superior utilizando la propiedad top. Por ejemplo, si
se define una función stop_scrolling() en la ventana de nivel
superior, un script en un marco anidado puede llamar a esta
función utilizando top.stop_scrolling();.
Capítulo 10 | Sección 2.3. El Objeto Documento|
Preguntas y respuestas
[Link]
¿Cuál es la importancia del objeto Document en
JavaScript en comparación con el objeto Window?
Respuesta:El objeto Document es más significativo
que el objeto Window porque, mientras que el
Window representa la interfaz del navegador, el
objeto Document representa el documento HTML
mostrado dentro de esa interfaz. Sirve como una
puerta de acceso al contenido de la página web,
permitiendo a los desarrolladores acceder y
manipular elementos HTML directamente a través
del Modelo de Objetos del Documento (DOM).
Entender el objeto Document es crucial para una
programación web efectiva.

[Link]
¿Cuáles son los diferentes tipos de DOM mencionados y
en qué se diferencian?
Respuesta:Se discuten tres tipos principales de DOM: DOM
Legado, DOM W3C y DOM IE 4. El DOM Legado
representa un modelo antiguo que soporta elementos básicos
como formularios e imágenes, pero es limitado en alcance. El
DOM W3C es un modelo moderno y estandarizado que
permite el acceso y la modificación completa del contenido
del documento y es ampliamente compatible con los
navegadores actuales. El DOM IE 4 introdujo características
propietarias para la manipulación de documentos que no
estaban estandarizadas, pero que siguen siendo influyentes.
Estas diferencias reflejan la evolución de los estándares web
y la necesidad de compatibilidad.

[Link]
¿Por qué debería un programador de JavaScript estar al
tanto de las variaciones del DOM?
Respuesta:Un programador de JavaScript debería estar al
tanto de las variaciones del DOM para escribir código
compatible en diferentes navegadores y para aprovechar
funcionalidades específicas de manera precisa. Entender
estas diferencias ayuda a desarrollar aplicaciones robustas
que funcionan de manera consistente, independientemente de
la elección del navegador por parte del usuario. El
conocimiento del DOM W3C es particularmente importante
para mantener los estándares web actuales, ya que asegura
una mayor compatibilidad y prepara el código para el futuro.

[Link]
¿Qué puedo hacer para explorar más el DOM para
programación en JavaScript?
Respuesta:Para explorar más el DOM para programación en
JavaScript, puedes leer recursos completos como 'JavaScript.
La guía definitiva', que cubre todas las funciones básicas del
DOM estándar. Además, la experimentación práctica
mediante la construcción de aplicaciones HTML y la
manipulación de elementos utilizando JavaScript
profundizará tu comprensión y mejorará tus habilidades.
Interactúa con documentación en línea y tutoriales para
mantenerte actualizado con las mejores prácticas y nuevos
estándares web.
Capítulo 11 | Sección 2.4. El DOM Legado|
Preguntas y respuestas
[Link]
¿Cuáles son los componentes clave del DOM legado que
mejoran la interacción con el documento en JavaScript?
Respuesta:El DOM legado proporciona propiedades
como formularios, imágenes, applets, enlaces y
anclajes que permiten acceder a elementos
específicos en un documento. Estas propiedades son
arreglos que contienen objetos correspondientes a
cada uno de estos elementos en el orden en que
aparecen en el documento. Además, el objeto Form
contiene un arreglo de elementos para los elementos
de formulario, lo que te permite referenciarlos por
índice o nombre.

[Link]
¿Cómo funciona el método write() en el DOM legado y
cuáles son sus limitaciones?
Respuesta:El método write() inserta texto en el documento en
la ubicación del script, permitiendo incluir etiquetas HTML
en el texto. Sin embargo, solo se puede usar mientras el
documento se está cargando, ya que invocarlo después
borrará el contenido del documento. También se puede usar
en controladores de eventos para diferentes ventanas, pero
requiere escribir todo el contenido del documento y llamar a
[Link]().

[Link]
¿Puedes explicar cómo se implementa la validación de
formularios en el DOM legado usando JavaScript?
Respuesta:La validación de formularios se maneja a través
del evento onsubmit de la etiqueta <form>. Al devolver false
desde el controlador del evento, se puede prevenir el envío
del formulario. Puedes recorrer los elementos del formulario,
verificar los campos obligatorios y alertar al usuario si
alguno no está completado. Por ejemplo, se puede crear una
función para iterar a través de cada campo de texto y alertar
al usuario si están vacíos.

[Link]
¿Qué técnicas se pueden utilizar para los rollover de
imágenes en páginas web que utilizan el DOM legado?
Respuesta:Los rollover de imágenes se logran cambiando la
propiedad src de un objeto Image basado en eventos del
mouse como onmouseover y onmouseout. Precargar
imágenes en memoria usando un objeto Image fuera de la
pantalla puede mejorar la experiencia del usuario al eliminar
los retrasos de carga cuando se necesita mostrar la imagen.

[Link]
¿Cómo se pueden gestionar las cookies en el DOM
legado?
Respuesta:Las cookies se pueden establecer y recuperar
usando la propiedad cookie del objeto Document. Para crear
una cookie, asignas una cadena con el formato
'nombre=valor' a la propiedad cookie. También puedes
establecer una fecha de expiración y un camino para la
cookie. Para recuperar cookies, puedes dividir la cadena de
cookies del documento y buscar el nombre de la cookie
deseada.

[Link]
¿Cuál es la importancia del DOM legado a pesar de sus
limitaciones?
Respuesta:El DOM legado proporciona funcionalidades
esenciales para la manipulación del contenido dinámico en
páginas web, incluyendo alterar la estructura del documento,
manejar envíos de formularios, validar la entrada del usuario,
crear formularios dinámicos y gestionar cookies. Aunque
carece de métodos completos para acceder a todos los
elementos del documento, establece las bases para APIs
DOM más avanzadas que abordan estas deficiencias.

[Link]
¿Cómo puedes actualizar dinámicamente el contenido de
un elemento de formulario en el DOM legado?
Respuesta:Puedes actualizar el contenido de un elemento de
formulario accediendo a él a través del arreglo
[Link] y configurando sus propiedades. Por
ejemplo, para mostrar la hora actual cada segundo, puedes
establecer la propiedad value de un elemento de entrada de
texto en un objeto Form usando la función setInterval de
JavaScript.
Capítulo 12 | Sección 2.5. El W3C DOM| Preguntas
y respuestas
[Link]
¿Cuáles son las ventajas de usar el W3C DOM en lugar
del DOM legado en JavaScript?
Respuesta:El W3C DOM estandariza la mayoría de
las características del DOM legado mientras agrega
nuevas capacidades, como la posibilidad de
manipular todos los elementos del documento de
manera uniforme, no solo los de propósito específico
como formularios e imágenes. Esto facilita a los
scripts el acceso, recorrido y manipulación de
cualquier parte del documento.

[Link]
¿Cómo podemos acceder a los elementos en un
documento utilizando su ID?
Respuesta:Puedes acceder a los elementos por su ID
utilizando el método getElementById() del objeto Document.
Por ejemplo, si tienes un elemento <h1
id='title'>Título</h1>, puedes recuperarlo en JavaScript con
var t = [Link]('title');.

[Link]
¿Cuál es la estructura de un documento en el W3C
DOM?
Respuesta:El W3C DOM representa un documento como un
árbol, donde cada etiqueta HTML, cadena de texto y
comentario corresponde a nodos en ese árbol. Cada nodo es
un objeto de JavaScript con propiedades que permiten
recorrer y manipular otros nodos.

[Link]
¿Cuáles son los diferentes tipos de nodos en un
documento W3C DOM?
Respuesta:Los principales tipos de nodos relevantes para
documentos HTML incluyen: 1 para nodos Element
(etiquetas HTML), 2 para nodos de Texto (texto en el
documento), 8 para nodos Comentario (comentarios HTML)
y 9 para nodos Documento (el documento en sí). Estos tipos
de nodos ayudan a organizar la estructura del documento.

[Link]
¿Cómo puedes cambiar el contenido de texto de un
elemento del documento?
Respuesta:El contenido de texto de un elemento del
documento se puede cambiar configurando la propiedad
nodeValue de un nodo de Texto. Alternativamente, puedes
usar la propiedad innerHTML para establecer directamente el
contenido HTML, lo cual permite estructuras más complejas.

[Link]
¿Cómo podemos manipular la estructura de un
documento en el W3C DOM?
Respuesta:Puedes manipular la estructura del documento
utilizando métodos de Node para insertar, agregar, eliminar o
reemplazar nodos hijos, así como métodos de Document para
crear nuevos nodos Element y Texto. Por ejemplo, para
agregar un nuevo elemento de lista a una lista ordenada,
podrías crear un nuevo elemento <li> y agregarlo al <ol>.

[Link]
¿Puedes proporcionar un ejemplo de cómo cambiar el
texto del documento?
Respuesta:¡Por supuesto! Para cambiar el texto de la primera
etiqueta <h1> en un documento, utilizarías el siguiente
código: var h1 = [Link]('h1')[0];
[Link] = 'Nuevo encabezado'; Recuerda que
esto supone que el <h1> solo contiene texto plano.

[Link]
¿Qué método se puede usar para crear nuevos elementos
en el documento?
Respuesta:El método createElement() del objeto Document
se puede usar para crear nuevos elementos. Por ejemplo, var
item = [Link]('li'); crea un nuevo elemento
<li>.

[Link]
¿Cómo puedes eliminar un elemento del documento?
Respuesta:Puedes eliminar un elemento utilizando el método
removeChild(). Por ejemplo, si quieres eliminar un elemento
que se había agregado previamente a una lista, llamarías a
[Link](item); en la lista padre.

[Link]
¿Cuál es el propósito de la función embolden en el
ejemplo proporcionado?
Respuesta:La función embolden crea una nueva etiqueta <b>
(negrita) y reubica un nodo de documento especificado
dentro de ella, haciendo que el nodo original aparezca en
negrita. Esto ilustra cómo manipular la estructura del
documento y aplicar formato de manera programática.
Capítulo 13 | Sección 2.6. DOM de IE 4| Preguntas y
respuestas
[Link]
¿Cuál es una diferencia clave entre el DOM de IE 4 y el
DOM de W3C al acceder a los elementos del documento?
Respuesta:El DOM de IE 4 no admite el método
getElementById() y, en su lugar, permite el acceso a
los elementos a través del array all[]. Puedes acceder
a un elemento mediante su atributo id usando
métodos como [Link]['mylist'] o
[Link].

[Link]
¿En qué se diferencia el método de recorrido del árbol del
documento entre IE 4 y el DOM de W3C?
Respuesta:En el DOM de IE 4, usas propiedades como
children[] y parentElement en lugar de childNodes[] y
parentNode como se utiliza en el DOM de W3C. Además, el
DOM de IE 4 ignora los comentarios y el texto del
documento como parte de su estructura de árbol.

[Link]
¿Cuáles son las implicaciones de modificar el contenido
del documento en IE 4 usando innerText e innerHTML?
Respuesta:Usar innerText reemplaza todo el contenido dentro
de un elemento con el texto especificado, eliminando las
etiquetas existentes. En contraste, innerHTML te permite
reemplazar el contenido de un elemento con HTML, pero
requiere invocar el analizador HTML, lo que puede afectar la
eficiencia, pero proporciona mayor comodidad.

[Link]
¿Por qué es importante la compatibilidad al escribir
scripts para diferentes DOMs?
Respuesta:La compatibilidad es crucial porque los diferentes
navegadores implementan los estándares de DOM de manera
distinta. Usar pruebas de capacidad te permite escribir scripts
que se adaptan a las características disponibles en el
navegador del usuario, asegurando la funcionalidad en
navegadores modernos y legacy.

[Link]
¿Cuáles son algunos métodos relacionados con la
modificación de la estructura del documento disponibles
en el DOM de IE 4?
Respuesta:Los métodos innecesarios para modificar la
estructura del documento en el DOM de IE 4 incluyen
innerHTML, outerHTML e insertAdjacentHTML(). Sin
embargo, innerHTML es el más comúnmente empleado por
su conveniencia a pesar de ser no estándar.

[Link]
¿Cómo deben los desarrolladores abordar las
características heredadas del DOM, como el DOM de IE
4?
Respuesta:Los desarrolladores deben estar al tanto de las
características heredadas y considerar enfoques alternativos
que prioricen las prácticas estándar, como usar el DOM de
W3C cuando sea posible. También es beneficioso
implementar estrategias de degradación elegante para
asegurar que los navegadores antiguos puedan seguir
funcionando.
Capítulo 14 | Sección 2.7. DHTML: Programación
de estilos CSS| Preguntas y respuestas
[Link]
¿Cuál es el papel de DHTML en el desarrollo web?
Respuesta:DHTML, que significa HTML dinámico,
combina HTML, CSS y JavaScript para crear
experiencias interactivas y dinámicas en la web.
Permite a los desarrolladores manipular el estilo y el
comportamiento de los elementos HTML en tiempo
real, mejorando la experiencia del usuario al
responder a las acciones sin necesidad de recargar la
página.

[Link]
¿Cómo puedes modificar el estilo de los elementos HTML
usando JavaScript?
Respuesta:Puedes modificar el estilo de los elementos HTML
accediendo a la propiedad 'style' de un elemento a través de
JavaScript. Por ejemplo, para cambiar el color de un
elemento, usarías '[Link] = "red";'. Para
establecer un color de fondo, usarías
'[Link] = "blue";'.

[Link]
¿Cuál es el primer paso para animar un elemento usando
DHTML?
Respuesta:El primer paso para animar un elemento usando
DHTML es establecer su propiedad de posición como
'absolute', lo que te permite definir su ubicación en la página
más libremente usando las propiedades top y left.

[Link]
¿Por qué es importante convertir números en cadenas al
establecer ciertas propiedades CSS?
Respuesta:En JavaScript, todos los valores de las
propiedades CSS se tratan como cadenas, incluso aquellos
que representan valores numéricos como ancho o alto. Esto
significa que al establecer propiedades como
'[Link]', debes convertir el valor numérico en
una cadena y agregar la unidad apropiada, típicamente 'px',
para asegurarte de que sea interpretado correctamente por el
navegador.

[Link]
¿Qué efecto tiene la propiedad 'visibility' en un elemento?
Respuesta:La propiedad 'visibility' determina si un elemento
es visible en la página web. Ajustarla a 'hidden' lo quita de la
vista, pero el espacio que ocupa sigue estando asignado,
mientras que ajustarla a 'visible' lo hace aparecer
nuevamente.

[Link]
¿Cómo demuestra la función 'nextFrame()' la animación
DHTML?
Respuesta:La función 'nextFrame()' ilustra la animación
DHTML moviendo incrementalmente un elemento HTML
10 píxeles a la derecha cada 50 milisegundos. Utiliza un
bucle controlado por un contador de fotogramas para
restringir el movimiento a 20 fotogramas, después de los
cuales oculta el elemento estableciendo su visibilidad en
'hidden'.

[Link]
¿Qué sucede si estableces la propiedad 'position' de un
elemento en 'fixed'?
Respuesta:Cuando la propiedad 'position' se establece en
'fixed', el elemento se posiciona de manera relativa a la
ventana gráfica. Esto significa que permanecerá en el mismo
lugar en la pantalla incluso cuando la página se desplace,
proporcionando una forma de crear barras de navegación o
avisos persistentes.

[Link]
¿Qué controla la propiedad 'zIndex'?
Respuesta:La propiedad 'zIndex' controla el orden de
apilamiento de los elementos en la página web. Los
elementos con un valor de z-index más alto aparecerán
encima de aquellos con un valor más bajo, permitiendo
diseños en capas.
Capítulo 15 | Sección 2.8. Eventos y Manejo de
Eventos| Preguntas y respuestas
[Link]
¿Cuál es el propósito de los atributos de manejador de
eventos en HTML y cómo funcionan en JavaScript?
Respuesta:Los atributos de manejador de eventos en
HTML, como onclick, onsubmit y onload, se utilizan
para especificar funciones de JavaScript que deben
ejecutarse en respuesta a acciones específicas del
usuario o eventos del navegador. Estos atributos
están adjuntos a las etiquetas HTML y comienzan
con 'on'. Cuando ocurre un evento, el navegador
ejecuta el código JavaScript asociado. Por ejemplo,
si tienes un manejador de evento 'onsubmit' en un
formulario, se puede usar para validar la entrada
del usuario antes de que se envíe el formulario,
mejorando la interacción del usuario y permitiendo
retroalimentación en tiempo real.

[Link]
¿Cómo se pueden definir los manejadores de eventos de
manera diferente en JavaScript en comparación con los
atributos HTML?
Respuesta:En JavaScript, los manejadores de eventos se
pueden definir como funciones reales asignadas a
propiedades de los objetos del documento en lugar de
escribirse como cadenas de código dentro de los atributos
HTML. Por ejemplo, puedes crear una función llamada
validate para la presentación de formularios y asignarla a la
propiedad onsubmit de un formulario usando
'[Link][0].onsubmit = validate;'. Este método
permite un código más limpio y mejor programabilidad.

[Link]
¿Cuáles son los desafíos que presentan los diferentes
modelos de manejo de eventos entre navegadores?
Respuesta:Existen tres modelos principales de manejo de
eventos: el modelo W3C DOM, el modelo de Internet
Explorer y el modelo de Netscape 4. Cada uno de estos
modelos tiene formas únicas de gestionar eventos, lo que
complica la compatibilidad entre navegadores. Por ejemplo,
en el modelo W3C, el objeto Event se pasa a la función
manejadora, mientras que en IE, se almacena en la propiedad
de evento de la ventana. Debido a estas diferencias, los
desarrolladores a menudo necesitan escribir código adicional
o utilizar bibliotecas para asegurar que sus funciones de
manejo de eventos funcionen correctamente en todos los
navegadores principales.
[Link]
¿Cómo funciona la propagación de eventos en modelos de
eventos avanzados?
Respuesta:La propagación de eventos permite que los
eventos viajen a través de la jerarquía de elementos del
documento, activando cualquier manejador de eventos
relevante en el camino. En los modelos W3C y Netscape, los
eventos comienzan en el objeto documento y se propagan
hacia el elemento objetivo, mientras que en el modelo IE,
ciertos eventos pueden burbujear hacia arriba después de ser
manejados. Los desarrolladores pueden establecer
manejadores de eventos en múltiples niveles, por ejemplo,
añadiendo un oyente onclick a un <div> que maneja clics de
cualquiera de sus elementos hijos, simplificando así la
gestión de eventos.

[Link]
¿Cuál es la importancia del método addEventListener()
en el modelo W3C?
Respuesta:El método addEventListener() en el modelo W3C
permite a los desarrolladores adjuntar múltiples manejadores
de eventos a un solo tipo de evento sin sobreescribir los
manejadores existentes. Esto es significativo para construir
aplicaciones complejas donde puede que desees que varias
funciones respondan a la misma acción del usuario,
mejorando la modularidad y mantenibilidad del código.
Capítulo 16 | Sección 2.9. Restricciones de Seguridad
en JavaScript| Preguntas y respuestas
[Link]
¿Cuáles son algunas razones para las restricciones de
seguridad en JavaScript del lado del cliente?
Respuesta:Las restricciones de seguridad en
JavaScript del lado del cliente se imponen
principalmente para proteger los datos del usuario y
garantizar la privacidad. Por ejemplo, evitar que los
scripts eliminen archivos en el disco duro local de un
usuario previene accesos no autorizados y posibles
pérdidas de datos. De manera similar, la política de
mismo origen limita que los scripts accedan a
contenido cargado desde diferentes servidores web,
lo que ayuda a prevenir acciones maliciosas como el
robo de datos y ataques de scripting en sitios
cruzados. Al limitar capacidades como el envío de
correos electrónicos y la carga de archivos sin el
consentimiento del usuario, los navegadores
protegen las interacciones del usuario, manteniendo
una confianza general en las aplicaciones web.

[Link]
¿Cómo funciona la política de mismo origen en la
seguridad de JavaScript?
Respuesta:La política de mismo origen es un mecanismo de
seguridad crítico en JavaScript del lado del cliente que
prohíbe a los scripts leer propiedades de ventanas o
documentos cargados desde un origen diferente al del propio
script. Por ejemplo, si tienes un script que se ejecuta en
'[Link]', no puede interactuar con un documento de
'[Link]'. Esto previene que los scripts accedan a
información potencialmente sensible que el usuario podría
tener abierta en otras pestañas o ventanas, asegurando así los
datos del usuario contra accesos no autorizados.

[Link]
¿Pueden los scripts de JavaScript cerrar cualquier
ventana del navegador?
Respuesta:No, los scripts solo pueden cerrar ventanas del
navegador que ellos mismos hayan creado. Esta restricción
está en su lugar para prevenir prácticas abusivas donde los
scripts podrían cerrar arbitrariamente ventanas que el usuario
no tenía la intención de cerrar, lo que podría ser muy
frustrante o engañoso para el usuario.

[Link]
¿Cuál es la importancia de la confirmación del usuario en
la seguridad de JavaScript?
Respuesta:La confirmación del usuario actúa como un filtro
crucial para acciones que podrían interrumpir la experiencia
del usuario o comprometer la seguridad. Por ejemplo, cuando
un script intenta enviar un formulario a una dirección de
correo electrónico o publicar noticias, requerir la
confirmación del usuario asegura que los usuarios sean
conscientes de estas acciones, previniendo envíos no
deseados y preservando la integridad de las interacciones del
usuario.

[Link]
¿Cómo han influido las actualizaciones más recientes de
los navegadores en los estándares de seguridad de
JavaScript?
Respuesta:Los navegadores más nuevos se han adaptado a las
crecientes preocupaciones de seguridad y al uso indebido de
JavaScript, introduciendo configuraciones de seguridad que
los usuarios pueden ajustar. Esto permite a los usuarios
prevenir que los scripts realicen acciones molestas, como
abrir anuncios emergentes o manipular los tamaños de las
ventanas actuales. Tales mejoras reflejan la capacidad de
respuesta de los desarrolladores de navegadores ante las
necesidades de los usuarios por un mayor control y
ciberseguridad.

[Link]
¿Por qué es importante que los navegadores web tengan
restricciones de seguridad para JavaScript?
Respuesta:Las restricciones de seguridad son vitales para
mantener un entorno de navegación seguro. Protegen a los
usuarios de acciones potencialmente perjudiciales que
podrían ser ejecutadas a través de scripts maliciosos. Al hacer
cumplir estas reglas, los navegadores reducen el riesgo de
vulnerabilidades que podrían comprometer los datos del
usuario, prevenir brechas de privacidad y mantener la
confianza del usuario en las aplicaciones web.
Capítulo 17 | Array| Preguntas y respuestas
[Link]
¿Cuáles son las diferentes formas de crear un arreglo en
JavaScript?
Respuesta:Puedes crear un arreglo utilizando el
constructor `new Array()`, que crea un arreglo
vacío, `new Array(n)` para un arreglo con 'n'
elementos no especificados, o `new Array(e0, e1,...)`
para crear un arreglo con elementos especificados.
Además, utilizando la sintaxis literal, puedes crear e
inicializar un arreglo con una lista separada por
comas dentro de corchetes, como `var a = [1, true,
'abc'];`.

[Link]
¿Cómo funciona la propiedad `length` en los arreglos de
JavaScript?
Respuesta:La propiedad `length` representa la cantidad de
elementos en el arreglo. Si los elementos no son contiguos
(es decir, si hay 'huecos' en el arreglo), la propiedad `length`
devolverá un número uno mayor que el índice más alto con
un valor.

[Link]
¿Cuál es el propósito del método `concat()`? ¿Puedes dar
un ejemplo?
Respuesta:El método `concat()` se utiliza para combinar
múltiples arreglos o valores en un nuevo arreglo. Por
ejemplo, si tienes dos arreglos `var a = [1, 2]` y `var b = [3,
4]`, al usar `[Link](b)` se producirá un nuevo arreglo `[1, 2,
3, 4]`.

[Link]
Explica el uso del método `join()` con un ejemplo.
Respuesta:El método `join()` convierte todos los elementos
de un arreglo en una cadena, insertando un separador
especificado entre ellos. Por ejemplo, si tienes un arreglo `var
fruits = ['apple', 'banana', 'cherry']`, al usar `[Link](', ')` se
devolverá la cadena 'apple, banana, cherry'.
[Link]
¿Qué sucede cuando usas el método `pop()`?
Respuesta:Cuando usas el método `pop()` en un arreglo,
elimina el último elemento del arreglo y devuelve ese
elemento, al mismo tiempo que decrementa la longitud del
arreglo en uno. Por ejemplo, si tienes `var numbers = [1, 2,
3]` y haces `[Link]()`, devolverá '3' y `numbers` se
convertirá en `[1, 2]`.

[Link]
Describe la diferencia entre los métodos `shift()` y
`unshift()`.
Respuesta:El método `shift()` elimina el primer elemento de
un arreglo y lo devuelve, desplazando todos los elementos
restantes hacia abajo. Por ejemplo, de `var arr = [1, 2, 3]`, al
llamar `[Link]()` devolvería '1' y cambiaría `arr` a `[2, 3]`.
Por el contrario, `unshift()` añade uno o más elementos al
principio del arreglo, desplazando los elementos existentes
hacia arriba. Si llamas `[Link](0)` después del anterior
`shift()`, `arr` se convertirá en `[0, 2, 3]`.
[Link]
¿Cuál es la función del método `splice()`? Proporciona un
ejemplo.
Respuesta:El método `splice()` modifica un arreglo
eliminando una cantidad de elementos en un índice
especificado y también puede añadir nuevos elementos en ese
índice. Por ejemplo, si tienes `var arr = [1, 2, 3, 4, 5]` y
llamas `[Link](2, 2, 'a', 'b')`, eliminará dos elementos
comenzando desde el índice 2 (originalmente '3' y '4') e
insertará 'a' y 'b' en su lugar. El arreglo resultante será `[1, 2,
'a', 'b', 5]`.

[Link]
¿Puedes explicar cómo funciona el método `sort()`?
Respuesta:El método `sort()` ordena los elementos de un
arreglo in situ y puede tomar una función opcional que defina
el orden en que se deben ordenar los elementos. Por ejemplo,
si tienes `var nums = [3, 1, 2]` y usas `[Link]()`, ordenará
el arreglo a `[1, 2, 3]`. También puedes proporcionar una
función de ordenación personalizada, como ordenar números
en orden descendente con `[Link]((a, b) => b - a)`.

[Link]
¿Qué hace el método `reverse()`?
Respuesta:El método `reverse()` invierte el orden de los
elementos en un arreglo. Por ejemplo, si tienes `var arr = [1,
2, 3]` y llamas `[Link]()`, modificará `arr` para
convertirse en `[3, 2, 1]`.

[Link]
¿Cómo difieren en uso los métodos `toString()` y
`toLocaleString()`?
Respuesta:El método `toString()` convierte un arreglo en una
cadena sin ninguna localización, mientras que
`toLocaleString()` respeta la configuración regional del
entorno del usuario, potencialmente formateando las cadenas
de manera diferente según las convenciones locales. Por
ejemplo, llamar a `[Link]()` podría devolver '1,2,3',
mientras que `[Link]()` podría devolver '1.0, 2.0,
3.0' en ciertas configuraciones regionales, dependiendo del
formato numérico.
Capítulo 18 | Fecha| Preguntas y respuestas
[Link]
¿Cuál es el propósito del constructor Date en JavaScript?
Respuesta:El constructor Date proporciona una
manera de crear objetos de fecha, que pueden
representar la fecha y hora actuales, analizar
cadenas que representan fechas o especificar
componentes individuales de la fecha como el año,
mes, día, horas, etc. Esta flexibilidad permite a los
desarrolladores manipular fechas y horas según sus
necesidades específicas.

[Link]
¿Cómo funciona el método getTime() y por qué es
importante?
Respuesta:El método getTime() devuelve el número de
milisegundos desde la medianoche UTC del 1 de enero de
1970, para el objeto Date. Esta representación numérica es
crucial para realizar cálculos y comparaciones de fechas, ya
que permite a los desarrolladores entender y manipular
fácilmente datos basados en el tiempo.

[Link]
¿Cuáles son las diferencias entre los métodos de hora
local y UTC en el objeto Date?
Respuesta:Los métodos de hora local interactúan con la
configuración de zona horaria local del usuario, mientras que
los métodos UTC proporcionan resultados consistentes
basados en el Tiempo Universal Coordinado. Esta distinción
es importante para aplicaciones que necesitan tener en cuenta
las zonas horarias o realizar operaciones sobre fechas y horas
que sean consistentes independientemente de la ubicación del
usuario.

[Link]
¿Puedes explicar la importancia del método
getTimezoneOffset()?
Respuesta:El método getTimezoneOffset() devuelve la
diferencia en minutos entre la zona horaria local y UTC. Esto
es significativo para entender cómo las horas locales se
relacionan con el tiempo universal y para programar tareas
que requieren sincronización a través de diferentes zonas
horarias.

[Link]
¿Cuáles son las implicaciones de usar métodos obsoletos
como getYear() y setYear()?
Respuesta:Usar métodos obsoletos como getYear() y
setYear() puede llevar a problemas de claridad y
compatibilidad, ya que esos métodos pueden no comportarse
como se espera en entornos modernos de JavaScript. Se
recomienda a los desarrolladores utilizar sus equivalentes
actualizados como getFullYear() y setUTCFullYear() para
mayor precisión y consistencia.

[Link]
¿Cómo mejoran los métodos estáticos como [Link]()
y [Link]() la funcionalidad del objeto Date?
Respuesta:Los métodos estáticos como [Link]() y
[Link]() amplían las capacidades del objeto Date al
permitir a los desarrolladores convertir fácilmente cadenas en
objetos de fecha y crear representaciones UTC de fechas sin
necesidad de instanciar primero un objeto Date. Esto
simplifica la manipulación de fechas y mejora la eficiencia
general del código.

[Link]
¿Por qué es esencial para los desarrolladores entender
tanto los métodos get como set del objeto Date?
Respuesta:Entender los métodos get y set del objeto Date es
crucial para los desarrolladores porque les permite recuperar
y alterar con precisión los valores de fecha y hora en sus
aplicaciones. Este conocimiento es fundamental para tareas
como la programación, el formateo de fechas y garantizar
cálculos de tiempo correctos.

[Link]
¿Cuál es el beneficio de usar métodos como
toLocaleDateString() y toLocaleTimeString()?
Respuesta:Métodos como toLocaleDateString() y
toLocaleTimeString() formatean fechas y horas de acuerdo
con la configuración local del usuario, facilitando la
presentación de la información de fecha de una manera que
sea familiar y comprensible para los usuarios. Esto mejora la
experiencia del usuario y asegura una mejor comunicación de
la información relacionada con las fechas.

[Link]
¿Cómo puede afectar el objeto Date de JavaScript a las
aplicaciones que se ocupan de la programación o
transacciones sensibles al tiempo?
Respuesta:El objeto Date proporciona métodos esenciales
para gestionar y manipular datos de fecha y hora de manera
precisa, lo cual es crítico para aplicaciones que tratan con
programación y transacciones sensibles al tiempo. Al
aprovechar el objeto Date, los desarrolladores pueden
asegurar que los eventos estén correctamente sincronizados y
mostrar información de fecha relevante de manera clara y
precisa para los usuarios.

[Link]
¿Qué consideraciones deben tener en cuenta los
desarrolladores respecto al horario de verano al usar los
métodos del objeto Date?
Respuesta:Los desarrolladores deben tener en cuenta que
ciertos métodos, como getTimezoneOffset(), devolverán
diferentes valores dependiendo de si el horario de verano está
en efecto. Esto puede impactar cualquier lógica basada en
cálculos de fechas y horas, enfatizando la importancia de
probar estos cálculos en torno a las fechas de inicio y fin del
horario de verano.
Capítulo 19 | Documento| Preguntas y respuestas
[Link]
¿Por qué se considera que el objeto Document es uno de
los más importantes en JavaScript del lado del cliente?
Respuesta:El objeto Document representa el
documento HTML que se muestra en el navegador,
permitiendo a los desarrolladores interactuar y
manipular el contenido de las páginas web de
manera dinámica. Proporciona métodos y
propiedades esenciales para acceder y modificar
elementos, formularios y otros componentes de la
página, creando un puente entre HTML y
JavaScript.

[Link]
¿Cuál es la importancia de propiedades como 'cookie' en
el objeto Document?
Respuesta:La propiedad 'cookie' en el objeto Document
permite a JavaScript leer y escribir cookies asociadas con el
documento. Esto es crucial para mantener el estado de sesión,
las preferencias del usuario y gestionar datos en el lado del
cliente, mejorando así la experiencia del usuario en los sitios
web.

[Link]
¿Cómo afectan las diferentes implementaciones del objeto
Document (como W3C DOM, IE y Netscape) al desarrollo
web?
Respuesta:Las diferentes implementaciones del objeto
Document pueden llevar a problemas de compatibilidad entre
navegadores. Por ejemplo, Netscape e IE introdujeron
propiedades y métodos no estándar que pueden no ser
soportados en navegadores compatibles con W3C. Esto
obliga a los desarrolladores a escribir código específico para
cada navegador o utilizar detección de características para
asegurar un comportamiento consistente en las plataformas.

[Link]
¿Por qué se podrían considerar obsoletas propiedades
como 'alinkColor' y 'bgColor'?
Respuesta:Propiedades como 'alinkColor' y 'bgColor' se
consideran obsoletas porque dependen de prácticas HTML
más antiguas que ya no se recomiendan en el desarrollo web
moderno. En su lugar, se prefiere CSS (Hojas de Estilo en
Cascada) para el estilo de las páginas web, proporcionando
más flexibilidad y manteniendo la separación entre contenido
y presentación.

[Link]
¿Cómo se relaciona el estado de carga de un documento
con la experiencia del usuario?
Respuesta:El estado de carga, indicado por la propiedad
'readyState', impacta directamente en la experiencia del
usuario. Por ejemplo, si un documento está 'cargando', los
usuarios pueden ver contenido parcial o no receptivo. Los
desarrolladores pueden utilizar esta información para
proporcionar animaciones de carga o marcadores de posición,
mejorando la percepción de rendimiento e interactividad de
la aplicación.

[Link]
¿Qué papel juega la propiedad 'documentElement' en el
acceso a la estructura HTML?
Respuesta:La propiedad 'documentElement' proporciona a
los desarrolladores acceso directo a la etiqueta <html> del
documento, sirviendo como punto de partida para navegar
por toda la estructura del DOM. Esta propiedad simplifica el
acceso a la configuración general de la página web y es
esencial para aplicar manipulaciones a nivel de documento.

[Link]
¿Por qué es crítico entender y diferenciar entre
propiedades y métodos soportados por varias versiones
del objeto Document?
Respuesta:Entender las diferencias es crucial para desarrollar
aplicaciones web robustas y compatibles. Al utilizar
características específicas de ciertos navegadores o versiones
de JavaScript, los desarrolladores pueden evitar trampas,
garantizar una mayor accesibilidad y crear un código más
resistente que se adapte a diversos entornos.

[Link]
¿Cómo ha evolucionado el objeto Document desde su
introducción en JavaScript 1.0?
Respuesta:El objeto Document ha evolucionado
significativamente, con propiedades y métodos adicionales
añadidos en versiones posteriores (por ejemplo, JS 1.1 y
DOM Level 2). Esta evolución incorpora prácticas
estandarizadas del W3C, mejorada compatibilidad con
estándares web modernos y funcionalidades mejoradas como
la creación de nodos y acceso a contenido dinámico.

[Link]
¿Cuáles son los desafíos potenciales asociados con el uso
de propiedades no estándar definidas por navegadores
como IE?
Respuesta:El uso de propiedades no estándar puede llevar a
un comportamiento inconsistente entre diferentes
navegadores. Si un desarrollador depende de estas
propiedades, la aplicación web puede funcionar
incorrectamente o no mostrarse adecuadamente para los
usuarios en navegadores que no soportan estas
características, perjudicando en última instancia la
accesibilidad y la experiencia del usuario.

[Link]
¿Cómo empodera el método 'createElement' a los
desarrolladores en JavaScript?
Respuesta:El método 'createElement' permite a los
desarrolladores crear dinámicamente nuevos elementos en el
documento, permitiéndoles construir interfaces web
interactivas y responsivas en tiempo real. Esta capacidad es
fundamental para las aplicaciones web modernas que
requieren mantener una experiencia de usuario fluida sin
recargas constantes de la página.
Capítulo 20 | Elemento| Preguntas y respuestas
[Link]
¿Cuál es la importancia del objeto Element en el DOM y
cómo facilita la manipulación de los elementos HTML?
Respuesta:El objeto Element es fundamental en el
Modelo de Objetos del Documento (DOM) ya que
representa cada elemento o etiqueta HTML dentro
de un documento. Esto permite a los desarrolladores
interactuar de forma programática con la
estructura, contenido y estilo de una página web.
Por ejemplo, al acceder a propiedades como
className, style, o métodos como setAttribute, los
desarrolladores pueden cambiar dinámicamente la
apariencia y comportamiento de los elementos según
la interacción del usuario o la lógica de la aplicación.
Esta interacción une la naturaleza estática de
HTML con las capacidades dinámicas de
JavaScript, mejorando la experiencia del usuario.

[Link]
¿En qué se diferencian las especificaciones del DOM del
W3C y del IE respecto a las propiedades y métodos
disponibles para los elementos HTML?
Respuesta:Las especificaciones del DOM del W3C y del IE
divergen significativamente tanto en sus propiedades como
en sus métodos. Si bien existen propiedades comunes como
className y tagName, el DOM del W3C se adhiere a un
estándar que se implementa de manera uniforme en los
navegadores compatibles. Por el contrario, el DOM de IE
incorpora muchas propiedades no estándar, como
innerHTML y outerHTML, que no están definidas por el
W3C, lo que lleva a inconsistencias en el comportamiento
entre diferentes navegadores. Esta variación obliga a los
desarrolladores a emplear código condicional para garantizar
la compatibilidad entre navegadores.

[Link]
¿Qué papel juegan los manejadores de eventos en los
elementos HTML y cómo pueden mejorar la interacción
del usuario?
Respuesta:Los manejadores de eventos son fundamentales
para los elementos HTML ya que definen las distintas
interacciones que un usuario puede realizar, como clics,
pulsaciones de teclas y movimientos del ratón. Por ejemplo,
utilizando el manejador de eventos onclick, los
desarrolladores pueden desencadenar funciones específicas
en respuesta a clics del usuario, permitiendo actualizaciones
dinámicas de contenido o iniciando animaciones. Esta
capacidad transforma una página web estática en una
aplicación interactiva, lo que resulta vital para crear
interfaces de usuario receptivas.
[Link]
¿Por qué es importante entender las propiedades y
métodos específicos proporcionados por las diferentes
implementaciones del DOM?
Respuesta:Comprender las propiedades y métodos
específicos de las diferentes implementaciones del DOM es
crucial para que los desarrolladores aseguren que sus
aplicaciones funcionen correctamente en varios navegadores.
Dado que pueden surgir incompatibilidades debido a las
variaciones en la interpretación del DOM por parte de los
navegadores, los desarrolladores deben estar equipados con
el conocimiento de estas diferencias para escribir un código
robusto y compatible entre navegadores. Esta experiencia
ayuda a abordar de manera preventiva problemas que pueden
surgir por depender de características no estándar en un
contexto de navegador único.

[Link]
Explica la importancia de métodos como getAttribute y
setAttribute en el contexto del objeto Element.
Respuesta:Métodos como getAttribute y setAttribute
proporcionan funcionalidad esencial para interactuar con los
atributos HTML de un elemento. getAttribute permite a los
desarrolladores recuperar el valor actual de un atributo
específico, facilitando la lectura y utilización de datos
definidos en el HTML. Por el contrario, setAttribute permite
a los desarrolladores modificar o definir los valores de los
atributos de forma programática. Esto es crucial para las
aplicaciones del lado del cliente que requieren
actualizaciones dinámicas basadas en interacciones del
usuario u otra lógica, mejorando así la interactividad y
funcionalidad de las aplicaciones web.

[Link]
¿Cómo se diferencia la propiedad innerHTML de
innerText en términos de su impacto en la gestión del
contenido en un documento HTML?
Respuesta:La propiedad innerHTML facilita la manipulación
del contenido HTML de un elemento, permitiendo a los
desarrolladores insertar o cambiar estructuras HTML
completas, incluidas etiquetas y estilos. Esto la hace
poderosa, pero puede llevar a riesgos de seguridad
potenciales (como XSS) si no se maneja adecuadamente. En
contraste, innerText recupera o modifica solo el contenido de
texto plano, eliminando cualquier etiqueta HTML. Esta
diferencia es vital para los desarrolladores, ya que
comprender cuándo usar cada una puede asegurar el
resultado deseado, ya sea para mantener el formato o
simplemente mostrar texto de manera estática.
Capítulo 21 | Evento| Preguntas y respuestas
[Link]
¿Cuál es el propósito del objeto Event en JavaScript?
Respuesta:El objeto Event proporciona detalles
sobre un evento y control sobre su propagación, lo
que permite manejar interacciones del usuario en las
páginas web.

[Link]
¿En qué difieren los objetos Event entre los diferentes
navegadores?
Respuesta:Navegadores como IE 4, 5 y 6 utilizan objetos
propietarios que difieren del objeto Event estandarizado
definido en DOM Level 2. Netscape 4 también tiene su
propio objeto propietario, lo que demuestra la falta de
uniformidad en el manejo de eventos a través de diferentes
navegadores.

[Link]
¿Qué indica la propiedad eventPhase?
Respuesta:La propiedad eventPhase indica la fase actual de la
propagación del evento, que puede ser de captura, en el
objetivo o de burbujeo, ayudando a los desarrolladores a
entender cómo fluyen los eventos a través del árbol del
documento.

[Link]
¿Se puede cancelar la acción predeterminada de un
evento? ¿Cómo?
Respuesta:Sí, la acción predeterminada se puede cancelar
utilizando el método preventDefault() si el evento es
cancelable, lo que permite a los desarrolladores controlar
cómo se comportan los eventos en una página web.
[Link]
¿Cuáles son las diferencias en las propiedades entre el
objeto Event del DOM y el modelo de evento de IE?
Respuesta:Aunque ambos proporcionan funcionalidades
similares, el modelo de evento de IE incluye propiedades
adicionales como cancelBubble, que se usa para evitar que el
evento se propague más, mientras que el modelo del DOM
utiliza métodos como stopPropagation() para efectos
similares.

[Link]
¿Qué representa la propiedad target en el objeto Event?
Respuesta:La propiedad target representa el nodo del
documento que generó el evento, permitiendo a los
manejadores identificar la fuente del evento.

[Link]
¿Cómo se determina la posición de los eventos del mouse?
Respuesta:Los eventos del mouse se determinan por
propiedades como clientX y clientY, que dan las coordenadas
X e Y del puntero del mouse en relación con la ventana del
navegador.
[Link]
En el contexto del manejo de eventos, ¿qué se entiende
por 'burbujeo'?
Respuesta:El burbujeo es una fase en la propagación de
eventos donde el evento comienza desde el elemento objetivo
y se propaga hacia arriba a través de los ancestros en la
jerarquía del DOM, permitiendo que los elementos padres
también respondan al evento.

[Link]
¿Cuál es la importancia de definir constantes como
Event.CAPTURING_PHASE, Event.AT_TARGET y
Event.BUBBLING_PHASE?
Respuesta:Estas constantes proporcionan una manera
estandarizada de referirse a fases específicas de la
propagación de eventos, ayudando a los desarrolladores a
gestionar y comprender el flujo de eventos más fácilmente.

[Link]
¿Por qué podría ser útil el objeto Event de Netscape 4 a
pesar de los estándares de DOM Level 2?
Respuesta:El objeto Event de Netscape 4 puede ser útil para
programadores interesados en eventos de teclado, ya que
DOM Level 2 no especifica eventos de teclado,
proporcionando así una forma alternativa de manejar tales
situaciones.
Capítulo 22 | Global| Preguntas y respuestas
[Link]
¿Cuál es la importancia del objeto Global en JavaScript y
cómo se relaciona con las propiedades y métodos
definidos por el usuario?
Respuesta:El objeto Global en JavaScript es la base
fundamental del lenguaje, permitiendo que
cualquier variable y función definida en el nivel
superior de tu código se convierta en una propiedad
de este objeto. Esto significa que si declaras una
variable en tu script sin envolverla en ningún objeto,
esencialmente pertenece al objeto Global. Por
ejemplo, si defines una función `function greet() {
return 'Hello, World!'; }`, puedes llamarla en
cualquier lugar como `greet()` ya que es
inherentemente parte del objeto Global. Este
principio es crucial porque enfatiza cómo funciona
el ámbito en JavaScript; entender el objeto Global
ayuda a prevenir conflictos de nombres y permite a
los desarrolladores utilizar recursos globales de
manera sabia.

[Link]
¿Puedes explicar la diferencia entre las funciones
encodeURI() y encodeURIComponent()? ¿Por qué es
importante entender sus diferencias?
Respuesta:La función `encodeURI()` se utiliza para codificar
una URI (Identificador Uniforme de Recursos) completa,
pero no codifica caracteres que tienen significados especiales
en una URI, como `#`, `?` y `&`. Por otro lado,
`encodeURIComponent()` codifica caracteres que pueden
crear problemas en los componentes de una URI, lo que la
hace adecuada para codificar componentes individuales de
una URI. Por ejemplo, si deseas enviar un parámetro de
consulta que incluya símbolos especiales, deberías usar
`encodeURIComponent()` para asegurarte de que se
transmitan de manera segura. Entender estas diferencias es
crucial para evitar errores al construir URIs, asegurando que
tus aplicaciones interpreten y naveguen correctamente entre
URLs.

[Link]
¿Qué papel juega la función eval() en JavaScript y cuáles
son las implicaciones de usarla?
Respuesta:La función `eval()` evalúa una cadena de código
JavaScript que se le pasa como parámetro y la ejecuta como
si fuera código real. Por ejemplo, llamar a `eval('2 + 2')`
devolvería `4`. Sin embargo, es importante usar `eval()` con
precaución, ya que puede introducir riesgos de seguridad,
especialmente si se ejecutan cadenas proporcionadas por el
usuario, lo que puede llevar a ataques de inyección de
código. Además, puede dificultar la depuración y afectar el
rendimiento. Por lo tanto, confiar en `eval()` generalmente se
desaconseja en favor de prácticas de codificación más
seguras y mantenibles.

[Link]
¿Cómo contribuyen funciones como isNaN() e isFinite() al
manejo de valores numéricos en JavaScript?
Respuesta:Las funciones `isNaN()` e `isFinite()`
proporcionan una forma de validar valores numéricos en
JavaScript. `isNaN()` verifica si un valor dado es el valor
especial Not-a-Number (NaN), lo que puede ayudar a
asegurar que las operaciones destinadas a variables
numéricas no produzcan errores. Por otro lado, `isFinite()`
verifica si un valor es un número finito, lo cual es crucial
para gestionar eficazmente los límites numéricos en las
aplicaciones, previniendo problemas como el
desbordamiento aritmético o comportamientos inesperados
de los valores infinitos. Estas funciones empoderan a los
desarrolladores para manejar las entradas numéricas de
manera robusta, mejorando la fiabilidad de sus aplicaciones.

[Link]
¿Cuál era el propósito de las funciones escape() y
unescape(), y por qué deberían ser desaprobadas a favor
de funciones más nuevas?
Respuesta:Las funciones `escape()` y `unescape()` se
utilizaban originalmente para codificar y decodificar cadenas,
reemplazando caracteres especiales con representaciones
hexadecimales. Sin embargo, estas funciones fueron
desaprobadas en ECMAScript 3 debido a su funcionalidad
limitada y al potencial de malinterpretar ciertos caracteres.
Alternativas modernas como `encodeURI()`,
`encodeURIComponent()`, `decodeURI()`, y
`decodeURIComponent()` proporcionan capacidades de
codificación y decodificación más precisas y completas,
haciéndolas más seguras y efectivas para trabajar con URIs y
asegurando que las cadenas estén correctamente formateadas
para su transmisión a través de la web.
Capítulo 23 | Input| Preguntas y respuestas
[Link]
¿Cuál es la importancia de la propiedad 'checked' en el
objeto Input y cómo puede mejorar la experiencia del
usuario en los formularios?
Respuesta:La propiedad 'checked' permite a los
desarrolladores determinar si una casilla de
verificación o un botón de opción están
seleccionados por el usuario. Esto es crucial para
formularios que requieren selecciones del usuario,
como acuerdos o preferencias. Ajustar esta
propiedad puede mejorar la experiencia del usuario
al recordar las elecciones del usuario a través de
sesiones o controlar el estado de los componentes de
la interfaz de usuario según las interacciones del
usuario. Por ejemplo, si se está completando un
formulario y el usuario vuelve a una sección, marcar
previamente las opciones relevantes puede ahorrar
tiempo y reducir la frustración.

[Link]
¿Cómo juega un papel la propiedad 'defaultValue' en la
usabilidad del formulario y por qué es importante para
una buena experiencia del usuario?
Respuesta:La propiedad 'defaultValue' define qué texto
aparece en los campos de texto o contraseña cuando se carga
por primera vez el formulario. Esto es importante ya que
proporciona a los usuarios ejemplos de la entrada esperada,
guiando visualmente sus entradas. Por ejemplo, colocar un
marcador de posición como 'Introduce tu correo electrónico'
ayuda a los usuarios a entender el formato requerido. Una
buena usabilidad disminuye las tasas de error y aumenta la
satisfacción, haciendo que los formularios sean menos
intimidantes.

[Link]
Explica la importancia de la propiedad 'value' en varios
tipos de entrada y cómo afecta la presentación de datos en
aplicaciones web.
Respuesta:La propiedad 'value' contiene los datos que se
transmitirán cuando se envíe un formulario. Para entradas de
texto y contraseña, refleja el texto ingresado por el usuario,
lo que lo hace esencial para recopilar los datos del usuario de
manera precisa. Para botones, muestra la etiqueta, guiando a
los usuarios sobre acciones como 'Enviar' o 'Restablecer'.
Asegurarse de que se capture el valor correcto ayuda a
mantener la integridad de los datos y mejora la funcionalidad
general de la aplicación.

[Link]
¿Qué ventajas ofrecen los métodos 'focus()' y 'blur()' para
los elementos del formulario, especialmente en términos
de accesibilidad?
Respuesta:Los métodos 'focus()' y 'blur()' son vitales para
mejorar la accesibilidad del formulario. 'focus()' permite a los
desarrolladores dirigir programáticamente la atención del
usuario a campos de entrada específicos, lo que puede ayudar
significativamente a las personas que utilizan navegación por
teclado o tecnologías de asistencia. Por otro lado, 'blur()'
ayuda a gestionar el enfoque del teclado, contribuyendo a una
experiencia de interfaz de usuario más fluida. Juntos, ayudan
a crear una atmósfera más interactiva y fácil de usar,
haciendo que los formularios sean accesibles para un público
más amplio.

[Link]
¿Por qué es crucial para los desarrolladores comprender
los controladores de eventos como 'onchange' y 'onclick'
al trabajar con JavaScript del lado del cliente?
Respuesta:Comprender los controladores de eventos como
'onchange' y 'onclick' es esencial para los desarrolladores, ya
que permiten la interactividad y la capacidad de respuesta en
los formularios web. 'onchange' permite que la aplicación
reaccione cuando los usuarios terminan su entrada, activando
la validación o la lógica de procesamiento. 'onclick' habilita
acciones al hacer clic en botones, siendo crucial para
determinar las intenciones del usuario. Dominar estos
eventos fomenta una experiencia del usuario dinámica,
haciendo que las aplicaciones se sientan receptivas e
intuitivas, lo que en última instancia conduce a una mayor
satisfacción del usuario.
Capítulo 24 | Capa| Preguntas y respuestas
[Link]
¿Cuál es la importancia del objeto Layer en Netscape 4 y
por qué se considera no estándar?
Respuesta:El objeto Layer era significativo porque
proporcionaba un medio para trabajar con
elementos posicionados dinámicamente usando
JavaScript en Netscape 4, que carecía de un
estándar sólido para manejar la posición en ese
momento. Sin embargo, se considera no estándar
porque esta característica no fue adoptada en
versiones posteriores de Netscape, como Netscape 6,
y no cumple con las prácticas modernas de
desarrollo web. Su uso es mayormente histórico,
ejemplificando la evolución de las tecnologías web.

[Link]
¿Cómo gestiona el objeto Layer la visibilidad y la
posición en una página web?
Respuesta:El objeto Layer permite a los desarrolladores
controlar la visibilidad de las capas a través de propiedades
como 'hidden' y 'visibility', lo que permite mostrar u ocultar
secciones de una página web de manera dinámica. Además,
propiedades como 'left', 'top' y 'zIndex' definen la posición de
la capa dentro del documento, permitiendo un control preciso
sobre el diseño y la superposición. Por ejemplo, establecer un
'zIndex' más alto en una capa asegura que aparezca sobre otra
capa, lo que es crucial para crear presentaciones web
interactivas.
[Link]
¿Puedes explicar cómo funcionan los métodos moveAbove
y moveBelow?
Respuesta:Los métodos 'moveAbove( other_layer)' y
'moveBelow( other_layer)' se utilizan para modificar el orden
de apilamiento de los objetos Layer. Cuando quieres que una
capa intercepte visualmente a otra (como hacer que un
pop-up aparezca sobre un fondo), llamarías a 'moveAbove' en
esa capa, pasando la otra capa como argumento. Por el
contrario, 'moveBelow' te permite colocar una capa detrás de
otra, controlando efectivamente qué contenido se ve primero
por el usuario. Este es un aspecto fundamental de la
superposición en el diseño web, mejorando la experiencia del
usuario.

[Link]
¿Cuál es el propósito de las propiedades 'clip' en el objeto
Layer?
Respuesta:Las propiedades 'clip' definen el área visible de un
objeto Layer. Al establecer las dimensiones y coordenadas
del área de recorte (como [Link], [Link], [Link] y
[Link]), los desarrolladores pueden crear efectos donde
solo se muestra una parte de la capa mientras se recorta el
resto. Esto es particularmente útil en escenarios donde hay
contenido superpuesto, ya que permite personalizar qué
partes de la capa son visibles para los usuarios.

[Link]
¿En qué se diferencia el objeto Layer en Netscape 4 de los
estándares web modernos como HTML5 y CSS?
Respuesta:El objeto Layer es específico de Netscape 4 y ha
quedado obsoleto por los estándares modernos de CSS que
utilizan estilos como 'position: absolute;' para propósitos
similares de manera consistente en todos los navegadores. A
diferencia del objeto Layer, que era poco fiable debido a su
no estandarización, CSS proporciona un marco bien
establecido para la posicionamiento y visibilidad que es
universalmente aceptado y funcional en el diseño web
contemporáneo. Esta evolución ilustra un cambio hacia
prácticas estandarizadas en el desarrollo web.
[Link]
¿Qué deben considerar los desarrolladores al trabajar
con características no estándar como el objeto Layer?
Respuesta:Los desarrolladores deben ser cautelosos al usar
características no estándar como el objeto Layer, ya que
pueden no funcionar en todos los navegadores o en versiones
futuras. Es esencial priorizar la compatibilidad y la capacidad
de respuesta; usar características estándar de HTML5 y CSS
asegura una accesibilidad más amplia y la longevidad de las
aplicaciones web. Además, depender de tecnologías
obsoletas podría generar problemas de mantenimiento y una
mala experiencia para el usuario.
Capítulo 25 | Enlace| Preguntas y respuestas
[Link]
¿Cuáles son las principales propiedades de un objeto Link
en JavaScript y por qué son importantes?
Respuesta:Las principales propiedades de un objeto
Link incluyen hash, host, hostname, href, pathname,
port, protocol, search y target. Estas propiedades
son importantes porque permiten a los
desarrolladores manipular y entender diversos
componentes de una URL, permitiendo un
comportamiento dinámico en aplicaciones web,
como navegaciones, búsquedas e interacciones
dentro de diferentes marcos o ventanas. Por
ejemplo, al modificar el `href`, los desarrolladores
pueden redirigir a los usuarios a diferentes páginas,
mejorando la experiencia del usuario.

[Link]
¿Cómo pueden los controladores de eventos de JavaScript
para enlaces mejorar la interacción del usuario?
Respuesta:Los controladores de eventos como onclick,
onmouseover y onmouseout proporcionan una forma de
responder a las acciones del usuario sobre los enlaces,
mejorando la interactividad. Por ejemplo, con el controlador
de eventos onclick, los desarrolladores pueden ejecutar
código JavaScript adicional cuando un usuario hace clic en
un enlace, como rastrear clics para análisis o prevenir la
navegación devolviendo false. Esto permite experiencias de
usuario más ricas y un control sobre cómo se comportan los
enlaces según el contexto.

[Link]
¿Por qué usarías la propiedad target de un objeto Link?
Respuesta:La propiedad target se utiliza para especificar
cómo se debe mostrar un documento vinculado en relación
con la ventana o marco actual. Usando valores como '_blank'
se abre el enlace en una nueva pestaña, mientras que '_self' lo
abre en el mismo marco. Esto permite a los desarrolladores
crear una experiencia de navegación controlada, facilitando
una mejor navegación sin perder la página actual.
[Link]
¿Puedes explicar la importancia de la propiedad search
en una URL?
Respuesta:La propiedad search, que incluye la cadena de
consulta de una URL, es significativa porque se relaciona con
cómo se envían los datos al servidor para su procesamiento.
Por ejemplo, en una aplicación de búsqueda, parámetros
como `?q=JavaScript&m=10` ayudan a transmitir la entrada
o preferencias del usuario al servidor, permitiendo respuestas
y resultados personalizados. Esto subraya la importancia de
entender los componentes de la URL para un desarrollo web
efectivo.

[Link]
¿Cómo contribuye comprender las propiedades del objeto
Link a buenas prácticas de desarrollo web?
Respuesta:Comprender las propiedades del objeto Link
permite a los desarrolladores crear aplicaciones web robustas
y dinámicas que interactúan sin problemas con los usuarios.
Por ejemplo, al manipular las propiedades href o search, los
desarrolladores pueden cambiar dinámicamente el contenido
sin necesidad de recargar la página. Esto enriquece la
experiencia del usuario y aumenta la participación,
mostrando cómo un conocimiento profundo de JavaScript
puede llevar a una mejor funcionalidad y satisfacción en
proyectos web.
Capítulo 26 | Math| Preguntas y respuestas
[Link]
¿Cuál es el propósito del objeto Math en JavaScript?
Respuesta:El objeto Math sirve como una colección
de constantes y funciones matemáticas. A diferencia
de otros objetos como Date y String, no representa
una clase de objetos y no se puede instanciar. En su
lugar, proporciona métodos estáticos que realizan
diversas operaciones matemáticas.

[Link]
¿Cuál es la importancia de la constante [Link]?
Respuesta:[Link] es una constante matemática crucial que
representa la relación entre la circunferencia de un círculo y
su diámetro, aproximadamente 3.14159. Se utiliza
ampliamente en cálculos que involucran círculos,
trigonometría y geometría.

[Link]
¿Cómo mejora la función [Link] el manejo de datos?
Respuesta:La función [Link] devuelve el valor absoluto de
un número dado, permitiendo a los desarrolladores ignorar
fácilmente el signo de un número. Esto es útil en situaciones
donde solo importa la magnitud de un número, como en
cálculos de distancias.

[Link]
¿Puedes explicar la diferencia entre [Link] y
[Link]?
Respuesta:[Link] devuelve el mayor de los argumentos
proporcionados, mientras que [Link] devuelve el menor.
Esta funcionalidad es esencial para comparar valores
numéricos y determinar los extremos en conjuntos de datos.

[Link]
¿Cómo funciona la función [Link] y cuándo
podría usarse?
Respuesta:[Link] genera un número de punto flotante
pseudoaleatorio entre 0 (inclusive) y 1 (exclusive). Esta
función es especialmente útil en situaciones que involucran
aleatoriedad, como la creación de elementos aleatorios en
juegos, el desordenamiento de datos o la selección de
usuarios al azar.

[Link]
¿Cuál es el beneficio de usar [Link]?
Respuesta:[Link] permite la exponentiación, lo que
significa que puede calcular cualquier número elevado a
cualquier potencia. Esta operación es fundamental en muchos
cálculos matemáticos, desde cuadrados simples hasta
cálculos de potencias más complejos que surgen en campos
como la física y la ingeniería.

[Link]
¿Cuál es el uso práctico de las funciones [Link] y
[Link]?
Respuesta:[Link] redondea un número hacia arriba al
entero más cercano, mientras que [Link] redondea hacia
abajo. Esto puede ser útil en aplicaciones que requieren
valores enteros limpios, como en la paginación, donde no se
pueden tener páginas fraccionarias.

[Link]
¿Cómo mejora la comprensión de las funciones
matemáticas en JavaScript las habilidades de
programación?
Respuesta:Comprender las funciones matemáticas permite a
los desarrolladores de JavaScript manipular números de
manera efectiva, resolver problemas complejos e innovar
soluciones digitales, fomentando la creatividad y la lógica en
el desarrollo de software.
Capítulo 27 | Navegador| Preguntas y respuestas
[Link]
¿Cuál es el propósito de la propiedad `appCodeName` en
Navigator?
Respuesta:La propiedad `appCodeName`
proporciona un apodo para el navegador,
asegurando la compatibilidad entre diferentes
navegadores. Por ejemplo, es 'Mozilla' en todos los
navegadores Netscape y también en los de Microsoft
por coherencia.

[Link]
¿Cómo puede ser útil la propiedad `appVersion` en el
desarrollo de JavaScript?
Respuesta:La propiedad `appVersion` ofrece información
detallada sobre la versión del navegador y la plataforma en la
que se está ejecutando. Utilizando funciones como
`parseInt()` y `parseFloat()`, los desarrolladores pueden
extraer fácilmente los números de versión principal y
secundaria, lo que puede ayudar a adaptar el comportamiento
de la aplicación web a versiones específicas del navegador.

[Link]
¿Qué tipo de información proporciona la propiedad
`cookieEnabled` y por qué es importante?
Respuesta:La propiedad `cookieEnabled` indica si el
navegador tiene habilitados las cookies. Esto es crucial para
los desarrolladores al implementar características que
dependen de las cookies para la gestión de sesiones,
preferencias de usuario o seguimiento.

[Link]
¿En qué escenarios podrían ser particularmente útiles las
propiedades `language` y `userLanguage`?
Respuesta:La propiedad `language` puede ayudar a los
desarrolladores a personalizar el contenido según el idioma
predeterminado del navegador del usuario, mientras que
`userLanguage` indica el idioma preferido del usuario. Esto
es especialmente beneficioso para crear aplicaciones web
localizadas que mejoran la experiencia del usuario.

[Link]
¿Por qué es significativo que la propiedad `platform`
pueda tener valores variados?
Respuesta:Los valores variados de la propiedad `platform`
recuerdan a los desarrolladores que sus aplicaciones web
deben adaptarse a una amplia gama de sistemas operativos y
configuraciones de hardware. Comprender estas variaciones
puede influir en las decisiones de diseño y en las estrategias
de prueba para garantizar la compatibilidad entre
plataformas.

[Link]
¿Qué indica el método `javaEnabled()` sobre un
navegador y cómo puede afectar a la funcionalidad web?
Respuesta:El método `javaEnabled()` verifica si Java está
soportado en el navegador actual. Esto es significativo
porque ciertas aplicaciones web o applets dependen de Java;
saber si está habilitado puede determinar si se deben cargar
estos componentes.

[Link]
¿Cómo mejoran las propiedades y métodos de Navigator
las prácticas de desarrollo web?
Respuesta:Estas propiedades y métodos brindan a los
desarrolladores información sobre el entorno del cliente,
permitiéndoles construir aplicaciones más robustas y
amigables. Pueden optimizar el rendimiento, asegurar la
compatibilidad y mejorar la interacción del usuario en
función de las capacidades específicas del navegador.
Capítulo 28 | Nodo| Preguntas y respuestas
[Link]
¿Cuáles son los diferentes tipos de nodos definidos en el
Nivel 1 del DOM y cómo clasifica la propiedad
nodeType?
Respuesta:Los tipos de nodos en el Nivel 1 del DOM
incluyen Nodo de Elemento (nodeType = 1), Nodo de
Atributo (nodeType = 2), Nodo de Texto (nodeType
= 3), Nodo de Comentario (nodeType = 8), Nodo de
Documento (nodeType = 9) y Nodo de Fragmento de
Documento (nodeType = 11). La propiedad
nodeType nos permite identificar a qué subclase
pertenece una instancia de Nodo, proporcionando
claridad sobre cómo interactuar con él.

[Link]
¿Cuál es la importancia de la propiedad attributes en los
nodos Elemento y cómo se utiliza normalmente?
Respuesta:La propiedad attributes de un nodo Elemento es
un array de solo lectura que contiene los objetos Attr que
representan los atributos del elemento. Aunque se puede
acceder a él por número o por nombre de atributo, es menos
común utilizar este array ya que todos los atributos HTML
también tienen propiedades correspondientes en el objeto
Element, lo que hace que el acceso directo sea generalmente
más sencillo.

[Link]
Explica el propósito del método addEventListener y sus
parámetros. ¿Cómo se relaciona con el manejo de eventos
en el DOM?
Respuesta:El método addEventListener se utiliza para
registrar un oyente de eventos para un nodo. Sus parámetros
incluyen type (una cadena que especifica el tipo de evento,
como 'click'), listener (la función manejadora del evento que
se activará) y useCapture (un booleano que indica la fase de
propagación del evento). Esto es crucial para manejar
interacciones de usuario y hacer que la aplicación web sea
receptiva a eventos.

[Link]
¿Cómo funciona el método insertBefore y qué papel
desempeña en la manipulación del árbol DOM?
Respuesta:El método insertBefore nos permite agregar un
nuevo Nodo hijo al árbol del documento justo antes de un
Nodo refChild especificado que ya es hijo de su padre. Este
método es fundamental para reorganizar la estructura del
DOM, ya que puede actualizar dinámicamente la
representación visual del documento sin necesidad de recrear
elementos.

[Link]
Describe el método cloneNode y su parámetro deep. ¿Por
qué podría usarse esta funcionalidad?
Respuesta:El método cloneNode devuelve una copia del
Nodo especificado. El parámetro deep determina si también
se deben clonar los descendientes del Nodo, creando así una
copia completa del subárbol (si es verdadero). Esto es útil
para duplicar elementos, especialmente en situaciones donde
se quiere preservar una estructura compleja y sus atributos.

[Link]
¿Cuál es la importancia del método normalize en el
contexto de los nodos de Texto?
Respuesta:El método normalize limpia un Nodo fusionando
nodos de Texto adyacentes y eliminando los vacíos. Esto
ordena efectivamente el contenido, asegurando que la
estructura del documento no esté desordenada con nodos
innecesarios, lo que puede mejorar el rendimiento y hacer
que la manipulación posterior sea más eficiente.

[Link]
¿Puedes describir la relación entre parentNode y
childNodes en el árbol DOM?
Respuesta:La propiedad parentNode se refiere al padre
inmediato del Nodo, mientras que childNodes se refiere a la
colección de Nodos que son hijos directos de un Nodo. Estas
relaciones representan la naturaleza jerárquica del DOM,
permitiendo a los desarrolladores navegar y manipular
elementos según su contexto estructural.

[Link]
¿Cuáles son algunos métodos para eliminar un Nodo del
DOM y cómo funcionan?
Respuesta:Los métodos removeChild y removeEventListener
sirven para gestionar Nodos en el DOM. removeChild toma
un Nodo oldChild como argumento y lo elimina de su padre.
Esta operación ayuda a alterar dinámicamente el contenido
de una página web. removeEventListener, por otro lado,
desvincula un oyente de eventos que se había adjuntado
anteriormente, permitiendo controlar las interacciones de
eventos para un elemento.
Capítulo 29 | Número| Preguntas y respuestas
[Link]
¿Cuál es el propósito del constructor Number en
JavaScript?
Respuesta:El constructor Number, cuando se invoca
con el operador 'new', crea un nuevo objeto Number
y convierte su argumento en un valor numérico. Si
se usa sin 'new', funciona como una función de
conversión que convierte directamente su
argumento en un número.

[Link]
¿Cuáles son las constantes clave definidas en el objeto
Number?
Respuesta:Las constantes clave incluyen:
Number.MAX_VALUE (el número más grande
representable, ~1.79E+308), Number.MIN_VALUE (el
número más pequeño representable, ~5E-324), [Link]
(valor no numérico), Number.NEGATIVE_INFINITY (valor
infinito negativo) y Number.POSITIVE_INFINITY (valor
infinito positivo). Estas constantes proporcionan límites
importantes y valores especiales para cálculos numéricos.

[Link]
¿Cómo funciona el método toExponential en JavaScript?
Respuesta:El método toExponential convierte un número en
una cadena en notación exponencial, asegurando que haya un
dígito antes del punto decimal y un número especificado de
dígitos después de él. El parámetro 'digits' puede estar entre 0
y 20, y ajusta el número en consecuencia redondeando o
completando con ceros cuando es necesario.

[Link]
¿Puedes explicar la diferencia entre los métodos toFixed y
toLocaleString?
Respuesta:El método toFixed devuelve una representación en
cadena de un número con un número fijo de decimales,
definido por el parámetro 'digits'. En contraste,
toLocaleString formatea el número de acuerdo con las
convenciones locales, que pueden incluir diferentes símbolos
para los puntos decimales y los separadores de miles,
haciéndolo más adecuado para presentaciones amigables para
el usuario.

[Link]
¿Cuál es el significado de [Link] en JavaScript?
Respuesta:[Link] representa un valor 'no numérico',
que es esencial para el manejo de errores y la validación de
cálculos numéricos en JavaScript. Indica que un valor no es
un número válido, lo cual es importante para asegurar la
integridad de las operaciones matemáticas.

[Link]
¿Cómo convertirías un número a una cadena en una base
diferente usando JavaScript?
Respuesta:Puedes usar el método toString del objeto
Number, especificando la base (o radix). La radix puede ser
cualquier número entero entre 2 y 36, lo que te permite
convertir el número en binario, decimal, hexadecimal u otros
sistemas numéricos. Si no se proporciona ninguna radix, por
defecto es base 10.

[Link]
¿Cuáles son algunas implicaciones de usar constantes
Number como Number.MAX_VALUE y
Number.MIN_VALUE en tu código?
Respuesta:El uso de constantes como
Number.MAX_VALUE y Number.MIN_VALUE ayuda a los
desarrolladores a establecer límites en los cálculos
numéricos, evitar errores de desbordamiento o
subdesbordamiento, y escribir un código más robusto y
resistente a errores. Estas constantes proporcionan una
protección contra el exceso de las capacidades numéricas de
JavaScript.

[Link]
¿En qué escenarios se utilizaría el método toPrecision?
Respuesta:El método toPrecision es particularmente útil
cuando necesitas presentar números con un número
específico de dígitos significativos, como en informes
científicos, estados financieros, o siempre que se requiera un
control preciso sobre la representación de datos numéricos.
Capítulo 30 | Objeto| Preguntas y respuestas
[Link]
¿Cuál es la importancia del constructor Object en
JavaScript?
Respuesta:El constructor Object es fundamental en
JavaScript, ya que crea un objeto vacío al que se
pueden añadir propiedades arbitrarias. Esta
flexibilidad es crucial para la programación
dinámica, permitiendo a los desarrolladores crear
estructuras que pueden contener diferentes tipos de
datos y propiedades según sea necesario.

[Link]
¿Cómo mejoran los métodos 'hasOwnProperty',
'isPrototypeOf' y 'propertyIsEnumerable' las
interacciones con objetos en JavaScript?
Respuesta:Estos métodos proporcionan herramientas
esenciales para gestionar las propiedades de los objetos y la
herencia en JavaScript. 'hasOwnProperty' permite verificar si
una propiedad pertenece directamente a un objeto,
asegurando la integridad de los datos. 'isPrototypeOf' ayuda a
entender las cadenas de prototipos, facilitando la herencia.
'propertyIsEnumerable' ofrece información sobre la
visibilidad de las propiedades durante la enumeración, lo cual
es vital para los procesos de iteración, como los bucles.

[Link]
¿En qué se diferencia 'toString()' entre los distintos tipos
de objetos en JavaScript?
Respuesta:Mientras que el método base 'toString()' en la
clase Object ofrece una representación genérica, diferentes
tipos de objetos como Number o Boolean suelen sobrescribir
este método para proporcionar una salida más significativa.
Por ejemplo, al llamar a 'toString()' en un Number, se
devuelve el número como una cadena, lo que lo hace más útil
para los desarrolladores que buscan salidas específicas.
[Link]
¿Por qué un subclass podría sobrescribir el método
'toLocaleString()'?
Respuesta:Un subclass podría sobrescribir 'toLocaleString()'
para proporcionar una representación de cadena específica
para la localidad, mejorando la usabilidad para la
internacionalización. Por ejemplo, un objeto Date podría
formatear las fechas de manera diferente según la
configuración regional del usuario, asegurando que las
aplicaciones puedan atender a diversos grupos de usuarios de
manera eficaz.

[Link]
¿Cuál es el papel del método 'valueOf()' en los objetos de
JavaScript?
Respuesta:El método 'valueOf()' está diseñado para devolver
el valor primitivo asociado con un objeto cuando es
necesario, como durante operaciones que requieren un tipo
no objeto. Por ejemplo, cuando se utiliza un objeto en un
contexto matemático, invocar 'valueOf()' permite que la
operación lo convierta al tipo primitivo relevante sin
problemas.
Capítulo 31 | RegExp| Preguntas y respuestas
[Link]
¿Cuál es el propósito de usar expresiones regulares en
JavaScript?
Respuesta:Las expresiones regulares se utilizan para
hacer coincidencias de patrones en cadenas, lo que
permite buscar, reemplazar y manipular texto
basado en patrones específicos. Esto puede ser
particularmente útil para tareas como validar la
entrada del usuario, analizar archivos de texto o
implementar funcionalidades de búsqueda.

[Link]
¿Cómo influye la propiedad 'global' de un RegExp en el
proceso de coincidencia?
Respuesta:La propiedad 'global', cuando se establece en
verdadero, indica que la expresión regular buscará todas las
coincidencias en la cadena en lugar de detenerse después de
la primera coincidencia. Esto significa que si utilizas el
indicador global (g) en tu RegExp, métodos como exec()
devolverán todas las coincidencias encontradas.

[Link]
¿Qué hace la propiedad 'ignoreCase' en el contexto de las
expresiones regulares?
Respuesta:La propiedad 'ignoreCase' permite hacer
coincidencias sin tener en cuenta mayúsculas y minúsculas.
Esto significa que si se crea un RegExp con el atributo 'i',
tratará las letras mayúsculas y minúsculas como equivalentes
al realizar coincidencias, facilitando así la coincidencia de
cadenas independientemente de su caso.

[Link]
¿Puedes explicar la importancia de la propiedad
'lastIndex' en un RegExp global?
Respuesta:La propiedad 'lastIndex' es crucial para los objetos
RegExp globales porque mantiene un registro de la posición
en la cadena donde comenzará la próxima coincidencia.
Después de llamar a exec() o test() en un RegExp global, esta
propiedad se actualiza para apuntar al carácter justo después
de la última coincidencia, permitiendo una iteración
adecuada a través de la cadena sin perder coincidencias.

[Link]
¿Cuándo usarías la propiedad 'multiline' de un RegExp?
Respuesta:La propiedad 'multiline' es útil cuando trabajas
con cadenas que contienen caracteres de nueva línea. Al
establecer el atributo 'm' en tu RegExp, la coincidencia de
patrones tratará cada línea como una cadena separada, lo que
afecta el comportamiento de los anclajes de inicio (^) y fin
($) para coincidir tanto al principio como al final de cada
línea, en lugar de solo al inicio y al final de toda la cadena.

[Link]
¿Cuál es el resultado de usar el método 'exec()' en una
cadena con un RegExp, y cómo puedes interpretar sus
resultados?
Respuesta:Cuando se utiliza el método 'exec()' en una cadena
con un RegExp, devuelve un array que incluye el texto
coincidente completo como el primer elemento, junto con
cualquier grupo capturado como elementos subsecuentes. Si
no se encuentra ninguna coincidencia, devuelve null. Este
array también incluye una propiedad 'index' que indica dónde
se encontró la coincidencia en la cadena original, facilitando
localizar la coincidencia dentro de la cadena.

[Link]
¿En qué se diferencian 'test()' y 'exec()' al trabajar con
RegExp?
Respuesta:El método 'test()' devuelve un booleano que indica
si el RegExp coincide con alguna parte de la cadena, lo que
lo convierte en una forma rápida de verificar una
coincidencia. En contraste, 'exec()' proporciona un array
detallado de coincidencias que incluye grupos capturados, lo
que lo hace más informativo pero también más complejo.
Usa 'test()' para comprobaciones simples y 'exec()' cuando
necesites información de coincidencia más detallada.
Capítulo 32 | Select| Preguntas y respuestas
[Link]
¿Cuál es la importancia de la propiedad `selectedIndex`
en un objeto Select?
Respuesta:La propiedad `selectedIndex` es vital ya
que permite a los desarrolladores rastrear qué
opción ha seleccionado el usuario dentro de una lista
desplegable. Devuelve el valor del índice de la opción
actualmente seleccionada, lo que puede ser útil para
lógica condicional en scripts. Por ejemplo, si un
usuario selecciona 'Opción 2', `selectedIndex`
devolvería 1 (ya que comienza en cero), lo que
permite ejecutar código específico o manipular la
interfaz según la elección del usuario.

[Link]
¿Cómo se añaden opciones a un elemento Select
utilizando JavaScript?
Respuesta:Para añadir opciones a un elemento Select, puedes
utilizar el constructor `Option()` para crear una nueva opción
y luego adjuntarla al array `options` del objeto Select. Por
ejemplo:

```javascript
var selectElement = [Link]('miSelect');
var newOption = new Option('Texto de Nueva Opción',
'valorNuevaOpcion');
[Link][[Link]] =
newOption;
```
Este fragmento de código añade de manera efectiva una
nueva opción al final de la lista de selección, aumentando la
interacción y las opciones para el usuario.

[Link]
¿En qué escenarios usarías el método `remove` en un
objeto Select?
Respuesta:Normalmente utilizarías el método `remove`
cuando necesites actualizar dinámicamente el contenido de
una lista de selección en función de las interacciones del
usuario o la lógica de la aplicación. Por ejemplo, si un
usuario selecciona su país de una lista y deseas filtrar países
que no son relevantes según su elección, puedes eliminar las
opciones irrelevantes del elemento Select para mejorar la
experiencia del usuario.
[Link]
Explica el propósito de los controladores de eventos como
`onchange` y `onfocus` en el contexto de los elementos
Select.
Respuesta:Los controladores de eventos como `onchange` y
`onfocus` son cruciales para mejorar la interactividad en las
aplicaciones web. El controlador de eventos `onchange` se
activa cuando el usuario selecciona o modifica su selección,
permitiendo una retroalimentación o actualizaciones
inmediatas en la interfaz basada en la selección realizada.
Esto podría usarse para cargar dinámicamente contenido
relacionado. Por otro lado, el controlador de eventos
`onfocus` se invoca cuando el usuario hace clic o navega
hacia el elemento Select, a menudo utilizado para resaltar el
elemento o proporcionar instrucciones al usuario, mejorando
así la usabilidad.

[Link]
¿Cuáles son las propiedades de solo lectura del objeto
Select y por qué son importantes?
Respuesta:El objeto Select contiene varias propiedades de
solo lectura, como `form`, `length` y `type`. Estas
propiedades proporcionan información esencial sobre el
contexto y la funcionalidad del elemento Select. Por ejemplo,
`form` permite acceder al objeto Form que contiene el Select,
lo que es útil para gestionar múltiples elementos de
formulario. `length` indica el conteo de opciones disponibles,
lo que puede ayudar a validar la entrada del usuario o ajustar
dinámicamente la interfaz según la cantidad de selecciones
disponibles. La propiedad `type` especifica si se permiten
múltiples selecciones, guiando a los desarrolladores sobre
cómo manejar adecuadamente la entrada del usuario.

[Link]
¿Cómo puede el método `add` facilitar la experiencia del
usuario en los formularios?
Respuesta:El método `add` mejora la experiencia del usuario
al permitir a los desarrolladores insertar opciones en los
elementos Select en posiciones específicas. Esto es
particularmente útil en escenarios donde el orden de las
opciones es importante, como asegurarse de que un elemento
'más relevante' aparezca en la parte superior de una lista
según la actividad o preferencias del usuario. Al gestionar
programáticamente las opciones disponibles, los
desarrolladores pueden crear una interfaz más intuitiva y
eficiente que responda dinámicamente a las necesidades del
usuario.
Capítulo 33 | Cadena| Preguntas y respuestas
[Link]
¿Cuál es la importancia de entender cómo manipular
cadenas en JavaScript?
Respuesta:Entender la manipulación de cadenas en
JavaScript es esencial, ya que permite a los
desarrolladores manejar y transformar datos
textuales de manera efectiva. Esto incluye tareas
como buscar caracteres específicos, concatenar
cadenas y realizar conversiones de mayúsculas y
minúsculas, que son fundamentales tanto en el
desarrollo front-end como back-end. Dominar estas
técnicas ayuda a crear aplicaciones dinámicas y a
garantizar una mejor experiencia para el usuario.

[Link]
¿Cómo mejora el método 'slice' la manipulación de
cadenas?
Respuesta:El método 'slice' es especialmente útil para extraer
porciones específicas de una cadena sin modificar la cadena
original. Permite a los desarrolladores obtener subcadenas
especificando índices de inicio y final, y admite índices
negativos que cuentan desde el final de la cadena. Por
ejemplo, al cortar la cadena '¡Hola Mundo!' con slice(6, 11)
se obtendrá 'Mundo', lo cual es instrumental en tareas como
la extracción de subcadenas en entradas de usuario o
procesamiento de datos.

[Link]
¿Por qué es esencial el método 'indexOf' al trabajar con
cadenas?
Respuesta:El método 'indexOf' es fundamental porque
proporciona una forma de localizar la primera ocurrencia de
una subcadena dentro de una cadena más grande,
devolviendo su posición. Esto es crucial para la validación de
datos, funcionalidades de búsqueda y coincidencias de
patrones, empoderando a los desarrolladores para construir
aplicaciones más inteligentes al permitir búsquedas
específicas dentro del texto.

[Link]
¿En qué escenarios utilizarías el método 'replace', y cómo
funciona?
Respuesta:El método 'replace' es invaluable cuando necesitas
actualizar o modificar partes de una cadena basándote en
patrones o textos específicos. Por ejemplo, si quisieras
cambiar todas las instancias de 'manzana' en 'Me encanta la
tarta de manzana' a 'naranja', podrías usar
replace(/manzana/g, 'naranja'), que utiliza una expresión
regular para asegurar que todas las ocurrencias se cambien.
Este método facilita actualizaciones de contenido dinámico,
como sanitizar entradas de usuario o generar nuevo texto
basado en preferencias del usuario.

[Link]
¿Cuáles son las mejores prácticas para crear un nuevo
objeto String y cuándo deberías usarlo?
Respuesta:Crear un nuevo objeto String utilizando 'new
String(s)' no se recomienda generalmente, ya que envuelve el
valor en un objeto en lugar de crear una cadena primitiva, lo
que puede llevar a comportamientos inesperados. La mejor
práctica es usar literales de cadena o el constructor String sin
'new'. Úsalo con moderación cuando necesites un objeto con
métodos de cadena; sin embargo, en la mayoría de los casos,
mantente con cadenas primitivas por razones de rendimiento
y simplicidad.

[Link]
¿Cómo contribuyen los métodos 'toLowerCase' y
'toUpperCase' a la consistencia de los datos?
Respuesta:Los métodos 'toLowerCase' y 'toUpperCase' son
vitales para mantener la consistencia de los datos,
especialmente en situaciones de entrada de usuario donde la
sensibilidad a mayúsculas y minúsculas puede llevar a
discrepancias. Por ejemplo, convertir la entrada del usuario a
minúsculas antes de almacenarla asegura que las
comparaciones sean uniformes, evitando problemas como
'NombreDeUsuario' frente a 'nombredeusuario'. Esta práctica
no solo mejora la integridad de los datos, sino que también
mejora la experiencia del usuario al evitar errores
relacionados con mayúsculas.

[Link]
¿Qué papel desempeñan las expresiones regulares en
métodos como 'match' y 'search'?
Respuesta:Las expresiones regulares (regex) son
herramientas poderosas utilizadas dentro de los métodos
'match' y 'search' para realizar coincidencias de patrones
complejas en cadenas. Estos métodos aprovechan las regex
para identificar secuencias específicas, validar formatos o
extraer información significativa de textos más grandes.
Dominar las expresiones regulares combinadas con estos
métodos eleva la capacidad de un desarrollador para
implementar funcionalidades de búsqueda sofisticadas,
validaciones de datos y tareas de procesamiento de texto.
Capítulo 34 | Estilo| Preguntas y respuestas
[Link]
¿Cuál es la relación entre las propiedades de CSS y las
propiedades de estilo del DOM en JavaScript?
Respuesta:Las propiedades del objeto Style en
JavaScript reflejan de cerca las de los atributos de
CSS, con ciertas convenciones de nomenclatura
adaptadas a la sintaxis de JavaScript. Por ejemplo,
propiedades de CSS como 'font-family' se convierten
en 'fontFamily' en JavaScript, eliminando los
guiones y capitalizando las palabras siguientes. Esto
permite a los desarrolladores manipular estilos de
CSS directamente a través del DOM de JavaScript.

[Link]
¿Cuáles son algunas consideraciones especiales al
trabajar con propiedades de estilo que tienen valores
numéricos?
Respuesta:Al tratar con propiedades de CSS que tienen
valores numéricos, es crucial convertir entre cadenas y
números. Usa parseFloat() para recuperar el valor numérico
de una cadena, y al establecer una propiedad, asegúrate de
convertir el número de nuevo a una cadena, incluyendo las
unidades necesarias (como 'px'); por ejemplo, establecer el
ancho de un elemento podría verse así: '[Link] =
"100px".'

[Link]
¿Por qué algunas propiedades de CSS pueden no estar
implementadas en todos los navegadores?
Respuesta:Los diferentes navegadores pueden tener distintos
niveles de soporte para las propiedades de CSS, lo que
significa que, aunque las propiedades de estilo estén
definidas dentro del objeto Style, su comportamiento puede
variar. Por eso, los desarrolladores deben verificar siempre la
compatibilidad entre navegadores y consultar recursos
externos de CSS para obtener la información más fiable.

[Link]
¿Cómo ayuda el modelo de objetos en JavaScript a
estilizar páginas web de manera dinámica?
Respuesta:El modelo de objetos de JavaScript permite la
manipulación en tiempo real de los estilos CSS, lo que
significa que los desarrolladores pueden cambiar la
apariencia de los elementos web de forma dinámica,
basándose en interacciones del usuario u otras condiciones.
Esto es fundamental para crear diseños responsivos y
aplicaciones web interactivas, mejorando la experiencia del
usuario al permitir una retroalimentación visual inmediata.

[Link]
¿Cuál es la importancia de la propiedad ‘cssFloat’ en
JavaScript?
Respuesta:La propiedad ‘cssFloat’ es una adaptación dentro
del objeto Style de JavaScript para manejar los atributos de
flotación de CSS, ya que 'float' es una palabra reservada en
JavaScript. Esto resalta la importancia de adaptar las
propiedades de CSS a la sintaxis de JavaScript y asegurar que
los desarrolladores puedan controlar efectivamente las
propiedades de diseño a través de scripting.

[Link]
¿Cómo pueden los desarrolladores asegurarse de que
están referenciando correctamente los estilos de CSS al
utilizar JavaScript?
Respuesta:Los desarrolladores deben referirse a referencias
de CSS actualizadas para comprender las propiedades
disponibles y su sintaxis. También necesitan tener en cuenta
las reglas que rigen cómo se convierten las propiedades de
CSS a propiedades de JavaScript, asegurándose de seguir las
convenciones de nomenclatura adecuadas para evitar errores
en su código.
Capítulo 35 | Window| Preguntas y respuestas
[Link]
¿Cuál es el propósito principal del objeto Window en
JavaScript del lado del cliente?
Respuesta:El objeto Window actúa como el objeto
global para todo JavaScript del lado del cliente,
proporcionando propiedades y métodos que facilitan
la interacción con el navegador y permiten a los
desarrolladores crear contenido dinámico.

[Link]
¿Cómo demuestra la función 'alert' la interactividad de
JavaScript?
Respuesta:La función 'alert' muestra un cuadro de diálogo
con un mensaje, pausando la ejecución del script hasta que el
usuario cierre el diálogo. Esto ejemplifica la capacidad de
JavaScript para crear experiencias interactivas en
aplicaciones web.

[Link]
¿Cuáles son los comportamientos especiales asociados con
la propiedad 'location' del objeto Window?
Respuesta:La propiedad 'location' puede recuperar la URL
actual de la ventana del navegador y, al asignarle una nueva
cadena de URL, indica al navegador que cargue y muestre la
URL especificada, lo que permite la navegación entre
diferentes páginas.

[Link]
¿Por qué es importante entender que JavaScript es un
lenguaje sensible a mayúsculas y minúsculas?
Respuesta:Saber que JavaScript es sensible a mayúsculas y
minúsculas ayuda a prevenir errores relacionados con la
nomenclatura de variables y funciones, asegurando que los
programadores utilicen consistentemente la forma correcta
para referirse a sus identificadores.

[Link]
¿Cuál es la importancia de la propiedad 'navigator' en el
objeto Window?
Respuesta:La propiedad 'navigator' proporciona detalles
importantes sobre el navegador web del usuario, incluyendo
su nombre y versión, lo cual es crucial para escribir código
compatible entre navegadores.

[Link]
¿De qué manera las funciones definidas por el usuario
pueden mejorar la capacidad de un programa
JavaScript?
Respuesta:Las funciones definidas por el usuario permiten un
código modular y reutilizable, habilitando a los
desarrolladores para encapsular lógica y reducir la
redundancia al llamar a la misma función múltiples veces con
diferentes argumentos según sea necesario.

[Link]
¿Cómo contribuye el concepto de 'prototipo' a la
programación orientada a objetos en JavaScript?
Respuesta:El prototipo permite que los objetos hereden
propiedades y métodos de otros objetos, facilitando una
forma de herencia que promueve la reutilización de código y
una gestión eficiente de la memoria al no duplicar métodos
para cada instancia.

[Link]
¿Qué papel juega el manejo de eventos en JavaScript del
lado del cliente?
Respuesta:El manejo de eventos permite que JavaScript
responda a las interacciones del usuario con elementos
HTML (como clics o pulsaciones de teclas), habilitando
respuestas dinámicas como la actualización del contenido de
la página web sin necesidad de recargarla completamente.

[Link]
Explica el concepto de 'alcance' en JavaScript y su
importancia.
Respuesta:El alcance define la visibilidad y duración de las
variables en JavaScript. Entender el alcance es crucial para
gestionar el acceso a las variables y evitar conflictos en
programas más grandes, particularmente con la distinción
entre variables globales y locales.

[Link]
¿Por qué es esencial para los desarrolladores entender los
tipos de datos en JavaScript?
Respuesta:Entender los tipos de datos es vital ya que dictan
cómo se pueden usar, manipular y comparar los valores en
JavaScript, influyendo en el rendimiento y la corrección en la
lógica de programación.
JavaScript. La guía definitiva
Cuestionario y prueba
Ver la respuesta correcta en el sitio web de Bookey

Capítulo 1 | Sección 1.1. Sintaxis| Cuestionario y

prueba
[Link] sintaxis de JavaScript. La guía definitiva se
asemeja a la de Java, que a su vez deriva de C y
C++.
[Link]. La guía definitiva no distingue entre
mayúsculas y minúsculas para palabras clave e
identificadores.
[Link] identificadores en JavaScript. La guía definitiva
pueden comenzar con un dígito.
Capítulo 2 | Sección 1.3. Tipos de Datos|
Cuestionario y prueba
[Link]. La guía definitiva soporta tres tipos de
datos primitivos: números, booleanos y cadenas; y
dos tipos de datos compuestos: objetos y arreglos.
[Link] tipo booleano en JavaScript tiene tres valores posibles:
 verdadero, falso y nulo.
[Link] cadenas en JavaScript son mutables, lo que significa
que las modificaciones alteran la cadena original.
Capítulo 3 | Sección 1.4. Expresiones y Operadores|
Cuestionario y prueba
[Link]. La guía definitiva utiliza los mismos
operadores que C y C++ sin operadores
adicionales.
[Link] operador '+' en JavaScript puede usarse tanto para la
suma como para la concatenación de cadenas.
[Link] JavaScript, el operador 'typeof' solo se puede usar con
números.
Capítulo 4 | Sección 1.5. Sentencias| Cuestionario y
prueba
[Link] expresión en JavaScript puede ser una
declaración independiente.
[Link] declaración vacía se representa por llaves ({ }) y no
hace nada.
[Link] declaración 'for/in' se utiliza para iterar sobre las
propiedades de un objeto.
Capítulo 5 | Sección 1.6. JavaScript orientado a
objetos| Cuestionario y prueba
[Link] objetos en JavaScript son arreglos asociativos
que vinculan valores con propiedades nombradas.
[Link] función constructora se utiliza para crear una nueva
clase en JavaScript y se invoca sin el operador 'new'.
[Link] propiedades definidas en el prototipo de un constructor
no son heredadas por los objetos creados con ese
constructor.
Capítulo 6 | Sección 1.7. Expresiones Regulares|
Cuestionario y prueba
[Link] expresiones regulares de JavaScript utilizan
 una sintaxis similar a la de Java.
[Link] las expresiones regulares, el carácter '.' coincide con
cualquier carácter excepto un salto de línea.
[Link] cuantificador '+' en las expresiones regulares coincide
cero o una vez.
Capítulo 7 | Sección 1.8. Versiones de JavaScript|
Cuestionario y prueba
[Link]. La guía definitiva 1.0 fue la primera
versión de JavaScript implementada en Netscape 2
y ahora está obsoleta.
[Link] 5.5 es equivalente a JavaScript. La guía definitiva
1.4 y cumple con ECMA v2.
[Link] se puede incluir en HTML a través de la etiqueta
<script>, controladores de eventos y URLs de JavaScript.
Capítulo 8 | Sección 2.1. JavaScript en HTML|
Cuestionario y prueba
[Link]. La guía definitiva se puede integrar en
archivos HTML a través de scripts, controladores
de eventos y URLs de JavaScript.
[Link] atributo `language` es la forma recomendada para
especificar el lenguaje de script en la etiqueta <script>.
[Link]. La guía definitiva solo se puede ejecutar a
través de la etiqueta <script> y no puede ser activado por
controladores de eventos o URLs.
Capítulo 9 | Sección 2.2. El objeto Window|
Cuestionario y prueba
[Link] objeto Window es el objeto global en JavaScript
del lado del cliente.
[Link] método `setInterval()` se utiliza para ejecutar código
solo una vez en un intervalo específico.
[Link] propiedad `navigator` proporciona información sobre el
sistema del usuario, incluido el nombre del navegador.
Capítulo 10 | Sección 2.3. El Objeto Documento|
Cuestionario y prueba
[Link] objeto Window tiene una propiedad
document que se refiere a un objeto Document, lo
cual es crucial ya que representa el documento
HTML que se muestra en la ventana del
navegador.
[Link] DOM del W3C no está estandarizado y no proporciona
acceso completo a todo el contenido del documento.
[Link] DOM de IE 4 fue desarrollado por Microsoft y ofreció
poderosas características para la manipulación del
contenido del documento que no estaban estandarizadas.
Capítulo 11 | Sección 2.4. El DOM Legado|
Cuestionario y prueba
[Link] DOM legado permite acceder a varias
propiedades y contenidos del documento.
[Link] propiedades del objeto Document incluyen un método
para interactuar directamente con todos los tipos de
etiquetas HTML.
[Link] propiedad cookie se puede utilizar para establecer y
 recuperar cookies del documento en JavaScript.
Capítulo 12 | Sección 2.5. El W3C DOM|
Cuestionario y prueba
[Link] DOM de W3C permite a los scripts manipular
solo formularios e imágenes.
[Link] encontrar elementos por su id único utilizando el
método getElementById().
[Link] propiedad nodeType indica el tipo de un nodo con
valores como 1 para Texto y 2 para Elemento.
Capítulo 13 | Sección 2.6. DOM de IE 4|
Cuestionario y prueba
[Link] DOM de IE 4 es un modelo de objeto de
documento estándar.
[Link] elementos en el DOM de IE 4 se pueden acceder
utilizando el array all[] del objeto document.
[Link] recorrido del árbol de documentos en el DOM de IE 4
utiliza la propiedad children[] en lugar de childNodes[].
Capítulo 14 | Sección 2.7. DHTML: Programación
de estilos CSS| Cuestionario y prueba
[Link] dinámico (DHTML) combina HTML, CSS
y JavaScript para modificaciones de estilo
dinámicas.
[Link] JavaScript, los atributos de CSS con guiones se acceden
utilizando la misma convención de nombres con guiones.
[Link] atributo 'float' en CSS se refiere como 'cssFloat' en
JavaScript.
Capítulo 15 | Sección 2.8. Eventos y Manejo de
Eventos| Cuestionario y prueba
[Link] atributos de los manejadores de eventos en
 HTML comienzan con 'on'.
[Link] falso desde un manejador de eventos evitará la
acción de onmouseover en todos los casos.
[Link] modelo W3C permite registrar múltiples manejadores de
eventos para un solo tipo de evento usando
addEventListener().
Capítulo 16 | Sección 2.9. Restricciones de Seguridad
en JavaScript| Cuestionario y prueba
[Link] scripts pueden acceder a las propiedades de
las ventanas y documentos desde cualquier
servidor web debido a la Política de Origen
Mismo.
[Link] no puede manipular la propiedad value del
elemento de formulario FileUpload.
[Link] configuraciones del navegador pueden permitir a los
usuarios bloquear anuncios emergentes y manipular el
tamaño de las ventanas debido a las restricciones de
seguridad de JavaScript en evolución.
Capítulo 17 | Array| Cuestionario y prueba
[Link] método constructor 'new Array()' crea un array
vacío en JavaScript.
[Link] arrays en JavaScript solo se pueden crear utilizando el
método constructor 'new Array()', no con la sintaxis literal.
[Link] método 'pop()' elimina el primer elemento de un array en
JavaScript.
Capítulo 18 | Fecha| Cuestionario y prueba
[Link] objeto Date en JavaScript puede crearse
utilizando diferentes formatos, incluyendo un
timestamp en milisegundos.
[Link] método `getYear()` en el objeto Date devuelve el año
completo (por ejemplo, 2023).
[Link] método `[Link](...)` devuelve la representación en
milisegundos para la fecha y hora local especificadas.
Capítulo 19 | Documento| Cuestionario y prueba
[Link] objeto Document fue introducido en JavaScript
1.0 y ha sido mejorado en JavaScript 1.1.
[Link] propiedad 'alinkColor' del objeto Document es
actualmente recomendada para su uso.
[Link] método 'createElement(tagName)' se utiliza para crear
un nuevo nodo Element en el documento.
Capítulo 20 | Elemento| Cuestionario y prueba
[Link] objeto Elemento representa un elemento o
etiqueta HTML en un documento y hereda
propiedades del objeto Nodo según lo definido en
el DOM Nivel 1.
[Link] propiedad 'all[]' es una propiedad del DOM W3C
utilizada para acceder a los objetos Elemento
descendientes.
[Link] método 'getAttribute(name)' se utiliza para eliminar un
atributo nombrado de un objeto Elemento.
Capítulo 21 | Evento| Cuestionario y prueba
[Link] objeto Event proporciona detalles sobre un
 evento y controla su propagación en diferentes
entornos de navegador.
[Link] las propiedades del objeto Event son de lectura y
escritura, lo que permite modificarlas durante el manejo de
eventos.
[Link] el modelo de IE, el evento se puede acceder a través de
la propiedad event del objeto Window.
Capítulo 22 | Global| Cuestionario y prueba
[Link] objeto Global en JavaScript está representado
por el objeto Window en el scripting del lado del
cliente.
[Link] función isNaN(n) verifica si n es un número.
[Link] función encodeURIComponent(s) codifica todos los
caracteres en una URI.
Capítulo 23 | Input| Cuestionario y prueba
[Link] objeto Input en JavaScript representa
elementos HTML `<input>` y proporciona
propiedades para sus atributos.
[Link] propiedad 'defaultChecked' indica si un campo de
entrada de texto estaba marcado al inicio.
[Link] controlador de eventos 'onchange' se activa cuando se
cambia el texto y se pierde el enfoque.
Capítulo 24 | Capa| Cuestionario y prueba
[Link] objeto Layer es una característica estándar que
se utiliza en todos los navegadores.
[Link] hacer referencia a un objeto Layer usando
 [Link][i] o [Link][nombre-capa].
[Link] método load(src, width) se utiliza solo para cambiar el
tamaño de la capa a dimensiones específicas.
Capítulo 25 | Enlace| Cuestionario y prueba
[Link] objeto Link en JavaScript. La guía definitiva
hereda de la clase Element.
[Link] propiedad 'search' del objeto Link no incluye el signo de
interrogación en su valor.
[Link] manejador de eventos 'onclick' se puede utilizar para
evitar seguir un enlace si devuelve falso en JavaScript 1.1.
Capítulo 26 | Math| Cuestionario y prueba
[Link] objeto Math en JavaScript. La guía definitiva
tiene un constructor y sus funciones son métodos
de un objeto.
[Link] es una constante que representa el valor de À en
JavaScript.
[Link]() devolverá -Infinity si no se proporcionan
argumentos.
Capítulo 27 | Navegador| Cuestionario y prueba
[Link] propiedad appCodeName en el objeto
navigator típicamente devuelve 'Mozilla' tanto
para los navegadores Netscape como para los de
 Microsoft.
[Link] propiedad userLanguage especifica el idioma
predeterminado del usuario como un valor numérico.
[Link] método javaEnabled() devuelve verdadero si Java no es
compatible en el navegador actual.
Capítulo 28 | Nodo| Cuestionario y prueba
[Link] nodo en un árbol de documentos puede ser de
tipos como Atributo, Comentario, Documento,
Fragmento de Documento, Elemento o Texto.
[Link] propiedad nodeType de un objeto Nodo especifica el
valor de su tipo de nodo, pero no es de solo lectura.
[Link] método `addEventListener(type, listener, useCapture)`
se utiliza para eliminar un listener de eventos de un Nodo.
Capítulo 29 | Número| Cuestionario y prueba
[Link] constructor Number solo puede crear un nuevo
objeto Number cuando se utiliza con el operador
new.
[Link].MAX_VALUE representa el número más pequeño
que se puede representar en JavaScript.
[Link] método toFixed devuelve una representación en cadena
de un número con un número especificado de cifras
decimales.
Capítulo 30 | Objeto| Cuestionario y prueba
[Link] constructor `new Object();` crea un objeto vacío
 al que se le pueden añadir propiedades arbitrarias.
[Link] método `valueOf()` para el tipo Object devuelve su valor
primitivo si está disponible. Para Object, devuelve un
objeto diferente en lugar del objeto en sí.
[Link] método `toLocaleString()` proporciona una
representación en forma de cadena genérica del objeto sin
permitir que las subclases sobrescriban su comportamiento.
Capítulo 31 | RegExp| Cuestionario y prueba
[Link] expresiones regulares (RegExp) solo se pueden
definir utilizando un constructor en JavaScript.
[Link] método 'test' de RegExp devuelve true si hay una
coincidencia, de lo contrario devuelve false.
[Link] propiedad de instancia 'global' indica si la RegExp se
utiliza para coincidencias que no distinguen entre
mayúsculas y minúsculas.
Capítulo 32 | Select| Cuestionario y prueba
[Link] propiedad 'selectedIndex' devuelve -1 si no se
ha seleccionado ninguna opción.
[Link] método 'remove(n)' elimina el primer elemento del array
de opciones cuando n es 0.
[Link] método 'blur()' se utiliza para obtener el enfoque del
teclado en un objeto Select.
Capítulo 33 | Cadena| Cuestionario y prueba
[Link] manipulación de cadenas se introdujo en
JavaScript 1.0.
[Link] método `substring(from, to)` extrae caracteres entre `to`
 y `from`.
[Link] propiedad `length` de una cadena en JavaScript es una
propiedad de solo lectura que representa el número de
caracteres en la cadena.
Capítulo 34 | Estilo| Cuestionario y prueba
[Link] objeto Style en JavaScript. La guía definitiva
permite la manipulación directa de las
propiedades CSS definidas por la especificación
CSS2.
[Link] propiedad float se mantiene como 'float' en el objeto
Style para mantener la consistencia con los estándares de
CSS.
[Link] las propiedades CSS soportadas por el objeto Style
están garantizadas de ser implementadas por todos los
navegadores actuales.
Capítulo 35 | Window| Cuestionario y prueba
[Link] método `alert()` se utiliza para mostrar un
mensaje en un cuadro de diálogo en JavaScript del
lado del cliente.
[Link] propiedad `navigator` proporciona información
específica del sistema operativo del usuario.
[Link] controladores de eventos en JavaScript se definen
utilizando atributos dentro de las etiquetas HTML.